Feat: Add string OpCodes and IT.

Author: dylan-sutton-chavez

compiler/src/modules/vm/handlers/attr.rs

@@ -12,10 +12,20 @@ impl<'a> VM<'a> {
         let obj = self.pop()?;
 
         let method_id = match (self.type_name(obj), name.as_str()) {
-            ("list", "append") => BuiltinMethodId::ListAppend,
-            ("dict", "keys")   => BuiltinMethodId::DictKeys,
-            ("dict", "values") => BuiltinMethodId::DictValues,
-            ("dict", "items")  => BuiltinMethodId::DictItems,
+            ("list", "append")      => BuiltinMethodId::ListAppend,
+            ("dict", "keys")        => BuiltinMethodId::DictKeys,
+            ("dict", "values")      => BuiltinMethodId::DictValues,
+            ("dict", "items")       => BuiltinMethodId::DictItems,
+            ("str", "upper")        => BuiltinMethodId::StrUpper,
+            ("str", "lower")        => BuiltinMethodId::StrLower,
+            ("str", "strip")        => BuiltinMethodId::StrStrip,
+            ("str", "split")        => BuiltinMethodId::StrSplit,
+            ("str", "join")         => BuiltinMethodId::StrJoin,
+            ("str", "replace")      => BuiltinMethodId::StrReplace,
+            ("str", "startswith")   => BuiltinMethodId::StrStartswith,
+            ("str", "endswith")     => BuiltinMethodId::StrEndswith,
+            ("str", "find")         => BuiltinMethodId::StrFind,
+            ("str", "count")        => BuiltinMethodId::StrCount,
             (ty, attr) => {
                 return Err(attr_not_found(ty, attr));
             }

compiler/src/modules/vm/handlers/function.rs

@@ -275,6 +275,126 @@ impl<'a> VM<'a> {
                 self.push(val);
                 Ok(())
             }
+            StrUpper => {
+                let s = self.recv_str(recv)?;
+                let val = self.heap.alloc(HeapObj::Str(s.to_uppercase()))?;
+                self.push(val);
+                Ok(())
+            }
+            StrLower => {
+                let s = self.recv_str(recv)?;
+                let val = self.heap.alloc(HeapObj::Str(s.to_lowercase()))?;
+                self.push(val);
+                Ok(())
+            }
+            StrStrip => {
+                let s = self.recv_str(recv)?;
+                let val = self.heap.alloc(HeapObj::Str(s.trim().to_string()))?;
+                self.push(val);
+                Ok(())
+            }
+            StrSplit => {
+                let s = self.recv_str(recv)?;
+                let parts: Vec<Val> = if positional.is_empty() {
+                    s.split_whitespace()
+                        .map(|p| self.heap.alloc(HeapObj::Str(p.to_string())))
+                        .collect::<Result<_, _>>()?
+                } else {
+                    let sep = self.val_to_str(positional[0])?;
+                    s.split(sep.as_str())
+                        .map(|p| self.heap.alloc(HeapObj::Str(p.to_string())))
+                        .collect::<Result<_, _>>()?
+                };
+                let val = self.heap.alloc(HeapObj::List(Rc::new(RefCell::new(parts))))?;
+                self.push(val);
+                Ok(())
+            }
+            StrJoin => {
+                let sep = self.recv_str(recv)?;
+                if positional.len() != 1 {
+                    return Err(VmErr::Type("join() takes exactly one argument"));
+                }
+                let items = match self.heap.get(positional[0]) {
+                    HeapObj::List(rc)  => rc.borrow().clone(),
+                    HeapObj::Tuple(v)  => v.clone(),
+                    _ => return Err(VmErr::Type("join() argument must be iterable")),
+                };
+                let mut parts: Vec<String> = Vec::with_capacity(items.len());
+                for v in items {
+                    parts.push(self.val_to_str(v)?);
+                }
+                let val = self.heap.alloc(HeapObj::Str(parts.join(sep.as_str())))?;
+                self.push(val);
+                Ok(())
+            }
+            StrReplace => {
+                if positional.len() != 2 {
+                    return Err(VmErr::Type("replace() takes exactly 2 arguments"));
+                }
+                let s   = self.recv_str(recv)?;
+                let old = self.val_to_str(positional[0])?;
+                let new = self.val_to_str(positional[1])?;
+                let val = self.heap.alloc(HeapObj::Str(s.replace(old.as_str(), new.as_str())))?;
+                self.push(val);
+                Ok(())
+            }
+            StrStartswith => {
+                if positional.len() != 1 {
+                    return Err(VmErr::Type("startswith() takes exactly one argument"));
+                }
+                let s      = self.recv_str(recv)?;
+                let prefix = self.val_to_str(positional[0])?;
+                self.push(Val::bool(s.starts_with(prefix.as_str())));
+                Ok(())
+            }
+            StrEndswith => {
+                if positional.len() != 1 {
+                    return Err(VmErr::Type("endswith() takes exactly one argument"));
+                }
+                let s      = self.recv_str(recv)?;
+                let suffix = self.val_to_str(positional[0])?;
+                self.push(Val::bool(s.ends_with(suffix.as_str())));
+                Ok(())
+            }
+            StrFind => {
+                if positional.len() != 1 {
+                    return Err(VmErr::Type("find() takes exactly one argument"));
+                }
+                let s   = self.recv_str(recv)?;
+                let sub = self.val_to_str(positional[0])?;
+                let idx = s.find(sub.as_str())
+                    .map(|i| s[..i].chars().count() as i64)
+                    .unwrap_or(-1);
+                self.push(Val::int(idx));
+                Ok(())
+            }
+            StrCount => {
+                if positional.len() != 1 {
+                    return Err(VmErr::Type("count() takes exactly one argument"));
+                }
+                let s   = self.recv_str(recv)?;
+                let sub = self.val_to_str(positional[0])?;
+                let n   = s.matches(sub.as_str()).count() as i64;
+                self.push(Val::int(n));
+                Ok(())
+            }
+        }
+    }
+
+    // Extracts the string content from a Str receiver.
+    fn recv_str(&self, recv: Val) -> Result<String, VmErr> {
+        match self.heap.get(recv) {
+            HeapObj::Str(s) => Ok(s.clone()),
+            _ => Err(VmErr::Type("method requires a string receiver")),
+        }
+    }
+
+    // Converts a Val to String for use as a method argument.
+    fn val_to_str(&self, v: Val) -> Result<String, VmErr> {
+        match self.heap.get(v) {
+            HeapObj::Str(s) => Ok(s.clone()),
+            _ => Err(VmErr::Type("argument must be a string")),
         }
     }
