Implement the 'perform:withArguments' primitive.

ltratt · ltratt · commit ef599ea6e4f0 · 2020-06-12T17:50:09.000+01:00
This requires a few more changes than might appear immediately necessary. First, to make things a bit nicer, I've (slightly tortuously) added an "iter" method to both types of Array. Then, in order to avoid the problem that Java SOM has (SOM-st/SOM#43 (comment)), we have to check the number of arguments passed, which means storing those in methods.
diff --git a/lang_tests/perform_witharguments.som b/lang_tests/perform_witharguments.som
@@ -0,0 +1,20 @@
+"
+VM:
+  status: success
+  stdout:
+    5
+    6
+    7
+"
+
+perform_witharguments = (
+    run = (
+        self perform: #f:b:c: withArguments: #(5 6 7).
+    )
+
+    f: a b: b c: c = (
+        a println.
+        b println.
+        c println.
+    )
+)
diff --git a/lang_tests/perform_witharguments_wrong.som b/lang_tests/perform_witharguments_wrong.som
@@ -0,0 +1,20 @@
+"
+VM:
+  status: error
+  stderr:
+    Traceback...
+    ...
+    Tried passing 1 arguments to a function that requires 3.
+"
+
+perform_witharguments_wrong = (
+    run = (
+        self perform: #f:b:c: withArguments: #(5).
+    )
+
+    f: a b: b c: c = (
+        a println.
+        b println.
+        c println.
+    )
+)
diff --git a/src/lib/compiler/ast_to_instrs.rs b/src/lib/compiler/ast_to_instrs.rs
@@ -248,9 +248,10 @@ impl<'a, 'input> Compiler<'a, 'input> {
                 ((pairs[0].0, name), args)
             }
         };
+        let args_len = args.len();
         let body = self.c_body(vm, astmeth.span, (name.0, &name.1), args, &astmeth.body)?;
         let sig = String_::new_sym(vm, name.1.clone());
-        let meth = Method::new(vm, sig, body);
+        let meth = Method::new(vm, sig, args_len, body);
         Ok((name.1, Val::from_obj(vm, meth)))
     }
 
diff --git a/src/lib/vm/core.rs b/src/lib/vm/core.rs
@@ -919,7 +919,44 @@ impl VM {
                 }
             }
             Primitive::PerformInSuperClass => unimplemented!(),
-            Primitive::PerformWithArguments => unimplemented!(),
+            Primitive::PerformWithArguments => {
+                let args_tobj = stry!(self.stack.pop().tobj(self));
+                let args = stry!(args_tobj.to_array());
+                let sig_val = self.stack.pop();
+                let sig = stry!(String_::symbol_to_string_(self, sig_val));
+                let cls_val = rcv.get_class(self);
+                let cls = stry!(cls_val.downcast::<Class>(self));
+                match cls.get_method(self, sig.as_str()) {
+                    Ok(m) => {
+                        if args_tobj.length() != m.num_params() {
+                            return SendReturn::Err(VMError::new(
+                                self,
+                                VMErrorKind::WrongNumberOfArgs {
+                                    wanted: m.num_params(),
+                                    got: args_tobj.length(),
+                                },
+                            ));
+                        }
+                        for v in args.iter() {
+                            self.stack.push(v);
+                        }
+                        self.send_args_on_stack(rcv, m, args_tobj.length())
+                    }
+                    Err(box VMError {
+                        kind: VMErrorKind::UnknownMethod,
+                        ..
+                    }) => {
+                        let meth = cls
+                            .get_method(self, "doesNotUnderstand:arguments:")
+                            .unwrap();
+                        self.stack.push(sig_val);
+                        let arr = NormalArray::new(self, 0);
+                        self.stack.push(arr);
+                        self.send_args_on_stack(rcv, meth, 2)
+                    }
+                    Err(e) => return SendReturn::Err(e),
+                }
+            }
             Primitive::PerformWithArgumentsInSuperClass => unimplemented!(),
             Primitive::PositiveInfinity => {
                 let dbl = Double::new(self, f64::INFINITY);
diff --git a/src/lib/vm/error.rs b/src/lib/vm/error.rs
@@ -182,6 +182,11 @@ pub enum VMErrorKind {
     UnknownGlobal(String),
     /// An unknown method.
     UnknownMethod,
+    /// Tried calling a method with the wrong number of arguments.
+    WrongNumberOfArgs {
+        wanted: usize,
+        got: usize,
+    },
 }
 
 impl VMErrorKind {
@@ -234,6 +239,10 @@ impl VMErrorKind {
             VMErrorKind::ShiftTooBig => Ok("Shift too big".to_owned()),
             VMErrorKind::UnknownGlobal(name) => Ok(format!("Unknown global '{}'", name)),
             VMErrorKind::UnknownMethod => Ok("Unknown method".to_owned()),
+            VMErrorKind::WrongNumberOfArgs { wanted, got } => Ok(format!(
+                "Tried passing {} arguments to a function that requires {}",
+                got, wanted
+            )),
         }
     }
 }
