feat: run cargo fix --edition

iajoiner · iajoiner · commit 468d7a09e8d2 · 2025-02-20T19:00:39.000-05:00
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
@@ -3698,7 +3698,7 @@ impl fmt::Display for Statement {
                     local = if *local { " LOCAL" } else { "" },
                     path = path
                 )?;
-                if let Some(ref ff) = file_format {
+                if let Some(ff) = file_format {
                     write!(f, " STORED AS {ff}")?
                 }
                 write!(f, " {source}")
@@ -3750,7 +3750,7 @@ impl fmt::Display for Statement {
                     }
                 }
 
-                if let Some(ref parts) = partitions {
+                if let Some(parts) = partitions {
                     if !parts.is_empty() {
                         write!(f, " PARTITION ({})", display_comma_separated(parts))?;
                     }
@@ -3817,7 +3817,7 @@ impl fmt::Display for Statement {
                     "ANALYZE{}{table_name}",
                     if *has_table_keyword { " TABLE " } else { " " }
                 )?;
-                if let Some(ref parts) = partitions {
+                if let Some(parts) = partitions {
                     if !parts.is_empty() {
                         write!(f, " PARTITION ({})", display_comma_separated(parts))?;
                     }
@@ -4139,7 +4139,7 @@ impl fmt::Display for Statement {
                     overwrite = if *overwrite { "OVERWRITE " } else { "" },
                     table_name = table_name,
                 )?;
-                if let Some(ref parts) = &partitioned {
+                if let Some(parts) = &partitioned {
                     if !parts.is_empty() {
                         write!(f, " PARTITION ({})", display_comma_separated(parts))?;
                     }
diff --git a/src/keywords.rs b/src/keywords.rs
@@ -36,7 +36,7 @@ use sqlparser_derive::{Visit, VisitMut};
 /// Defines a string constant for a single keyword: `kw_def!(SELECT);`
 /// expands to `pub const SELECT = "SELECT";`
 macro_rules! kw_def {
-    ($ident:ident = $string_keyword:expr) => {
+    ($ident:ident = $string_keyword:expr_2021) => {
         pub const $ident: &'static str = $string_keyword;
     };
     ($ident:ident) => {
@@ -48,7 +48,7 @@ macro_rules! kw_def {
 /// and defines an ALL_KEYWORDS array of the defined constants.
 macro_rules! define_keywords {
     ($(
-        $ident:ident $(= $string_keyword:expr)?
+        $ident:ident $(= $string_keyword:expr_2021)?
     ),*) => {
         #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)]
         #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
@@ -50,7 +50,7 @@ pub enum ParserError {
 
 // Use `Parser::expected` instead, if possible
 macro_rules! parser_err {
-    ($MSG:expr, $loc:expr) => {
+    ($MSG:expr_2021, $loc:expr_2021) => {
         Err(ParserError::ParserError(format!("{}{}", $MSG, $loc)))
     };
 }
@@ -14727,7 +14727,7 @@ mod tests {
         use crate::test_utils::TestedDialects;
 
         macro_rules! test_parse_data_type {
-            ($dialect:expr, $input:expr, $expected_type:expr $(,)?) => {{
+            ($dialect:expr_2021, $input:expr_2021, $expected_type:expr_2021 $(,)?) => {{
                 $dialect.run_parser_method(&*$input, |parser| {
                     let data_type = parser.parse_data_type().unwrap();
                     assert_eq!($expected_type, data_type);
@@ -15045,7 +15045,7 @@ mod tests {
     fn test_parse_schema_name() {
         // The expected name should be identical as the input name, that's why I don't receive both
         macro_rules! test_parse_schema_name {
-            ($input:expr, $expected_name:expr $(,)?) => {{
+            ($input:expr_2021, $expected_name:expr_2021 $(,)?) => {{
                 all_dialects().run_parser_method(&*$input, |parser| {
                     let schema_name = parser.parse_schema_name().unwrap();
                     // Validate that the structure is the same as expected
@@ -15077,7 +15077,7 @@ mod tests {
     #[test]
     fn mysql_parse_index_table_constraint() {
         macro_rules! test_parse_table_constraint {
-            ($dialect:expr, $input:expr, $expected:expr $(,)?) => {{
+            ($dialect:expr_2021, $input:expr_2021, $expected:expr_2021 $(,)?) => {{
                 $dialect.run_parser_method(&*$input, |parser| {
                     let constraint = parser.parse_optional_table_constraint().unwrap().unwrap();
                     // Validate that the structure is the same as expected
@@ -15255,7 +15255,7 @@ mod tests {
     #[test]
     fn test_parse_multipart_identifier_negative() {
         macro_rules! test_parse_multipart_identifier_error {
-            ($input:expr, $expected_err:expr $(,)?) => {{
+            ($input:expr_2021, $expected_err:expr_2021 $(,)?) => {{
                 all_dialects().run_parser_method(&*$input, |parser| {
                     let actual_err = parser.parse_multipart_identifier().unwrap_err();
                     assert_eq!(actual_err.to_string(), $expected_err);
diff --git a/src/test_utils.rs b/src/test_utils.rs
@@ -302,11 +302,11 @@ pub fn assert_eq_vec<T: ToString>(expected: &[&str], actual: &[T]) {
 
 pub fn only<T>(v: impl IntoIterator<Item = T>) -> T {
     let mut iter = v.into_iter();
-    if let (Some(item), None) = (iter.next(), iter.next()) {
+    match (iter.next(), iter.next()) { (Some(item), None) => {
         item
-    } else {
+    } _ => {
         panic!("only called on collection without exactly one item")
-    }
+    }}
 }
 
 pub fn expr_from_projection(item: &SelectItem) -> &Expr {
diff --git a/src/tokenizer.rs b/src/tokenizer.rs
@@ -281,26 +281,26 @@ impl fmt::Display for Token {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             Token::EOF => f.write_str("EOF"),
-            Token::Word(ref w) => write!(f, "{w}"),
-            Token::Number(ref n, l) => write!(f, "{}{long}", n, long = if *l { "L" } else { "" }),
-            Token::Char(ref c) => write!(f, "{c}"),
-            Token::SingleQuotedString(ref s) => write!(f, "'{s}'"),
-            Token::TripleSingleQuotedString(ref s) => write!(f, "'''{s}'''"),
-            Token::DoubleQuotedString(ref s) => write!(f, "\"{s}\""),
-            Token::TripleDoubleQuotedString(ref s) => write!(f, "\"\"\"{s}\"\"\""),
-            Token::DollarQuotedString(ref s) => write!(f, "{s}"),
-            Token::NationalStringLiteral(ref s) => write!(f, "N'{s}'"),
-            Token::EscapedStringLiteral(ref s) => write!(f, "E'{s}'"),
-            Token::UnicodeStringLiteral(ref s) => write!(f, "U&'{s}'"),
-            Token::HexStringLiteral(ref s) => write!(f, "X'{s}'"),
-            Token::SingleQuotedByteStringLiteral(ref s) => write!(f, "B'{s}'"),
-            Token::TripleSingleQuotedByteStringLiteral(ref s) => write!(f, "B'''{s}'''"),
-            Token::DoubleQuotedByteStringLiteral(ref s) => write!(f, "B\"{s}\""),
-            Token::TripleDoubleQuotedByteStringLiteral(ref s) => write!(f, "B\"\"\"{s}\"\"\""),
-            Token::SingleQuotedRawStringLiteral(ref s) => write!(f, "R'{s}'"),
-            Token::DoubleQuotedRawStringLiteral(ref s) => write!(f, "R\"{s}\""),
-            Token::TripleSingleQuotedRawStringLiteral(ref s) => write!(f, "R'''{s}'''"),
-            Token::TripleDoubleQuotedRawStringLiteral(ref s) => write!(f, "R\"\"\"{s}\"\"\""),
+            Token::Word(w) => write!(f, "{w}"),
+            Token::Number(n, l) => write!(f, "{}{long}", n, long = if *l { "L" } else { "" }),
+            Token::Char(c) => write!(f, "{c}"),
+            Token::SingleQuotedString(s) => write!(f, "'{s}'"),
+            Token::TripleSingleQuotedString(s) => write!(f, "'''{s}'''"),
+            Token::DoubleQuotedString(s) => write!(f, "\"{s}\""),
+            Token::TripleDoubleQuotedString(s) => write!(f, "\"\"\"{s}\"\"\""),
+            Token::DollarQuotedString(s) => write!(f, "{s}"),
+            Token::NationalStringLiteral(s) => write!(f, "N'{s}'"),
+            Token::EscapedStringLiteral(s) => write!(f, "E'{s}'"),
+            Token::UnicodeStringLiteral(s) => write!(f, "U&'{s}'"),
+            Token::HexStringLiteral(s) => write!(f, "X'{s}'"),
+            Token::SingleQuotedByteStringLiteral(s) => write!(f, "B'{s}'"),
+            Token::TripleSingleQuotedByteStringLiteral(s) => write!(f, "B'''{s}'''"),
+            Token::DoubleQuotedByteStringLiteral(s) => write!(f, "B\"{s}\""),
+            Token::TripleDoubleQuotedByteStringLiteral(s) => write!(f, "B\"\"\"{s}\"\"\""),
+            Token::SingleQuotedRawStringLiteral(s) => write!(f, "R'{s}'"),
+            Token::DoubleQuotedRawStringLiteral(s) => write!(f, "R\"{s}\""),
+            Token::TripleSingleQuotedRawStringLiteral(s) => write!(f, "R'''{s}'''"),
+            Token::TripleDoubleQuotedRawStringLiteral(s) => write!(f, "R\"\"\"{s}\"\"\""),
             Token::Comma => f.write_str(","),
             Token::Whitespace(ws) => write!(f, "{ws}"),
             Token::DoubleEq => f.write_str("=="),
@@ -368,7 +368,7 @@ impl fmt::Display for Token {
             Token::TildeEqual => f.write_str("~="),
             Token::ShiftLeftVerticalBar => f.write_str("<<|"),
             Token::VerticalBarShiftRight => f.write_str("|>>"),
-            Token::Placeholder(ref s) => write!(f, "{s}"),
+            Token::Placeholder(s) => write!(f, "{s}"),
             Token::Arrow => write!(f, "->"),
             Token::LongArrow => write!(f, "->>"),
             Token::HashArrow => write!(f, "#>"),
diff --git a/tests/sqlparser_clickhouse.rs b/tests/sqlparser_clickhouse.rs
@@ -994,7 +994,7 @@ fn parse_select_parametric_function() {
             match &projection[0] {
                 UnnamedExpr(Expr::Function(f)) => {
                     let args = match &f.args {
-                        FunctionArguments::List(ref args) => args,
+                        FunctionArguments::List(args) => args,
                         _ => unreachable!(),
                     };
                     assert_eq!(args.args.len(), 2);
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
@@ -1123,9 +1123,9 @@ fn parse_column_aliases() {
     let select = verified_only_select(sql);
     if let SelectItem::ExprWithAlias {
         expr: Expr::BinaryOp {
-            ref op, ref right, ..
+            op, right, ..
         },
-        ref alias,
+        alias,
     } = only(&select.projection)
     {
         assert_eq!(&BinaryOperator::Plus, op);
@@ -3280,17 +3280,16 @@ fn test_double_value() {
 
     for (input, expected) in test_cases {
         for (i, expr) in input.iter().enumerate() {
-            if let Statement::Query(query) =
-                dialects.one_statement_parses_to(&format!("SELECT {}", expr), "")
-            {
+            match dialects.one_statement_parses_to(&format!("SELECT {}", expr), "")
+            { Statement::Query(query) => {
                 if let SetExpr::Select(select) = *query.body {
                     assert_eq!(expected[i], select.projection[0]);
                 } else {
                     panic!("Expected a SELECT statement");
                 }
-            } else {
+            } _ => {
                 panic!("Expected a SELECT statement");
-            }
+            }}
         }
     }
 }
@@ -7071,7 +7070,7 @@ fn parse_ctes() {
     let sql = &format!("SELECT ({with})");
     let select = verified_only_select(sql);
     match expr_from_projection(only(&select.projection)) {
-        Expr::Subquery(ref subquery) => {
+        Expr::Subquery(subquery) => {
             assert_ctes_in_select(&cte_sqls, subquery.as_ref());
         }
         _ => panic!("Expected: subquery"),
diff --git a/tests/sqlparser_regression.rs b/tests/sqlparser_regression.rs
@@ -21,7 +21,7 @@ use sqlparser::dialect::GenericDialect;
 use sqlparser::parser::Parser;
 
 macro_rules! tpch_tests {
-    ($($name:ident: $value:expr,)*) => {
+    ($($name:ident: $value:expr_2021,)*) => {
         const QUERIES: &[&str] = &[
             $(include_str!(concat!("queries/tpch/", $value, ".sql"))),*
         ];
diff --git a/tests/test_utils/mod.rs b/tests/test_utils/mod.rs
@@ -30,7 +30,7 @@ pub use sqlparser::test_utils::*;
 
 #[macro_export]
 macro_rules! nest {
-    ($base:expr $(, $join:expr)*) => {
+    ($base:expr_2021 $(, $join:expr_2021)*) => {
         TableFactor::NestedJoin { table_with_joins: Box::new(TableWithJoins {
             relation: $base,
             joins: vec![$(join($join)),*]

Original file line number	Diff line number	Diff line change
`@@ -3698,7 +3698,7 @@ impl fmt::Display for Statement {`
`3698`	`3698`	`local = if *local { " LOCAL" } else { "" },`
`3699`	`3699`	`path = path`
`3700`	`3700`	`)?;`
`3701`		`- if let Some(ref ff) = file_format {`
	`3701`	`+ if let Some(ff) = file_format {`
`3702`	`3702`	`write!(f, " STORED AS {ff}")?`
`3703`	`3703`	`}`
`3704`	`3704`	`write!(f, " {source}")`
`@@ -3750,7 +3750,7 @@ impl fmt::Display for Statement {`
`3750`	`3750`	`}`
`3751`	`3751`	`}`
`3752`	`3752`
`3753`		`- if let Some(ref parts) = partitions {`
	`3753`	`+ if let Some(parts) = partitions {`
`3754`	`3754`	`if !parts.is_empty() {`
`3755`	`3755`	`write!(f, " PARTITION ({})", display_comma_separated(parts))?;`
`3756`	`3756`	`}`
`@@ -3817,7 +3817,7 @@ impl fmt::Display for Statement {`
`3817`	`3817`	`"ANALYZE{}{table_name}",`
`3818`	`3818`	`if *has_table_keyword { " TABLE " } else { " " }`
`3819`	`3819`	`)?;`
`3820`		`- if let Some(ref parts) = partitions {`
	`3820`	`+ if let Some(parts) = partitions {`
`3821`	`3821`	`if !parts.is_empty() {`
`3822`	`3822`	`write!(f, " PARTITION ({})", display_comma_separated(parts))?;`
`3823`	`3823`	`}`
`@@ -4139,7 +4139,7 @@ impl fmt::Display for Statement {`
`4139`	`4139`	`overwrite = if *overwrite { "OVERWRITE " } else { "" },`
`4140`	`4140`	`table_name = table_name,`
`4141`	`4141`	`)?;`
`4142`		`- if let Some(ref parts) = &partitioned {`
	`4142`	`+ if let Some(parts) = &partitioned {`
`4143`	`4143`	`if !parts.is_empty() {`
`4144`	`4144`	`write!(f, " PARTITION ({})", display_comma_separated(parts))?;`
`4145`	`4145`	`}`