From bf8baa7cd48187bc26b3592c0c688b865b3e71d2 Mon Sep 17 00:00:00 2001
From: sofia <sofia@teascade.net>
Date: Sun, 13 Jul 2025 18:02:27 +0300
Subject: [PATCH] Add parsing for setting indexed values

---
 reid/examples/reid/array.reid |  4 ++-
 reid/src/ast/mod.rs           |  8 ++++-
 reid/src/ast/parse.rs         | 65 ++++++++++++++++++++++++-----------
 reid/src/ast/process.rs       |  2 +-
 4 files changed, 55 insertions(+), 24 deletions(-)

diff --git a/reid/examples/reid/array.reid b/reid/examples/reid/array.reid
index 54b5a07..4fd1cb9 100644
--- a/reid/examples/reid/array.reid
+++ b/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];
 }
diff --git a/reid/src/ast/mod.rs b/reid/src/ast/mod.rs
index 1cb6e56..ddc1096 100644
--- a/reid/src/ast/mod.rs
+++ b/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,
     },
diff --git a/reid/src/ast/parse.rs b/reid/src/ast/parse.rs
index 1f8c3a6..54901ef 100644
--- a/reid/src/ast/parse.rs
+++ b/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() {
-            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)")?);
-            }
+        while let Ok(ValueIndex(idx)) = stream.parse() {
+            expr = Expression(
+                ExpressionKind::Index(Box::new(expr), idx),
+                stream.get_range().unwrap(),
+            );
         }
 
         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() {
-            stream.expect(Token::Equals)?;
-            let expr = stream.parse()?;
-            stream.expect(Token::Semi)?;
-            Ok(Self(ident, expr, stream.get_range().unwrap()))
-        } else {
-            Err(stream.expected_err("identifier")?)?
-        }
+        let var_ref = stream.parse()?;
+        stream.expect(Token::Equals)?;
+        let expr = stream.parse()?;
+        stream.expect(Token::Semi)?;
+        Ok(SetStatement(var_ref, expr, stream.get_range().unwrap()))
     }
 }
 
diff --git a/reid/src/ast/process.rs b/reid/src/ast/process.rs
index cecc090..e2feae2 100644
--- a/reid/src/ast/process.rs
+++ b/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(),