Not formatting any part of function

[JMS55]

This function is located in a standalone { } block in main

        fn tree_harvest_ai(self_entity: Entity, lazy_world: &LazyUpdate) {
            lazy_world.exec(move |world| {
                let container_data = world.read_storage::<Container>();
                let world_location_data = world.read_storage::<WorldLocation>();
                let entity_type_data = world.read_storage::<EntityType>();
                let time_tracker_data = world.read_storage::<TimeTracker>();
                let mut action_attack_data = world.write_storage::<ActionAttack>();
                let mut action_move_to_data = world.write_storage::<ActionMoveTo>();
                let mut action_take_from_container_data = world.write_storage::<ActionTakeFromContainer>();
                let self_container = container_data
                    .get(self_entity)
                    .expect("Entity with tree_harvest_ai() did not have a Container component");
                let self_position = &world_location_data
                    .get(self_entity)
                    .expect("Entity with tree_harvest_ai() did not have a Position component")
                    .position;
                if let Some(axe_entity) = self_container.children.iter().find(|child| {
                    entity_type_data
                        .get(**child)
                        .expect("Entity did not have a EntityType component in tree_harvest_ai()")
                        == &EntityType::Axe
                }) {
                    if let Some(tree_entity) = (
                        &entity_type_data,
                        &time_tracker_data,
                        &world_location_data,
                        &world.entities(),
                    )
                        .join()
                        .find(|(entity_type, time_tracker, world_location, _)| {
                            entity_type == &&EntityType::Tree
                                && time_tracker.time_passed
                                    >= (TREE_STAGES - 1) * TIME_PER_TREE_STAGE
                                && world_location.position.is_adjacent_to(self_position)
                        })
                        .map(|(_, _, _, entity)| entity)
                    {
                        action_attack_data
                            .insert(
                                self_entity,
                                ActionAttack {
                                    weapon: axe_entity.clone(),
                                    target_entity: tree_entity,
                                },
                            )
                            .expect("Could not insert ActionAttack component in tree_harvest_ai()");
                    } else {
                        if let Some(tree_position) = (
                            &entity_type_data,
                            &time_tracker_data,
                            &world_location_data,
                        )
                            .join()
                            .find(|(entity_type, time_tracker, _)| {
                                entity_type == &&EntityType::Tree
                                && time_tracker.time_passed  >= (TREE_STAGES - 1) * TIME_PER_TREE_STAGE
                            }).map(|(_, _, world_location)| world_location.position.clone())
                        {
                             action_move_to_data
                            .insert(
                                self_entity,
                              ActionMoveTo::new(tree_position)
                            )
                            .expect("Could not insert ActionMoveTo(tree_position) component in tree_harvest_ai()");
                        }
                    }
                } else {
                    let axe_crate_position = Position {
                        x: I32F32::from(-7),
                        y: I32F32::from(0),
                        z: I32F32::from(1),
                    };
                    if self_position.is_adjacent_to(&axe_crate_position) {
                        if let Some(axe_crate_entity) = (&world_location_data,   &world.entities()).join().find(|(world_location, _)| world_location.position == axe_crate_position).map(|(_, entity)| entity) {
                                                    action_take_from_container_data.insert(self_entity, ActionTakeFromContainer{entity_type: EntityType::Axe, source_container: axe_crate_entity}).expect("Could not insert ActionTakeFromContainer component in tree_harvest_ai()");
                        };
                    } else {
                         action_move_to_data
                            .insert(
                                self_entity,
                              ActionMoveTo::new(axe_crate_position)
                            )
                            .expect("Could not insert ActionMoveTo(axe_crate_position) component in tree_harvest_ai()");
                    }
                }
            });
        }

[topecongiro]

Not calling wrap_str when the chain expression is at the statement position (ExprType::Statement) may fix this.

rustfmt/src/chains.rs

Line 426 in 05547d9

return wrap_str(result, context.config.max_width(), shape);

rustfmt/src/chains.rs

Line 436 in 05547d9

wrap_str(result, context.config.max_width(), shape)

[ytmimi]

@calebcartwright I believe the is a duplicate of #3416. When setting max_width=115 we can get the snippet to format. We could also set format_strings=true to get the snippet to format.

[ytmimi]

#3416 was recently closed in favor of #3863, and In the spirit of consolidating duplicates I'm going to close this one as well