Add basic implementation of instance methods

9 files changed, 104 insertions, 32 deletions

diff --git a/src/main/java/org/zwobble/couscous/interpreter/Evaluator.java b/src/main/java/org/zwobble/couscous/interpreter/Evaluator.java
index 9f183ec..ee67da0 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/Evaluator.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/Evaluator.java
@@ -4,6 +4,7 @@ import java.util.List;
 import java.util.stream.Collectors;
 
 import org.zwobble.couscous.ast.AssignmentNode;
+import org.zwobble.couscous.ast.ConstructorCallNode;
 import org.zwobble.couscous.ast.ExpressionNode;
 import org.zwobble.couscous.ast.LiteralNode;
 import org.zwobble.couscous.ast.MethodCallNode;
@@ -66,14 +67,7 @@ public class Evaluator implements ExpressionNodeMapper<InterpreterValue> {
         val receiver = eval(methodCall.getReceiver());
         val type = receiver.getType();
         val arguments = evalArguments(methodCall.getArguments());
-        return type.callMethod(receiver, methodCall.getMethodName(), arguments);
-    }
-
-    private List<InterpreterValue> evalArguments(List<ExpressionNode> arguments) {
-        return arguments
-            .stream()
-            .map(argument -> eval(argument))
-            .collect(Collectors.toList());
+        return type.callMethod(environment, receiver, methodCall.getMethodName(), arguments);
     }
 
     @Override
@@ -82,4 +76,18 @@ public class Evaluator implements ExpressionNodeMapper<InterpreterValue> {
         val arguments = evalArguments(staticMethodCall.getArguments());
         return clazz.callStaticMethod(environment, staticMethodCall.getMethodName(), arguments);
     }
+
+    @Override
+    public InterpreterValue visit(ConstructorCallNode call) {
+        val clazz = environment.findClass(call.getType());
+        val arguments = evalArguments(call.getArguments());
+        return clazz.callConstructor(environment, arguments);
+    }
+
+    private List<InterpreterValue> evalArguments(List<ExpressionNode> arguments) {
+        return arguments
+            .stream()
+            .map(argument -> eval(argument))
+            .collect(Collectors.toList());
+    }
 }
