Fix clippy warnings following GH Actions Rust version bump (#288)

alancai98 · web-flow · commit 747f41abab84 · 2023-01-27T13:14:21.000-08:00
diff --git a/partiql-ast/partiql-ast-macros/src/lib.rs b/partiql-ast/partiql-ast-macros/src/lib.rs
@@ -50,11 +50,11 @@ fn should_skip_variant(variant: &syn::Variant) -> bool {
 fn impl_visit(ast: &syn::DeriveInput) -> proc_macro2::TokenStream {
     let visit_fn_name = &ast.ident.to_string().to_snake_case();
     let enter_fn_name = Ident::new(
-        &format!("enter_{}", visit_fn_name),
+        &format!("enter_{visit_fn_name}"),
         proc_macro2::Span::call_site(),
     );
     let exit_fn_name = Ident::new(
-        &format!("exit_{}", visit_fn_name),
+        &format!("exit_{visit_fn_name}"),
         proc_macro2::Span::call_site(),
     );
 
diff --git a/partiql-ast/src/ast.rs b/partiql-ast/src/ast.rs
@@ -43,7 +43,7 @@ pub enum Item {
 impl fmt::Display for Item {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Use Debug formatting for now
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
diff --git a/partiql-conformance-test-generator/src/generator.rs b/partiql-conformance-test-generator/src/generator.rs
@@ -290,7 +290,7 @@ impl Generator {
             .join("___")
             + ".env.ion";
 
-        let data_file = format!("{}/{}", TEST_DATA_DIR, env_file);
+        let data_file = format!("{TEST_DATA_DIR}/{env_file}");
         scope.raw(
             quote! {
                 const ENV_ION_TEXT : &'static str = include_str!(#data_file);
@@ -446,7 +446,7 @@ impl Generator {
                                 Node::Value(TestValueNode { value: expected }),
                             );
 
-                            let data_file = format!("{}/{}", TEST_DATA_DIR, expected_file);
+                            let data_file = format!("{TEST_DATA_DIR}/{expected_file}");
                             quote! {include_str!(#data_file)}
                         } else {
                             quote! {#expected}
diff --git a/partiql-conformance-tests/tests/mod.rs b/partiql-conformance-tests/tests/mod.rs
@@ -50,9 +50,7 @@ pub(crate) fn fail_syntax(statement: &str) {
     let res = parse(statement);
     assert!(
         res.is_err(),
-        "For `{}`, expected `Err(_)`, but was `{:#?}`",
-        statement,
-        res
+        "For `{statement}`, expected `Err(_)`, but was `{res:#?}`"
     );
 }
 
@@ -63,9 +61,7 @@ pub(crate) fn pass_syntax(statement: &str) -> Parsed {
     let res = parse(statement);
     assert!(
         res.is_ok(),
-        "For `{}`, expected `Ok(_)`, but was `{:#?}`",
-        statement,
-        res
+        "For `{statement}`, expected `Ok(_)`, but was `{res:#?}`"
     );
     res.unwrap()
 }
@@ -86,9 +82,7 @@ pub(crate) fn pass_semantics(statement: &str) {
     let lowered: Result<_, ()> = Ok(lower(&parsed));
     assert!(
         lowered.is_ok(),
-        "For `{}`, expected `Ok(_)`, but was `{:#?}`",
-        statement,
-        lowered
+        "For `{statement}`, expected `Ok(_)`, but was `{lowered:#?}`"
     );
 }
 
diff --git a/partiql-conformance-tests/tests/test_value.rs b/partiql-conformance-tests/tests/test_value.rs
@@ -60,7 +60,7 @@ fn parse_test_value(reader: &mut Reader, typ: IonType) -> Value {
             // TODO ion Decimal doesn't give a lot of functionality to get at the data currently
             // TODO    and it's not clear whether we'll continue with rust decimal or switch to big decimal
             let ion_dec = reader.read_decimal().unwrap();
-            let ion_dec_str = format!("{}", ion_dec).replace('d', "e");
+            let ion_dec_str = format!("{ion_dec}").replace('d', "e");
             Value::Decimal(rust_decimal::Decimal::from_scientific(&ion_dec_str).unwrap())
         }
         IonType::Timestamp => todo!("timestamp"),
diff --git a/partiql-eval/src/env.rs b/partiql-eval/src/env.rs
@@ -43,7 +43,7 @@ pub mod basic {
                 self.sensitive.insert(name.to_string(), idx);
                 e.insert(idx);
             } else {
-                panic!("Cannot insert duplicate binding of name {}", name)
+                panic!("Cannot insert duplicate binding of name {name}")
             }
         }
     }
diff --git a/partiql-eval/src/eval.rs b/partiql-eval/src/eval.rs
@@ -91,8 +91,7 @@ impl EvalPlan {
             }
             Err(e) => Err(EvalErr {
                 errors: vec![EvaluationError::InvalidEvaluationPlan(format!(
-                    "Malformed evaluation plan detected: {:?}",
-                    e
+                    "Malformed evaluation plan detected: {e:?}"
                 ))],
             }),
         }
@@ -1050,14 +1049,14 @@ impl EvalExpr for EvalBinOpExpr {
                         let lhs = if let Value::String(s) = lhs {
                             *s
                         } else {
-                            format!("{:?}", lhs)
+                            format!("{lhs:?}")
                         };
                         let rhs = if let Value::String(s) = rhs {
                             *s
                         } else {
-                            format!("{:?}", rhs)
+                            format!("{rhs:?}")
                         };
-                        Value::String(Box::new(format!("{}{}", lhs, rhs)))
+                        Value::String(Box::new(format!("{lhs}{rhs}")))
                     }
                 }
             }
diff --git a/partiql-eval/src/lib.rs b/partiql-eval/src/lib.rs
@@ -1276,8 +1276,7 @@ mod tests {
                     "data".into(),
                 ))),
                 vec![PathComponent::Key(BindingsName::CaseInsensitive(format!(
-                    "arg{}",
-                    i
+                    "arg{i}"
                 )))],
             )
         }
@@ -1300,7 +1299,7 @@ mod tests {
         elements
             .into_iter()
             .enumerate()
-            .for_each(|(i, e)| data.insert(&format!("arg{}", i), e));
+            .for_each(|(i, e)| data.insert(&format!("arg{i}"), e));
         bindings.insert("data", partiql_list![data].into());
 
         let result = evaluate(plan, bindings).coerce_to_bag();
diff --git a/partiql-logical-planner/src/lower.rs b/partiql-logical-planner/src/lower.rs
@@ -648,7 +648,7 @@ impl<'ast> Visitor<'ast> for AstToLogical {
         // TODO intern strings
         let as_key = match as_key {
             name_resolver::Symbol::Known(sym) => sym.value.clone(),
-            name_resolver::Symbol::Unknown(id) => format!("_{}", id),
+            name_resolver::Symbol::Unknown(id) => format!("_{id}"),
         };
         self.push_value(as_key.into());
     }
diff --git a/partiql-parser/src/lexer.rs b/partiql-parser/src/lexer.rs
@@ -737,16 +737,16 @@ impl<'input> fmt::Display for Token<'input> {
             Token::Caret => write!(f, "^"),
             Token::Period => write!(f, "."),
             Token::DblPipe => write!(f, "||"),
-            Token::UnquotedIdent(id) => write!(f, "<{}:UNQUOTED_IDENT>", id),
-            Token::QuotedIdent(id) => write!(f, "<{}:QUOTED_IDENT>", id),
-            Token::UnquotedAtIdentifier(id) => write!(f, "<{}:UNQUOTED_ATIDENT>", id),
-            Token::QuotedAtIdentifier(id) => write!(f, "<{}:QUOTED_ATIDENT>", id),
-            Token::Int(txt) => write!(f, "<{}:INT>", txt),
-            Token::ExpReal(txt) => write!(f, "<{}:REAL>", txt),
-            Token::Real(txt) => write!(f, "<{}:REAL>", txt),
-            Token::String(txt) => write!(f, "<{}:STRING>", txt),
+            Token::UnquotedIdent(id) => write!(f, "<{id}:UNQUOTED_IDENT>"),
+            Token::QuotedIdent(id) => write!(f, "<{id}:QUOTED_IDENT>"),
+            Token::UnquotedAtIdentifier(id) => write!(f, "<{id}:UNQUOTED_ATIDENT>"),
+            Token::QuotedAtIdentifier(id) => write!(f, "<{id}:QUOTED_ATIDENT>"),
+            Token::Int(txt) => write!(f, "<{txt}:INT>"),
+            Token::ExpReal(txt) => write!(f, "<{txt}:REAL>"),
+            Token::Real(txt) => write!(f, "<{txt}:REAL>"),
+            Token::String(txt) => write!(f, "<{txt}:STRING>"),
             Token::EmbeddedIonQuote => write!(f, "<ION>"),
-            Token::Ion(txt) => write!(f, "<{}:ION>", txt),
+            Token::Ion(txt) => write!(f, "<{txt}:ION>"),
 
             Token::All
             | Token::Asc
@@ -811,7 +811,7 @@ impl<'input> fmt::Display for Token<'input> {
             | Token::With
             | Token::Without
             | Token::Zone => {
-                write!(f, "{}", format!("{:?}", self).to_uppercase())
+                write!(f, "{}", format!("{self:?}").to_uppercase())
             }
         }
     }
diff --git a/partiql-parser/src/preprocessor.rs b/partiql-parser/src/preprocessor.rs
@@ -174,7 +174,7 @@ impl<'a> FnExprSet<'a> {
             } else {
                 spc.fn_names
                     .iter()
-                    .map(|n| format!("(?:{})", n))
+                    .map(|n| format!("(?:{n})"))
                     .collect::<Vec<_>>()
                     .join("|")
             }
diff --git a/partiql-source-map/src/location.rs b/partiql-source-map/src/location.rs
@@ -109,7 +109,7 @@ impl From<usize> for BytePosition {
 impl fmt::Display for BytePosition {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         let BytePosition(ByteOffset(n)) = self;
-        write!(f, "b{}", n)
+        write!(f, "b{n}")
     }
 }
 
@@ -400,7 +400,7 @@ mod tests {
         assert_eq!(display, loc.into());
         assert_eq!(display, unsafe { LineAndColumn::new_unchecked(14, 43) });
         assert_eq!(display, LineAndColumn::new(14, 43).unwrap());
-        assert_eq!("14:43", format!("{}", display));
+        assert_eq!("14:43", format!("{display}"));
         assert_eq!("14:43", display.to_string());
     }
 }
diff --git a/partiql-value/src/ion.rs b/partiql-value/src/ion.rs
@@ -34,7 +34,7 @@ fn parse_value(reader: &mut Reader, typ: IonType) -> Value {
             // TODO ion Decimal doesn't give a lot of functionality to get at the data currently
             // TODO    and it's not clear whether we'll continue with rust decimal or switch to big decimal
             let ion_dec = reader.read_decimal().unwrap();
-            let ion_dec_str = format!("{}", ion_dec).replace('d', "e");
+            let ion_dec_str = format!("{ion_dec}").replace('d', "e");
             Value::Decimal(rust_decimal::Decimal::from_scientific(&ion_dec_str).unwrap())
         }
         IonType::Timestamp => todo!("timestamp"),
diff --git a/partiql-value/src/lib.rs b/partiql-value/src/lib.rs
@@ -25,8 +25,10 @@ pub enum BindingsName {
 // TODO have an optional-like wrapper for null/missing instead of inlined here?
 #[derive(Hash, PartialEq, Eq, Clone)]
 #[allow(dead_code)] // TODO remove once out of PoC
+#[derive(Default)]
 pub enum Value {
     Null,
+    #[default]
     Missing,
     Boolean(bool),
     Integer(i64),
@@ -485,12 +487,6 @@ fn coerce_int_to_real(value: &Value) -> Value {
     }
 }
 
-impl Default for Value {
-    fn default() -> Self {
-        Value::Missing
-    }
-}
-
 impl Value {
     pub fn from_ion(ion: &str) -> Self {
         ion::parse_ion(ion)
@@ -635,12 +631,12 @@ impl Debug for Value {
         match self {
             Value::Null => write!(f, "NULL"),
             Value::Missing => write!(f, "MISSING"),
-            Value::Boolean(b) => write!(f, "{}", b),
-            Value::Integer(i) => write!(f, "{}", i),
+            Value::Boolean(b) => write!(f, "{b}"),
+            Value::Integer(i) => write!(f, "{i}"),
             Value::Real(r) => write!(f, "{}", r.0),
-            Value::Decimal(d) => write!(f, "{}", d),
-            Value::String(s) => write!(f, "'{}'", s),
-            Value::Blob(s) => write!(f, "'{:?}'", s),
+            Value::Decimal(d) => write!(f, "{d}"),
+            Value::String(s) => write!(f, "'{s}'"),
+            Value::Blob(s) => write!(f, "'{s:?}'"),
             Value::List(l) => l.fmt(f),
             Value::Bag(b) => b.fmt(f),
             Value::Tuple(t) => t.fmt(f),
@@ -1109,9 +1105,9 @@ impl Debug for Bag {
         let mut iter = self.iter().peekable();
         while let Some(v) = iter.next() {
             if iter.peek().is_some() {
-                write!(f, "{:?}, ", v)?;
+                write!(f, "{v:?}, ")?;
             } else {
-                write!(f, "{:?}", v)?;
+                write!(f, "{v:?}")?;
             }
         }
         write!(f, ">>")
@@ -1304,8 +1300,8 @@ impl Iterator for Tuple {
 
 impl PartialEq for Tuple {
     fn eq(&self, other: &Self) -> bool {
-        let s1: HashSet<(&str, &Value)> = self.pairs().into_iter().collect();
-        let s2: HashSet<(&str, &Value)> = other.pairs().into_iter().collect();
+        let s1: HashSet<(&str, &Value)> = self.pairs().collect();
+        let s2: HashSet<(&str, &Value)> = other.pairs().collect();
         s1.eq(&s2)
     }
 }
@@ -1328,12 +1324,12 @@ impl Hash for Tuple {
 impl Debug for Tuple {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "{{")?;
-        let mut iter = self.pairs().into_iter().peekable();
+        let mut iter = self.pairs().peekable();
         while let Some((k, v)) = iter.next() {
             if iter.peek().is_some() {
-                write!(f, " {}: {:?},", k, v)?;
+                write!(f, " {k}: {v:?},")?;
             } else {
-                write!(f, " {}: {:?} ", k, v)?;
+                write!(f, " {k}: {v:?} ")?;
             }
         }
         write!(f, "}}")
diff --git a/partiql/benches/bench_eval_multi_like.rs b/partiql/benches/bench_eval_multi_like.rs
@@ -233,7 +233,7 @@ fn employee_data() -> Vec<Value> {
     let combined = name1
         .iter()
         .cartesian_product(name2.iter())
-        .map(|(n1, n2)| format!("{} {}", n1, n2));
+        .map(|(n1, n2)| format!("{n1} {n2}"));
 
     // seed the rng with a known value to assure same data across runs
     let mut rng = rand::rngs::StdRng::from_seed([42; 32]);
@@ -253,7 +253,7 @@ fn employee_data() -> Vec<Value> {
             let suffix: String = (0..suffix_size)
                 .map(|_| rng.sample(chars) as char)
                 .collect();
-            let full_name = format!("{} {} {}", prefix, person, suffix);
+            let full_name = format!("{prefix} {person} {suffix}");
             partiql_tuple![("id", id), ("name", full_name)].into()
         })
         .collect_vec();

Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ pub enum Item {`
`43`	`43`	`impl fmt::Display for Item {`
`44`	`44`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`45`	`45`	`// Use Debug formatting for now`
`46`		`- write!(f, "{:?}", self)`
	`46`	`+ write!(f, "{self:?}")`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ fn parse_test_value(reader: &mut Reader, typ: IonType) -> Value {`
`60`	`60`	`// TODO ion Decimal doesn't give a lot of functionality to get at the data currently`
`61`	`61`	`// TODO and it's not clear whether we'll continue with rust decimal or switch to big decimal`
`62`	`62`	`let ion_dec = reader.read_decimal().unwrap();`
`63`		`- let ion_dec_str = format!("{}", ion_dec).replace('d', "e");`
	`63`	`+ let ion_dec_str = format!("{ion_dec}").replace('d', "e");`
`64`	`64`	`Value::Decimal(rust_decimal::Decimal::from_scientific(&ion_dec_str).unwrap())`
`65`	`65`	`}`
`66`	`66`	`IonType::Timestamp => todo!("timestamp"),`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ pub mod basic {`
`43`	`43`	`self.sensitive.insert(name.to_string(), idx);`
`44`	`44`	`e.insert(idx);`
`45`	`45`	`} else {`
`46`		`- panic!("Cannot insert duplicate binding of name {}", name)`
	`46`	`+ panic!("Cannot insert duplicate binding of name {name}")`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,8 +91,7 @@ impl EvalPlan {`
`91`	`91`	`}`
`92`	`92`	`Err(e) => Err(EvalErr {`
`93`	`93`	`errors: vec![EvaluationError::InvalidEvaluationPlan(format!(`
`94`		`- "Malformed evaluation plan detected: {:?}",`
`95`		`- e`
	`94`	`+ "Malformed evaluation plan detected: {e:?}"`
`96`	`95`	`))],`
`97`	`96`	`}),`
`98`	`97`	`}`
`@@ -1050,14 +1049,14 @@ impl EvalExpr for EvalBinOpExpr {`
`1050`	`1049`	`let lhs = if let Value::String(s) = lhs {`
`1051`	`1050`	`*s`
`1052`	`1051`	`} else {`
`1053`		`- format!("{:?}", lhs)`
	`1052`	`+ format!("{lhs:?}")`
`1054`	`1053`	`};`
`1055`	`1054`	`let rhs = if let Value::String(s) = rhs {`
`1056`	`1055`	`*s`
`1057`	`1056`	`} else {`
`1058`		`- format!("{:?}", rhs)`
	`1057`	`+ format!("{rhs:?}")`
`1059`	`1058`	`};`
`1060`		`- Value::String(Box::new(format!("{}{}", lhs, rhs)))`
	`1059`	`+ Value::String(Box::new(format!("{lhs}{rhs}")))`
`1061`	`1060`	`}`
`1062`	`1061`	`}`
`1063`	`1062`	`}`
Original file line number	Diff line number	Diff line change
`@@ -648,7 +648,7 @@ impl<'ast> Visitor<'ast> for AstToLogical {`
`648`	`648`	`// TODO intern strings`
`649`	`649`	`let as_key = match as_key {`
`650`	`650`	`name_resolver::Symbol::Known(sym) => sym.value.clone(),`
`651`		`- name_resolver::Symbol::Unknown(id) => format!("_{}", id),`
	`651`	`+ name_resolver::Symbol::Unknown(id) => format!("_{id}"),`
`652`	`652`	`};`
`653`	`653`	`self.push_value(as_key.into());`
`654`	`654`	`}`