Add support for implicit getters and setters

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';
 
 class NotImplemented {
   String message;
 
@@ skipping 101 matching lines @@
   }
 
   Value visitVariableGet(VariableGet node, env) {
     return env.lookup(node.variable);
   }
 
   Value visitVariableSet(VariableSet node, env) {
     return env.assign(node.variable, eval(node.value, env));
   }
 
+  Value visitPropertyGet(PropertyGet node, env) {
+    ObjectValue receiver = eval(node.receiver, env);

[Kevin Millikin (Google), 2017/03/23 10:42:51]

We have to support property get on things like int and String (.hashCode is an
obvious example).

I think that suggests that those classes have to be able to have getters and
setters too.

Perhaps it makes most sense to have a base Value class that has a superclass,
methods, getters, and setters, and then int, String, etc. are subclasses?

[zhivkag, 2017/03/23 13:50:39]

Indeed, thanks! Done.

+    return receiver.propertyGet(node.name);

[Kevin Millikin (Google), 2017/03/23 10:42:50]

I suggest we factor this slightly differently:

1. Look up the getter by name on the receiver's class.
2. Invoke it, whatever it is.

That looks like:

return receiver.class.lookupGetter(node.name)(receiver);

[zhivkag, 2017/03/23 13:50:38]

Done.

+  }
+
+  Value visitPropertySet(PropertySet node, env) {
+    ObjectValue receiver = eval(node.receiver, env);
+    Value value = eval(node.value, env);
+    return receiver.propertySet(node.name, value);
+  }
+
+  Value visitDirectPropertyGet(DirectPropertyGet node, env) {
+    ObjectValue receiver = eval(node.receiver, env);
+    return receiver.directPropertyGet(node.target);
+  }
+
+  Value visitDirectPropertySet(DirectPropertySet node, env) {
+    ObjectValue receiver = eval(node.receiver, env);
+    Value value = eval(node.value, env);
+    return receiver.directPropertySet(node.target, value);
+  }
+
+  Value visitStaticGet(StaticGet node, env) => defaultExpression(node, env);
+  Value visitStaticSet(StaticSet node, env) => defaultExpression(node, env);
+
   Value visitStaticInvocation(StaticInvocation node, env) {
     if ('print' == node.name.toString()) {
       // Special evaluation of print.
       var res = eval(node.arguments.positional[0], env);
       print(res.value);
       return Value.nullInstance;
     } else {
       throw new NotImplemented('Support for statement type '
           '${node.runtimeType} is not implemented');
     }
   }
 
   Value visitMethodInvocation(MethodInvocation node, env) {
     // Currently supports only method invocation with <2 arguments and is used
     // to evaluate implemented operators for int, double and String values.
     var receiver = eval(node.receiver, env);
     if (node.arguments.positional.isNotEmpty) {
       var argValue = eval(node.arguments.positional.first, env);
-      return receiver.invokeMethod(node.name.name, argValue);
+      return receiver.invokeMethod(node.name, argValue);
     } else {
-      return receiver.invokeMethod(node.name.name);
+      return receiver.invokeMethod(node.name);
     }
   }
 