diff --git a/src/lib/vm/objects/array.rs b/src/lib/vm/objects/array.rs
@@ -10,9 +10,20 @@ use crate::vm::{
 };
 
 pub trait Array {
+    /// Return the item at index `idx` (using SOM indexing starting at 1) or an error if the index
+    /// is invalid.
     fn at(&self, vm: &VM, idx: usize) -> Result<Val, Box<VMError>>;
+
+    /// Return the item at index `idx` (using SOM indexing starting at 1). This will lead to
+    /// undefined behaviour if the index is invalid.
     unsafe fn unchecked_at(&self, idx: usize) -> Val;
+
+    /// Set the item at index `idx` (using SOM indexing starting at 1) to `val` or return an error
+    /// if the index is invalid.
     fn at_put(&self, vm: &mut VM, idx: usize, val: Val) -> Result<(), Box<VMError>>;
+
+    /// Iterate over this array's values.
+    fn iter<'a>(&'a self) -> ArrayIterator<'a>;
 }
 
 #[derive(Debug)]
@@ -54,8 +65,6 @@ impl StaticObjType for NormalArray {
 }
 
 impl Array for NormalArray {
-    /// Return the item at index `idx` (using SOM indexing starting at 1) or an error if the index
-    /// is invalid.
     fn at(&self, vm: &VM, mut idx: usize) -> Result<Val, Box<VMError>> {
         let store = unsafe { &*self.store.get() };
         if idx > 0 && idx <= store.len() {
@@ -72,8 +81,6 @@ impl Array for NormalArray {
         }
     }
 
-    /// Return the item at index `idx` (using SOM indexing starting at 1). This will lead to
-    /// undefined behaviour if the index is invalid.
     unsafe fn unchecked_at(&self, mut idx: usize) -> Val {
         debug_assert!(idx > 0);
         let store = &*self.store.get();
@@ -82,8 +89,6 @@ impl Array for NormalArray {
         *store.get_unchecked(idx)
     }
 
-    /// Set the item at index `idx` (using SOM indexing starting at 1) to `val` or return an error
-    /// if the index is invalid.
     fn at_put(&self, vm: &mut VM, mut idx: usize, val: Val) -> Result<(), Box<VMError>> {
         let store = unsafe { &mut *self.store.get() };
         if idx > 0 && idx <= store.len() {
@@ -100,6 +105,14 @@ impl Array for NormalArray {
             ))
         }
     }
+
+    fn iter<'a>(&'a self) -> ArrayIterator<'a> {
+        ArrayIterator {
+            arr: self,
+            len: self.length(),
+            i: 0,
+        }
+    }
 }
 
 impl NormalArray {
@@ -163,8 +176,6 @@ impl StaticObjType for MethodsArray {
 }
 
 impl Array for MethodsArray {
-    /// Return the item at index `idx` (using SOM indexing starting at 1) or an error if the index
-    /// is invalid.
     fn at(&self, vm: &VM, mut idx: usize) -> Result<Val, Box<VMError>> {
         let store = unsafe { &*self.store.get() };
         if idx > 0 && idx <= store.len() {
@@ -181,8 +192,6 @@ impl Array for MethodsArray {
         }
     }
 
-    /// Return the item at index `idx` (using SOM indexing starting at 1). This will lead to
-    /// undefined behaviour if the index is invalid.
     unsafe fn unchecked_at(&self, mut idx: usize) -> Val {
         debug_assert!(idx > 0);
         let store = &*self.store.get();
@@ -191,8 +200,6 @@ impl Array for MethodsArray {
         *store.get_unchecked(idx)
     }
 
-    /// Set the item at index `idx` (using SOM indexing starting at 1) to `val` or return an error
-    /// if the index is invalid.
     fn at_put(&self, vm: &mut VM, mut idx: usize, val: Val) -> Result<(), Box<VMError>> {
         let store = unsafe { &mut *self.store.get() };
         if idx > 0 && idx <= store.len() {
@@ -210,6 +217,14 @@ impl Array for MethodsArray {
             ))
         }
     }
+
+    fn iter<'a>(&'a self) -> ArrayIterator<'a> {
+        ArrayIterator {
+            arr: self,
+            len: self.length(),
+            i: 0,
+        }
+    }
 }
 
 impl MethodsArray {
@@ -221,23 +236,19 @@ impl MethodsArray {
             },
         )
     }
-
-    /// Iterate over this array's values.
-    pub fn iter<'a>(&'a self) -> MethodsArrayIterator<'a> {
-        MethodsArrayIterator { arr: self, i: 0 }
-    }
 }
 
-pub struct MethodsArrayIterator<'a> {
-    arr: &'a MethodsArray,
+pub struct ArrayIterator<'a> {
+    arr: &'a dyn Array,
+    len: usize,
     i: usize,
 }
 
