cargo fix & fmt

Author: noituri

crates/ash_core/src/ir/ir.rs

@@ -107,7 +107,7 @@ impl<'a> IR<'a> {
                         let expr_stmt = ir::Stmt::Expression(returns, ty);
                         DesugaredAst::new((expr_stmt, span), expr.rest)
                     }
-                    None => DesugaredAst::rest(expr.rest)
+                    None => DesugaredAst::rest(expr.rest),
                 }
             }
             ty::Stmt::VariableAssign {
@@ -189,7 +189,7 @@ impl<'a> IR<'a> {
                     right,
                     ty,
                 };
-                
+
                 DesugaredAst::new(binary, rest)
             }
             ty::Expr::Literal(value) => DesugaredAst::returns(ir::Expr::Literal(value)),
@@ -278,16 +278,17 @@ impl<'a> IR<'a> {
 
     fn desugar_if_stmt(&mut self, r#if: If<ty::Expr, ty::Stmt>) -> DesugaredAst<Spanned<ir::Stmt>> {
         let mut insert_before = Vec::new();
-        let mut desugar_inner = |inner: IfInner<ty::Expr, ty::Stmt>| -> IfInner<ir::Expr, ir::Stmt> {
-            let mut condition_desugar = self.desugar_expr(inner.condition.0);
-            insert_before.append(&mut condition_desugar.rest);
-            let condition = (condition_desugar.returns.unwrap(), inner.condition.1);
-
-            IfInner {
-                condition,
-                body: self.desugar_statements(inner.body),
-            }
-        };
+        let mut desugar_inner =
+            |inner: IfInner<ty::Expr, ty::Stmt>| -> IfInner<ir::Expr, ir::Stmt> {
+                let mut condition_desugar = self.desugar_expr(inner.condition.0);
+                insert_before.append(&mut condition_desugar.rest);
+                let condition = (condition_desugar.returns.unwrap(), inner.condition.1);
+
+                IfInner {
+                    condition,
+                    body: self.desugar_statements(inner.body),
+                }
+            };
 
         let r#if = If {
             then: Box::new(desugar_inner(*r#if.then)),
@@ -303,11 +304,7 @@ impl<'a> IR<'a> {
         DesugaredAst::new((if_stmt, Span::default()), insert_before)
     }
 
-    fn desugar_if_expr(
-        &mut self,
-        r#if: If<ty::Expr, ty::Stmt>,
-        ty: Ty,
-    ) -> DesugaredAst<ir::Expr> {
+    fn desugar_if_expr(&mut self, r#if: If<ty::Expr, ty::Stmt>, ty: Ty) -> DesugaredAst<ir::Expr> {
         let mut insert_before = Vec::new();
         let (final_var_id, final_var_name) = self.init_new_var(&mut insert_before, ty.clone());
 
@@ -360,10 +357,7 @@ impl<'a> IR<'a> {
             ),
         };
 
-        insert_before.push((
-            ir::Stmt::If(r#if),
-            Span::default(),
-        ));
+        insert_before.push((ir::Stmt::If(r#if), Span::default()));
         DesugaredAst::new(
             self.new_var_read(final_var_name, ty, final_var_id),
             insert_before,
@@ -390,7 +384,7 @@ impl<'a> IR<'a> {
         let fun_ty = ir_fun.proto.0.ty.fun_return_ty();
         let span = fun.body.1.clone();
         let body = match fun.body.0 {
-            ty::Stmt::Expression(ty::Expr::Block(mut statements, _), _) => {
+            ty::Stmt::Expression(ty::Expr::Block(statements, _), _) => {
                 let statements = self.desugar_statements(statements);
                 self.desugar_fun_return_expr(statements, fun_ty.clone())
             }

crates/ash_core/src/ir/mod.rs

@@ -1,5 +1,5 @@
-pub mod ir;
 pub mod ast;
+pub mod ir;
 
+pub use ast::*;
 pub use ir::*;
-pub use ast::*;

crates/ash_core/src/parser/common.rs

@@ -43,8 +43,8 @@ pub(super) fn block_parser<'a>(
         .padded_by(just(Token::NewLine).repeated())
         .then_ignore(just(Token::RBrace))
         .map(Expr::Block)
-        // .recover_with(skip_until([Token::LBrace, Token::RBrace], |_| Expr::Block(Vec::new())))
-        // .recover_with(nested_delimiters(Token::LBrace, Token::RBrace, [], |_| Expr::Block(Vec::new())))
+    // .recover_with(skip_until([Token::LBrace, Token::RBrace], |_| Expr::Block(Vec::new())))
+    // .recover_with(nested_delimiters(Token::LBrace, Token::RBrace, [], |_| Expr::Block(Vec::new())))
 }
 
 pub(super) fn type_parser() -> impl Parser<Token, Ty, Error = Simple<Token>> {

crates/ash_core/src/parser/conditional.rs

@@ -1,7 +1,7 @@
 use crate::{core::Spanned, lexer::token::Token};
 use chumsky::prelude::*;
 
-use super::{common::block_parser, expression_parser, Expr, StmtRecursive, Stmt};
+use super::{common::block_parser, expression_parser, Expr, StmtRecursive};
 
 #[derive(Debug, Clone)]
 pub(crate) struct If<E, S> {
@@ -37,9 +37,11 @@ pub(super) fn if_parser<'a>(
     then.labelled("if")
         .then(else_if.labelled("else if").repeated())
         .then(otherwise.labelled("else").or_not())
-        .map(|((then, else_ifs), otherwise)| Expr::If(If {
-            then: Box::new(then),
-            else_ifs,
-            otherwise: otherwise.unwrap_or(Vec::new()),
-        }))
+        .map(|((then, else_ifs), otherwise)| {
+            Expr::If(If {
+                then: Box::new(then),
+                else_ifs,
+                otherwise: otherwise.unwrap_or(Vec::new()),
+            })
+        })
 }

crates/ash_core/src/parser/expr.rs

@@ -10,7 +10,8 @@ use super::{
     function::call_parser,
     literal::literal_parser,
     operator::{operator_parser, BinaryOp, UnaryOp},
-    stmt::Stmt, If,
+    stmt::Stmt,
+    If,
 };
 
 #[derive(Debug, Clone)]
@@ -39,7 +40,7 @@ impl Expr {
     pub fn block_data(self) -> Vec<Spanned<Stmt>> {
         match self {
             Self::Block(data) => data,
-            _ => unreachable!("Not block expression")
+            _ => unreachable!("Not block expression"),
         }
     }
 }
@@ -48,8 +49,7 @@ pub(super) type ExprRecursive<'a> = Recursive<'a, Token, Expr, Simple<Token>>;
 
 pub(super) fn expression_parser() -> impl Parser<Token, Expr, Error = Simple<Token>> + Clone {
     recursive(|expr| {
-        let variable = ident_parser()
-            .map(|name| Expr::Variable(next_id(), name));
+        let variable = ident_parser().map(|name| Expr::Variable(next_id(), name));
         let group = expr
             .clone()
             .delimited_by(just(Token::LParen), just(Token::RParen))

crates/ash_core/src/parser/mod.rs

@@ -1,14 +1,14 @@
+pub use conditional::*;
 pub use expr::*;
 pub use stmt::*;
-pub use conditional::*;
 
 mod annotation;
 mod common;
+pub mod conditional;
 pub(crate) mod expr;
 mod function;
 mod literal;
 pub(crate) mod operator;
 pub(crate) mod parser;
 pub(crate) mod stmt;
 mod variable;
-pub mod conditional;

crates/ash_core/src/parser/stmt.rs

@@ -11,9 +11,10 @@ use chumsky::prelude::*;
 use super::{
     annotation::annotation_parser,
     common::block_parser,
+    conditional::if_parser,
     expr::{expression_parser, Expr},
     function::{function_parser, function_proto_parser, return_parser},
-    variable::{variable_assign_parse, variable_decl_parse}, conditional::if_parser,
+    variable::{variable_assign_parse, variable_decl_parse},
 };
 
 #[derive(Debug, Clone)]
@@ -67,5 +68,7 @@ pub(super) fn statement_parser() -> impl Parser<Token, Spanned<Stmt>, Error = Si
 pub(super) fn stmt_expression_parser<'a>(
     stmt: StmtRecursive<'a>,
 ) -> impl Parser<Token, Expr, Error = Simple<Token>> + 'a {
-    if_parser(stmt.clone()).or(block_parser(stmt)).or(expression_parser())
+    if_parser(stmt.clone())
+        .or(block_parser(stmt))
+        .or(expression_parser())
 }

crates/ash_core/src/resolver/resolver.rs

@@ -197,7 +197,11 @@ impl<'a> Resolver<'a> {
             }
             Expr::Group(expr) => self.resolve_expr(expr, span),
             Expr::Block(stmts) => self.block(stmts),
-            Expr::If(If { then, else_ifs, otherwise }) => {
+            Expr::If(If {
+                then,
+                else_ifs,
+                otherwise,
+            }) => {
                 let (cond, cond_span) = &then.condition;
                 self.resolve_expr(cond, cond_span);
                 self.resolve_statements(&then.body);

crates/ash_core/src/ty/ast.rs

@@ -1,12 +1,15 @@
 use crate::{
     core::{Annotation, Id, Spanned},
-    parser::{operator::{BinaryOp, UnaryOp}, conditional::IfInner, If},
+    parser::{
+        operator::{BinaryOp, UnaryOp},
+        If,
+    },
 };
 
 use super::{
     function::{Function, ProtoFunction},
     ty::Ty,
-    Value, TypeSystem,
+    TypeSystem, Value,
 };
 
 #[derive(Debug)]

crates/ash_core/src/ty/ty.rs

@@ -11,7 +11,7 @@ pub(crate) enum Ty {
     F64,
     Void,
     Fun(Vec<Ty>, Box<Ty>),
-    DeferTyCheck(Vec<Ty>, Span)    
+    DeferTyCheck(Vec<Ty>, Span),
 }
 
 impl Default for Ty {