return stable

SkymanOne · Jan 31, 2024 · 0efd0f1 · 0efd0f1
1 parent e918dc3
commit 0efd0f1
Show file tree

Hide file tree

Showing 5 changed files with 56 additions and 166 deletions.
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -19,8 +19,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@nightly
+      - uses: dtolnay/rust-toolchain@stable
       - uses: Swatinem/rust-cache@v2
       - run: cargo clippy --workspace --all-targets --all-features
-      - run: cargo +nightly fmt --check --all
+      - run: cargo fmt --check --all
       - run: cargo doc --workspace --no-deps
diff --git a/.rustfmt.toml b/.rustfmt.toml
diff --git a/crates/derive_node/src/lib.rs b/crates/derive_node/src/lib.rs
@@ -12,16 +12,12 @@ fn node_derive(mut s: synstructure::Structure) -> TokenStream2 {
         .add_bounds(synstructure::AddBounds::Fields)
         .underscore_const(true);
     match &s.ast().data {
-        syn::Data::Struct(_) => {
-            node_derive_struct(s).unwrap_or_else(|err| err.to_compile_error())
-        }
-        _ => {
-            syn::Error::new(
-                s.ast().span(),
-                "can only derive `Node` for Rust `struct` items",
-            )
-            .to_compile_error()
-        }
+        syn::Data::Struct(_) => node_derive_struct(s).unwrap_or_else(|err| err.to_compile_error()),
+        _ => syn::Error::new(
+            s.ast().span(),
+            "can only derive `Node` for Rust `struct` items",
+        )
+        .to_compile_error(),
     }
 }
 

diff --git a/crates/parser/src/lexer.rs b/crates/parser/src/lexer.rs
@@ -1,12 +1,6 @@
 use super::Span;
-use logos::{
-    Logos,
-    SpannedIter,
-};
-use std::{
-    fmt,
-    num::ParseIntError,
-};
+use logos::{Logos, SpannedIter};
+use std::{fmt, num::ParseIntError};
 use thiserror::Error;
 
 #[derive(Default, Clone, Debug, PartialEq)]
@@ -326,12 +320,10 @@ impl<'input> Iterator for Lexer<'input> {
     fn next(&mut self) -> Option<Self::Item> {
         if let Some((tok_res, span)) = self.token_stream.next() {
             match tok_res {
-                Ok(tok) => {
-                    match tok {
-                        Token::Comment(_) => self.next(),
-                        _ => Some((span.start, tok, span.end)),
-                    }
-                }
+                Ok(tok) => match tok {
+                    Token::Comment(_) => self.next(),
+                    _ => Some((span.start, tok, span.end)),
+                },
                 Err(err) => {
                     self.errors.push(logos_to_lexical_error(&err, &span));
                     self.next()

diff --git a/crates/parser/src/tests.rs b/crates/parser/src/tests.rs
@@ -1,36 +1,12 @@
 use crate::{
     ast::{
-        self,
-        AccessAttribute,
-        BinaryExpression,
-        Declaration,
-        Expression,
-        FuncReturnType,
-        FunctionCall,
-        FunctionDeclaration,
-        FunctionVisibility,
-        Identifier,
-        IfElse,
-        List,
-        Mapping,
-        MappingRelation,
-        Param,
-        Set,
-        Source,
-        StBlock,
-        StateDeclaration,
-        Statement,
-        StatementBlock,
-        StructInit,
-        TypeVariant,
-        UnaryExpression,
-        Variable,
+        self, AccessAttribute, BinaryExpression, Declaration, Expression, FuncReturnType,
+        FunctionCall, FunctionDeclaration, FunctionVisibility, Identifier, IfElse, List, Mapping,
+        MappingRelation, Param, Set, Source, StBlock, StateDeclaration, Statement, StatementBlock,
+        StructInit, TypeVariant, UnaryExpression, Variable,
     },
     folidity,
-    lexer::{
-        Lexer,
-        Token,
-    },
+    lexer::{Lexer, Token},
 };
 
 #[test]
@@ -279,67 +255,53 @@ fn test_factorial_tree() {
                         }),
                         else_part: Some(Box::new(Statement::Block(StatementBlock {
                             loc: 175..349,
-                            statements: vec![Statement::Return(
-                                Expression::FunctionCall(FunctionCall {
+                            statements: vec![Statement::Return(Expression::FunctionCall(
+                                FunctionCall {
                                     loc: 192..342,
                                     name: Identifier {
                                         loc: 192..201,
                                         name: "calculate".to_string(),
                                     },
                                     args: vec![Expression::Pipe(BinaryExpression {
                                         loc: 296..324,
-                                        left: Box::new(Expression::Multiply(
-                                            BinaryExpression {
-                                                loc: 296..315,
-                                                left: Box::new(Expression::Variable(
-                                                    Identifier {
-                                                        loc: 296..301,
-                                                        name: "value".to_string(),
-                                                    },
-                                                )),
-                                                right: Box::new(Expression::Subtract(
-                                                    BinaryExpression {
-                                                        loc: 305..314,
-                                                        left: Box::new(
-                                                            Expression::Variable(
-                                                                Identifier {
-                                                                    loc: 305..310,
-                                                                    name: "value"
-                                                                        .to_string(),
-                                                                },
-                                                            ),
-                                                        ),
-                                                        right: Box::new(
-                                                            Expression::Number(
-                                                                UnaryExpression {
-                                                                    loc: 313..314,
-                                                                    element: "1"
-                                                                        .to_string(),
-                                                                },
-                                                            ),
-                                                        ),
-                                                    },
-                                                )),
-                                            },
-                                        )),
-                                        right: Box::new(Expression::FunctionCall(
-                                            FunctionCall {
-                                                loc: 319..324,
-                                                name: Identifier {
-                                                    loc: 319..321,
-                                                    name: "or".to_string(),
+                                        left: Box::new(Expression::Multiply(BinaryExpression {
+                                            loc: 296..315,
+                                            left: Box::new(Expression::Variable(Identifier {
+                                                loc: 296..301,
+                                                name: "value".to_string(),
+                                            })),
+                                            right: Box::new(Expression::Subtract(
+                                                BinaryExpression {
+                                                    loc: 305..314,
+                                                    left: Box::new(Expression::Variable(
+                                                        Identifier {
+                                                            loc: 305..310,
+                                                            name: "value".to_string(),
+                                                        },
+                                                    )),
+                                                    right: Box::new(Expression::Number(
+                                                        UnaryExpression {
+                                                            loc: 313..314,
+                                                            element: "1".to_string(),
+                                                        },
+                                                    )),
                                                 },
-                                                args: vec![Expression::Number(
-                                                    UnaryExpression {
-                                                        loc: 322..323,
-                                                        element: "1".to_string(),
-                                                    },
-                                                )],
+                                            )),
+                                        })),
+                                        right: Box::new(Expression::FunctionCall(FunctionCall {
+                                            loc: 319..324,
+                                            name: Identifier {
+                                                loc: 319..321,
+                                                name: "or".to_string(),
                                             },
-                                        )),
+                                            args: vec![Expression::Number(UnaryExpression {
+                                                loc: 322..323,
+                                                element: "1".to_string(),
+                                            })],
+                                        })),
                                     })],
-                                }),
-                            )],
+                                },
+                            ))],
                         }))),
                     })],
                 }),