-impl<'a> Iterator for MethodsArrayIterator<'a> {
+impl<'a> Iterator for ArrayIterator<'a> {
     type Item = Val;
 
     fn next(&mut self) -> Option<Val> {
-        if self.i < self.arr.length() {
+        if self.i < self.len {
             self.i += 1;
             Some(unsafe { self.arr.unchecked_at(self.i) })
         } else {
diff --git a/src/lib/vm/objects/method.rs b/src/lib/vm/objects/method.rs
@@ -14,6 +14,7 @@ use crate::{
 #[derive(Debug)]
 pub struct Method {
     sig: Cell<Val>,
+    num_params: usize,
     pub body: MethodBody,
     holder: Cell<Val>,
 }
@@ -57,9 +58,10 @@ impl StaticObjType for Method {
 }
 
 impl Method {
-    pub fn new(vm: &VM, sig: Val, body: MethodBody) -> Method {
+    pub fn new(vm: &VM, sig: Val, num_params: usize, body: MethodBody) -> Method {
         Method {
             sig: Cell::new(sig),
+            num_params,
             body,
             holder: Cell::new(vm.nil),
         }
@@ -69,6 +71,10 @@ impl Method {
         self.holder.get()
     }
 
+    pub fn num_params(&self) -> usize {
+        self.num_params
+    }
+
     pub fn set_holder(&self, _: &VM, class: Val) {
         self.holder.set(class);
     }

Original file line number	Diff line number	Diff line change
`@@ -248,9 +248,10 @@ impl<'a, 'input> Compiler<'a, 'input> {`
`248`	`248`	`((pairs[0].0, name), args)`
`249`	`249`	`}`
`250`	`250`	`};`
	`251`	`+ let args_len = args.len();`
`251`	`252`	`let body = self.c_body(vm, astmeth.span, (name.0, &name.1), args, &astmeth.body)?;`
`252`	`253`	`let sig = String_::new_sym(vm, name.1.clone());`
`253`		`- let meth = Method::new(vm, sig, body);`
	`254`	`+ let meth = Method::new(vm, sig, args_len, body);`
`254`	`255`	`Ok((name.1, Val::from_obj(vm, meth)))`
`255`	`256`	`}`
`256`	`257`
Original file line number	Diff line number	Diff line change
`@@ -182,6 +182,11 @@ pub enum VMErrorKind {`
`182`	`182`	`UnknownGlobal(String),`
`183`	`183`	`/// An unknown method.`
`184`	`184`	`UnknownMethod,`
	`185`	`+ /// Tried calling a method with the wrong number of arguments.`
	`186`	`+ WrongNumberOfArgs {`
	`187`	`+ wanted: usize,`
	`188`	`+ got: usize,`
	`189`	`+ },`
`185`	`190`	`}`
`186`	`191`
`187`	`192`	`impl VMErrorKind {`
`@@ -234,6 +239,10 @@ impl VMErrorKind {`
`234`	`239`	`VMErrorKind::ShiftTooBig => Ok("Shift too big".to_owned()),`
`235`	`240`	`VMErrorKind::UnknownGlobal(name) => Ok(format!("Unknown global '{}'", name)),`
`236`	`241`	`VMErrorKind::UnknownMethod => Ok("Unknown method".to_owned()),`
	`242`	`+ VMErrorKind::WrongNumberOfArgs { wanted, got } => Ok(format!(`
	`243`	`+ "Tried passing {} arguments to a function that requires {}",`
	`244`	`+ got, wanted`
	`245`	`+ )),`
`237`	`246`	`}`
`238`	`247`	`}`
`239`	`248`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@ use crate::{`
`14`	`14`	`#[derive(Debug)]`
`15`	`15`	`pub struct Method {`
`16`	`16`	`sig: Cell<Val>,`
	`17`	`+ num_params: usize,`
`17`	`18`	`pub body: MethodBody,`
`18`	`19`	`holder: Cell<Val>,`
`19`	`20`	`}`
`@@ -57,9 +58,10 @@ impl StaticObjType for Method {`
`57`	`58`	`}`
`58`	`59`
`59`	`60`	`impl Method {`
`60`		`- pub fn new(vm: &VM, sig: Val, body: MethodBody) -> Method {`
	`61`	`+ pub fn new(vm: &VM, sig: Val, num_params: usize, body: MethodBody) -> Method {`
`61`	`62`	`Method {`
`62`	`63`	`sig: Cell::new(sig),`
	`64`	`+ num_params,`
`63`	`65`	`body,`
`64`	`66`	`holder: Cell::new(vm.nil),`
`65`	`67`	`}`
`@@ -69,6 +71,10 @@ impl Method {`
`69`	`71`	`self.holder.get()`
`70`	`72`	`}`
`71`	`73`
	`74`	`+ pub fn num_params(&self) -> usize {`
	`75`	`+ self.num_params`
	`76`	`+ }`
	`77`	`+`
`72`	`78`	`pub fn set_holder(&self, _: &VM, class: Val) {`
`73`	`79`	`self.holder.set(class);`
`74`	`80`	`}`