parsing '&mut' into pointer for, e.g. function calls

cobalt-ast/src/ops.rs

@@ -1253,6 +1253,10 @@ pub fn pre_op<'ctx>(loc: SourceSpan, (mut val, vloc): (Value<'ctx>, SourceSpan),
             _ => Err(err)
         }
         Type::Int(s, u) => match op {
+            "&mut" => {
+                val.data_type = Type::Pointer(Box::new(Type::Mut(Box::new(Type::Int(s, u)))));
+                Ok(val)
+            }
             "+" => {
                 val.data_type = Type::Int(s, u);
                 Ok(val)

cobalt-parser/src/lib.rs

@@ -1454,8 +1454,32 @@ fn expr(mode: u8, src: &str, start: usize) -> ParserReturn<Box<dyn AST>> {
             else {break}
             process(ignored, &mut src, &mut start, &mut errs);
         }
+
+        let mut cleaned_ops = Vec::with_capacity(ops.len());
+        if ops.len() > 0 {
+            let mut i=0;
+            let mut just_combined = false;
+            while i < ops.len()-1 {
+                if ops[i].1 == "&" && ops[i+1].1 == "mut" {
+                    cleaned_ops.push((ops[i].0, "&mut".to_string()));
+                    i += 2;
+                    just_combined = true;
+                } else {
+                    cleaned_ops.push(ops[i].clone());
+                    i += 1;
+                    just_combined = false;
+                }
+            }
+
+            if !just_combined {
+                cleaned_ops.push(ops[ops.len()-1].clone());
+            }
+        }
+
         let ast = process(postfix, &mut src, &mut start, &mut errs)?.0;
-        let ast = ops.into_iter().rfold(ast, |ast, (loc, op)| Box::new(PrefixAST::new((loc, op.len()).into(), op, ast)) as _);
+        // Start from the rightmost prefix operator and work left (right associative).
+        let ast = cleaned_ops.into_iter().rfold(ast, |ast, (loc, op)| Box::new(PrefixAST::new((loc, op.len()).into(), op, ast)) as _);
+
         Some((ast, (begin..start).into(), src, errs))
     }
     // TODO: Macros would be more DRY, maybe switch to them?