diff --git a/src/main/java/org/zwobble/couscous/interpreter/Executor.java b/src/main/java/org/zwobble/couscous/interpreter/Executor.java
index 93adf16..e9304cb 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/Executor.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/Executor.java
@@ -19,7 +19,7 @@ import static org.zwobble.couscous.interpreter.Evaluator.eval;
 import lombok.val;
 
 public class Executor implements StatementNodeMapper<Optional<InterpreterValue>> {
-    public static InterpreterValue callMethod(Environment environment, MethodNode method, Arguments arguments) {
+    public static InterpreterValue callMethod(Environment environment, MethodNode method, PositionalArguments arguments) {
         val innerEnvironment = buildEnvironment(environment, method, arguments);
       
         for (val statement : method.getBody()) {
@@ -34,7 +34,7 @@ public class Executor implements StatementNodeMapper<Optional<InterpreterValue>>
     private static Environment buildEnvironment(
         final Environment environment,
         final MethodNode method,
-        Arguments arguments) {
+        PositionalArguments arguments) {
         
         val stackFrame = new StackFrameBuilder();
         for (int index = 0; index < method.getArguments().size(); index++) {
diff --git a/src/main/java/org/zwobble/couscous/interpreter/Arguments.java b/src/main/java/org/zwobble/couscous/interpreter/PositionalArguments.java
index f34a456..429b529 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/Arguments.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/PositionalArguments.java
@@ -4,10 +4,10 @@ import java.util.List;
 
 import org.zwobble.couscous.interpreter.values.InterpreterValue;
 
-public class Arguments {
+public class PositionalArguments {
     private List<InterpreterValue> values;
     
-    public Arguments(List<InterpreterValue> values) {
+    public PositionalArguments(List<InterpreterValue> values) {
         this.values = values;
     }
     
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 a4902a4..70ba96a 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/values/ConcreteType.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/ConcreteType.java
@@ -7,7 +7,7 @@ import java.util.stream.Collectors;
 
 import org.zwobble.couscous.ast.ClassNode;
 import org.zwobble.couscous.ast.TypeName;
-import org.zwobble.couscous.interpreter.Arguments;
+import org.zwobble.couscous.interpreter.PositionalArguments;
 import org.zwobble.couscous.interpreter.Environment;
 import org.zwobble.couscous.interpreter.Executor;
 import org.zwobble.couscous.interpreter.NoSuchMethod;
@@ -38,10 +38,11 @@ public class ConcreteType {
         public Builder<T> method(
                 String name,
                 List<TypeName> argumentsTypes,
-                BiFunction<T, Arguments, InterpreterValue> method) {
-            methods.put(name, new MethodValue(argumentsTypes, (receiver, arguments) -> {
-                return Casts.tryCast(interpreterValueType, receiver)
-                    .map(typedReceiver -> method.apply(typedReceiver, arguments))
+                BiFunction<Environment, MethodCallArguments<T>, InterpreterValue> method) {
+            methods.put(name, new MethodValue(argumentsTypes, (environment, arguments) -> {
+                return Casts.tryCast(interpreterValueType, arguments.getReceiver())
+                    .map(typedReceiver ->
+                        method.apply(environment, MethodCallArguments.of(typedReceiver, arguments.getPositionalArguments())))
                     .orElseThrow(() -> new RuntimeException("receiver is of wrong type"));
             }));
             return this;
@@ -50,7 +51,7 @@ public class ConcreteType {
         public Builder<T> staticMethod(
                 String name,
                 List<TypeName> argumentsTypes,
-                BiFunction<Environment, Arguments, InterpreterValue> method) {
+                BiFunction<Environment, PositionalArguments, InterpreterValue> method) {
             staticMethods.put(name, new StaticMethodValue(argumentsTypes, method));
             return this;
         }
@@ -61,6 +62,20 @@ public class ConcreteType {
     }
     
     public static ConcreteType fromNode(ClassNode classNode) {
+        val methods = classNode.getMethods().stream()
+            .filter(method -> !method.isStatic())
+            .collect(toMap(
+                method -> method.getName(),
+                method -> {
+                    List<TypeName> argumentTypes = method.getArguments()
+                        .stream()
+                        .map(arg -> arg.getType())
+                        .collect(Collectors.toList());
+                    return new MethodValue(argumentTypes, (environment, arguments) -> {
+                        return Executor.callMethod(environment, method, arguments.getPositionalArguments());
+                    });
+                }));
+        
         val staticMethods = classNode.getMethods()
             .stream()
             .filter(method -> method.isStatic())
@@ -77,7 +92,7 @@ public class ConcreteType {
                 }));
         return new ConcreteType(
             classNode.getName(),
-            ImmutableMap.of(),
+            methods,
             staticMethods);
     }
 
@@ -106,14 +121,22 @@ public class ConcreteType {
         return builder(interpreterValueType, TypeName.of(name));
     }
 
-    public InterpreterValue callMethod(InterpreterValue receiver, String methodName, List<InterpreterValue> arguments) {
+    public InterpreterValue callMethod(Environment environment, InterpreterValue receiver, String methodName, List<InterpreterValue> arguments) {
         val method = findMethod(methods, methodName, arguments);
-        return method.apply(receiver, new Arguments(arguments));
+        return method.apply(
+            environment,
+            MethodCallArguments.of(receiver, new PositionalArguments(arguments)));
     }
 
     public InterpreterValue callStaticMethod(Environment environment, String methodName, List<InterpreterValue> arguments) {
         val method = findMethod(staticMethods, methodName, arguments);
-        return method.apply(environment, new Arguments(arguments));
+        return method.apply(environment, new PositionalArguments(arguments));
+    }
+
+    public InterpreterValue callConstructor(
+            Environment environment,
+            List<InterpreterValue> arguments) {
+        return new ObjectInterpreterValue(this);
     }
     
     private static <T extends Callable> T findMethod(Map<String, T> methods, String methodName, List<InterpreterValue> arguments) {
diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/MethodCallArguments.java b/src/main/java/org/zwobble/couscous/interpreter/values/MethodCallArguments.java
new file mode 100644
index 0000000..9f3e937
--- /dev/null
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/MethodCallArguments.java
@@ -0,0 +1,17 @@
+package org.zwobble.couscous.interpreter.values;
+
+import org.zwobble.couscous.interpreter.PositionalArguments;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@AllArgsConstructor(staticName="of")
+@Getter
+public class MethodCallArguments<T> {
+    private final T receiver;
+    private final PositionalArguments positionalArguments;
+    
+    public InterpreterValue get(int index) {
+        return positionalArguments.get(index);
+    }
+}
diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/MethodValue.java b/src/main/java/org/zwobble/couscous/interpreter/values/MethodValue.java
index c1f2c6e..b5068fc 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/values/MethodValue.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/MethodValue.java
@@ -4,7 +4,7 @@ import java.util.List;
 import java.util.function.BiFunction;
 
 import org.zwobble.couscous.ast.TypeName;
-import org.zwobble.couscous.interpreter.Arguments;
+import org.zwobble.couscous.interpreter.Environment;
 
 import lombok.AccessLevel;
 import lombok.Getter;
@@ -14,9 +14,9 @@ import lombok.Value;
 public class MethodValue implements Callable {
     List<TypeName> argumentTypes;
     @Getter(value=AccessLevel.NONE)
-    BiFunction<InterpreterValue, Arguments, InterpreterValue> apply;
+    BiFunction<Environment, MethodCallArguments<InterpreterValue>, InterpreterValue> apply;
     
-    public InterpreterValue apply(InterpreterValue receiver, Arguments arguments) {
-        return apply.apply(receiver, arguments);
+    public InterpreterValue apply(Environment environment, MethodCallArguments<InterpreterValue> arguments) {
+        return apply.apply(environment, arguments);
     }
 }
diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/ObjectInterpreterValue.java b/src/main/java/org/zwobble/couscous/interpreter/values/ObjectInterpreterValue.java
new file mode 100644
index 0000000..4383353
--- /dev/null
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/ObjectInterpreterValue.java
@@ -0,0 +1,23 @@
+package org.zwobble.couscous.interpreter.values;
+
+import java.util.Optional;
+
+import org.zwobble.couscous.values.PrimitiveValue;
+
+public class ObjectInterpreterValue implements InterpreterValue {
+    private final ConcreteType type;
+
+    public ObjectInterpreterValue(ConcreteType type) {
+        this.type = type;
+    }
+    
+    @Override
+    public ConcreteType getType() {
+        return type;
+    }
+
+    @Override
+    public Optional<PrimitiveValue> toPrimitiveValue() {
+        return Optional.empty();
+    }
+}
diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/StaticMethodValue.java b/src/main/java/org/zwobble/couscous/interpreter/values/StaticMethodValue.java
index 4754d80..37f3c56 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/values/StaticMethodValue.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/StaticMethodValue.java
@@ -4,7 +4,7 @@ import java.util.List;
 import java.util.function.BiFunction;
 
 import org.zwobble.couscous.ast.TypeName;
-import org.zwobble.couscous.interpreter.Arguments;
+import org.zwobble.couscous.interpreter.PositionalArguments;
 import org.zwobble.couscous.interpreter.Environment;
 
 import lombok.AccessLevel;
@@ -15,9 +15,9 @@ import lombok.Value;
 public class StaticMethodValue implements Callable {
     List<TypeName> argumentTypes;
     @Getter(value=AccessLevel.NONE)
-    BiFunction<Environment, Arguments, InterpreterValue> apply;
+    BiFunction<Environment, PositionalArguments, InterpreterValue> apply;
     
-    public InterpreterValue apply(Environment environment, Arguments arguments) {
+    public InterpreterValue apply(Environment environment, PositionalArguments arguments) {
         return apply.apply(environment, arguments);
     }
 
diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/StringInterpreterValue.java b/src/main/java/org/zwobble/couscous/interpreter/values/StringInterpreterValue.java
index 98165b2..aa3432a 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/values/StringInterpreterValue.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/values/StringInterpreterValue.java
@@ -16,13 +16,14 @@ import lombok.val;
 public class StringInterpreterValue implements InterpreterValue {
     public static final ConcreteType TYPE = ConcreteType.builder(StringInterpreterValue.class, StringValue.REF)
         .method("length", asList(),
-            (receiver, arguments) -> new IntegerInterpreterValue(receiver.value.length()))
+            (environment, arguments) ->
+                new IntegerInterpreterValue(arguments.getReceiver().value.length()))
         
         .method("substring", asList(IntegerValue.REF, IntegerValue.REF),
-            (receiver, arguments) -> {
+            (environment, arguments) -> {
                 val startIndex = (IntegerInterpreterValue)arguments.get(0);
                 val endIndex = (IntegerInterpreterValue)arguments.get(1);
-                return new StringInterpreterValue(receiver.value.substring(startIndex.getValue(), endIndex.getValue()));
+                return new StringInterpreterValue(arguments.getReceiver().value.substring(startIndex.getValue(), endIndex.getValue()));
             })
         
         .build();