-  Value visitConstructorInvocation(ConstructorInvocation node, env) =>
-      defaultExpression(node, env);
+  Value visitConstructorInvocation(ConstructorInvocation node, env) {
+    ClassDeclaration classDeclaration =
+        new ClassDeclaration(node.target.enclosingClass.reference);
+
+    Environment emptyEnv = new Environment.empty();
+    // Currently we don't support initializers.
+    // TODO: Modify to respect dart semantics for initialization.
+    //  1. Init fields and eval initializers, repeat the same with super.
+    //  2. Eval the Function body of the constructor.
+    List<Value> fields = classDeclaration.instanceFields
+        .map((Field f) => eval(f.initializer, emptyEnv))
+        .toList(growable: false);
+
+    return new ObjectValue(classDeclaration, fields);
+  }
 
   Value visitNot(Not node, env) {
     Value operand = eval(node.operand, env).toBoolean();
     return identical(operand, Value.trueInstance)
         ? Value.falseInstance
         : Value.trueInstance;
   }
 
   Value visitLogicalExpression(LogicalExpression node, env) {
     if ('||' == node.operator) {
@@ skipping 42 matching lines @@
     return eval(node.body, letEnv);
   }
 }
 
 // TODO(zhivkag): Change misleading name.
 // This is representation of a class in the interpreter, not a declaration.
 class ClassDeclaration {
   static final Map<Reference, ClassDeclaration> _classes =
       <Reference, ClassDeclaration>{};
 
-  Class currentClass;
-  ClassDeclaration superClass;
+  Class superClass;

[Kevin Millikin (Google), 2017/03/23 10:42:51]

We might not agree, but superclass is one word in both the Dart language spec
and in the Kernel AST implementation.  superClass ==> superclass.

[zhivkag, 2017/03/23 13:50:38]

Done.

+  List<Field> instanceFields = <Field>[];
+  List<Field> staticFields = <Field>[];
+  // Implicit getters and setters for instance Fields.
+  Map<Name, int> getters = <Name, int>{};

[Kevin Millikin (Google), 2017/03/23 10:42:51]

Thinking ahead, this needs to map names to getters (not just the implicit
getters).

I'd change that here to have:

typedef Value Getter(Value);

and:

Map<Name, Getter> getters ...

[zhivkag, 2017/03/23 13:50:38]

Done.

+  Map<Name, int> setters = <Name, int>{};
   // The initializers of static fields are evaluated the first time the field
   // is accessed.
-  List<Value> staticFields = <Value>[];
-  List<Procedure> getters = <Procedure>[];
-  List<Procedure> setters = <Procedure>[];
+  List<Value> staticFieldValues = <Value>[];
+
   List<Procedure> methods = <Procedure>[];
 
   factory ClassDeclaration(Reference classRef) {
     if (_classes.containsKey(classRef)) {
       return _classes[classRef];
     }
     _classes[classRef] = new ClassDeclaration._internal(classRef.asClass);
     return _classes[classRef];
   }
 
-  ClassDeclaration._internal(this.currentClass) {
+  ClassDeclaration._internal(Class currentClass) {
     if (currentClass.superclass != null) {
-      superClass = new ClassDeclaration(currentClass.superclass.reference);
+      superClass = currentClass.superclass;
     }
-    // TODO: Populate getters, setters and methods.
+
+    _populateInstanceFields(currentClass);
+
+    // Populate implicit setters and getters.
+    for (int i = 0; i < instanceFields.length; i++) {
+      Field f = instanceFields[i];
+      assert(f.hasImplicitGetter);
+      getters[f.name] = i;

[Kevin Millikin (Google), 2017/03/23 10:42:51]

So the getter function should be:

getters[f.name] = (Value receiver) => receiver.fields[i];

[zhivkag, 2017/03/23 13:50:38]

Done.

+      if (f.hasImplicitSetter) {
+        setters[f.name] = i;
+      }
+    }
+    // TODO: Populate methods.
+  }
+
+  Value propertyGet(ObjectValue object, Name name) {

[Kevin Millikin (Google), 2017/03/23 10:42:51]

The name should be the verb form: getProperty.

[zhivkag, 2017/03/23 13:50:38]

Done.

+    if (getters.containsKey(name)) {

[Kevin Millikin (Google), 2017/03/23 10:42:51]

We should look in the superclass for a getter.  If we factor this into first
looking up the getter and then invoking it, the lookup would be something like:

Getter lookupGetter(Name name) {
  Getter getter = getters[name];
  if (getter != null) return getter;
  if (superclass != null) return superclass.lookupGetter(name);
  return (Value receiver) => notImplemented(obj: name);
}

[zhivkag, 2017/03/23 13:50:38]

Makes sense, thanks! Done.

+      return (object.fields)[getters[name]];
+    }
+    // TODO: return NoSuchMethod if Name is not a Getter or Method tear-off
+    return notImplemented(obj: name);
+  }
+
+  Value propertySet(ObjectValue object, Name name, Value value) {

[Kevin Millikin (Google), 2017/03/23 10:42:51]

Likewise, I's split this into looking up the setter:

typedef void Setter(Value receiver, Value value);

Map<Name, Setter> setters = ...;

Setter lookupSetter(Name name) {
  Setter setter = setters[name];
  if (setter != null) return setter;
  if (superclass != null) return superclass.lookupSetter(name);
  return (Value receiver, Value value) => ...
}

And invoking the setter in the interpreter:

Value visitPropertySet(PropertySet node, Environment env) {
  Value receiver = eval(node.receiver, env);
  Value value = eval(node.value, env);
  receiver.class.lookupSetter(node.name)(receiver, value);
  return value;
}

[zhivkag, 2017/03/23 13:50:39]

Applied the suggestion but I have a doubt whether the setter should return
value. The type of setters being void, if we don't return value, does it make
sense to return Value.nullInstance instead? 

+    if (setters.containsKey(name)) {
+      object.fields[setters[name]] = value;
+    }
+    // TODO: return NoSuchMethodError if Name is not a Setter.
+    return Value.nullInstance;
+  }
+
+  Value directPropertyGet(ObjectValue object, Member member) {
+    if (member is Field) {
+      for (int i = 0; i < instanceFields.length; i++) {
+        if (identical(member, instanceFields[i])) {
+          return object.fields[i];
+        }
+      }
+      // TODO: throw NoSuchMethodError instead.
+      return notImplemented(m: 'NoSuchMethod: Field ${member} not found.');
+    }
+    return notImplemented(obj: member);
+  }
+
+  Value directPropertySet(ObjectValue object, Member member, Value value) {
+    if (member is Field) {
+      for (int i = 0; i < instanceFields.length; i++) {
+        if (identical(member, instanceFields[i])) {
+          object.fields[i] = value;
+        }
+        return Value.nullInstance;
+      }
+      // TODO: throw NoSuchMethodError instead.
+      return notImplemented(m: 'NoSuchMethod: Field $member not found.');
+    }
+    return notImplemented(obj: member);
+  }
+
+  // Populates with the instance fields of the current class and all its
+  // superclasses recursively.
+  _populateInstanceFields(Class class_) {
+    for (Field f in class_.fields) {
+      if (f.isInstanceMember) {
+        instanceFields.add(f);
+      }
+    }
+
+    if (class_.superclass != null) {
+      _populateInstanceFields(class_.superclass);
+    }
   }
 }
 
 abstract class Value {
   Object get value;
 
   static final NullValue nullInstance = const NullValue();
   static final BoolValue trueInstance = const BoolValue(true);
   static final BoolValue falseInstance = const BoolValue(false);
 
   const Value();
 
   BoolValue toBoolean() {
     return identical(this, Value.trueInstance)
         ? Value.trueInstance
         : Value.falseInstance;
   }
 
   BoolValue equals(Value other) =>
       value == other.value ? Value.trueInstance : Value.falseInstance;
 
-  Value invokeMethod(String name, [Value arg]) {
+  Value invokeMethod(Name name, [Value arg]) {
     throw notImplemented(obj: name);
   }
 }
 
 class ObjectValue extends Value {
   List<Value> fields;
   ClassDeclaration classDeclaration;
 
   Object get value => this;
 
-  ObjectValue(Constructor constructor, Environment env) {
-    // TODO: Init fields and eval initializers, repeat the same with super.
-    // TODO: Eval the Function body of the constructor, with env expanded with
-    // {VariableDeclaration("this") => this}
-    notImplemented(obj: constructor.name);
+  ObjectValue(this.classDeclaration, this.fields);
+
+  Value propertyGet(Name name) {
+    return classDeclaration.propertyGet(this, name);
   }
+
+  Value propertySet(Name name, Value value) =>
+      classDeclaration.propertySet(this, name, value);
+
+  Value directPropertyGet(Member member) =>
+      classDeclaration.directPropertyGet(this, member);
+  Value directPropertySet(Member member, Value value) =>
+      classDeclaration.directPropertySet(this, member, value);
 }
 
 class StringValue extends Value {
   final String value;
 
   static final operators = <String, Function>{
     '[]': (StringValue v1, Value v2) => v1[v2],
     '==': (StringValue v1, Value v2) => v1.equals(v2)
   };
 
   StringValue(this.value);
 
-  Value invokeMethod(String name, [Value arg]) {
-    if (!operators.containsKey(name)) {
+  Value invokeMethod(Name name, [Value arg]) {
+    if (!operators.containsKey(name.name)) {
       return notImplemented(obj: name);
     }
-    return operators[name](this, arg);
+    return operators[name.name](this, arg);
   }
 
   // Operators
   Value operator [](Value index) => new StringValue(value[index.value]);
 }
 
 abstract class NumValue extends Value {
   num get value;
 
   NumValue();
 
   factory NumValue.fromValue(num value) {
     if (value is int) {
       return new IntValue(value);
     } else {
       assert(value is double);
       return new DoubleValue(value);
     }
   }
 
   static final operators = <String, Function>{
     '+': (NumValue v1, Value v2) => v1 + v2,
     '-': (NumValue v1, Value v2) => v1 - v2,
     '>': (NumValue v1, Value v2) => v1 > v2,
     '<': (NumValue v1, Value v2) => v1 < v2,
     '==': (NumValue v1, Value v2) => v1.equals(v2),
     'unary-': (NumValue v1) => -v1,
   };
 
-  Value invokeMethod(String name, [Value arg]) {
-    if (!operators.containsKey(name)) return notImplemented(obj: name);
-    if (arg == null) return operators[name](this);
-    return operators[name](this, arg);
+  Value invokeMethod(Name name, [Value arg]) {
+    if (!operators.containsKey(name.name)) return notImplemented(obj: name);
+    if (arg == null) return operators[name.name](this);
+    return operators[name.name](this, arg);
   }
 
   // Operators
   NumValue operator +(Value other) =>
       new NumValue.fromValue(value + other.value);
   NumValue operator -(Value other) =>
       new NumValue.fromValue(value - other.value);
   NumValue operator -() => new NumValue.fromValue(-value);
 
   BoolValue operator >(Value other) =>
@@ skipping 22 matching lines @@
 
 class NullValue extends Value {
   Object get value => null;
 
   const NullValue();
 }
 
 notImplemented({String m, Object obj}) {
   throw new NotImplemented(m ?? 'Evaluation for $obj is not implemented');
 }