Use normal method call exec in interpreter entry point

9 files changed, 133 insertions, 68 deletions

diff --git a/src/main/java/org/zwobble/couscous/Project.java b/src/main/java/org/zwobble/couscous/Project.java
index 6afac6e..56b439f 100644
--- a/src/main/java/org/zwobble/couscous/Project.java
+++ b/src/main/java/org/zwobble/couscous/Project.java
@@ -1,7 +1,7 @@
 package org.zwobble.couscous;
 
-import org.zwobble.couscous.ast.ClassNode;
+import org.zwobble.couscous.values.ConcreteType;
 
 public interface Project {
-    ClassNode findClass(String name);
+    ConcreteType<?> findClass(String name);
 }
diff --git a/src/main/java/org/zwobble/couscous/ast/ClassNode.java b/src/main/java/org/zwobble/couscous/ast/ClassNode.java
index ffa5165..6dd7b12 100644
--- a/src/main/java/org/zwobble/couscous/ast/ClassNode.java
+++ b/src/main/java/org/zwobble/couscous/ast/ClassNode.java
@@ -9,6 +9,7 @@ import lombok.Value;
 @Builder
 @Value
 public class ClassNode {
+    String name;
     @Singular
     List<MethodNode> methods;
 }
diff --git a/src/main/java/org/zwobble/couscous/ast/FormalArgumentNode.java b/src/main/java/org/zwobble/couscous/ast/FormalArgumentNode.java
index da3a838..72a5f51 100644
--- a/src/main/java/org/zwobble/couscous/ast/FormalArgumentNode.java
+++ b/src/main/java/org/zwobble/couscous/ast/FormalArgumentNode.java
@@ -1,9 +1,21 @@
 package org.zwobble.couscous.ast;
 
+import java.util.function.Supplier;
+
+import org.zwobble.couscous.values.ConcreteType;
+
+import lombok.AccessLevel;
+import lombok.Getter;
 import lombok.Value;
 
 @Value
 public class FormalArgumentNode implements VariableNode {
     int id;
+    @Getter(value=AccessLevel.NONE)
+    Supplier<ConcreteType<?>> type;
     String name;
+    
+    public ConcreteType<?> getType() {
+        return type.get();
+    }
 }
