From 7324dc0bd7c70c0be4a28ca2bba5522cceaf277f Mon Sep 17 00:00:00 2001 From: Michael Williamson Date: Tue, 6 Oct 2015 13:44:18 +0100 Subject: Add basic implementation of instance methods --- .../couscous/interpreter/values/ConcreteType.java | 43 +++++++++++++++++----- .../interpreter/values/MethodCallArguments.java | 17 +++++++++ .../couscous/interpreter/values/MethodValue.java | 8 ++-- .../interpreter/values/ObjectInterpreterValue.java | 23 ++++++++++++ .../interpreter/values/StaticMethodValue.java | 6 +-- .../interpreter/values/StringInterpreterValue.java | 7 ++-- 6 files changed, 84 insertions(+), 20 deletions(-) create mode 100644 src/main/java/org/zwobble/couscous/interpreter/values/MethodCallArguments.java create mode 100644 src/main/java/org/zwobble/couscous/interpreter/values/ObjectInterpreterValue.java (limited to 'src/main/java/org/zwobble/couscous/interpreter/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 method( String name, List argumentsTypes, - BiFunction method) { - methods.put(name, new MethodValue(argumentsTypes, (receiver, arguments) -> { - return Casts.tryCast(interpreterValueType, receiver) - .map(typedReceiver -> method.apply(typedReceiver, arguments)) + BiFunction, 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 staticMethod( String name, List argumentsTypes, - BiFunction method) { + BiFunction 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 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 arguments) { + public InterpreterValue callMethod(Environment environment, InterpreterValue receiver, String methodName, List 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 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 arguments) { + return new ObjectInterpreterValue(this); } private static T findMethod(Map methods, String methodName, List 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 { + 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 argumentTypes; @Getter(value=AccessLevel.NONE) - BiFunction apply; + BiFunction, InterpreterValue> apply; - public InterpreterValue apply(InterpreterValue receiver, Arguments arguments) { - return apply.apply(receiver, arguments); + public InterpreterValue apply(Environment environment, MethodCallArguments 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 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 argumentTypes; @Getter(value=AccessLevel.NONE) - BiFunction apply; + BiFunction 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(); -- cgit v1.2.3