Change method bodies to be optional

2 files changed, 40 insertions, 8 deletions

diff --git a/src/main/java/org/zwobble/couscous/interpreter/Executor.java b/src/main/java/org/zwobble/couscous/interpreter/Executor.java
index 60f7d9c..8ba263c 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/Executor.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/Executor.java
@@ -15,18 +15,50 @@ import static org.zwobble.couscous.interpreter.Evaluator.eval;
 import static org.zwobble.couscous.interpreter.Evaluator.evalCondition;
 
 public class Executor implements StatementNodeMapper<Optional<InterpreterValue>> {
-    public static InterpreterValue callMethod(Environment environment, CallableNode method, Optional<InterpreterValue> thisValue, PositionalArguments arguments) {
-        Environment innerEnvironment = buildEnvironment(environment, method, thisValue, arguments);
-        return exec(innerEnvironment, method.getBody())
+    public static InterpreterValue callMethod(
+        Environment environment,
+        MethodNode method,
+        Optional<InterpreterValue> thisValue,
+        PositionalArguments actualArguments)
+    {
+        List<StatementNode> body = method.getBody().orElseThrow(() -> new RuntimeException("Cannot call abstract method"));
+        return callMethod(environment, method.getArguments(), body, thisValue, actualArguments);
+    }
+
+    public static InterpreterValue callConstructor(
+        Environment environment,
+        ConstructorNode constructor,
+        Optional<InterpreterValue> thisValue,
+        PositionalArguments actualArguments)
+    {
+        return callMethod(environment, constructor.getArguments(), constructor.getBody(), thisValue, actualArguments);
+    }
+
+    private static InterpreterValue callMethod(
+        Environment environment,
+        List<FormalArgumentNode> formalArguments,
+        List<StatementNode> statements,
+        Optional<InterpreterValue> thisValue,
+        PositionalArguments actualArguments)
+    {
+        Environment innerEnvironment = buildEnvironment(environment, formalArguments, statements, thisValue, actualArguments);
+        return exec(innerEnvironment, statements)
             .orElse(UnitInterpreterValue.UNIT);
     }
 
-    private static Environment buildEnvironment(final Environment environment, final CallableNode method, Optional<InterpreterValue> thisValue, PositionalArguments arguments) {
+    private static Environment buildEnvironment(
+        Environment environment,
+        List<FormalArgumentNode> formalArguments,
+        List<StatementNode> statements,
+        Optional<InterpreterValue> thisValue,
+        PositionalArguments arguments)
+    {
+        // TODO use map with multiple iterables
         final org.zwobble.couscous.interpreter.StackFrameBuilder stackFrame = new StackFrameBuilder();
-        for (int index = 0; index < method.getArguments().size(); index++) {
-            stackFrame.declare(method.getArguments().get(index), arguments.get(index));
+        for (int index = 0; index < formalArguments.size(); index++) {
+            stackFrame.declare(formalArguments.get(index), arguments.get(index));
         }
-        findDeclarations(method.getBody()).forEach(declaration -> stackFrame.declare(declaration));
+        findDeclarations(statements).forEach(declaration -> stackFrame.declare(declaration));
         return environment.withStackFrame(thisValue, stackFrame.build());
     }
 
diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/ConcreteType.java b/src/main/java/org/zwobble/couscous/interpreter/values/ConcreteType.java
index 98036f1..19a6039 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/values/ConcreteType.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/ConcreteType.java
@@ -99,7 +99,7 @@ public class ConcreteType {
                 field -> field));
         MethodValue constructor = new MethodValue(
             getArgumentTypes(classNode.getConstructor().getArguments()),
-            (environment, arguments) -> Executor.callMethod(
+            (environment, arguments) -> Executor.callConstructor(
                 environment,
                 classNode.getConstructor(),
                 Optional.of(arguments.getReceiver()),