Add support for field initialization in objects

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 652 matching lines @@
         constructor.function, argValues);
 
     var newObject = new ObjectValue(constructor.enclosingClass);
     var cont = new InitializationEK(
         constructor, ctrEnv, new NewSK(continuation, new Location(newObject)));
 
     return new ValuePassingConfiguration(cont, newObject);
   }
 }
 
+/// Represents the application continuation applied on the list of evaluated
+/// field initializer expressions.
+class InstanceFieldsA extends ApplicationContinuation {
+  final Constructor constructor;
+  final Location location;
+  final Environment environment;
+  final ConstructorBodySK continuation;
+
+  final Class _currentClass;
+
+  InstanceFieldsA(
+      this.constructor, this.location, this.environment, this.continuation)
+      : _currentClass = new Class(constructor.enclosingClass.reference);
+
+  Configuration call(List<InterpreterValue> fieldValues) {
+    for (FieldInitializerValue f in fieldValues) {
+      // Directly set the field with the corresponding implicit setter.
+      _currentClass.implicitSetters[f.field.name](location.value, f.value);
+    }
+
+    // TODO(zhivkag): Execute constructor initializer list before initializing
+    // fields in immediately enclosing class to null.
+    _initializeNullFields(_currentClass, location.value);
+    return new ForwardConfiguration(continuation, environment);
+  }
+}
+
 // ------------------------------------------------------------------------
 //                           Expression Continuations
 // ------------------------------------------------------------------------
 
 /// Represents an expression continuation.
 ///
 /// There are various kinds of [ExpressionContinuation]s and their names are
 /// suffixed with "EK".
 abstract class ExpressionContinuation extends Continuation {
   Configuration call(Value v);
@@ skipping 270 matching lines @@
 
   InitializationEK(this.constructor, this.environment, this.continuation);
 
   Configuration call(Value value) {
     if (constructor.enclosingClass.superclass.superclass != null) {
       throw 'Support for super constructors in not implemented.';
     }
 
     if (constructor.initializers.isNotEmpty &&
         !(constructor.initializers.last is SuperInitializer)) {
-      throw 'Support for initializer is not implemented.';
+      throw 'Support for initializers is not implemented.';
     }
 
     // The statement body is captured by the next statement continuation and
     // expressions for field initialization are evaluated.
     var ctrEnv = environment.extendWithThis(value);
     var bodyCont =
         new ConstructorBodySK(constructor.function.body, ctrEnv, continuation);
-    // TODO(zhivkag): Add support for initialization of fields with initializers.
-    return new ForwardConfiguration(bodyCont, ctrEnv);
+    var initializers = _getFieldInitializers(constructor.enclosingClass);
+    var fieldsCont =
+        new InstanceFieldsA(constructor, new Location(value), ctrEnv, bodyCont);

[Dmitry Stefantsov, 2017/07/27 09:10:39]

I think [InstanceFieldsA] here is something different from FieldsA from the
spec?  Is it intentional?

[zhivkag, 2017/07/27 10:38:21]

It should be the same thing, except for the step (i.e. call method)*.
But you have a good point, I notice that in the specification we use directly
the initializer list. We would need to close over the class of the current
constructor being run too, to know which non-initialized fieds need to be
initialized to null eventually. 
This is why I would prefer to close over the target constructor instead. I
updated the specification.

*The call method is different because we don't have support for initializer list
here yet, which is in a followup CL.

[Dmitry Stefantsov, 2017/07/27 10:43:31]

Thanks for the explanation!

+    return new EvalListConfiguration(
+        initializers, new Environment.empty(), fieldsCont);
   }
 }
 
 /// Executes statements.
 ///
 /// Execution of a statement completes in one of the following ways:
 /// - It completes normally, in which case the execution proceeds to applying
 /// the next continuation.
 /// - It breaks with a label, in which case the corresponding continuation is
 /// returned and applied.
@@ skipping 379 matching lines @@
     var current = providedArgs.named[i];
     args.add(new NamedExpression(current.name, current.value));
     namedFormals.remove(current.name);
   }
 
   // Add missing optional named initializers.
   args.addAll(namedFormals.values);
 
   return args;
 }
+
+/// Creates a list of all field expressions to be evaluated.
+///
+/// A field expression is an initializer expression for a given field defined when

[Dmitry Stefantsov, 2017/07/27 09:10:39]

The line is too long.

[zhivkag, 2017/07/27 10:38:21]

Done.

+/// the field was created.
+List<InterpreterExpression> _getFieldInitializers(ast.Class class_) {
+  var fieldInitializers = new List<InterpreterExpression>();
+
+  for (Field f in class_.fields) {
+    if (f.initializer != null) {
+      fieldInitializers.add(new FieldInitializerExpression(f, f.initializer));
+    }
+  }
+
+  return fieldInitializers;
+}
+
+/// 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;
+    }
+  }
+}