Change layout of fields in a object values

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;
 
 class NotImplemented {
   String message;
 
   NotImplemented(this.message);
 
   String toString() => message;
 }
 
 class Interpreter {
@@ skipping 79 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) {
     Value receiver = eval(node.receiver, env);
-    return receiver.classDeclaration.lookupGetter(node.name)(receiver);
+    return receiver.class_.lookupGetter(node.name)(receiver);
   }
 
   Value visitPropertySet(PropertySet node, env) {
     Value receiver = eval(node.receiver, env);
     Value value = eval(node.value, env);
-    receiver.classDeclaration.lookupSetter(node.name)(receiver, value);
+    receiver.class_.lookupSetter(node.name)(receiver, value);
     return value;
   }
 
   Value visitDirectPropertyGet(DirectPropertyGet node, env) {
     Value receiver = eval(node.receiver, env);
-    return receiver.classDeclaration.getProperty(receiver, node.target);
+    return receiver.class_.getProperty(receiver, node.target);
   }
 
   Value visitDirectPropertySet(DirectPropertySet node, env) {
     Value receiver = eval(node.receiver, env);
     Value value = eval(node.value, env);
-    receiver.classDeclaration.setProperty(receiver, node.target, value);
+    receiver.class_.setProperty(receiver, node.target, value);
     return 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);
@@ skipping 11 matching lines @@
     var receiver = eval(node.receiver, env);
     if (node.arguments.positional.isNotEmpty) {
       var argValue = eval(node.arguments.positional.first, env);
       return receiver.invokeMethod(node.name, argValue);
     } else {
       return receiver.invokeMethod(node.name);
     }
   }
 
   Value visitConstructorInvocation(ConstructorInvocation node, env) {
-    ClassDeclaration classDeclaration =
-        new ClassDeclaration(node.target.enclosingClass.reference);
+    Class class_ = new Class(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))
+    List<Value> fields = class_.instanceFields
+        .map((Field f) => eval(f.initializer ?? new NullLiteral(), emptyEnv))
         .toList(growable: false);
 
-    return new ObjectValue(classDeclaration, fields);
+    return new ObjectValue(class_, 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) {
@@ skipping 88 matching lines @@
         : Value.nullInstance;
     env.expand(node, value);
   }
 }
 
 typedef Value Getter(Value receiver);
 typedef void Setter(Value receiver, Value value);
 
 // 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 Class {
+  static final Map<Reference, Class> _classes = <Reference, Class>{};
 
-  ClassDeclaration superclass;
+  Class superclass;
   List<Field> instanceFields = <Field>[];
   List<Field> staticFields = <Field>[];
   // Implicit getters and setters for instance Fields.
   Map<Name, Getter> getters = <Name, Getter>{};
   Map<Name, Setter> setters = <Name, Setter>{};
   // The initializers of static fields are evaluated the first time the field
   // is accessed.
   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];
+  int get instanceSize => instanceFields.length;
+
+  factory Class(Reference classRef) {
+    return _classes.putIfAbsent(
+        classRef, () => new Class._internal(classRef.asClass));
   }
 
-  ClassDeclaration._internal(Class currentClass) {
+  Class._internal(ast.Class currentClass) {
     if (currentClass.superclass != null) {
-      superclass = new ClassDeclaration(currentClass.superclass.reference);
+      superclass = new Class(currentClass.superclass.reference);
     }
 
     _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] = (Value receiver) => receiver.fields[i];
-      if (f.hasImplicitSetter) {
-        setters[f.name] =
-            (Value receiver, Value value) => receiver.fields[i] = value;
-      }
-    }
     // TODO: Populate methods.
   }
 
   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);
   }
 
@@ skipping 18 matching lines @@
     if (member is Field) {
       int index = instanceFields.indexOf(member);
       // TODO: throw NoSuchMethodError instead.
       if (index < 0) return notImplemented(m: 'NoSuchMethod: ${member}');
       object.fields[index] = value;
       return Value.nullInstance;
     }
     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);
-      }
+  /// Populates instance variables and the corresponding implicit getters and
+  /// setters for the current class and its superclass recursively.
+  _populateInstanceFields(ast.Class class_) {
+    if (class_.superclass != null) {
+      _populateInstanceFields(class_.superclass);
     }
 
-    if (class_.superclass != null) {
-      _populateInstanceFields(class_.superclass);
+    for (Field f in class_.fields) {
+      if (f.isStatic) continue;
+      instanceFields.add(f);
+      assert(f.hasImplicitGetter);
+
+      int currentFieldIndex = instanceFields.length - 1;
+
+      // Shadowing an inherited getter with the same name.
+      getters[f.name] = (Value receiver) => receiver.fields[currentFieldIndex];
+      if (f.hasImplicitSetter) {
+        // Shadowing an inherited setter with the same name.
+        setters[f.name] = (Value receiver, Value value) =>
+            receiver.fields[currentFieldIndex] = value;
+      }
     }
   }
 }
 
 abstract class Value {
-  ClassDeclaration get classDeclaration;
+  Class get class_;
   List<Value> get fields;
   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(Name name, [Value arg]) {
     throw notImplemented(obj: name);
   }
 }
 
 class ObjectValue extends Value {
-  ClassDeclaration classDeclaration;
+  Class class_;
   List<Value> fields;
   Object get value => this;
 
-  ObjectValue(this.classDeclaration, this.fields);
+  ObjectValue(this.class_, this.fields);
 }
 
 abstract class LiteralValue extends Value {
-  ClassDeclaration get classDeclaration =>
+  Class get class_ =>
       notImplemented(m: "Loading class for literal is not implemented.");
   List<Value> get fields =>
       notImplemented(m: "Literal value does not have fields");
 
   const LiteralValue();
 }
 
 class StringValue extends LiteralValue {
   final String value;
 
@@ skipping 77 matching lines @@
 
 class NullValue extends LiteralValue {
   Object get value => null;
 
   const NullValue();
 }
 
 notImplemented({String m, Object obj}) {
   throw new NotImplemented(m ?? 'Evaluation for $obj is not implemented');
 }