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 97 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 42 matching lines @@
     letEnv.expand(node.variable, value);
     return eval(node.body, letEnv);
   }
 }
 
 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) {
+  int get classSize => instanceFields.length;

[Kevin Millikin (Google), 2017/03/28 06:56:26]

This is more like instanceSize.

[zhivkag, 2017/03/28 09:18:14]

Done.

+
+  factory Class(Reference classRef) {
     if (_classes.containsKey(classRef)) {

[Kevin Millikin (Google), 2017/03/28 06:56:26]

This pattern is in the libraries as putIfAbsent so we could have:

return _classes.putIfAbsent(classRef,
    () => new Class._internal(classRef.asClass));

[zhivkag, 2017/03/28 09:18:14]

Done.

       return _classes[classRef];
     }
-    _classes[classRef] = new ClassDeclaration._internal(classRef.asClass);
+    _classes[classRef] = new Class._internal(classRef.asClass);
     return _classes[classRef];
   }
 
-  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++) {
+    for (int i = (superclass?.classSize ?? 0); i < instanceFields.length; i++) {

[Kevin Millikin (Google), 2017/03/28 06:56:26]

I think it makes sense to move this into _populateInstanceFields, so there we'd
have:

for (Field f in class_.fields) {
  if (f.isStatic) continue;
  instanceFields.add(f);
  assert(f.hasImplicitGetter);

  // Shadowing an inherited getter with the same name.
  getters[f.name] = ...;
  if (f.hasImplicitSetter) ...;
}

[zhivkag, 2017/03/28 09:18:14]

Done.

       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.
   }
@@ skipping 28 matching lines @@
       // 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_) {
+  _populateInstanceFields(ast.Class class_) {
+    if (class_.superclass != null) {
+      _populateInstanceFields(class_.superclass);
+    }
     for (Field f in class_.fields) {
       if (f.isInstanceMember) {
         instanceFields.add(f);
       }
     }
-
-    if (class_.superclass != null) {
-      _populateInstanceFields(class_.superclass);
-    }
   }
 }
 
 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');
 }