Implement support for property accessors

pkg/kernel/lib/interpreter/interpreter.dart

 // Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 library kernel.interpreter;
 
 import '../ast.dart';
 import '../ast.dart' as ast show Class;
 
 import '../log.dart';
 export '../log.dart';
@@ skipping 144 matching lines @@
   }
 
   Configuration visitVariableSet(VariableSet node, EvalConfiguration config) {
     var cont = new VariableSetEK(
         node.variable, config.environment, config.continuation);
     return new EvalConfiguration(
         node.value, config.environment, config.exceptionComponents, cont);
   }
 
   Configuration visitPropertyGet(PropertyGet node, EvalConfiguration config) {
-    var cont = new PropertyGetEK(node.name, config.continuation);
+    var cont = new PropertyGetEK(
+        node.name, config.exceptionComponents, config.continuation);
     return new EvalConfiguration(
         node.receiver, config.environment, config.exceptionComponents, cont);
   }
 
   Configuration visitPropertySet(PropertySet node, EvalConfiguration config) {
     var cont = new PropertySetEK(node.value, node.name, config.environment,
         config.exceptionComponents, config.continuation);
     return new EvalConfiguration(
         node.receiver, config.environment, config.exceptionComponents, cont);
   }
@@ skipping 780 matching lines @@
 
   Configuration call(Value v) {
     log.info('print(${v.value.runtimeType}: ${v.value})\n');
     print(v.value);
     return new ValuePassingConfiguration(continuation, Value.nullInstance);
   }
 }
 
 class PropertyGetEK extends ExpressionContinuation {
   final Name name;
+  final ExceptionComponents exceptionComponents;
   final ExpressionContinuation continuation;
 
-  PropertyGetEK(this.name, this.continuation);
+  PropertyGetEK(this.name, this.exceptionComponents, this.continuation);
 
   Configuration call(Value receiver) {
+    if (receiver.class_.isMethod(name)) {
+      var method = receiver.class_.lookup(name);
+      // Return the function value with this bound to receiver.
+      method.location.environment =
+          new Environment.empty().extendWithThis(receiver);
+      return new ValuePassingConfiguration(continuation, method);
+    }
+
+    if (receiver.class_.isGetter(name)) {
+      var getter = receiver.class_.lookup(name);
+      var state = new State.initial()
+          .withReturnContinuation(continuation)
+          .withContinuation(new ExitSK(continuation, Value.nullInstance))
+          .withException(exceptionComponents);
+      return new ExecConfiguration(getter.function.body,
+          new Environment.empty().extendWithThis(receiver), state);
+    }
+
     Value propertyValue = receiver.class_.lookupImplicitGetter(name)(receiver);
     return new ValuePassingConfiguration(continuation, propertyValue);
   }
 }
 
 class PropertySetEK extends ExpressionContinuation {
   final Expression value;
   final Name setterName;
   final Environment environment;
   final ExceptionComponents exceptionComponents;
   final ExpressionContinuation continuation;
 
   PropertySetEK(this.value, this.setterName, this.environment,
       this.exceptionComponents, this.continuation);
 
   Configuration call(Value receiver) {
-    var cont = new SetterEK(receiver, setterName, continuation);
+    var cont =
+        new SetterEK(receiver, setterName, exceptionComponents, continuation);
     return new EvalConfiguration(value, environment, exceptionComponents, cont);
   }
 }
 
 class SetterEK extends ExpressionContinuation {
   final Value receiver;
   final Name name;
+  final ExceptionComponents exceptionComponents;
   final ExpressionContinuation continuation;
 
-  SetterEK(this.receiver, this.name, this.continuation);
+  SetterEK(
+      this.receiver, this.name, this.exceptionComponents, this.continuation);
 
   Configuration call(Value v) {
+    if (receiver.class_.isSetter(name)) {
+      var setter = receiver.class_.lookup(name);
+      var env = new Environment.empty()
+          .extendWithThis(receiver)
+          .extend(setter.function.positionalParameters.first, v);
+      var state = new State.initial()
+          .withReturnContinuation(continuation)
+          .withContinuation(new ExitSK(continuation, Value.nullInstance))
+          .withException(exceptionComponents);
+      return new ExecConfiguration(setter.function.body, env, state);
+    }
+
     Setter setter = receiver.class_.lookupImplicitSetter(name);
     setter(receiver, v);
     return new ValuePassingConfiguration(continuation, v);
   }
 }
 
 /// Represents a continuation to be called after the evaluation of an actual
 /// argument for function invocation.
 class ExpressionListEK extends ExpressionContinuation {
   final InterpreterExpression currentExpression;
@@ skipping 17 matching lines @@
   final Arguments arguments;
   final Name methodName;
   final Environment environment;
   final ExceptionComponents exceptionComponents;
   final ExpressionContinuation continuation;
 
   MethodInvocationEK(this.arguments, this.methodName, this.environment,
       this.exceptionComponents, this.continuation);
 
   Configuration call(Value receiver) {
-    if (receiver is FunctionValue) {
-      // TODO(zhivkag): use method lookup instead.
-      assert(methodName.toString() == 'call');
-      var args = _getArgumentExpressions(arguments, receiver.function);
-      var acont =
-          new FunctionValueA(receiver, exceptionComponents, continuation);
-      return new EvalListConfiguration(
-          args, environment, exceptionComponents, acont);
+    if (receiver is LiteralValue) {
+      // TODO(zhivkag): CPS method invocation for literals
+      if (arguments.positional.isEmpty) {
+        Value returnValue = receiver.invokeMethod(methodName);
+        return new ValuePassingConfiguration(continuation, returnValue);
+      }
+      var cont = new ArgumentsEK(
+          receiver, methodName, arguments, environment, continuation);
+
+      return new EvalConfiguration(
+          arguments.positional.first, environment, exceptionComponents, cont);
     }
 
-    if (arguments.positional.isEmpty) {
-      Value returnValue = receiver.invokeMethod(methodName);
-      return new ValuePassingConfiguration(continuation, returnValue);
+    FunctionValue fun;
+    if (receiver is FunctionValue) {
+      assert(methodName.toString() == "call");

[Dmitry Stefantsov, 2017/08/16 08:48:55]

Maybe it's better to throw an exception here using the recently added exception
machinery?  At least, we may write a TODO for it now :)

[zhivkag, 2017/08/16 09:39:49]

Added a TODO.

+      fun = receiver;
+    } else {
+      assert(receiver.class_.isMethod(methodName));
+      fun = receiver.class_.lookup(methodName);
+      fun.location.environment =
+          new Environment.empty().extendWithThis(receiver);
     }
-    var cont = new ArgumentsEK(
-        receiver, methodName, arguments, environment, continuation);
 
-    return new EvalConfiguration(
-        arguments.positional.first, environment, exceptionComponents, cont);
+    var args = _getArgumentExpressions(arguments, fun.function);
+    var acont = new FunctionValueA(receiver, exceptionComponents, continuation);
+    return new EvalListConfiguration(
+        args, environment, exceptionComponents, acont);
   }
 }
 
 class ArgumentsEK extends ExpressionContinuation {
   final Value receiver;
   final Name methodName;
   final Arguments arguments;
   final Environment environment;
   final ExpressionContinuation continuation;
 
@@ skipping 629 matching lines @@
     Getter getter = implicitGetters[name];
     if (getter != null) return getter;
     if (superclass != null) return superclass.lookupImplicitGetter(name);
     return (Value receiver) => notImplemented(obj: name);
   }
 
   Setter lookupImplicitSetter(Name name) {
     Setter setter = implicitSetters[name];
     if (setter != null) return setter;
     if (superclass != null) return superclass.lookupImplicitSetter(name);
+    // todo: throw NoSuchInstance error instead.

[Dmitry Stefantsov, 2017/08/16 08:48:55]

todo ==> TODO

[zhivkag, 2017/08/16 09:39:49]

Done.

     return (Value receiver, Value value) => notImplemented(obj: name);
   }
 
+  FunctionValue lookup(Name name) {
+    var fun = methods[name]?.function;
+    assert(fun != null);
+    return new FunctionValue(fun, new EnvironmentLocation.empty());
+  }
+
+  bool isGetter(Name name) => methods[name]?.isGetter ?? false;
+  bool isSetter(Name name) => methods[name]?.isSetter ?? false;
+  bool isMethod(Name name) => !(methods[name]?.isAccessor ?? true);
+
   /// Populates implicit getters and setters for the current class and its
   /// superclass recursively.
   _populateImplicitGettersAndSetters(ast.Class class_) {
     if (class_.superclass != null) {
       _populateImplicitGettersAndSetters(class_.superclass);
     }
 
     for (Field f in class_.fields) {
       if (f.isStatic) continue;
       assert(f.hasImplicitGetter);
@@ skipping 236 matching lines @@
 /// Initializes all non initialized fields from the provided class to
 /// `Value.nullInstance` in the provided value.
 void _initializeNullFields(Class class_, Value value) {
   int startIndex = class_.superclass?.instanceSize ?? 0;
   for (int i = startIndex; i < class_.instanceSize; i++) {
     if (value.fields[i].value == null) {
       value.fields[i].value = Value.nullInstance;
     }
   }
 }