Store constants as VM values instead of strings

This is kind of a prefactor to adding number expressions to the language

Author: kyleect

spec/valid/call_id_with_string.expr.disassembled

@@ -1,5 +1,5 @@
 VERSION 0800
 ----
 0000 GET BUILTIN         0 == 'id'
-0003 CONSTANT            0 == 'test'
+0003 CONSTANT            0 == '`test`'
 0005 CALL             (1 args)

spec/valid/eq_matching_strings.expr.disassembled

@@ -1,6 +1,6 @@
 VERSION 0800
 ----
 0000 GET BUILTIN        15 == 'eq'
-0003 CONSTANT            0 == 'foo'
-0005 CONSTANT            0 == 'foo'
+0003 CONSTANT            0 == '`foo`'
+0005 CONSTANT            0 == '`foo`'
 0007 CALL             (2 args)

spec/valid/eq_mismatching_strings.expr.disassembled

@@ -1,6 +1,6 @@
 VERSION 0800
 ----
 0000 GET BUILTIN        15 == 'eq'
-0003 CONSTANT            0 == 'foo'
-0005 CONSTANT            1 == 'bar'
+0003 CONSTANT            0 == '`foo`'
+0005 CONSTANT            1 == '`bar`'
 0007 CALL             (2 args)

spec/valid/string.expr.disassembled

@@ -1,3 +1,3 @@
 VERSION 0800
 ----
-0000 CONSTANT            0 == 'test string'
+0000 CONSTANT            0 == '`test string`'

spec/valid/type_string_empty.expr.disassembled

@@ -1,5 +1,5 @@
 VERSION 0800
 ----
 0000 GET BUILTIN        14 == 'type'
-0003 CONSTANT            0 == ''
+0003 CONSTANT            0 == '``'
 0005 CALL             (1 args)

src/compiler.rs

@@ -9,6 +9,7 @@ use crate::{
     },
     prelude::lookup::TYPE,
     types::Type,
