fix: clippy collapsible-if and rustfmt formatting

Author: lennyburdette

apollo-federation/src/connectors/expand/mod.rs

@@ -247,13 +247,15 @@ fn add_connected_selections(
             use apollo_compiler::ast::InputValueDefinition;
             use apollo_compiler::ast::Type;
             let join_field_def = join_field_def.make_mut();
-            join_field_def.arguments.push(Node::new(InputValueDefinition {
-                description: None,
-                name: JOIN_CONNECTED_SELECTION_ARGUMENT_NAME,
-                ty: Node::new(Type::Named(name!("join__FieldSet"))),
-                default_value: None,
-                directives: Default::default(),
-            }));
+            join_field_def
+                .arguments
+                .push(Node::new(InputValueDefinition {
+                    description: None,
+                    name: JOIN_CONNECTED_SELECTION_ARGUMENT_NAME,
+                    ty: Node::new(Type::Named(name!("join__FieldSet"))),
+                    default_value: None,
+                    directives: Default::default(),
+                }));
         }
     }
 
@@ -306,10 +308,10 @@ fn build_service_name_to_enum_value(
         // Look for @join__graph(name: "service_name") on this enum value
         for directive in enum_value_def.directives.get_all(&name!("join__graph")) {
             for arg in &directive.arguments {
-                if arg.name == name!("name") {
-                    if let Value::String(service_name) = arg.value.as_ref() {
-                        map.insert(service_name.clone(), enum_value_name.clone());
-                    }
+                if arg.name == name!("name")
+                    && let Value::String(service_name) = arg.value.as_ref()
+                {
+                    map.insert(service_name.clone(), enum_value_name.clone());
                 }
             }
         }

apollo-federation/src/connectors/validation/connect/selection.rs

@@ -176,11 +176,7 @@ impl<'schema> Selection<'schema> {
                     return Ok(Vec::new());
                 }
 
-                let mut validator = SelectionValidator::new(
-                    schema,
-                    &self.node,
-                    self.coordinate,
-                );
+                let mut validator = SelectionValidator::new(schema, &self.node, self.coordinate);
 
                 // Clear seen_fields for this connector
                 validator.seen_fields.clear();
@@ -216,11 +212,7 @@ impl<'schema> Selection<'schema> {
                     });
                 }
 
-                let mut validator = SelectionValidator::new(
-                    schema,
-                    &self.node,
-                    self.coordinate,
-                );
+                let mut validator = SelectionValidator::new(schema, &self.node, self.coordinate);
 
                 // Clear seen_fields for this connector
                 validator.seen_fields.clear();

apollo-federation/src/query_graph/build_query_graph.rs

@@ -18,9 +18,9 @@ use crate::bail;
 use crate::error::FederationError;
 use crate::error::SingleFederationError;
 use crate::link::federation_spec_definition::FederationSpecDefinition;
-use crate::link::join_spec_definition::JoinSpecDefinition;
 use crate::link::federation_spec_definition::KeyDirectiveArguments;
 use crate::link::federation_spec_definition::get_federation_spec_definition_from_subgraph;
+use crate::link::join_spec_definition::JoinSpecDefinition;
 use crate::operation::Selection;
 use crate::operation::SelectionSet;
 use crate::operation::merge_selection_sets;
