Satisfy warnings

src/ast/basic.rs

@@ -62,8 +62,8 @@ pub enum Separated<E, S1, S2> {
 impl<E, S1, S2> HasSpan for Separated<E, S1, S2> {
     fn span(&self) -> Span {
         match self {
-            Separated::Empty(span) => *span,
-            Separated::NonEmpty { span, .. } => *span,
+            Self::Empty(span) => *span,
+            Self::NonEmpty { span, .. } => *span,
         }
     }
 }

src/ast/call.rs

@@ -40,9 +40,9 @@ pub enum Call {
 impl HasSpan for Call {
     fn span(&self) -> Span {
         match self {
-            Call::Arg { span, .. } => *span,
-            Call::NoArg { span, .. } => *span,
-            Call::Constr { span, .. } => *span,
+            Self::Arg { span, .. } => *span,
+            Self::NoArg { span, .. } => *span,
+            Self::Constr { span, .. } => *span,
         }
     }
 }

src/ast/expr.rs

@@ -186,17 +186,17 @@ impl fmt::Debug for Expr {
 impl HasSpan for Expr {
     fn span(&self) -> Span {
         match self {
-            Expr::Lit(lit) => lit.span(),
-            Expr::Call(call) => call.span(),
-            Expr::Field(field) => field.span(),
-            Expr::Var(var) => var.span(),
-            Expr::TableConstr(constr) => constr.span(),
-            Expr::TableDestr(destr) => destr.span(),
-            Expr::FuncDef(def) => def.span(),
-            Expr::Paren { span, .. } => *span,
-            Expr::Neg { span, .. } => *span,
-            Expr::Not { span, .. } => *span,
-            Expr::BinOp { span, .. } => *span,
+            Self::Lit(lit) => lit.span(),
+            Self::Call(call) => call.span(),
+            Self::Field(field) => field.span(),
+            Self::Var(var) => var.span(),
+            Self::TableConstr(constr) => constr.span(),
+            Self::TableDestr(destr) => destr.span(),
+            Self::FuncDef(def) => def.span(),
+            Self::Paren { span, .. } => *span,
+            Self::Neg { span, .. } => *span,
+            Self::Not { span, .. } => *span,
+            Self::BinOp { span, .. } => *span,
         }
     }
 }

src/ast/field.rs

@@ -60,10 +60,10 @@ pub enum Field {
 impl HasSpan for Field {
     fn span(&self) -> Span {
         match self {
-            Field::Access { span, .. } => *span,
-            Field::Assign { span, .. } => *span,
-            Field::AccessIdent { span, .. } => *span,
-            Field::AssignIdent { span, .. } => *span,
+            Self::Access { span, .. } => *span,
+            Self::Assign { span, .. } => *span,
+            Self::AccessIdent { span, .. } => *span,
+            Self::AssignIdent { span, .. } => *span,
         }
     }
 }

src/ast/func_def.rs

@@ -90,12 +90,12 @@ pub enum FuncDef {
 impl HasSpan for FuncDef {
     fn span(&self) -> Span {
         match self {
-            FuncDef::AnonNoArg { span, .. } => *span,
-            FuncDef::AnonArg { span, .. } => *span,
-            FuncDef::AnonDestr { span, .. } => *span,
-            FuncDef::NamedNoArg { span, .. } => *span,
-            FuncDef::NamedArg { span, .. } => *span,
-            FuncDef::NamedDestr { span, .. } => *span,
+            Self::AnonNoArg { span, .. } => *span,
+            Self::AnonArg { span, .. } => *span,
+            Self::AnonDestr { span, .. } => *span,
+            Self::NamedNoArg { span, .. } => *span,
+            Self::NamedArg { span, .. } => *span,
+            Self::NamedDestr { span, .. } => *span,
         }
     }
 }

src/ast/lit.rs

@@ -119,8 +119,8 @@ pub enum TableLitElem {
 impl HasSpan for TableLitElem {
     fn span(&self) -> Span {
         match self {
-            TableLitElem::Positional(value) => value.span(),
-            TableLitElem::Named { span, .. } => *span,
+            Self::Positional(value) => value.span(),
+            Self::Named { span, .. } => *span,
         }
     }
 }
@@ -187,12 +187,12 @@ impl fmt::Debug for Lit {
 impl HasSpan for Lit {
     fn span(&self) -> Span {
         match self {
-            Lit::Nil(span) => *span,
-            Lit::Bool(_, span) => *span,
-            Lit::Builtin(_, span) => *span,
-            Lit::Num(n) => n.span(),
-            Lit::String(s) => s.span(),
-            Lit::Table(t) => t.span(),
+            Self::Nil(span) => *span,
+            Self::Bool(_, span) => *span,
+            Self::Builtin(_, span) => *span,
+            Self::Num(n) => n.span(),
+            Self::String(s) => s.span(),
+            Self::Table(t) => t.span(),
         }
     }
 }

src/ast/program.rs

@@ -25,8 +25,8 @@ pub enum Program {
 impl HasSpan for Program {
     fn span(&self) -> Span {
         match self {
-            Program::Expr { span, .. } => *span,
-            Program::Module { span, .. } => *span,
+            Self::Expr { span, .. } => *span,
+            Self::Module { span, .. } => *span,
         }
     }
 }

src/ast/table_constr.rs

@@ -24,8 +24,8 @@ pub enum TableConstrElem {
 impl HasSpan for TableConstrElem {
     fn span(&self) -> Span {
         match self {
-            TableConstrElem::Lit(lit) => lit.span(),
-            TableConstrElem::Indexed { span, .. } => *span,
+            Self::Lit(lit) => lit.span(),
+            Self::Indexed { span, .. } => *span,
         }
     }
 }

src/ast/table_destr.rs

@@ -24,8 +24,8 @@ pub enum TablePatternElem {
 impl HasSpan for TablePatternElem {
     fn span(&self) -> Span {
         match self {
-            TablePatternElem::Positional(ident) => ident.span(),
-            TablePatternElem::Named { span, .. } => *span,
+            Self::Positional(ident) => ident.span(),
+            Self::Named { span, .. } => *span,
         }
     }
 }

src/ast/var.rs

@@ -49,10 +49,10 @@ pub enum Var {
 impl HasSpan for Var {
     fn span(&self) -> Span {
         match self {
-            Var::Access { span, .. } => *span,
-            Var::Assign { span, .. } => *span,
-            Var::AccessIdent(ident) => ident.span(),
-            Var::AssignIdent { span, .. } => *span,
+            Self::Access { span, .. } => *span,
+            Self::Assign { span, .. } => *span,
+            Self::AccessIdent(ident) => ident.span(),
+            Self::AssignIdent { span, .. } => *span,
         }
     }
 }