+    value::Value,
 };
 
 pub mod opcode {
@@ -190,12 +191,12 @@ impl CompileTimeEnv {
 pub struct ExprByteCode {
     version: [u8; 4],
     codes: Vec<u8>,
-    strings: Vec<String>,
+    constants: Vec<Value>,
     types: Vec<Type>,
 }
 
 impl ExprByteCode {
-    pub fn new(codes: Vec<u8>, strings: Vec<String>, types: Vec<Type>) -> Self {
+    pub fn new(codes: Vec<u8>, constants: Vec<Value>, types: Vec<Type>) -> Self {
         let version_bytes = get_version_bytes();
         let version_bytes_from_codes = &codes[0..4];
 
@@ -209,7 +210,7 @@ impl ExprByteCode {
         Self {
             version: version_bytes,
             codes,
-            strings,
+            constants,
             types,
         }
     }
@@ -226,8 +227,8 @@ impl ExprByteCode {
         self.codes.get(index)
     }
 
-    pub fn strings(&self) -> &[String] {
-        &self.strings
+    pub fn constants(&self) -> &[Value] {
+        &self.constants
     }
 
     pub fn types(&self) -> &[Type] {
@@ -246,21 +247,21 @@ pub fn get_version_bytes() -> [u8; 4] {
 
 /// Compile an [`ast::Expr`] into [`ExprByteCode`]
 pub fn compile(expr: &mut ExprS, env: &CompileTimeEnv) -> ExprResult<ExprByteCode> {
-    let mut strings: Vec<String> = vec![];
+    let mut constants: Vec<Value> = vec![];
     let mut types: Vec<Type> = vec![];
     let mut codes = vec![];
 
     codes.extend(get_version_bytes());
 
-    codes.extend(compile_expr(expr, env, &mut strings, &mut types)?);
+    codes.extend(compile_expr(expr, env, &mut constants, &mut types)?);
 
-    Ok(ExprByteCode::new(codes, strings, types))
+    Ok(ExprByteCode::new(codes, constants, types))
 }
 
 fn compile_expr(
     (expr, span): &mut ExprS,
     env: &CompileTimeEnv,
-    strings: &mut Vec<String>,
+    constants: &mut Vec<Value>,
     types: &mut Vec<Type>,
 ) -> ExprResult<Vec<u8>> {
     use opcode::*;
@@ -272,12 +273,18 @@ fn compile_expr(
 
     match expr {
         Expr::String(string) => {
-            if let Some(index) = strings.iter().position(|x| x == &string.0) {
+            if let Some(index) = constants.iter().position(|x| {
+                if let Value::String(string_constant) = x {
+                    string_constant == &string.0
+                } else {
+                    false
+                }
+            }) {
                 codes.push(CONSTANT);
                 codes.push(index as u8);
             } else {
-                strings.push(string.0.clone());
-                let index = strings.len() - 1;
+                constants.push(Value::String(string.0.clone()));
+                let index = constants.len() - 1;
                 codes.push(CONSTANT);
                 codes.push(index as u8);
             }
@@ -356,7 +363,7 @@ fn compile_expr(
             }
         }
         Expr::Call(expr_call) => {
-            let callee_bytecode = compile_expr(&mut expr_call.callee, env, strings, types)?;
+            let callee_bytecode = compile_expr(&mut expr_call.callee, env, constants, types)?;
 
             if let Some(_op) = callee_bytecode.first()
                 && let Some(lookup) = callee_bytecode.get(1)
@@ -433,7 +440,7 @@ fn compile_expr(
             codes.extend(callee_bytecode);
 
             for arg in expr_call.args.iter_mut() {
-                match compile_expr(arg, env, strings, types) {
+                match compile_expr(arg, env, constants, types) {
                     Ok(arg_bytecode) => {
                         codes.extend(arg_bytecode);
                     }

src/disassembler.rs

@@ -95,9 +95,9 @@ impl<'bytecode, 'env> Disassembler<'bytecode, 'env> {
 
         let value = self
             .bytecode
-            .strings()
+            .constants()
             .get(constant_idx)
-            .expect("should have string at index");
+            .expect("should have value in constants at index");
 
         let string = format!("{name:16} {constant_idx:>4} == '{value}'\n");
 

src/vm.rs

@@ -195,11 +195,11 @@ impl Vm {
             .bytecode
             .as_ref()
             .expect("should have bytecode")
-            .strings()
+            .constants()
             .get(get_idx)
             .unwrap_or_else(|| panic!("undefined string: {}", get_idx));
 
-        self.stack_push(Value::String(s.clone()));
+        self.stack_push(s.clone());
 
         Ok(())
     }

tests/integration_tests.rs

@@ -236,11 +236,11 @@ mod valid {
             crate::make_test_bytecode(vec![
                 opcode::CONSTANT, 0
             ]),
-            vec!["test string".to_string()],
+            vec![Value::String("test string".to_string())],
             vec![]
         ));
 
-        disassembles to: "VERSION 0800\n----\n0000 CONSTANT            0 == 'test string'\n";
+        disassembles to: "VERSION 0800\n----\n0000 CONSTANT            0 == '`test string`'\n";
 
         runtime env: {
             ..Default::default()
@@ -391,12 +391,12 @@ mod valid {
                 opcode::CALL, 1
             ]),
             vec![
-                "test value".to_string(),
+                Value::String("test value".to_string()),
             ],
             vec![]
         ));
 
-        disassembles to: "VERSION 0800\n----\n0000 GET BUILTIN         0 == 'id'\n0003 CONSTANT            0 == 'test value'\n0005 CALL             (1 args)\n";
+        disassembles to: "VERSION 0800\n----\n0000 GET BUILTIN         0 == 'id'\n0003 CONSTANT            0 == '`test value`'\n0005 CALL             (1 args)\n";
 
         runtime env: {
             ..Default::default()
@@ -1300,13 +1300,13 @@ mod valid {
                 opcode::CALL, 3
             ]),
             vec![
-                "foo".to_string(),
-                "bar".to_string(),
+                Value::String("foo".to_string()),
+                Value::String("bar".to_string()),
             ],
             vec![]
         ));
 
-        disassembles to: "VERSION 0800\n----\n0000 GET BUILTIN         5 == 'cond'\n0003 TRUE\n0004 CONSTANT            0 == 'foo'\n0006 CONSTANT            1 == 'bar'\n0008 CALL             (3 args)\n";
+        disassembles to: "VERSION 0800\n----\n0000 GET BUILTIN         5 == 'cond'\n0003 TRUE\n0004 CONSTANT            0 == '`foo`'\n0006 CONSTANT            1 == '`bar`'\n0008 CALL             (3 args)\n";
 
         runtime env: {
             ..Default::default()
@@ -1353,13 +1353,13 @@ mod valid {
                 opcode::CALL, 3
             ]),
             vec![
-                "foo".to_string(),
-                "bar".to_string(),
+                Value::String("foo".to_string()),
+                Value::String("bar".to_string()),
             ],
             vec![]
         ));
 
-        disassembles to: "VERSION 0800\n----\n0000 GET BUILTIN         5 == 'cond'\n0003 FALSE\n0004 CONSTANT            0 == 'foo'\n0006 CONSTANT            1 == 'bar'\n0008 CALL             (3 args)\n";
+        disassembles to: "VERSION 0800\n----\n0000 GET BUILTIN         5 == 'cond'\n0003 FALSE\n0004 CONSTANT            0 == '`foo`'\n0006 CONSTANT            1 == '`bar`'\n0008 CALL             (3 args)\n";
 
         runtime env: {
             ..Default::default()