@@ -2210,10 +2210,8 @@ impl FederatedQueryGraphBuilder {
     /// nodes that only have the specified field edges plus key resolution edges.
     fn handle_connected_selection(&mut self) -> Result<(), FederationError> {
         // Get join spec from supergraph
-        let (_, join_spec, _) =
-            validate_supergraph_for_query_planning(&self.supergraph_schema)?;
-        let join_field_def =
-            join_spec.field_directive_definition(&self.supergraph_schema)?;
+        let (_, join_spec, _) = validate_supergraph_for_query_planning(&self.supergraph_schema)?;
+        let join_field_def = join_spec.field_directive_definition(&self.supergraph_schema)?;
         let join_field_name = join_field_def.name.clone();
 
         // Build graph enum value -> source name mapping
@@ -2244,13 +2242,12 @@ impl FederatedQueryGraphBuilder {
                     let args = join_spec.field_directive_arguments(directive)?;
                     if let (Some(graph_enum_value), Some(connected_sel)) =
                         (args.graph, args.connected_selection)
+                        && let Some(source_name) = graph_enum_to_source.get(&graph_enum_value)
                     {
-                        if let Some(source_name) = graph_enum_to_source.get(&graph_enum_value) {
-                            restrictions.insert(
-                                (source_name.clone(), type_name.clone(), field_name.clone()),
-                                connected_sel.to_string(),
-                            );
-                        }
+                        restrictions.insert(
+                            (source_name.clone(), type_name.clone(), field_name.clone()),
+                            connected_sel.to_string(),
+                        );
                     }
                 }
             }
@@ -2300,8 +2297,7 @@ impl FederatedQueryGraphBuilder {
             let conditions = parse_field_set(schema, tail_type_name, connected_sel, true)?;
 
             provide_id += 1;
-            let new_tail =
-                self.create_restricted_copy(tail, &source, &conditions, provide_id)?;
+            let new_tail = self.create_restricted_copy(tail, &source, &conditions, provide_id)?;
             Self::update_edge_tail(&mut self.base, edge, new_tail)?;
             // Mark ancestors of the head as having reachable "cross-subgraph"
             // edges. Even though the restricted copy is in the same subgraph,
@@ -2318,8 +2314,7 @@ impl FederatedQueryGraphBuilder {
         &self,
         join_spec: &'static JoinSpecDefinition,
     ) -> Result<IndexMap<Name, Arc<str>>, FederationError> {
-        let graph_directive_def =
-            join_spec.graph_directive_definition(&self.supergraph_schema)?;
+        let graph_directive_def = join_spec.graph_directive_definition(&self.supergraph_schema)?;
         let graph_enum_name = self
             .supergraph_schema
             .schema()
@@ -2410,10 +2405,10 @@ impl FederatedQueryGraphBuilder {
         // Register in types_to_nodes for the federated graph
         let current_source = self.base.query_graph.current_source.clone();
         self.base.query_graph.current_source = FEDERATED_GRAPH_ROOT_SOURCE.into();
-        if let Ok(nodes) = self.base.query_graph.types_to_nodes_mut() {
-            if let Some(node_set) = nodes.get_mut(type_pos.type_name()) {
-                node_set.insert(new_node);
-            }
+        if let Ok(nodes) = self.base.query_graph.types_to_nodes_mut()
+            && let Some(node_set) = nodes.get_mut(type_pos.type_name())
+        {
+            node_set.insert(new_node);
         }
         self.base.query_graph.current_source = current_source;
 
@@ -2459,12 +2454,8 @@ impl FederatedQueryGraphBuilder {
             if let Some((transition, tail)) = existing {
                 if let Some(nested_selections) = &field_selection.selection_set {
                     // Nested selection - create another restricted copy for the next level
-                    let new_tail = self.create_restricted_copy(
-                        tail,
-                        source,
-                        nested_selections,
-                        provide_id,
-                    )?;
+                    let new_tail =
+                        self.create_restricted_copy(tail, source, nested_selections, provide_id)?;
                     self.base
                         .add_edge(restricted_node, new_tail, transition, None, None)?;
                 } else {

apollo-federation/src/query_graph/graph_path.rs

@@ -1725,8 +1725,9 @@ where
                 // node. Copy nodes have fewer fields than the original, so the
                 // "detour" (re-entering the subgraph) is actually necessary to
                 // access fields not on the copy.
-                if !tail_is_copy && let Some(last_subgraph_entering_edge_info) =
-                    &to_advance.last_subgraph_entering_edge_info
+                if !tail_is_copy
+                    && let Some(last_subgraph_entering_edge_info) =
+                        &to_advance.last_subgraph_entering_edge_info
                 {
                     let Some(last_subgraph_entering_edge) =
                         to_advance.edges[last_subgraph_entering_edge_info.index].into()

apollo-federation/src/query_plan/query_planner.rs

@@ -1521,8 +1521,11 @@ type User @join__type(graph: CONNECTOR, key: "id") {
             planner.api_schema().schema(),
             r#"{ user(id: "1") { friends { name } } }"#,
             "op.graphql",
-        ).unwrap();
-        let plan = planner.build_query_plan(&doc, None, Default::default()).unwrap();
+        )
+        .unwrap();
+        let plan = planner
+            .build_query_plan(&doc, None, Default::default())
+            .unwrap();
         // name IS on the restricted copy, so single fetch
         insta::assert_snapshot!(plan, @r###"
         QueryPlan {
@@ -1544,8 +1547,11 @@ type User @join__type(graph: CONNECTOR, key: "id") {
             planner.api_schema().schema(),
             r#"{ user(id: "1") { friends { name friends { name } } } }"#,
             "op.graphql",
-        ).unwrap();
-        let plan2 = planner.build_query_plan(&doc2, None, Default::default()).unwrap();
+        )
+        .unwrap();
+        let plan2 = planner
+            .build_query_plan(&doc2, None, Default::default())
+            .unwrap();
         // friends is NOT on the restricted copy, so needs entity resolution
         insta::assert_snapshot!(plan2, @r###"
         QueryPlan {
@@ -1653,8 +1659,11 @@ type User @join__type(graph: CONNECTOR, key: "id") {
             planner.api_schema().schema(),
             r#"{ user(id: "1") { friends { friends { friends { name } } } } }"#,
             "op.graphql",
-        ).unwrap();
-        let plan = planner.build_query_plan(&doc, None, Default::default()).unwrap();
+        )
+        .unwrap();
+        let plan = planner
+            .build_query_plan(&doc, None, Default::default())
+            .unwrap();
         insta::assert_snapshot!(plan, @r###"
         QueryPlan {
           Sequence {
@@ -1807,7 +1816,9 @@ type User @join__type(graph: CONNECTORS, key: "id") {
             "op.graphql",
         )
         .unwrap();
-        let plan = planner.build_query_plan(&doc, None, Default::default()).unwrap();
+        let plan = planner
+            .build_query_plan(&doc, None, Default::default())
+            .unwrap();
         let plan_str = plan.to_string();
 
         assert!(