+    
 }

compiler/src/modules/vm/ops.rs

@@ -122,10 +122,20 @@ impl<'a> VM<'a> {
             HeapObj::Type(name) => format!("<class '{}'>", name),
             HeapObj::Func(i, _) => format!("<function {}>", i),
             HeapObj::BoundMethod(_, id) => match id {
-                BuiltinMethodId::ListAppend => "<built-in method append>".into(),
-                BuiltinMethodId::DictKeys   => "<built-in method keys>".into(),
-                BuiltinMethodId::DictValues => "<built-in method values>".into(),
-                BuiltinMethodId::DictItems  => "<built-in method items>".into(),
+                BuiltinMethodId::ListAppend    => "<built-in method append>".into(),
+                BuiltinMethodId::DictKeys      => "<built-in method keys>".into(),
+                BuiltinMethodId::DictValues    => "<built-in method values>".into(),
+                BuiltinMethodId::DictItems     => "<built-in method items>".into(),
+                BuiltinMethodId::StrUpper      => "<built-in method upper>".into(),
+                BuiltinMethodId::StrLower      => "<built-in method lower>".into(),
+                BuiltinMethodId::StrStrip      => "<built-in method strip>".into(),
+                BuiltinMethodId::StrSplit      => "<built-in method split>".into(),
+                BuiltinMethodId::StrJoin       => "<built-in method join>".into(),
+                BuiltinMethodId::StrReplace    => "<built-in method replace>".into(),
+                BuiltinMethodId::StrStartswith => "<built-in method startswith>".into(),
+                BuiltinMethodId::StrEndswith   => "<built-in method endswith>".into(),
+                BuiltinMethodId::StrFind       => "<built-in method find>".into(),
+                BuiltinMethodId::StrCount      => "<built-in method count>".into(),
             },
             HeapObj::Slice(s, e, st) => format!("slice({}, {}, {})",
                 self.display(*s), self.display(*e), self.display(*st)),

compiler/src/modules/vm/types.rs

@@ -469,6 +469,16 @@ pub enum BuiltinMethodId {
     DictKeys,
     DictValues,
     DictItems,
+    StrUpper,
+    StrLower,
+    StrStrip,
+    StrSplit,
+    StrJoin,
+    StrReplace,
+    StrStartswith,
+    StrEndswith,
+    StrFind,
+    StrCount,
 }
 
 /*

compiler/tests/cases/vm.json

@@ -349,5 +349,15 @@
   {"src": "print('abcde'[3:0:-1])", "output": ["dcb"], "result": "None"},
   {"src": "for a, *b in [[1,2,3],[4,5,6]]:\n    print(a, b)", "output": ["1 [2, 3]", "4 [5, 6]"], "result": "None"},
   {"src": "try:\n    x = 1/0\nexcept ZeroDivisionError as e:\n    print('caught')", "output": ["caught"], "result": "None"},
-  {"src": "f = lambda x, y=10: x + y\nprint(f(5))\nprint(f(5, 1))", "output": ["15", "6"], "result": "None"}
+  {"src": "f = lambda x, y=10: x + y\nprint(f(5))\nprint(f(5, 1))", "output": ["15", "6"], "result": "None"},
+  {"src": "print('hello'.upper())", "output": ["HELLO"], "result": "None"},
+  {"src": "print('HELLO'.lower())", "output": ["hello"], "result": "None"},
+  {"src": "print('  hi  '.strip())", "output": ["hi"], "result": "None"},
+  {"src": "print('a,b,c'.split(','))", "output": ["['a', 'b', 'c']"], "result": "None"},
+  {"src": "print(','.join(['a','b','c']))", "output": ["a,b,c"], "result": "None"},
+  {"src": "print('hello'.replace('l','r'))", "output": ["herro"], "result": "None"},
+  {"src": "print('hello'.startswith('he'))", "output": ["True"], "result": "None"},
+  {"src": "print('hello'.endswith('lo'))", "output": ["True"], "result": "None"},
+  {"src": "print('hello'.find('ll'))", "output": ["2"], "result": "None"},
+  {"src": "print('hello'.count('l'))", "output": ["2"], "result": "None"}
 ]