feat: strings in compiler and VM

ZakFarmer · Oct 25, 2023 · 1b05599 · 1b05599
1 parent 770a666
commit 1b05599
Show file tree

Hide file tree

Showing 4 changed files with 64 additions and 1 deletion.
diff --git a/compiler/src/lib.rs b/compiler/src/lib.rs
@@ -3,7 +3,7 @@ use std::rc::Rc;
 use anyhow::Error;
 use opcode::Opcode;
 use parser::ast::{
-    BlockStatement, BooleanLiteral, Expression, IntegerLiteral, Literal, Node, Statement,
+    BlockStatement, BooleanLiteral, Expression, IntegerLiteral, Literal, Node, Statement, StringLiteral,
 };
 use symbol_table::SymbolTable;
 
@@ -303,6 +303,15 @@ impl Compiler {
 
                     Ok(())
                 }
+                Literal::String(StringLiteral { value, .. }) => {
+                    let string = object::Object::String(value.clone());
+
+                    let constant = self.add_constant(string);
+
+                    self.emit(opcode::Opcode::OpConst, vec![constant]);
+
+                    Ok(())
+                }
                 _ => {
                     return Err(Error::msg("compile_expression: unimplemented"));
                 }

diff --git a/compiler/tests/compiler_tests.rs b/compiler/tests/compiler_tests.rs
@@ -196,6 +196,37 @@ fn test_integer_arithmetic() -> Result<(), Error> {
     Ok(())
 }
 
+#[test]
+fn test_string_expressions() -> Result<(), Error> {
+    let tests = vec![
+        CompilerTestCase {
+            input: "\"hello\"".to_string(),
+            expected_constants: vec![Object::String("hello".to_string())],
+            expected_instructions: vec![
+                opcode::make(opcode::Opcode::OpConst, &vec![0]),
+                opcode::make(opcode::Opcode::OpPop, &vec![]),
+            ],
+        },
+        CompilerTestCase {
+            input: "\"hello\" + \"world\"".to_string(),
+            expected_constants: vec![
+                Object::String("hello".to_string()),
+                Object::String("world".to_string()),
+            ],
+            expected_instructions: vec![
+                opcode::make(opcode::Opcode::OpConst, &vec![0]),
+                opcode::make(opcode::Opcode::OpConst, &vec![1]),
+                opcode::make(opcode::Opcode::OpAdd, &vec![1]),
+                opcode::make(opcode::Opcode::OpPop, &vec![0]),
+            ]
+        }
+    ];
+
+    run_compiler_tests(tests)?;
+
+    Ok(())
+}
+
 fn run_compiler_tests(tests: Vec<CompilerTestCase>) -> Result<(), Error> {
     for test in tests {
         let mut parser = parser::Parser::new(Lexer::new(&test.input));

diff --git a/vm/src/lib.rs b/vm/src/lib.rs
@@ -107,6 +107,7 @@ impl Vm {
 
                     let result = match (&*left, &*right) {
                         (Object::Integer(l), Object::Integer(r)) => Object::Integer(l + r),
+                        (Object::String(l), Object::String(r)) => Object::String(format!("{}{}", l, r)),
                         _ => {
                             return Err(Error::msg(format!(
                                 "unsupported types for addition: {} + {}",

diff --git a/vm/tests/vm_tests.rs b/vm/tests/vm_tests.rs
@@ -249,3 +249,25 @@ fn test_global_dollar_statements() -> Result<(), Error> {
 
     Ok(())
 }
+
+#[test]
+fn test_string_expressions() -> Result<(), Error> {
+    let tests = vec![
+        VmTestCase {
+            input: r#""hello""#.to_string(),
+            expected: "hello".to_string(),
+        },
+        VmTestCase {
+            input: r#""hello" + "world""#.to_string(),
+            expected: "helloworld".to_string(),
+        },
+        VmTestCase {
+            input: r#""hello" + "world" + "!""#.to_string(),
+            expected: "helloworld!".to_string(),
+        },
+    ];
+
+    run_vm_tests(tests)?;
+
+    Ok(())
+}