apply lint fixes

Reviewed By: tyao1

Differential Revision: D80359270

fbshipit-source-id: 3248e3f644f97953ca87a6545661408274200d1a

Author: kassens

compiler/crates/common/src/console_logger.rs

@@ -20,13 +20,13 @@ pub struct ConsoleLogger;
 impl PerfLogEvent for ConsoleLogEvent {
     type Timer = (&'static str, Instant);
     fn number(&self, name: &'static str, number: usize) {
-        debug!("{}: {}", name, number);
+        debug!("{name}: {number}");
     }
     fn bool(&self, name: &'static str, value: bool) {
-        debug!("{}: {}", name, value);
+        debug!("{name}: {value}");
     }
     fn string(&self, name: &'static str, value: String) {
-        debug!("{}: {}", name, value);
+        debug!("{name}: {value}");
     }
     fn start(&self, name: &'static str) -> Self::Timer {
         (name, Instant::now())
@@ -47,7 +47,7 @@ impl PerfLogger for ConsoleLogger {
 
 pub fn print_time(name: &str, time: Instant) {
     let elapsed_ms = time.elapsed().as_millis();
-    let elapsed_str = format!("{:4}ms", elapsed_ms);
+    let elapsed_str = format!("{elapsed_ms:4}ms");
     let elapsed_color = if elapsed_ms < 10 {
         elapsed_str.dimmed()
     } else if elapsed_ms < 100 {

compiler/crates/common/src/feature_flags.rs

@@ -232,8 +232,8 @@ impl Display for FeatureFlag {
                 f.write_str("limited to: ")?;
                 f.write_str(&items.join(", "))
             }
-            FeatureFlag::Rollout { rollout } => write!(f, "Rollout: {:#?}", rollout),
-            FeatureFlag::RolloutRange { rollout } => write!(f, "RolloutRange: {:#?}", rollout),
+            FeatureFlag::Rollout { rollout } => write!(f, "Rollout: {rollout:#?}"),
+            FeatureFlag::RolloutRange { rollout } => write!(f, "RolloutRange: {rollout:#?}"),
         }
     }
 }

compiler/crates/dependency-analyzer/src/ast.rs

@@ -47,8 +47,7 @@ pub fn get_reachable_ast(
                 let name = FragmentDefinitionName(fragment.name.value);
                 assert!(
                     base_definitions_map.insert(name, base_definition).is_none(),
-                    "get_reachable_ast called on graph with duplicate definition of `{}`",
-                    name
+                    "get_reachable_ast called on graph with duplicate definition of `{name}`"
                 )
             }
             ExecutableDefinition::Operation(_) => {}

compiler/crates/dependency-analyzer/src/ir.rs

@@ -259,7 +259,7 @@ fn add_related_nodes(
 
     let parents = match dependency_graph.get(&key) {
         None => {
-            panic!("Fragment {:?} not found in IR.", key);
+            panic!("Fragment {key:?} not found in IR.");
         }
         Some(node) => &node.parents,
     };
@@ -301,7 +301,7 @@ fn add_descendants(
             }
         }
         _ => {
-            panic!("Fragment {:?} not found in IR.", key);
+            panic!("Fragment {key:?} not found in IR.");
         }
     }
 }

compiler/crates/fixture-tests/src/lib.rs

@@ -156,10 +156,9 @@ pub async fn test_fixture<T, U, V>(
             panic!(
                 "Expected transform to succeed but it failed with, use 'expected-to-throw' if this is expected. Error:
 #############################################################################
-{}
+{error}
 #############################################################################
-",
-                error
+"
             );
         }
         _ => {}

compiler/crates/fixture-tests/src/main.rs

@@ -64,12 +64,12 @@ fn main() {
             });
             if path.extension().unwrap() == EXPECTED_EXTENSION {
                 if let Some(ref previous) = test_case.expected {
-                    panic!("Conflicting fixture name, {:?} and {:?}", previous, path);
+                    panic!("Conflicting fixture name, {previous:?} and {path:?}");
                 }
                 test_case.expected = Some(path);
             } else {
                 if let Some(ref previous) = test_case.input {
-                    panic!("Conflicting fixture name, {:?} and {:?}", previous, path);
+                    panic!("Conflicting fixture name, {previous:?} and {path:?}");
                 }
                 test_case.input = Some(path);
             }
