Add parsing for setting indexed values

reid/examples/reid/array.reid

@@ -7,7 +7,9 @@ fn array() -> [u16; 4] {
 fn main() -> u16 {
     let heehoo = 10;
 
-    let list = array();
+    let mut list = array();
+
+    list[1] = 5;
 
     return list[0];
 }

reid/src/ast/mod.rs

@@ -132,11 +132,17 @@ pub struct Block(
     pub TokenRange,
 );
 
+#[derive(Debug, Clone)]
+pub enum VariableReference {
+    Name(String),
+    Index(Box<VariableReference>, u64),
+}
+
 #[derive(Debug, Clone)]
 pub enum BlockLevelStatement {
     Let(LetStatement),
     /// Try to set a variable to a specified expression value
-    Set(String, Expression, TokenRange),
+    Set(VariableReference, Expression, TokenRange),
     Import {
         _i: ImportStatement,
     },

reid/src/ast/parse.rs

@@ -115,17 +115,11 @@ impl Parse for PrimaryExpression {
             Err(stream.expected_err("expression")?)?
         };
 
-        while let Some(Token::BracketOpen) = stream.peek() {
+        while let Ok(ValueIndex(idx)) = stream.parse() {
-            stream.next(); // Consume BracketOpen
-            if let Some(Token::DecimalValue(idx)) = stream.next() {
-                stream.expect(Token::BracketClose)?;
             expr = Expression(
                 ExpressionKind::Index(Box::new(expr), idx),
                 stream.get_range().unwrap(),
             );
-            } else {
-                return Err(stream.expected_err("array index (number)")?);
-            }
         }
 
         Ok(PrimaryExpression(expr))
@@ -360,7 +354,6 @@ impl Parse for Block {
                 // Special list of expressions that are simply not warned about,
                 // if semicolon is missing.
                 if !matches!(e, Expression(ExpressionKind::IfExpr(_), _)) {
-                    dbg!(r_type, &e);
                     println!("Oh no, does this statement lack ;");
                 }
 
@@ -387,6 +380,39 @@ impl Parse for Block {
     }
 }
 
+impl Parse for VariableReference {
+    fn parse(mut stream: TokenStream) -> Result<Self, Error> {
+        if let Some(Token::Identifier(ident)) = stream.next() {
+            let mut var_ref = VariableReference::Name(ident);
+
+            dbg!(&var_ref);
+            while let Ok(ValueIndex(idx)) = stream.parse() {
+                dbg!(idx);
+                var_ref = VariableReference::Index(Box::new(var_ref), idx);
+            }
+
+            Ok(var_ref)
+        } else {
+            Err(stream.expected_err("identifier")?)?
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct ValueIndex(u64);
+
+impl Parse for ValueIndex {
+    fn parse(mut stream: TokenStream) -> Result<Self, Error> {
+        stream.expect(Token::BracketOpen)?;
+        if let Some(Token::DecimalValue(idx)) = stream.next() {
+            stream.expect(Token::BracketClose)?;
+            Ok(ValueIndex(idx))
+        } else {
+            return Err(stream.expected_err("array index (number)")?);
+        }
+    }
+}
+
 impl Parse for BlockLevelStatement {
     fn parse(mut stream: TokenStream) -> Result<Self, Error> {
         use BlockLevelStatement as Stmt;
@@ -421,18 +447,15 @@ impl Parse for BlockLevelStatement {
 }
 
 #[derive(Debug)]
-pub struct SetStatement(String, Expression, TokenRange);
+pub struct SetStatement(VariableReference, Expression, TokenRange);
 
 impl Parse for SetStatement {
     fn parse(mut stream: TokenStream) -> Result<Self, Error> {
-        if let Some(Token::Identifier(ident)) = stream.next() {
+        let var_ref = stream.parse()?;
         stream.expect(Token::Equals)?;
         let expr = stream.parse()?;
         stream.expect(Token::Semi)?;
-            Ok(Self(ident, expr, stream.get_range().unwrap()))
+        Ok(SetStatement(var_ref, expr, stream.get_range().unwrap()))
-        } else {
-            Err(stream.expected_err("identifier")?)?
-        }
     }
 }
 

reid/src/ast/process.rs

@@ -79,7 +79,7 @@ impl ast::Block {
                     StmtKind::Set(
                         VariableReference(
                             mir::TypeKind::Vague(mir::VagueType::Unknown),
-                            name.clone(),
+                            todo!(), // was name.clone()
                             (*range).into(),
                         ),
                         expression.process(),