sql_parser: clippy fix with clippy 1.85

Author: Almaz-KG

src/parser/alter/mod.rs

@@ -22,7 +22,7 @@ pub trait AlterTableStatementParser {
     ) -> Result<AlterTableStatement, ParsingError>;
 }
 
-impl<'a> AlterTableStatementParser for Parser<'a> {
+impl AlterTableStatementParser for Parser<'_> {
     fn parse_alter_table_statement(&mut self) -> Result<AlterTableStatement, ParsingError> {
         self.consume_as_keyword(Keyword::Alter)?;
         self.consume_as_keyword(Keyword::Table)?;
@@ -488,7 +488,7 @@ mod add_column_with_constraints_tests {
             }
         }
 
-        let fk_actions = vec![
+        let fk_actions = [
             FKAction::SetDefault,
             FKAction::SetNull,
             FKAction::Cascade,
@@ -574,7 +574,7 @@ mod add_column_with_constraints_tests {
 
     #[test]
     fn add_column_with_deferrable_clause() {
-        let deferrable_types = vec![
+        let deferrable_types = [
             FKDeferrableType::Deferrable,
             FKDeferrableType::InitiallyDeferred,
             FKDeferrableType::InitiallyImmediate,

src/parser/column/mod.rs

@@ -34,7 +34,7 @@ pub trait ColumnDefinitionParser {
     fn parse_fk_deferrable_type(&mut self) -> Result<Option<FKDeferrableType>, ParsingError>;
 }
 
-impl<'a> ColumnDefinitionParser for Parser<'a> {
+impl ColumnDefinitionParser for Parser<'_> {
     fn parse_column_definition(&mut self) -> Result<ColumnDefinition, ParsingError> {
         let column_name = self.parse_identifier()?;
 

src/parser/create/create_index.rs

@@ -13,7 +13,7 @@ pub trait CreateIndexStatementParser {
     ) -> Result<CreateIndexStatement, ParsingError>;
 }
 
-impl<'a> CreateIndexStatementParser for Parser<'a> {
+impl CreateIndexStatementParser for Parser<'_> {
     fn parse_create_index_statement(
         &mut self,
         unique: bool,

src/parser/create/create_table.rs

@@ -29,7 +29,7 @@ pub trait CreateTableStatementParser {
     fn parse_table_options(&mut self) -> Result<Vec<TableOption>, ParsingError>;
 }
 
-impl<'a> CreateTableStatementParser for Parser<'a> {
+impl CreateTableStatementParser for Parser<'_> {
     fn parse_create_table_statement(
         &mut self,
         is_temporary: bool,
@@ -373,10 +373,7 @@ mod create_table_tests {
                 });
 
             run_sunny_day_test(
-                &format!(
-                    "CREATE TABLE table_name (column_name1 INTEGER) {}",
-                    option.to_string()
-                ),
+                &format!("CREATE TABLE table_name (column_name1 INTEGER) {}", option),
                 Statement::CreateTable(expected_stmt.clone()),
             );
         }

src/parser/create/create_trigger.rs

@@ -24,7 +24,7 @@ pub trait CreateTriggerStatementParser {
     fn parse_when_clause(&mut self) -> Result<Option<Expression>, ParsingError>;
 }
 
-impl<'a> CreateTriggerStatementParser for Parser<'a> {
+impl CreateTriggerStatementParser for Parser<'_> {
     fn parse_create_trigger_statement(
         &mut self,
         is_temporary: bool,
@@ -212,7 +212,7 @@ mod create_trigger_tests {
 
         for temp_keyword in temp_keywords {
             run_sunny_day_test(
-                &format!("CREATE {} TRIGGER trigger_name DELETE ON table_name BEGIN SELECT * FROM table_name; END;", temp_keyword.to_string()),
+                &format!("CREATE {} TRIGGER trigger_name DELETE ON table_name BEGIN SELECT * FROM table_name; END;", temp_keyword),
                 Statement::CreateTrigger(expected.clone()),
             );
         }
@@ -256,7 +256,7 @@ mod create_trigger_tests {
             run_sunny_day_test(
                 &format!(
                     "CREATE TRIGGER trigger_name {} DELETE ON table_name BEGIN SELECT * FROM table_name; END;",
-                    trigger_pre_condition.to_string()
+                    trigger_pre_condition
                 ),
                 Statement::CreateTrigger(expected),
             );
@@ -316,7 +316,7 @@ mod create_trigger_tests {
 
             let query = format!(
                 "CREATE TRIGGER trigger_name {} ON table_name BEGIN SELECT * FROM table_name; END;",
-                trigger_event_type.to_string()
+                trigger_event_type
             );
             run_sunny_day_test(&query, Statement::CreateTrigger(expected));
         }

src/parser/create/create_view.rs

@@ -12,7 +12,7 @@ pub trait CreateViewStatementParser {
     ) -> Result<CreateViewStatement, ParsingError>;
 }
 
-impl<'a> CreateViewStatementParser for Parser<'a> {
+impl CreateViewStatementParser for Parser<'_> {
     fn parse_create_view_statement(
         &mut self,
         is_temporary: bool,

src/parser/create/create_virtual_table.rs

@@ -10,7 +10,7 @@ pub trait CreateVirtualTableStatementParser {
     fn parse_module_arguments(&mut self) -> Result<Vec<String>, ParsingError>;
 }
 
-impl<'a> CreateVirtualTableStatementParser for Parser<'a> {
+impl CreateVirtualTableStatementParser for Parser<'_> {
     fn parse_create_virtual_table_statement(
         &mut self,
     ) -> Result<CreateVirtualTableStatement, ParsingError> {

src/parser/create/mod.rs

@@ -20,7 +20,7 @@ pub trait CreateStatementParser {
     fn parse_if_not_exists(&mut self) -> Result<bool, ParsingError>;
 }
 
-impl<'a> CreateStatementParser for Parser<'a> {
+impl CreateStatementParser for Parser<'_> {
     fn parse_create_statement(&mut self) -> Result<Statement, ParsingError> {
         self.consume_as_keyword(Keyword::Create)?;
 

src/parser/cte/mod.rs

@@ -15,7 +15,7 @@ pub trait CteStatementParser {
     fn parse_cte_materialized(&mut self) -> Result<Option<MaterializationType>, ParsingError>;
 }
 
-impl<'a> CteStatementParser for Parser<'a> {
+impl CteStatementParser for Parser<'_> {
     fn parse_cte_statement(&mut self) -> Result<Statement, ParsingError> {
         self.consume_as_keyword(Keyword::With)?;
 

src/parser/data_type.rs

@@ -8,7 +8,7 @@ pub trait DataTypeParser {
     fn parse_data_type(&mut self) -> Result<DataType, ParsingError>;
 }
 
-impl<'a> DataTypeParser for Parser<'a> {
+impl DataTypeParser for Parser<'_> {
     fn parse_data_type(&mut self) -> Result<DataType, ParsingError> {
         let mut names = Vec::new();
 

src/parser/delete/mod.rs

@@ -12,7 +12,7 @@ pub trait DeleteStatementParser {
     fn parse_returning_clause(&mut self) -> Result<Vec<ReturningClause>, ParsingError>;
 }
 
-impl<'a> DeleteStatementParser for Parser<'a> {
+impl DeleteStatementParser for Parser<'_> {
     fn parse_delete_statement(&mut self) -> Result<DeleteStatement, ParsingError> {
         self.consume_as_keyword(Keyword::Delete)?;
         self.consume_as_keyword(Keyword::From)?;

src/parser/drop/drop_index.rs

@@ -6,7 +6,7 @@ pub trait DropIndexStatementParser {
     fn parse_drop_index_statement(&mut self) -> Result<Statement, ParsingError>;
 }
 
-impl<'a> DropIndexStatementParser for Parser<'a> {
+impl DropIndexStatementParser for Parser<'_> {
     fn parse_drop_index_statement(&mut self) -> Result<Statement, ParsingError> {
         self.consume_as_keyword(Keyword::Index)?;
 

src/parser/drop/drop_table.rs

@@ -6,7 +6,7 @@ pub trait DropTableStatementParser {
     fn parse_drop_table_statement(&mut self) -> Result<Statement, ParsingError>;
 }
 
-impl<'a> DropTableStatementParser for Parser<'a> {
+impl DropTableStatementParser for Parser<'_> {
     fn parse_drop_table_statement(&mut self) -> Result<Statement, ParsingError> {
         self.consume_as_keyword(Keyword::Table)?;
 

src/parser/drop/drop_trigger.rs

@@ -6,7 +6,7 @@ pub trait DropTriggerStatementParser {
     fn parse_drop_trigger_statement(&mut self) -> Result<Statement, ParsingError>;
 }
 
-impl<'a> DropTriggerStatementParser for Parser<'a> {
+impl DropTriggerStatementParser for Parser<'_> {
     fn parse_drop_trigger_statement(&mut self) -> Result<Statement, ParsingError> {
         self.consume_as_keyword(Keyword::Trigger)?;
 

src/parser/drop/drop_view.rs

@@ -6,7 +6,7 @@ pub trait DropViewStatementParser {
     fn parse_drop_view_statement(&mut self) -> Result<Statement, ParsingError>;
 }
 
-impl<'a> DropViewStatementParser for Parser<'a> {
+impl DropViewStatementParser for Parser<'_> {
     fn parse_drop_view_statement(&mut self) -> Result<Statement, ParsingError> {
         self.consume_as_keyword(Keyword::View)?;
 

src/parser/drop/mod.rs

@@ -17,7 +17,7 @@ pub trait DropStatementParser {
     // fn parse_drop_statement_generic(&mut self) -> Result<(bool, Identifier), ParsingError>;
 }
 
-impl<'a> DropStatementParser for Parser<'a> {
+impl DropStatementParser for Parser<'_> {
     /// Parse DROP statement
     /// The DROP statement consists of the
     ///   - DROP TABLE statements

src/parser/explain/mod.rs

@@ -6,7 +6,7 @@ pub trait ExplainStatementParser {
     fn parse_explain_statement(&mut self) -> Result<ExplainStatement, ParsingError>;
 }
 
-impl<'a> ExplainStatementParser for Parser<'a> {
+impl ExplainStatementParser for Parser<'_> {
     fn parse_explain_statement(&mut self) -> Result<ExplainStatement, ParsingError> {
         self.consume_as_keyword(Keyword::Explain)?;
 

src/parser/expression/between_expr.rs

@@ -12,7 +12,7 @@ pub trait BetweenExpressionParser {
     ) -> Result<Expression, ParsingError>;
 }
 
-impl<'a> BetweenExpressionParser for Parser<'a> {
+impl BetweenExpressionParser for Parser<'_> {
     fn parse_between_expression(
         &mut self,
         expression: Expression,

src/parser/expression/case_expr.rs

@@ -7,7 +7,7 @@ pub trait CaseExpressionParser {
     fn parse_case_expression(&mut self) -> Result<Expression, ParsingError>;
 }
 
-impl<'a> CaseExpressionParser for Parser<'a> {
+impl CaseExpressionParser for Parser<'_> {
     fn parse_case_expression(&mut self) -> Result<Expression, ParsingError> {
         self.consume_as_keyword(Keyword::Case)?;
 

src/parser/expression/cast_expr.rs

@@ -7,7 +7,7 @@ pub trait CastExpressionParser {
     fn parse_cast_expression(&mut self) -> Result<Expression, ParsingError>;
 }
 
-impl<'a> CastExpressionParser for Parser<'a> {
+impl CastExpressionParser for Parser<'_> {
     fn parse_cast_expression(&mut self) -> Result<Expression, ParsingError> {
         self.consume_as_keyword(Keyword::Cast)?;
 

src/parser/expression/collate_expr.rs

@@ -10,7 +10,7 @@ pub trait CollateExpressionParser {
     ) -> Result<Expression, ParsingError>;
 }
 
-impl<'a> CollateExpressionParser for Parser<'a> {
+impl CollateExpressionParser for Parser<'_> {
     fn parse_collate_expression(
         &mut self,
         expression: Expression,

src/parser/expression/exists_expr.rs

@@ -6,7 +6,7 @@ pub trait ExistsExpressionParser {
     fn parse_exists_expression(&mut self, is_not: bool) -> Result<Expression, ParsingError>;
 }
 
-impl<'a> ExistsExpressionParser for Parser<'a> {
+impl ExistsExpressionParser for Parser<'_> {
     fn parse_exists_expression(&mut self, is_not: bool) -> Result<Expression, ParsingError> {
         // Consume the EXISTS keyword, if it's present. The result is ignored, because
         // the EXISTS keyword is an optional keyword

src/parser/expression/function_expr.rs

@@ -17,7 +17,7 @@ pub trait FunctionParser {
     fn parse_function_filter_clause(&mut self) -> Result<Expression, ParsingError>;
 }
 
-impl<'a> FunctionParser for Parser<'a> {
+impl FunctionParser for Parser<'_> {
     /// Parse a function
     fn parse_function(&mut self, name: Identifier) -> Result<Expression, ParsingError> {
         let mut function = Function {

src/parser/expression/in_expr.rs

@@ -15,7 +15,7 @@ pub trait InExpressionParser {
     ) -> Result<Expression, ParsingError>;
 }
 
-impl<'a> InExpressionParser for Parser<'a> {
+impl InExpressionParser for Parser<'_> {
     fn parse_in_expression(
         &mut self,
         expression: Expression,

src/parser/expression/is_expr.rs

@@ -8,7 +8,7 @@ pub trait IsExpressionParser {
     fn parse_is_expression(&mut self, expression: Expression) -> Result<Expression, ParsingError>;
 }
 
-impl<'a> IsExpressionParser for Parser<'a> {
+impl IsExpressionParser for Parser<'_> {
     fn parse_is_expression(&mut self, expression: Expression) -> Result<Expression, ParsingError> {
         self.consume_as_keyword(Keyword::Is)?;
 

src/parser/expression/like_expr.rs

@@ -13,7 +13,7 @@ pub trait LikeExpressionParser {
     ) -> Result<Expression, ParsingError>;
 }
 
-impl<'a> LikeExpressionParser for Parser<'a> {
+impl LikeExpressionParser for Parser<'_> {
     fn parse_like_expression(
         &mut self,
         expression: Expression,

src/parser/expression/mod.rs

@@ -28,7 +28,7 @@ pub trait ExpressionParser {
     fn parse_comma_separated_expressions(&mut self) -> Result<Vec<Expression>, ParsingError>;
 }
 
-impl<'a> ExpressionParser for Parser<'a> {
+impl ExpressionParser for Parser<'_> {
     /// Parse an SQLite3 [expr](https://www.sqlite.org/lang_expr.html)
     fn parse_expression(&mut self) -> Result<Expression, ParsingError> {
         let expression = self.parse_expression_pratt(0)?;

src/parser/expression/pratt_parser.rs

@@ -32,7 +32,7 @@ pub trait PrattParser {
     fn parse_not_expression(&mut self) -> Result<Expression, ParsingError>;
 }
 
-impl<'a> PrattParser for Parser<'a> {
+impl PrattParser for Parser<'_> {
     /// Parse an expression using Pratt's parsing algorithm
     fn parse_expression_pratt(&mut self, precedence: u8) -> Result<Expression, ParsingError> {
         dbg!("parse_expression_pratt");

src/parser/expression/raise_expr.rs

@@ -5,7 +5,7 @@ pub trait RaiseExpressionParser {
     fn parse_raise_expression(&mut self) -> Result<Expression, ParsingError>;
 }
 
-impl<'a> RaiseExpressionParser for Parser<'a> {
+impl RaiseExpressionParser for Parser<'_> {
     fn parse_raise_expression(&mut self) -> Result<Expression, ParsingError> {
         // Consume the RAISE keyword
         self.consume_as_keyword(Keyword::Raise)?;

src/parser/expression/regexp_match_expr.rs

@@ -13,7 +13,7 @@ pub trait RegexpMatchExpressionParser {
     ) -> Result<Expression, ParsingError>;
 }
 
-impl<'a> RegexpMatchExpressionParser for Parser<'a> {
+impl RegexpMatchExpressionParser for Parser<'_> {
     fn parse_regexp_match_expression(
         &mut self,
         expression: Expression,

src/parser/identifier.rs

@@ -6,7 +6,7 @@ pub trait IdentifierParser {
     fn parse_identifier(&mut self) -> Result<Identifier, ParsingError>;
 }
 
-impl<'a> IdentifierParser for Parser<'a> {
+impl IdentifierParser for Parser<'_> {
     /// Parse an identifier
     fn parse_identifier(&mut self) -> Result<Identifier, ParsingError> {
         let mut components = Vec::new();

src/parser/insert/mod.rs

@@ -33,7 +33,7 @@ pub trait InsertStatementParser {
     fn parse_indexed_column(&mut self) -> Result<IndexedColumn, ParsingError>;
 }
 
-impl<'a> InsertStatementParser for Parser<'a> {
+impl InsertStatementParser for Parser<'_> {
     fn parse_insert_statement(&mut self) -> Result<InsertStatement, ParsingError> {
         if self.consume_as_keyword(Keyword::Replace).is_ok() {
             return Ok(InsertStatement {
@@ -430,7 +430,7 @@ mod insert_statement_tests {
             },
         ]);
 
-        run_sunny_day_test(&sql, Statement::Insert(expected_statement));
+        run_sunny_day_test(sql, Statement::Insert(expected_statement));
     }
 
     #[test]

src/parser/mod.rs

@@ -129,7 +129,7 @@ impl<'a> Parser<'a> {
                         TokenType::SingleLineComment(_) | TokenType::MultiLineComment(_) => {
                             // Consume comment token
                             self.consume_token()?;
-                            return self.peek_token();
+                            self.peek_token()
                         }
                         _ => Ok(token.clone()),
                     }

src/parser/select/column/mod.rs

@@ -9,7 +9,7 @@ pub trait SelectColumnsParser {
     fn parse_select_column(&mut self) -> Result<SelectItem, ParsingError>;
 }
 
-impl<'a> SelectColumnsParser for Parser<'a> {
+impl SelectColumnsParser for Parser<'_> {
     fn parse_select_columns(&mut self) -> Result<Vec<SelectItem>, ParsingError> {
         let mut select_items = Vec::new();
 

src/parser/select/from/function.rs

@@ -10,7 +10,7 @@ pub trait SelectFromFunctionParser {
     ) -> Result<FromClause, ParsingError>;
 }
 
-impl<'a> SelectFromFunctionParser for Parser<'a> {
+impl SelectFromFunctionParser for Parser<'_> {
     fn parse_from_function(
         &mut self,
         function_name: Identifier,

src/parser/select/from/join.rs

@@ -15,7 +15,7 @@ pub trait SelectFromJoinParser {
     ) -> Result<Option<JoinConstraint>, ParsingError>;
 }
 
-impl<'a> SelectFromJoinParser for Parser<'a> {
+impl SelectFromJoinParser for Parser<'_> {
     fn parse_from_join_clause(&mut self, lhs: FromClause) -> Result<FromClause, ParsingError> {
         let mut join_tables = Vec::new();
 

src/parser/select/from/mod.rs

@@ -12,7 +12,7 @@ pub trait SelectFromParser {
     fn parse_from_clause(&mut self) -> Result<Option<FromClause>, ParsingError>;
 }
 
-impl<'a> SelectFromParser for Parser<'a> {
+impl SelectFromParser for Parser<'_> {
     fn parse_from_clause(&mut self) -> Result<Option<FromClause>, ParsingError> {
         if let Ok(Keyword::From) = self.peek_as_keyword() {
             self.consume_as_keyword(Keyword::From)?;