@@ -109,17 +109,15 @@ async fn {0}() {{
                     test_case
                         .input
                         .unwrap_or_else(|| panic!(
-                            "Expected input for test {:?} to exist",
-                            test_case_name
+                            "Expected input for test {test_case_name:?} to exist"
                         ))
                         .file_name()
                         .and_then(|x| x.to_str())
                         .unwrap(),
                     test_case
                         .expected
                         .unwrap_or_else(|| panic!(
-                            "Expected output for test {:?} to exist",
-                            test_case_name
+                            "Expected output for test {test_case_name:?} to exist"
                         ))
                         .file_name()
                         .and_then(|x| x.to_str())
@@ -150,17 +148,12 @@ async fn {0}() {{
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * {signing_token}
+ * {SIGNING_TOKEN}
  */
 ",
-                signing_token = SIGNING_TOKEN,
             )
         } else if let Some(customized_header) = &opt.customized_header {
-            format!(
-                "// {signing_token}\n// {customized_header}\n",
-                signing_token = SIGNING_TOKEN,
-                customized_header = customized_header
-            )
+            format!("// {SIGNING_TOKEN}\n// {customized_header}\n")
         } else {
             format!(
                 "// {signing_token}
@@ -204,11 +197,8 @@ fn check_targets_file(test_dir: &Path) {
     if !targets_content.contains(&expected_substr) {
         eprintln!(
             "{}",
-            format!(
-                "WARNING: expected {:?} to contain substring {}",
-                targets_path, expected_substr
-            )
-            .yellow()
+            format!("WARNING: expected {targets_path:?} to contain substring {expected_substr}")
+                .yellow()
         );
     }
 }

compiler/crates/fixture-tests/src/print_diff.rs

@@ -16,15 +16,15 @@ pub(crate) fn print_diff(expected: &str, actual: &str) {
             Both(context, _context) => {
                 // Print 1 line of context
                 let prev_is_change = line_index > 0 && is_change(&changes[line_index - 1]);
-                let next_is_change = changes.get(line_index + 1).map_or(false, is_change);
+                let next_is_change = changes.get(line_index + 1).is_some_and(is_change);
                 if prev_is_change || next_is_change {
-                    format!("| {}", context).dimmed()
+                    format!("| {context}").dimmed()
                 } else {
                     continue;
                 }
             }
-            Left(removed) => format!("- {}", removed).red(),
-            Right(added) => format!("+ {}", added).green(),
+            Left(removed) => format!("- {removed}").red(),
+            Right(added) => format!("+ {added}").green(),
         };
         println!("{:4} {}", line_index + 1, formatted_line);
     }

compiler/crates/graphql-ir-validations/src/validate_selection_conflict.rs

@@ -505,8 +505,8 @@ impl<'s, B: LocationAgnosticBehavior + Sync> ValidateSelectionConflict<'s, B> {
         .metadata_for_machine("field_name", field_name.lookup())
         .metadata_for_machine("arg_a", arguments_a_printed)
         .metadata_for_machine("arg_b", arguments_b_printed)
-        .metadata_for_machine("loc_a", format!("{:?}", location_a))
-        .metadata_for_machine("loc_b", format!("{:?}", location_b))
+        .metadata_for_machine("loc_a", format!("{location_a:?}"))
+        .metadata_for_machine("loc_b", format!("{location_b:?}"))
     }
 }
 

compiler/crates/graphql-ir/src/build.rs

@@ -1358,12 +1358,12 @@ impl<'schema, 'signatures, 'options> Builder<'schema, 'signatures, 'options> {
         // Check for repeated directives that are not @repeatable
         if directives.len() > 1 {
             for (index, directive) in directives.iter().enumerate() {
-                let directive_repeatable = self.schema.get_directive(directive.name.item).map_or(
-                    // Default to `false` instead of expecting a definition
-                    // since @arguments directive is not defined in the schema.
-                    false,
-                    |dir| dir.repeatable,
-                );
+                let directive_repeatable =
+                    self.schema.get_directive(directive.name.item).is_some_and(
+                        // Default to `false` instead of expecting a definition
+                        // since @arguments directive is not defined in the schema.
+                        |dir| dir.repeatable,
+                    );
                 if directive_repeatable {
                     continue;
                 }
@@ -2037,7 +2037,7 @@ impl<'schema, 'signatures, 'options> Builder<'schema, 'signatures, 'options> {
                 if !self.options.allow_custom_scalar_literals {
                     return Err(vec![Diagnostic::error(
                         ValidationMessage::UnexpectedCustomScalarLiteral {
-                            literal_value: format!("{}", value),
+                            literal_value: format!("{value}"),
                             scalar_type_name: type_definition.name.item,
                         },
                         self.location.with_span(value.span()),

compiler/crates/graphql-ir/src/ir.rs

@@ -243,7 +243,7 @@ impl ExecutableDefinitionName {
     pub fn unwrap_fragment_definition_name(&self) -> FragmentDefinitionName {
         match self {
             ExecutableDefinitionName::OperationDefinitionName(_) => {
-                panic!("Expected FragmentDefinitionName, found {}", self)
+                panic!("Expected FragmentDefinitionName, found {self}")
             }
             ExecutableDefinitionName::FragmentDefinitionName(name) => *name,
         }
@@ -401,11 +401,11 @@ impl Selection {
 impl fmt::Debug for Selection {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Selection::FragmentSpread(node) => f.write_fmt(format_args!("{:#?}", node)),
-            Selection::InlineFragment(node) => f.write_fmt(format_args!("{:#?}", node)),
-            Selection::LinkedField(node) => f.write_fmt(format_args!("{:#?}", node)),
-            Selection::ScalarField(node) => f.write_fmt(format_args!("{:#?}", node)),
-            Selection::Condition(node) => f.write_fmt(format_args!("{:#?}", node)),
+            Selection::FragmentSpread(node) => f.write_fmt(format_args!("{node:#?}")),
+            Selection::InlineFragment(node) => f.write_fmt(format_args!("{node:#?}")),
+            Selection::LinkedField(node) => f.write_fmt(format_args!("{node:#?}")),
+            Selection::ScalarField(node) => f.write_fmt(format_args!("{node:#?}")),
+            Selection::Condition(node) => f.write_fmt(format_args!("{node:#?}")),
         }
     }
 }
@@ -663,15 +663,15 @@ impl Value {
     /// Panics if the value is not a constant.
     pub fn expect_constant(&self) -> &ConstantValue {
         self.get_constant().unwrap_or_else(|| {
-            panic!("expected a constant, got {:?}", self);
+            panic!("expected a constant, got {self:?}");
         })
     }
 
     /// Return the constant string literal of this value.
     /// Panics if the value is not a constant string literal.
     pub fn expect_string_literal(&self) -> StringKey {
         self.get_string_literal().unwrap_or_else(|| {
-            panic!("expected a string literal, got {:?}", self);
+            panic!("expected a string literal, got {self:?}");
         })
     }
 }