ast: Remove mutability from VarDeclaration

ast/src/lib.rs

@@ -189,7 +189,6 @@ pub enum Node {
         else_block: Option<Box<Ast>>,
     },
     VarDeclaration {
-        mutable: bool,
         to_declare: Symbol,
         value: Box<Ast>,
     },
@@ -409,19 +408,14 @@ pub trait Visitor {
     fn visit_var_declaration(
         &mut self,
         location: SpanTuple,
-        mutable: bool,
         to_declare: Symbol,
         value: Box<Ast>,
     ) -> Result<Ast, Error> {
         let value = self.boxed(value)?;
 
         Ok(Ast {
             location,
-            node: Node::VarDeclaration {
-                mutable,
-                to_declare,
-                value,
-            },
+            node: Node::VarDeclaration { to_declare, value },
         })
     }
 
@@ -503,11 +497,9 @@ pub trait Visitor {
                 if_block,
                 else_block,
             } => self.visit_if_else(ast.location, if_condition, if_block, else_block),
-            Node::VarDeclaration {
-                mutable,
-                to_declare,
-                value,
-            } => self.visit_var_declaration(ast.location, mutable, to_declare, value),
+            Node::VarDeclaration { to_declare, value } => {
+                self.visit_var_declaration(ast.location, to_declare, value)
+            }
             Node::VarAssign { to_assign, value } => {
                 self.visit_var_assign(ast.location, to_assign, value)
             }

flatten/src/lib.rs

@@ -768,7 +768,6 @@ impl<'ast> Ctx<'ast> {
     fn visit_var_declaration(
         self,
         ast: AstInfo<'ast>,
-        _mutable: bool,
         _to_declare: &Symbol,
         value: &'ast Ast,
     ) -> (Ctx<'ast>, RefIdx) {
@@ -900,11 +899,9 @@ impl<'ast> Ctx<'ast> {
                 if_block,
                 else_block,
             } => self.visit_if_else(node, if_condition, if_block, else_block),
-            AstNode::VarDeclaration {
-                mutable,
-                to_declare,
-                value,
-            } => self.visit_var_declaration(node, *mutable, to_declare, value),
+            AstNode::VarDeclaration { to_declare, value } => {
+                self.visit_var_declaration(node, to_declare, value)
+            }
             AstNode::VarAssign { to_assign, value } => {
                 self.visit_var_assign(node, to_assign, value)
             }
@@ -1013,7 +1010,7 @@ mod tests {
     fn where_expr() {
         let ast = ast! {
             where x = 15;
-            where mut y = x;
+            where y = x;
         };
 
         let fir = ast.flatten();

loop_desugar/src/lib.rs

@@ -86,7 +86,6 @@ fn var_declare<S: Into<Symbol>>(loc: &SpanTuple, to_declare: S, value: Box<Ast>)
     Ast {
         location: loc.clone(),
         node: Node::VarDeclaration {
-            mutable: false,
             to_declare: to_declare.into(),
             value,
         },

xparser/src/constructs.rs

@@ -229,7 +229,6 @@ fn method_or_field(
 ///
 ///      | 'type' type_id '(' named_args
 ///      | 'incl' spaced_identifier [ 'as' next IDENTIFIER ]
-///      | 'mut' spaced_identifier '=' expr (* mutable variable assigment *)
 ///      | '@' spaced_identifier '(' args
 ///
 ///      | 'extern' 'func' function_declaration ';'
@@ -617,19 +616,16 @@ fn unit_type_decl(input: ParseInput, start_loc: Location) -> ParseResult<ParseIn
     ))
 }
 
-/// mut? [`spaced_identifier`] '=' expr
+/// [`spaced_identifier`] '=' expr
 fn unit_var_decl(input: ParseInput) -> ParseResult<ParseInput, Ast> {
     let input = next(input);
-    let (input, mutable) = opt(tokens::mut_tok)(input)?;
-    let mutable = mutable.is_some();
 
     let (input, (symbol, (start_loc, _))) = spaced_identifier(input)?;
     let (input, _) = tokens::equal(input)?;
     let (input, value) = expr(input)?;
     let (input, end_loc) = position(input)?;
 
     let assignment = Node::VarDeclaration {
-        mutable,
         to_declare: Symbol::from(symbol),
         value: Box::new(value),
     };

xparser/src/tokens.rs

@@ -148,10 +148,6 @@ pub fn in_tok(input: ParseInput) -> ParseResult<ParseInput, ParseInput> {
     specific_token(input, "in")
 }
 
-pub fn mut_tok(input: ParseInput) -> ParseResult<ParseInput, ParseInput> {
-    specific_token(input, "mut")
-}
-
 pub fn if_tok(input: ParseInput) -> ParseResult<ParseInput, ParseInput> {
     specific_token(input, "if")
 }