diff --git a/src/main/java/org/zwobble/couscous/ast/LiteralNode.java b/src/main/java/org/zwobble/couscous/ast/LiteralNode.java
index cc57aef..0869653 100644
--- a/src/main/java/org/zwobble/couscous/ast/LiteralNode.java
+++ b/src/main/java/org/zwobble/couscous/ast/LiteralNode.java
@@ -10,6 +10,10 @@ import lombok.Value;
 
 @Value
 public class LiteralNode implements ExpressionNode {
+    public static LiteralNode literal(InterpreterValue value) {
+        return new LiteralNode(value);
+    }
+    
     public static LiteralNode literal(String value) {
         return new LiteralNode(new StringValue(value));
     }
diff --git a/src/main/java/org/zwobble/couscous/ast/StaticMethodCallNode.java b/src/main/java/org/zwobble/couscous/ast/StaticMethodCallNode.java
index 390c37f..4f1e9ff 100644
--- a/src/main/java/org/zwobble/couscous/ast/StaticMethodCallNode.java
+++ b/src/main/java/org/zwobble/couscous/ast/StaticMethodCallNode.java
@@ -14,6 +14,10 @@ public class StaticMethodCallNode implements ExpressionNode {
         return new StaticMethodCallNode(className, methodName, asList(arguments));
     }
     
+    public static StaticMethodCallNode staticMethodCall(String className, String methodName, List<ExpressionNode> arguments) {
+        return new StaticMethodCallNode(className, methodName, arguments);
+    }
+    
     String className;
     String methodName;
     List<ExpressionNode> arguments;
diff --git a/src/main/java/org/zwobble/couscous/interpreter/Environment.java b/src/main/java/org/zwobble/couscous/interpreter/Environment.java
index ea4a5e4..76aa56b 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/Environment.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/Environment.java
@@ -3,14 +3,16 @@ package org.zwobble.couscous.interpreter;
 import java.util.HashMap;
 import java.util.Map;
 
+import org.zwobble.couscous.Project;
 import org.zwobble.couscous.values.ConcreteType;
-import org.zwobble.couscous.values.IntegerValue;
 import org.zwobble.couscous.values.InterpreterValue;
 
 public class Environment {
-    private Map<Integer, InterpreterValue> stackFrame;
+    private final Map<Integer, InterpreterValue> stackFrame;
+    private final Project project;
 
-    public Environment(Map<Integer, InterpreterValue> stackFrame) {
+    public Environment(Project project, Map<Integer, InterpreterValue> stackFrame) {
+        this.project = project;
         this.stackFrame = new HashMap<>(stackFrame);
     }
 
@@ -23,10 +25,7 @@ public class Environment {
     }
 
     public ConcreteType<?> findClass(String className) {
-        if (className == "java.lang.Integer") {
-            return IntegerValue.TYPE;
-        } else {
-            throw new UnsupportedOperationException();
-        }
+        // TODO: handle missing classes
+        return project.findClass(className);
     }
 }
diff --git a/src/main/java/org/zwobble/couscous/interpreter/Executor.java b/src/main/java/org/zwobble/couscous/interpreter/Executor.java
new file mode 100644
index 0000000..633bf6b
--- /dev/null
+++ b/src/main/java/org/zwobble/couscous/interpreter/Executor.java
@@ -0,0 +1,34 @@
+package org.zwobble.couscous.interpreter;
+
+import java.util.Optional;
+
+import org.zwobble.couscous.ast.ExpressionStatementNode;
+import org.zwobble.couscous.ast.ReturnNode;
+import org.zwobble.couscous.ast.StatementNode;
+import org.zwobble.couscous.ast.visitors.StatementNodeVisitor;
+import org.zwobble.couscous.values.InterpreterValue;
+
+import static org.zwobble.couscous.interpreter.Evaluator.eval;
+
+public class Executor implements StatementNodeVisitor<Optional<InterpreterValue>> {
+    public static Optional<InterpreterValue> exec(Environment environment, StatementNode statement) {
+        return statement.accept(new Executor(environment));
+    }
+    
+    private final Environment environment;
+
+    private Executor(Environment environment) {
+        this.environment = environment;
+    }
+    
+    @Override
+    public Optional<InterpreterValue> visit(ReturnNode returnNode) {
+        return Optional.of(eval(environment, returnNode.getValue()));
+    }
+
+    @Override
+    public Optional<InterpreterValue> visit(ExpressionStatementNode expressionStatement) {
+        eval(environment, expressionStatement.getExpression());
+        return Optional.empty();
+    }
+}
diff --git a/src/main/java/org/zwobble/couscous/interpreter/Interpreter.java b/src/main/java/org/zwobble/couscous/interpreter/Interpreter.java
index bc82fee..884a082 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/Interpreter.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/Interpreter.java
@@ -1,20 +1,17 @@
 package org.zwobble.couscous.interpreter;
 
 import java.util.List;
-import java.util.Optional;
-import java.util.stream.IntStream;
+import java.util.stream.Collectors;
 
 import org.zwobble.couscous.Project;
-import org.zwobble.couscous.ast.ExpressionStatementNode;
-import org.zwobble.couscous.ast.MethodNode;
-import org.zwobble.couscous.ast.ReturnNode;
-import org.zwobble.couscous.ast.visitors.StatementNodeVisitor;
+import org.zwobble.couscous.ast.ExpressionNode;
+import org.zwobble.couscous.ast.LiteralNode;
 import org.zwobble.couscous.values.InterpreterValue;
 
-import static com.google.common.collect.Iterables.find;
-import static java.util.stream.Collectors.toMap;
+import com.google.common.collect.ImmutableMap;
+
+import static org.zwobble.couscous.ast.StaticMethodCallNode.staticMethodCall;
 import static org.zwobble.couscous.interpreter.Evaluator.eval;
-import static org.zwobble.couscous.values.UnitValue.UNIT;
 
 import lombok.val;
 
@@ -26,52 +23,11 @@ public class Interpreter {
     }
     
     public InterpreterValue run(String className, String methodName, List<InterpreterValue> arguments) {
-        val clazz = project.findClass(className);
-        val method = find(clazz.getMethods(),
-            method -> method.getName().equals(methodName));
-        val environment = buildEnvironment(method, arguments);
-        
-        for (val statement : method.getBody()) {
-            val result = statement.accept(new Executor(environment));
-            if (result.isPresent()) {
-                return result.get();
-            }
-        }
-        return UNIT;
-    }
-
-    private Environment buildEnvironment(
-        final MethodNode method,
-        List<InterpreterValue> arguments) {
-        
-        if (method.getArguments().size() != arguments.size()) {
-            throw new WrongNumberOfArguments(method.getArguments().size(), arguments.size());
-        }
-        
-        val stackFrame = IntStream.range(0, method.getArguments().size())
-            .boxed()
-            .collect(toMap(
-                index -> method.getArguments().get(index).getId(),
-                index -> arguments.get(index)));
-        return new Environment(stackFrame);
-    }
-    
-    private class Executor implements StatementNodeVisitor<Optional<InterpreterValue>> {
-        private Environment environment;
-
-        public Executor(Environment environment) {
-            this.environment = environment;
-        }
-        
-        @Override
-        public Optional<InterpreterValue> visit(ReturnNode returnNode) {
-            return Optional.of(eval(environment, returnNode.getValue()));
-        }
-
-        @Override
-        public Optional<InterpreterValue> visit(ExpressionStatementNode expressionStatement) {
-            eval(environment, expressionStatement.getExpression());
-            return Optional.empty();
-        }
+        val argumentExpressions = arguments
+            .stream()
+            .<ExpressionNode>map(LiteralNode::literal)
+            .collect(Collectors.toList());
+        return eval(new Environment(project, ImmutableMap.of()),
+            staticMethodCall(className, methodName, argumentExpressions));
     }
 }
diff --git a/src/main/java/org/zwobble/couscous/values/ConcreteType.java b/src/main/java/org/zwobble/couscous/values/ConcreteType.java
index db5209e..6aea1db 100644
--- a/src/main/java/org/zwobble/couscous/values/ConcreteType.java
+++ b/src/main/java/org/zwobble/couscous/values/ConcreteType.java
@@ -5,14 +5,23 @@ import java.util.Map;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
+import org.zwobble.couscous.Project;
+import org.zwobble.couscous.ast.ClassNode;
+import org.zwobble.couscous.ast.MethodNode;
 import org.zwobble.couscous.interpreter.Arguments;
+import org.zwobble.couscous.interpreter.Environment;
 import org.zwobble.couscous.interpreter.NoSuchMethod;
 import org.zwobble.couscous.interpreter.UnexpectedValueType;
 import org.zwobble.couscous.interpreter.WrongNumberOfArguments;
 
 import com.google.common.collect.ImmutableMap;
 
+import static java.util.stream.Collectors.toMap;
+import static org.zwobble.couscous.interpreter.Executor.exec;
+
 import lombok.val;
 
 public class ConcreteType<T> {
@@ -47,15 +56,61 @@ public class ConcreteType<T> {
             return new ConcreteType<T>(name, methods.build(), staticMethods.build());
         }
     }
+    
+    public static ConcreteType<?> fromNode(ClassNode classNode) {
+        val staticMethods = classNode.getMethods()
+            .stream()
+            .filter(method -> method.isStatic())
+            .collect(toMap(
+                method -> method.getName(),
+                method -> {
+                    Supplier<List<ConcreteType<?>>> argumentTypes = () -> method.getArguments()
+                        .stream()
+                        .<ConcreteType<?>>map(arg -> arg.getType())
+                        .collect(Collectors.toList());
+                    return new StaticMethodValue(argumentTypes, arguments -> {
+                        val environment = buildEnvironment(method, arguments);
+                      
+                        for (val statement : method.getBody()) {
+                            val result = exec(environment, statement);
+                            if (result.isPresent()) {
+                                return result.get();
+                            }
+                        }
+                        return UnitValue.UNIT;
+                    });
+                }));
+        return new ConcreteType<Void>(
+            classNode.getName(),
+            ImmutableMap.of(),
+            staticMethods);
+    }
+
+    private static Environment buildEnvironment(
+        final MethodNode method,
+        Arguments arguments) {
+        
+        val stackFrame = IntStream.range(0, method.getArguments().size())
+            .boxed()
+            .collect(toMap(
+                index -> method.getArguments().get(index).getId(),
+                index -> arguments.get(index)));
+        return new Environment(new Project() {
+            @Override
+            public ConcreteType<?> findClass(String name) {
+                throw new UnsupportedOperationException();
+            }
+        }, stackFrame);
+    }
 
     private String name;
     private Map<String, MethodValue<T>> methods;
-    private ImmutableMap<String, StaticMethodValue> staticMethods;
+    private Map<String, StaticMethodValue> staticMethods;
 
     public ConcreteType(
             String name,
             Map<String, MethodValue<T>> methods,
-            ImmutableMap<String, StaticMethodValue> staticMethods) {
+            Map<String, StaticMethodValue> staticMethods) {
         this.name = name;
         this.methods = methods;
         this.staticMethods = staticMethods;