diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index 7ae98f3..6bcfd7f 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -8,6 +8,7 @@ on:
 
 env:
   CARGO_TERM_COLOR: always
+  RUSTFLAGS: "-Dwarnings"
 
 jobs:
   build:
@@ -15,8 +16,10 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - name: Build
       run: cargo build --verbose
     - name: Run tests
       run: cargo test --verbose
+    - name: Run Clippy
+      run: cargo clippy --all-targets --all-features
\ No newline at end of file
diff --git a/src/alter.rs b/src/alter.rs
index 7e085e5..013ee4f 100644
--- a/src/alter.rs
+++ b/src/alter.rs
@@ -34,7 +34,7 @@ pub enum IndexOption<'a> {
     Comment(SString<'a>),
 }
 
-impl<'a> Spanned for IndexOption<'a> {
+impl Spanned for IndexOption<'_> {
     fn span(&self) -> Span {
         match &self {
             IndexOption::IndexTypeBTree(v) => v.span(),
@@ -127,7 +127,7 @@ pub struct IndexCol<'a> {
     pub size: Option<(u32, Span)>,
 }
 
-impl<'a> Spanned for IndexCol<'a> {
+impl Spanned for IndexCol<'_> {
     fn span(&self) -> Span {
         self.name.join_span(&self.size)
     }
@@ -155,7 +155,7 @@ pub enum AlterColumnAction<'a> {
     },
 }
 
-impl<'a> Spanned for AlterColumnAction<'a> {
+impl Spanned for AlterColumnAction<'_> {
     fn span(&self) -> Span {
         match self {
             AlterColumnAction::SetDefault {
@@ -254,7 +254,7 @@ pub enum AlterSpecification<'a> {
     },
 }
 
-impl<'a> Spanned for AlterSpecification<'a> {
+impl Spanned for AlterSpecification<'_> {
     fn span(&self) -> Span {
         match &self {
             AlterSpecification::AddColumn {
@@ -659,7 +659,7 @@ pub struct AlterTable<'a> {
     pub alter_specifications: Vec<AlterSpecification<'a>>,
 }
 
-impl<'a> Spanned for AlterTable<'a> {
+impl Spanned for AlterTable<'_> {
     fn span(&self) -> Span {
         self.alter_span
             .join_span(&self.online)
@@ -757,7 +757,7 @@ fn parse_alter_table<'a>(
                                 Token::Ident(_, Keyword::DEFAULT) => {
                                     let drop_default_span = parser.consume().join_span(&set_span);
                                     AlterColumnAction::DropDefault {
-                                        drop_default_span: drop_default_span,
+                                        drop_default_span,
                                     }
                                 }
                                 Token::Ident(_, Keyword::NOT) => {
diff --git a/src/create.rs b/src/create.rs
index 15f7756..71c30ec 100644
--- a/src/create.rs
+++ b/src/create.rs
@@ -132,7 +132,7 @@ pub enum TableOption<'a> {
     //UNION
 }
 
-impl<'a> Spanned for TableOption<'a> {
+impl Spanned for TableOption<'_> {
     fn span(&self) -> Span {
         match &self {
             TableOption::AutoExtendSize { identifier, value } => identifier.span().join_span(value),
@@ -183,7 +183,7 @@ pub enum CreateDefinition<'a> {
     },
 }
 
-impl<'a> Spanned for CreateDefinition<'a> {
+impl Spanned for CreateDefinition<'_> {
     fn span(&self) -> Span {
         match &self {
             CreateDefinition::ColumnDefinition {
@@ -229,7 +229,7 @@ pub enum CreateOption<'a> {
     SqlSecurityDefiner(Span, Span),
     SqlSecurityUser(Span, Span),
 }
-impl<'a> Spanned for CreateOption<'a> {
+impl Spanned for CreateOption<'_> {
     fn span(&self) -> Span {
         match &self {
             CreateOption::OrReplace(v) => v.span(),
@@ -290,7 +290,7 @@ pub struct CreateTable<'a> {
     pub options: Vec<TableOption<'a>>,
 }
 
-impl<'a> Spanned for CreateTable<'a> {
+impl Spanned for CreateTable<'_> {
     fn span(&self) -> Span {
         self.create_span
             .join_span(&self.create_options)
@@ -345,7 +345,7 @@ pub struct CreateView<'a> {
     pub select: Box<Statement<'a>>,
 }
 
-impl<'a> Spanned for CreateView<'a> {
+impl Spanned for CreateView<'_> {
     fn span(&self) -> Span {
         self.create_span
             .join_span(&self.create_options)
@@ -465,7 +465,7 @@ pub enum FunctionCharacteristic<'a> {
     Comment(SString<'a>),
 }
 
-impl<'a> Spanned for FunctionCharacteristic<'a> {
+impl Spanned for FunctionCharacteristic<'_> {
     fn span(&self) -> Span {
         match &self {
             FunctionCharacteristic::LanguageSql(v) => v.span(),
@@ -554,7 +554,7 @@ pub struct CreateFunction<'a> {
     pub return_: Option<Box<Statement<'a>>>,
 }
 
-impl<'a> Spanned for CreateFunction<'a> {
+impl Spanned for CreateFunction<'_> {
     fn span(&self) -> Span {
         self.create_span
             .join_span(&self.create_options)
@@ -813,7 +813,7 @@ pub struct CreateTrigger<'a> {
     pub statement: Box<Statement<'a>>,
 }
 
-impl<'a> Spanned for CreateTrigger<'a> {
+impl Spanned for CreateTrigger<'_> {
     fn span(&self) -> Span {
         self.create_span
             .join_span(&self.create_options)
@@ -918,7 +918,7 @@ pub struct CreateTypeEnum<'a> {
     pub values: Vec<SString<'a>>,
 }
 
-impl<'a> Spanned for CreateTypeEnum<'a> {
+impl Spanned for CreateTypeEnum<'_> {
     fn span(&self) -> Span {
         self.create_span
             .join_span(&self.create_options)
@@ -996,7 +996,7 @@ pub struct CreateIndex<'a> {
     pub where_: Option<(Span, Expression<'a>)>,
 }
 
-impl<'a> Spanned for CreateIndex<'a> {
+impl Spanned for CreateIndex<'_> {
     fn span(&self) -> Span {
         self.create_span
             .join_span(&self.create_options)
diff --git a/src/data_type.rs b/src/data_type.rs
index 77d4307..5705462 100644
--- a/src/data_type.rs
+++ b/src/data_type.rs
@@ -45,7 +45,7 @@ pub enum DataTypeProperty<'a> {
     Check((Span, Box<Expression<'a>>)),
 }
 
-impl<'a> Spanned for DataTypeProperty<'a> {
+impl Spanned for DataTypeProperty<'_> {
     fn span(&self) -> Span {
         match &self {
             DataTypeProperty::Signed(v) => v.span(),
@@ -123,7 +123,7 @@ pub enum Type<'a> {
     Inet6,
 }
 
-impl<'a> OptSpanned for Type<'a> {
+impl OptSpanned for Type<'_> {
     fn opt_span(&self) -> Option<Span> {
         match &self {
             Type::Boolean => None,
@@ -176,7 +176,7 @@ pub struct DataType<'a> {
     pub properties: Vec<DataTypeProperty<'a>>,
 }
 
-impl<'a> Spanned for DataType<'a> {
+impl Spanned for DataType<'_> {
     fn span(&self) -> Span {
         self.identifier
             .join_span(&self.type_)
diff --git a/src/delete.rs b/src/delete.rs
index 0efa9f2..363dfe9 100644
--- a/src/delete.rs
+++ b/src/delete.rs
@@ -82,7 +82,7 @@ pub struct Delete<'a> {
     pub returning: Option<(Span, Vec<SelectExpr<'a>>)>,
 }
 
-impl<'a> Spanned for Delete<'a> {
+impl Spanned for Delete<'_> {
     fn span(&self) -> Span {
         self.delete_span
             .join_span(&self.flags)
diff --git a/src/drop.rs b/src/drop.rs
index 7bcd1ca..dd18731 100644
--- a/src/drop.rs
+++ b/src/drop.rs
@@ -54,7 +54,7 @@ pub struct DropTable<'a> {
     pub cascade: Option<Span>,
 }
 
-impl<'a> Spanned for DropTable<'a> {
+impl Spanned for DropTable<'_> {
     fn span(&self) -> Span {
         self.drop_span
             .join_span(&self.temporary)
@@ -95,7 +95,7 @@ pub struct DropView<'a> {
     pub views: Vec<QualifiedName<'a>>,
 }
 
-impl<'a> Spanned for DropView<'a> {
+impl Spanned for DropView<'_> {
     fn span(&self) -> Span {
         self.drop_span
             .join_span(&self.temporary)
@@ -135,7 +135,7 @@ pub struct DropDatabase<'a> {
     pub database: Identifier<'a>,
 }
 
-impl<'a> Spanned for DropDatabase<'a> {
+impl Spanned for DropDatabase<'_> {
     fn span(&self) -> Span {
         self.drop_span
             .join_span(&self.database_span)
@@ -173,7 +173,7 @@ pub struct DropEvent<'a> {
     pub event: QualifiedName<'a>,
 }
 
-impl<'a> Spanned for DropEvent<'a> {
+impl Spanned for DropEvent<'_> {
     fn span(&self) -> Span {
         self.drop_span
             .join_span(&self.event_span)
@@ -211,7 +211,7 @@ pub struct DropFunction<'a> {
     pub function: QualifiedName<'a>,
 }
 
-impl<'a> Spanned for DropFunction<'a> {
+impl Spanned for DropFunction<'_> {
     fn span(&self) -> Span {
         self.drop_span
             .join_span(&self.function_span)
@@ -249,7 +249,7 @@ pub struct DropProcedure<'a> {
     pub procedure: QualifiedName<'a>,
 }
 
-impl<'a> Spanned for DropProcedure<'a> {
+impl Spanned for DropProcedure<'_> {
     fn span(&self) -> Span {
         self.drop_span
             .join_span(&self.procedure_span)
@@ -288,7 +288,7 @@ pub struct DropServer<'a> {
     pub server: Identifier<'a>,
 }
 
-impl<'a> Spanned for DropServer<'a> {
+impl Spanned for DropServer<'_> {
     fn span(&self) -> Span {
         self.drop_span
             .join_span(&self.server_span)
@@ -326,7 +326,7 @@ pub struct DropTrigger<'a> {
     pub identifier: QualifiedName<'a>,
 }
 
-impl<'a> Spanned for DropTrigger<'a> {
+impl Spanned for DropTrigger<'_> {
     fn span(&self) -> Span {
         self.drop_span
             .join_span(&self.trigger_span)
@@ -580,7 +580,7 @@ pub struct DropIndex<'a> {
     pub on: Option<(Span, QualifiedName<'a>)>,
 }
 
-impl<'a> Spanned for DropIndex<'a> {
+impl Spanned for DropIndex<'_> {
     fn span(&self) -> Span {
         self.drop_span
             .join_span(&self.index_span)
diff --git a/src/expression.rs b/src/expression.rs
index fa4eb1c..f5b3220 100644
--- a/src/expression.rs
+++ b/src/expression.rs
@@ -279,7 +279,7 @@ pub enum IdentifierPart<'a> {
     Star(Span),
 }
 
-impl<'a> Spanned for IdentifierPart<'a> {
+impl Spanned for IdentifierPart<'_> {
     fn span(&self) -> Span {
         match &self {
             IdentifierPart::Name(v) => v.span(),
@@ -301,7 +301,7 @@ pub struct When<'a> {
     pub then: Expression<'a>,
 }
 
-impl<'a> Spanned for When<'a> {
+impl Spanned for When<'_> {
     fn span(&self) -> Span {
         self.when_span
             .join_span(&self.when)
@@ -317,7 +317,7 @@ pub struct WindowSpec<'a> {
     pub order_by: (Span, Vec<(Expression<'a>, OrderFlag)>),
 }
 
-impl<'a> Spanned for WindowSpec<'a> {
+impl Spanned for WindowSpec<'_> {
     fn span(&self) -> Span {
         self.order_by.span()
     }
@@ -449,7 +449,7 @@ pub enum Expression<'a> {
     },
 }
 
-impl<'a> Spanned for Expression<'a> {
+impl Spanned for Expression<'_> {
     fn span(&self) -> Span {
         match &self {
             Expression::Binary {
diff --git a/src/identifier.rs b/src/identifier.rs
index e4462dc..a97babd 100644
--- a/src/identifier.rs
+++ b/src/identifier.rs
@@ -24,32 +24,32 @@ pub struct Identifier<'a> {
     pub span: Span,
 }
 
-impl<'a> PartialEq for Identifier<'a> {
+impl PartialEq for Identifier<'_> {
     fn eq(&self, other: &Self) -> bool {
         self.value == other.value
     }
 }
-impl<'a> Eq for Identifier<'a> {}
+impl Eq for Identifier<'_> {}
 
-impl<'a> PartialOrd for Identifier<'a> {
+impl PartialOrd for Identifier<'_> {
     fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
         Some(self.cmp(other))
     }
 }
 
-impl<'a> Ord for Identifier<'a> {
+impl Ord for Identifier<'_> {
     fn cmp(&self, other: &Self) -> core::cmp::Ordering {
         self.value.cmp(other.value)
     }
 }
 
-impl<'a> alloc::fmt::Display for Identifier<'a> {
+impl alloc::fmt::Display for Identifier<'_> {
     fn fmt(&self, f: &mut alloc::fmt::Formatter<'_>) -> alloc::fmt::Result {
         self.value.fmt(f)
     }
 }
 
-impl<'a> Borrow<str> for Identifier<'a> {
+impl Borrow<str> for Identifier<'_> {
     fn borrow(&self) -> &str {
         self.value
     }
@@ -75,7 +75,7 @@ impl<'a> core::ops::Deref for Identifier<'a> {
     }
 }
 
-impl<'a> Spanned for Identifier<'a> {
+impl Spanned for Identifier<'_> {
     fn span(&self) -> Span {
         self.span.span()
     }
diff --git a/src/insert_replace.rs b/src/insert_replace.rs
index 29893e3..db2e48b 100644
--- a/src/insert_replace.rs
+++ b/src/insert_replace.rs
@@ -68,7 +68,7 @@ pub enum OnConflictTarget<'a> {
     None,
 }
 
-impl<'a> OptSpanned for OnConflictTarget<'a> {
+impl OptSpanned for OnConflictTarget<'_> {
     fn opt_span(&self) -> Option<Span> {
         match self {
             OnConflictTarget::Column { name } => Some(name.span()),
@@ -91,7 +91,7 @@ pub enum OnConflictAction<'a> {
     },
 }
 
-impl<'a> Spanned for OnConflictAction<'a> {
+impl Spanned for OnConflictAction<'_> {
     fn span(&self) -> Span {
         match self {
             OnConflictAction::DoNothing(span) => span.span(),
@@ -111,7 +111,7 @@ pub struct OnConflict<'a> {
     pub action: OnConflictAction<'a>,
 }
 
-impl<'a> Spanned for OnConflict<'a> {
+impl Spanned for OnConflict<'_> {
     fn span(&self) -> Span {
         self.on_conflict_span
             .join_span(&self.target)
@@ -126,7 +126,7 @@ pub struct InsertReplaceSetPair<'a> {
     pub value: Expression<'a>,
 }
 
-impl<'a> Spanned for InsertReplaceSetPair<'a> {
+impl Spanned for InsertReplaceSetPair<'_> {
     fn span(&self) -> Span {
         self.column
             .join_span(&self.equal_span)
@@ -140,7 +140,7 @@ pub struct InsertReplaceSet<'a> {
     pub pairs: Vec<InsertReplaceSetPair<'a>>,
 }
 
-impl<'a> Spanned for InsertReplaceSet<'a> {
+impl Spanned for InsertReplaceSet<'_> {
     fn span(&self) -> Span {
         self.set_span.join_span(&self.pairs)
     }
@@ -152,7 +152,7 @@ pub struct InsertReplaceOnDuplicateKeyUpdate<'a> {
     pub pairs: Vec<InsertReplaceSetPair<'a>>,
 }
 
-impl<'a> Spanned for InsertReplaceOnDuplicateKeyUpdate<'a> {
+impl Spanned for InsertReplaceOnDuplicateKeyUpdate<'_> {
     fn span(&self) -> Span {
         self.on_duplicate_key_update_span.join_span(&self.pairs)
     }
@@ -242,7 +242,7 @@ pub struct InsertReplace<'a> {
     pub returning: Option<(Span, Vec<SelectExpr<'a>>)>,
 }
 
-impl<'a> Spanned for InsertReplace<'a> {
+impl Spanned for InsertReplace<'_> {
     fn span(&self) -> Span {
         self.type_
             .join_span(&self.flags)
diff --git a/src/issue.rs b/src/issue.rs
index e4229fa..1776c7b 100644
--- a/src/issue.rs
+++ b/src/issue.rs
@@ -52,7 +52,7 @@ pub struct IssueHandle<'a, 'b> {
     issue: &'b mut Issue<'a>,
 }
 
-impl<'a, 'b> IssueHandle<'a, 'b> {
+impl IssueHandle<'_, '_> {
     pub fn frag(
         &mut self,
         message: impl Into<Cow<'static, str>>,
@@ -137,7 +137,7 @@ impl<'a> Issues<'a> {
     }
 }
 
-impl<'a> Display for Issues<'a> {
+impl Display for Issues<'_> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         if self.issues.is_empty() {
             return writeln!(f, "No issues");
diff --git a/src/lexer.rs b/src/lexer.rs
index 8b02894..7fc6dc9 100644
--- a/src/lexer.rs
+++ b/src/lexer.rs
@@ -67,7 +67,7 @@ pub(crate) enum Token<'a> {
     Eof,
 }
 
-impl<'a> Token<'a> {
+impl Token<'_> {
     pub(crate) fn name(&self) -> &'static str {
         match self {
             Token::Ampersand => "'&'",
@@ -216,7 +216,7 @@ impl<'a> Lexer<'a> {
         }
         // Data ends at EOF without NL '\' '.' [NL].
         let span = start..self.src.len();
-        return (self.s(span.clone()), span);
+        (self.s(span.clone()), span)
     }
 
     pub fn next_token(&mut self) -> (Token<'a>, Span) {
diff --git a/src/parser.rs b/src/parser.rs
index 531d087..3c53d26 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -10,7 +10,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use alloc::{borrow::Cow, fmt::Write, format, string::String, vec::Vec};
+use alloc::{borrow::Cow, format, string::String, vec::Vec};
 
 use crate::{
     issue::{IssueHandle, Issues},
@@ -75,20 +75,20 @@ pub(crate) fn decode_double_quoted_string(s: &str) -> Cow<'_, str> {
     }
 }
 
-pub(crate) struct SingleQuotedString<'a>(pub(crate) &'a str);
+// pub(crate) struct SingleQuotedString<'a>(pub(crate) &'a str);
 
-impl<'a> alloc::fmt::Display for SingleQuotedString<'a> {
-    fn fmt(&self, f: &mut alloc::fmt::Formatter<'_>) -> alloc::fmt::Result {
-        f.write_char('\'')?;
-        for c in self.0.chars() {
-            if c == '\'' {
-                f.write_char('\'')?;
-            }
-            f.write_char(c)?;
-        }
-        f.write_char('\'')
-    }
-}
+// impl alloc::fmt::Display for SingleQuotedString<'_> {
+//     fn fmt(&self, f: &mut alloc::fmt::Formatter<'_>) -> alloc::fmt::Result {
+//         f.write_char('\'')?;
+//         for c in self.0.chars() {
+//             if c == '\'' {
+//                 f.write_char('\'')?;
+//             }
+//             f.write_char(c)?;
+//         }
+//         f.write_char('\'')
+//     }
+// }
 
 impl<'a, 'b> Parser<'a, 'b> {
     pub(crate) fn new(src: &'a str, issues: &'b mut Issues<'a>, options: &'b ParseOptions) -> Self {
diff --git a/src/qualified_name.rs b/src/qualified_name.rs
index e812e30..f8fa2c1 100644
--- a/src/qualified_name.rs
+++ b/src/qualified_name.rs
@@ -12,7 +12,7 @@ pub struct QualifiedName<'a> {
     pub identifier: Identifier<'a>,
 }
 
-impl<'a> Spanned for QualifiedName<'a> {
+impl Spanned for QualifiedName<'_> {
     fn span(&self) -> Span {
         self.identifier.join_span(&self.prefix)
     }
diff --git a/src/rename.rs b/src/rename.rs
index 8fab593..b12b2c1 100644
--- a/src/rename.rs
+++ b/src/rename.rs
@@ -16,7 +16,7 @@ pub struct TableToTable<'a> {
     pub new_table: QualifiedName<'a>,
 }
 
-impl<'a> Spanned for TableToTable<'a> {
+impl Spanned for TableToTable<'_> {
     fn span(&self) -> Span {
         self.table
             .join_span(&self.to_span)
@@ -53,7 +53,7 @@ pub struct RenameTable<'a> {
     pub table_to_tables: Vec<TableToTable<'a>>,
 }
 
-impl<'a> Spanned for RenameTable<'a> {
+impl Spanned for RenameTable<'_> {
     fn span(&self) -> Span {
         self.rename_span
             .join_span(&self.table_span)
diff --git a/src/select.rs b/src/select.rs
index fa4da15..312668a 100644
--- a/src/select.rs
+++ b/src/select.rs
@@ -32,7 +32,7 @@ pub struct SelectExpr<'a> {
     pub as_: Option<Identifier<'a>>,
 }
 
-impl<'a> Spanned for SelectExpr<'a> {
+impl Spanned for SelectExpr<'_> {
     fn span(&self) -> Span {
         self.expr.join_span(&self.as_)
     }
@@ -59,7 +59,7 @@ pub enum JoinSpecification<'a> {
     Using(Vec<Identifier<'a>>, Span),
 }
 
-impl<'a> Spanned for JoinSpecification<'a> {
+impl Spanned for JoinSpecification<'_> {
     fn span(&self) -> Span {
         match &self {
             JoinSpecification::On(v, s) => s.join_span(v),
@@ -155,7 +155,7 @@ pub struct IndexHint<'a> {
     pub rparen: Span,
 }
 
-impl<'a> Spanned for IndexHint<'a> {
+impl Spanned for IndexHint<'_> {
     fn span(&self) -> Span {
         self.use_
             .span()
@@ -204,7 +204,7 @@ pub enum TableReference<'a> {
     },
 }
 
-impl<'a> Spanned for TableReference<'a> {
+impl Spanned for TableReference<'_> {
     fn span(&self) -> Span {
         match &self {
             TableReference::Table {
@@ -560,7 +560,7 @@ pub struct Locking<'a> {
     pub of: Option<(Span, Vec<Identifier<'a>>)>,
     pub wait: LockWait,
 }
-impl<'a> Spanned for Locking<'a> {
+impl Spanned for Locking<'_> {
     fn span(&self) -> Span {
         self.for_span
             .join_span(&self.strength)
@@ -638,7 +638,7 @@ pub struct Select<'a> {
     pub locking: Option<Locking<'a>>,
 }
 
-impl<'a> Spanned for Select<'a> {
+impl Spanned for Select<'_> {
     fn span(&self) -> Span {
         self.select_span
             .join_span(&self.flags)
diff --git a/src/span.rs b/src/span.rs
index 522ef05..6120ab8 100644
--- a/src/span.rs
+++ b/src/span.rs
@@ -123,13 +123,13 @@ impl<S: Spanned> Spanned for (bool, S) {
     }
 }
 
-impl<'a, S: Spanned> Spanned for (&'a str, S) {
+impl<S: Spanned> Spanned for (&str, S) {
     fn span(&self) -> Span {
         self.1.span()
     }
 }
 
-impl<'a, S: Spanned> Spanned for (alloc::borrow::Cow<'a, str>, S) {
+impl<S: Spanned> Spanned for (alloc::borrow::Cow<'_, str>, S) {
     fn span(&self) -> Span {
         self.1.span()
     }
diff --git a/src/sstring.rs b/src/sstring.rs
index 60a7790..ecbe448 100644
--- a/src/sstring.rs
+++ b/src/sstring.rs
@@ -35,7 +35,7 @@ impl<'a> SString<'a> {
     }
 }
 
-impl<'a> core::ops::Deref for SString<'a> {
+impl core::ops::Deref for SString<'_> {
     type Target = str;
 
     fn deref(&self) -> &Self::Target {
@@ -43,7 +43,7 @@ impl<'a> core::ops::Deref for SString<'a> {
     }
 }
 
-impl<'a> Spanned for SString<'a> {
+impl Spanned for SString<'_> {
     fn span(&self) -> Span {
         self.span.span()
     }
diff --git a/src/statement.rs b/src/statement.rs
index 99f7704..8561dff 100644
--- a/src/statement.rs
+++ b/src/statement.rs
@@ -43,7 +43,7 @@ pub struct Set<'a> {
     pub values: Vec<(Identifier<'a>, Expression<'a>)>,
 }
 
-impl<'a> Spanned for Set<'a> {
+impl Spanned for Set<'_> {
     fn span(&self) -> Span {
         self.set_span.join_span(&self.values)
     }
@@ -158,7 +158,7 @@ pub struct IfCondition<'a> {
     pub then: Vec<Statement<'a>>,
 }
 
-impl<'a> Spanned for IfCondition<'a> {
+impl Spanned for IfCondition<'_> {
     fn span(&self) -> Span {
         self.then_span
             .join_span(&self.elseif_span)
@@ -181,7 +181,7 @@ pub struct If<'a> {
     pub endif_span: Span,
 }
 
-impl<'a> Spanned for If<'a> {
+impl Spanned for If<'_> {
     fn span(&self) -> Span {
         self.if_span
             .join_span(&self.conditions)
@@ -245,7 +245,7 @@ pub struct Return<'a> {
     pub expr: Expression<'a>,
 }
 
-impl<'a> Spanned for Return<'a> {
+impl Spanned for Return<'_> {
     fn span(&self) -> Span {
         self.return_span.join_span(&self.expr)
     }
@@ -303,7 +303,7 @@ pub struct Signal<'a> {
     pub sets: Vec<(SignalConditionInformationName, Span, Expression<'a>)>,
 }
 
-impl<'a> Spanned for Signal<'a> {
+impl Spanned for Signal<'_> {
     fn span(&self) -> Span {
         self.signal_span
             .join_span(&self.sqlstate_span)
@@ -424,7 +424,7 @@ pub enum Statement<'a> {
     Return(Return<'a>),
 }
 
-impl<'a> Spanned for Statement<'a> {
+impl Spanned for Statement<'_> {
     fn span(&self) -> Span {
         match &self {
             Statement::CreateIndex(v) => v.span(),
@@ -540,7 +540,7 @@ pub struct WhenStatement<'a> {
     pub then: Vec<Statement<'a>>,
 }
 
-impl<'a> Spanned for WhenStatement<'a> {
+impl Spanned for WhenStatement<'_> {
     fn span(&self) -> Span {
         self.when_span
             .join_span(&self.when)
@@ -564,7 +564,7 @@ pub struct CaseStatement<'a> {
     pub end_span: Span,
 }
 
-impl<'a> Spanned for CaseStatement<'a> {
+impl Spanned for CaseStatement<'_> {
     fn span(&self) -> Span {
         self.case_span
             .join_span(&self.value)
@@ -706,7 +706,7 @@ pub struct UnionWith<'a> {
     pub union_statement: Box<Statement<'a>>,
 }
 
-impl<'a> Spanned for UnionWith<'a> {
+impl Spanned for UnionWith<'_> {
     fn span(&self) -> Span {
         self.union_span
             .join_span(&self.union_type)
@@ -727,7 +727,7 @@ pub struct Union<'a> {
     pub limit: Option<(Span, Option<Expression<'a>>, Expression<'a>)>,
 }
 
-impl<'a> Spanned for Union<'a> {
+impl Spanned for Union<'_> {
     fn span(&self) -> Span {
         self.left
             .join_span(&self.with)
@@ -745,7 +745,7 @@ pub struct Copy<'a> {
     pub stdin_span: Span,
 }
 
-impl<'a> Spanned for Copy<'a> {
+impl Spanned for Copy<'_> {
     fn span(&self) -> Span {
         self.copy_span
             .join_span(&self.table)
@@ -755,7 +755,7 @@ impl<'a> Spanned for Copy<'a> {
     }
 }
 
-impl<'a> Copy<'a> {
+impl Copy<'_> {
     fn reads_from_stdin(&self) -> bool {
         // There are COPY statements that don't read from STDIN,
         // but we don't support them in this parser - we only support FROM STDIN.
diff --git a/src/truncate.rs b/src/truncate.rs
index 6ac3f0e..9a4a3cf 100644
--- a/src/truncate.rs
+++ b/src/truncate.rs
@@ -34,7 +34,7 @@ pub struct TruncateTable<'a> {
     pub table_name: QualifiedName<'a>,
 }
 
-impl<'a> Spanned for TruncateTable<'a> {
+impl Spanned for TruncateTable<'_> {
     fn span(&self) -> Span {
         self.truncate_span
             .join_span(&self.table_span)
diff --git a/src/update.rs b/src/update.rs
index b23fcdb..a86dbb7 100644
--- a/src/update.rs
+++ b/src/update.rs
@@ -73,7 +73,7 @@ pub struct Update<'a> {
     pub where_: Option<(Expression<'a>, Span)>,
 }
 
-impl<'a> Spanned for Update<'a> {
+impl Spanned for Update<'_> {
     fn span(&self) -> Span {
         let mut set_span = None;
         for (a, b) in &self.set {
diff --git a/src/with_query.rs b/src/with_query.rs
index 2fb94ae..ce5cc20 100644
--- a/src/with_query.rs
+++ b/src/with_query.rs
@@ -22,7 +22,7 @@ pub struct WithBlock<'a> {
     pub rparen_span: Span,
 }
 
-impl<'a> Spanned for WithBlock<'a> {
+impl Spanned for WithBlock<'_> {
     fn span(&self) -> Span {
         self.identifier
             .span()
@@ -61,7 +61,7 @@ pub struct WithQuery<'a> {
     pub statement: Box<Statement<'a>>,
 }
 
-impl<'a> Spanned for WithQuery<'a> {
+impl Spanned for WithQuery<'_> {
     fn span(&self) -> Span {
         self.with_span
             .join_span(&self.with_blocks)