supports reading variables

components/lox-compile/src/compile.rs

@@ -76,5 +76,9 @@ fn compile_expr(db: &dyn crate::Db, expr: &syntax::Expr, chunk: &mut Chunk) {
             }
         }
         syntax::Expr::Parenthesized(_) => todo!(),
+        syntax::Expr::Variable(word) => {
+            let word_str = word.as_str(db);
+            chunk.emit_byte(Code::Variable(word_str.to_string()))
+        },
     }
 }

components/lox-execute/src/vm.rs

@@ -230,6 +230,10 @@ impl VM {
                 bytecode::Code::Nil => {
                     self.push(Value::Nil);
                 },
+                bytecode::Code::Variable(name) => {
+                    let value = self.globals.get(&name).expect("variable not found");
+                    self.push(value.clone());
+                },
             }
             if let Some(step_inspect) = &mut step_inspect {
                 step_inspect(instruction, self);

components/lox-ir/src/bytecode.rs

@@ -18,7 +18,8 @@ pub enum Code {
     LessEqual,
     String(String),
     Print,
-    VarDeclaration(String), // name of the variable
+    VarDeclaration(String), 
+    Variable(String),       
     Nil,
 }
 

components/lox-ir/src/syntax.rs

@@ -25,6 +25,9 @@ pub enum Expr {
 
     // `(expr)`
     Parenthesized(Box<Expr>),
+
+    // `foo`
+    Variable(Word),
 }
 
 impl<'db> salsa::DebugWithDb<dyn crate::Db + 'db> for Expr {
@@ -53,6 +56,7 @@ impl<'db> salsa::DebugWithDb<dyn crate::Db + 'db> for Expr {
                 .finish(),
             Expr::BooleanLiteral(value) => write!(f, "BooleanLiteral({})", value),
             Expr::StringLiteral(word) => write!(f, "StringLiteral({})", word.as_str(db)),
+            Expr::Variable(word) => write!(f, "Variable({})", word.as_str(db)),
             _ => todo!(),
         }
     }

components/lox-parse/src/parser.rs

@@ -199,6 +199,8 @@ impl<'me> Parser<'me> {
             Some(Expr::BooleanLiteral(false))
         } else if self.eat(Keyword::Nil).is_some() {
             Some(Expr::NilLiteral)
+        } else if let Some((_, word)) = self.eat(Identifier) {
+            Some(Expr::Variable(word))
         } else if let Some((_, word)) = self.eat(Number) {
             Some(Expr::NumberLiteral(word))
         } else if let Some((_, word)) = self.eat(StringLiteral) {

lox_tests/var.lox

@@ -1,2 +1,3 @@
 var a = 1;
-var b;
+var b;
+print a;

lox_tests/var/bytecode

@@ -12,5 +12,9 @@ Chunk {
         VarDeclaration(
             "b",
         ),
+        Variable(
+            "a",
+        ),
+        Print,
     ],
 }

lox_tests/var/execute

@@ -24,3 +24,15 @@ execute: VarDeclaration(
 )
 stack: []
 
+execute: Variable(
+    "a",
+)
+stack: [
+    Number(
+        1.0,
+    ),
+]
+
+execute: Print
+stack: []
+

lox_tests/var/syntax

@@ -8,3 +8,6 @@ Var {
     name: "b",
     initializer: None,
 }
+Print {
+    expr: Variable(a),
+}

lox_tests/var/token

@@ -1,5 +1,5 @@
 TokenTree {
-    source text: "var a = 1;\nvar b;",
+    source text: "var a = 1;\nvar b;\nprint a;",
     tokens: [
         Alphabetic(var),
         Whitespace(' '),
@@ -14,5 +14,10 @@ TokenTree {
         Whitespace(' '),
         Alphabetic(b),
         Semicolon,
+        Whitespace('\n'),
+        Alphabetic(print),
+        Whitespace(' '),
+        Alphabetic(a),
+        Semicolon,
     ],
 }