Format Source & Update Workflows to use cargo insta for testing

.github/workflows/test.yml

@@ -14,39 +14,39 @@ jobs:
       - name: Test (default features)
         run: |
           cd full-moon
-          cargo test
+          cargo insta test
       - name: Test (Luau feature)
         run: |
           cd full-moon
-          cargo test --features luau
+          cargo insta test --features luau
       - name: Test (Lua 5.2 feature)
         run: |
           cd full-moon
-          cargo test --features lua52
+          cargo insta test --features lua52
       - name: Test (Lua 5.3 feature)
         run: |
           cd full-moon
-          cargo test --features lua53
+          cargo insta test --features lua53
       - name: Test (Lua 5.4 feature)
         run: |
           cd full-moon
-          cargo test --features lua54
+          cargo insta test --features lua54
       - name: Test (LuaJIT feature)
         run: |
           cd full-moon
-          cargo test --features luajit
+          cargo insta test --features luajit
       - name: Test (CfxLua feature)
         run: |
           cd full-moon
-          cargo test --features cfxlua
+          cargo insta test --features cfxlua
       - name: Test (all features)
         run: |
           cd full-moon
-          cargo test --features luau,lua52,lua53,lua54,luajit,cfxlua
+          cargo insta test --features luau,lua52,lua53,lua54,luajit,cfxlua
       - name: Test (no default features)
         run: |
           cd full-moon
-          cargo test --no-default-features --features serde
+          cargo insta test --no-default-features --features serde
       - name: Rustfmt
         run: |
           cargo fmt -- --check

full-moon/src/ast/compound.rs

@@ -1,8 +1,8 @@
-use derive_more::Display;
-use serde::{Deserialize, Serialize};
-use full_moon_derive::{Node, Visit};
 use crate::ast::{Expression, Var};
 use crate::tokenizer::{Symbol, TokenReference};
+use derive_more::Display;
+use full_moon_derive::{Node, Visit};
+use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, Display, PartialEq, Eq, Node, Visit)]
 #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
@@ -50,42 +50,41 @@ impl CompoundOp {
 
     pub(crate) fn from_token(token: TokenReference) -> Self {
         if token.is_symbol(Symbol::PlusEqual) {
-            return Self::PlusEqual(token)
+            return Self::PlusEqual(token);
         } else if token.is_symbol(Symbol::MinusEqual) {
-            return Self::MinusEqual(token)
+            return Self::MinusEqual(token);
         } else if token.is_symbol(Symbol::StarEqual) {
-            return Self::StarEqual(token)
+            return Self::StarEqual(token);
         } else if token.is_symbol(Symbol::SlashEqual) {
-            return Self::SlashEqual(token)
+            return Self::SlashEqual(token);
         } else if token.is_symbol(Symbol::CaretEqual) {
-            return Self::CaretEqual(token)
+            return Self::CaretEqual(token);
         }
 
         #[cfg(feature = "luau")]
         if token.is_symbol(Symbol::DoubleSlashEqual) {
-            return Self::DoubleSlashEqual(token)
+            return Self::DoubleSlashEqual(token);
         } else if token.is_symbol(Symbol::PercentEqual) {
-            return Self::PercentEqual(token)
+            return Self::PercentEqual(token);
         } else if token.is_symbol(Symbol::TwoDotsEqual) {
-            return Self::TwoDotsEqual(token)
+            return Self::TwoDotsEqual(token);
         }
 
         #[cfg(feature = "cfxlua")]
         if token.is_symbol(Symbol::LeftShift) {
-            return Self::LeftShift(token)
+            return Self::LeftShift(token);
         } else if token.is_symbol(Symbol::RightShift) {
-            return Self::RightShift(token)
+            return Self::RightShift(token);
         } else if token.is_symbol(Symbol::BitwiseAndAssignment) {
-            return Self::BitwiseAndAssignment(token)
+            return Self::BitwiseAndAssignment(token);
         } else if token.is_symbol(Symbol::BitwiseOrAssignment) {
-            return Self::BitwiseOrAssignment(token)
+            return Self::BitwiseOrAssignment(token);
         }
 
         unreachable!("converting an unknown token into a compound operator")
     }
 }
 
-
 /// A Compound Assignment statement, such as `x += 1` or `x -= 1`
 #[derive(Clone, Debug, Display, PartialEq, Node, Visit)]
 #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
@@ -138,4 +137,4 @@ impl CompoundAssignment {
     pub fn with_rhs(self, rhs: Expression) -> Self {
         Self { rhs, ..self }
     }
-}
+}

full-moon/src/ast/lua54.rs

@@ -50,4 +50,4 @@ impl Attribute {
     pub fn with_brackets(self, brackets: ContainedSpan) -> Self {
         Self { brackets, ..self }
     }
-}
+}

full-moon/src/ast/parsers.rs

@@ -10,9 +10,7 @@ use super::{
 };
 
 #[cfg(any(feature = "cfxlua", feature = "luau"))]
-use super::{
-    Var
-};
+use super::Var;
 
 use crate::{
     ast,
@@ -138,7 +136,6 @@ fn parse_compound_assignment(state: &mut ParserState, var: Var) -> ParserResult<
     )))
 }
 
-
 fn parse_stmt(state: &mut ParserState) -> ParserResult<StmtVariant> {
     let Ok(current_token) = state.current() else {
         return ParserResult::NotFound;
@@ -334,19 +331,19 @@ fn parse_stmt(state: &mut ParserState) -> ParserResult<StmtVariant> {
 
                 #[cfg(feature = "cfxlua")]
                 Ok(token)
-                if state.lua_version().has_cfxlua()
-                    && (token.is_symbol(Symbol::PlusEqual)
-                    || token.is_symbol(Symbol::MinusEqual)
-                    || token.is_symbol(Symbol::StarEqual)
-                    || token.is_symbol(Symbol::SlashEqual)
-                    || token.is_symbol(Symbol::CaretEqual)
-                    || token.is_symbol(Symbol::LeftShift)
-                    || token.is_symbol(Symbol::RightShift)
-                    || token.is_symbol(Symbol::BitwiseAndAssignment)
-                    || token.is_symbol(Symbol::BitwiseOrAssignment)) =>
-                    {
-                        return parse_compound_assignment(state, var);
-                    }
+                    if state.lua_version().has_cfxlua()
+                        && (token.is_symbol(Symbol::PlusEqual)
+                            || token.is_symbol(Symbol::MinusEqual)
+                            || token.is_symbol(Symbol::StarEqual)
+                            || token.is_symbol(Symbol::SlashEqual)
+                            || token.is_symbol(Symbol::CaretEqual)
+                            || token.is_symbol(Symbol::LeftShift)
+                            || token.is_symbol(Symbol::RightShift)
+                            || token.is_symbol(Symbol::BitwiseAndAssignment)
+                            || token.is_symbol(Symbol::BitwiseOrAssignment)) =>
+                {
+                    return parse_compound_assignment(state, var);
+                }
 
                 Ok(token) if token.is_symbol(Symbol::Comma) || token.is_symbol(Symbol::Equal) => {}
 
@@ -1075,13 +1072,11 @@ fn expect_local_assignment(
     #[cfg(feature = "cfxlua")]
     let symbols = [Symbol::Equal, Symbol::In];
 
-
     local_assignment.equal_token = match state.consume_if_symbols(&symbols) {
         Some(equal_token) => Some(equal_token),
         None => return Ok(local_assignment),
     };
 
-
     match parse_expression_list(state) {
         ParserResult::Value(expr_list) => local_assignment.expr_list = expr_list,
 
@@ -1237,7 +1232,9 @@ fn force_table_constructor(
                 let dot = state.consume().unwrap();
 
                 let key = match state.current() {
-                    Ok(token) if token.token_kind() == TokenKind::Identifier => state.consume().unwrap(),
+                    Ok(token) if token.token_kind() == TokenKind::Identifier => {
+                        state.consume().unwrap()
+                    }
                     Ok(token) => {
                         state.token_error(token.clone(), "expected identifier after `.`");
                         return unfinished_table(left_brace, fields);
@@ -1580,7 +1577,10 @@ fn parse_suffix(state: &mut ParserState) -> ParserResult<ast::Suffix> {
                 Err(()) => return ParserResult::LexerMoved,
             };
 
-            ParserResult::Value(ast::Suffix::Index(ast::Index::Dot { dot: safe_navigation, name }))
+            ParserResult::Value(ast::Suffix::Index(ast::Index::Dot {
+                dot: safe_navigation,
+                name,
+            }))
         }
 
         TokenType::Symbol {

full-moon/src/ast/visitors.rs

@@ -27,10 +27,7 @@ impl Visit for Field {
             }
 
             #[cfg(feature = "cfxlua")]
-            Field::SetConstructorField {
-                dot,
-                name
-            } => {
+            Field::SetConstructorField { dot, name } => {
                 dot.visit(visitor);
                 name.visit(visitor);
             }
@@ -74,10 +71,7 @@ impl VisitMut for Field {
             }
 
             #[cfg(feature = "cfxlua")]
-            Field::SetConstructorField {
-                dot,
-                name
-            } => Field::SetConstructorField {
+            Field::SetConstructorField { dot, name } => Field::SetConstructorField {
                 dot: dot.visit_mut(visitor),
                 name: name.visit_mut(visitor),
             },

full-moon/src/tokenizer/lexer.rs

@@ -358,7 +358,7 @@ impl Lexer {
                         start_position,
                         InterpolatedStringKind::Begin,
                         InterpolatedStringKind::Simple,
-                    ))
+                    ));
                 }
 
                 let (string, recovered) = self.read_string(quote);
@@ -376,8 +376,6 @@ impl Lexer {
                 )
             }
 
-
-
             '=' => {
                 if self.source.consume('=') {
                     self.create(

full-moon/src/tokenizer/structs.rs

@@ -4,13 +4,13 @@ use crate::{
     ShortString,
 };
 
+use super::{Lexer, LexerResult};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 use std::{
     cmp::Ordering,
     fmt::{self, Display},
 };
-use super::{Lexer, LexerResult};
 
 macro_rules! symbol {
     {

full-moon/tests/cfxlua_cases/pass/each_iteration/ast.snap

@@ -639,4 +639,7 @@ stmts:
               token_type:
                 type: Whitespace
                 characters: "\r\n"
+        type_specifiers:
+          - ~
+          - ~
     - ~