Run field initializers for new instance fields after a reload

runtime/vm/isolate_reload.cc

 // Copyright (c) 2016, 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.
 
 #include "vm/isolate_reload.h"
 
 #include "vm/become.h"
 #include "vm/bit_vector.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 33 matching lines @@
 #define TIMELINE_SCOPE(name)                                                   \
     TimelineDurationScope tds##name(Thread::Current(),                         \
                                    Timeline::GetIsolateStream(),               \
                                    #name)
 
 
 InstanceMorpher::InstanceMorpher(Zone* zone, const Class& from, const Class& to)
     : from_(Class::Handle(zone, from.raw())),
       to_(Class::Handle(zone, to.raw())),
       mapping_(zone, 0) {
-  ComputeMapping();
   before_ = new(zone) ZoneGrowableArray<const Instance*>(zone, 0);
   after_ = new(zone) ZoneGrowableArray<const Instance*>(zone, 0);
+  new_fields_ = new(zone) ZoneGrowableArray<const Field*>(zone, 0);
   ASSERT(from_.id() == to_.id());
   cid_ = from_.id();
+  ComputeMapping();
 }
 
 
 void InstanceMorpher::AddObject(RawObject* object) const {
   ASSERT(object->GetClassId() == cid());
   const Instance& instance = Instance::Cast(Object::Handle(object));
   before_->Add(&instance);
 }
 
 
 void InstanceMorpher::ComputeMapping() {
   if (from_.NumTypeArguments()) {
     // Add copying of the optional type argument field.
     intptr_t from_offset = from_.type_arguments_field_offset();
     ASSERT(from_offset != Class::kNoTypeArguments);
     intptr_t to_offset = to_.type_arguments_field_offset();
     ASSERT(to_offset != Class::kNoTypeArguments);
     mapping_.Add(from_offset);
     mapping_.Add(to_offset);
   }
 
   // Add copying of the instance fields if matching by name.
   // Note: currently the type of the fields are ignored.
   const Array& from_fields = Array::Handle(from_.OffsetToFieldMap());
   const Array& to_fields = Array::Handle(to_.OffsetToFieldMap());
   Field& from_field = Field::Handle();
   Field& to_field = Field::Handle();
   String& from_name = String::Handle();
   String& to_name = String::Handle();
-  for (intptr_t i = 0; i < from_fields.Length(); i++) {
-    if (from_fields.At(i) == Field::null()) continue;  // Ignore non-fields.
-    from_field = Field::RawCast(from_fields.At(i));
-    ASSERT(from_field.is_instance());
-    from_name = from_field.name();
-    // We now have to find where this field is in the to class.
-    for (intptr_t j = 0; j < to_fields.Length(); j++) {
-      if (to_fields.At(j) == Field::null()) continue;  // Ignore non-fields.
-      to_field = Field::RawCast(to_fields.At(j));
-      ASSERT(to_field.is_instance());
-      to_name = to_field.name();
+
+  // Scan across all the fields in the new class definition.
+  for (intptr_t i = 0; i < to_fields.Length(); i++) {
+    if (to_fields.At(i) == Field::null()) {
+      continue;  // Ignore non-fields.
+    }
+
+    // Grab the field's name.
+    to_field = Field::RawCast(to_fields.At(i));
+    ASSERT(to_field.is_instance());
+    to_name = to_field.name();
+
+    // Did this field not exist in the old class definition?
+    bool new_field = true;
+
+    // Find this field in the old class.
+    for (intptr_t j = 0; j < from_fields.Length(); j++) {
+      if (from_fields.At(j) == Field::null()) {
+        continue;  // Ignore non-fields.
+      }
+      from_field = Field::RawCast(from_fields.At(j));
+      ASSERT(from_field.is_instance());
+      from_name = from_field.name();
       if (from_name.Equals(to_name)) {
         // Success
         mapping_.Add(from_field.Offset());
         mapping_.Add(to_field.Offset());
+        // Field did exist in old class deifnition.
+        new_field = false;
+      }
+    }
+
+    if (new_field) {
+      if (to_field.has_initializer()) {
+        // This is a new field with an initializer.
+        const Field& field = Field::Handle(to_field.raw());
+        new_fields_->Add(&field);
       }
     }
   }
 }
 
 
 RawInstance* InstanceMorpher::Morph(const Instance& instance) const {
   const Instance& result = Instance::Handle(Instance::New(to_));
   // Morph the context from instance to result using mapping_.
   for (intptr_t i = 0; i < mapping_.length(); i +=2) {
     intptr_t from_offset = mapping_.At(i);
     intptr_t to_offset = mapping_.At(i+1);
     const Object& value =
         Object::Handle(instance.RawGetFieldAtOffset(from_offset));
     result.RawSetFieldAtOffset(to_offset, value);
   }
   // Convert the instance into a filler object.
   Become::MakeDummyObject(instance);
   return result.raw();
 }
 
 
+void InstanceMorpher::RunNewFieldInitializers() const {
+  if ((new_fields_->length() == 0) || (after_->length() == 0)) {
+    return;
+  }
+
+  TIR_Print("Running new field initializers for class: %s\n", to_.ToCString());
+  String& initializing_expression = String::Handle();
+  Function& eval_func = Function::Handle();
+  Object& result = Object::Handle();
+  // For each new field.
+  for (intptr_t i = 0; i < new_fields_->length(); i++) {
+    // Create a function that returns the expression.
+    const Field* field = new_fields_->At(i);
+    // Extract the initializing expression.
+    initializing_expression = field->InitializingExpression();
+    TIR_Print("New `%s` has initializing expression `%s`\n",
+              field->ToCString(),
+              initializing_expression.ToCString());
+    eval_func ^=  Function::EvaluateHelper(to_,

[rmacnak, 2016/11/09 00:36:32]

to_ -> field.owner to get the right scope

Check for compile time error.

[Cutch, 2016/11/09 23:20:58]

Done.

+                                           initializing_expression,
+                                           Array::empty_array(),
+                                           true);
+    for (intptr_t j = 0; j < after_->length(); j++) {
+      const Instance* instance = after_->At(j);
+      TIR_Print("Initializing instance %" Pd " / %" Pd "\n",
+                j + 1,  after_->length());
+      /// Run the function and assign the field.
+      result = DartEntry::InvokeFunction(eval_func, Array::empty_array());

[rmacnak, 2016/11/09 00:36:32]

fail stop

if (result.IsError()) return result.raw();

[Cutch, 2016/11/09 23:20:58]

going with:

log error to standard error
leave field as null.

+      instance->RawSetFieldAtOffset(field->Offset(), result);
+    }
+  }
+}
+
+
 void InstanceMorpher::CreateMorphedCopies() const {
   for (intptr_t i = 0; i < before()->length(); i++) {
     const Instance& copy = Instance::Handle(Morph(*before()->At(i)));
     after()->Add(&copy);
   }
 }
 
 
 void InstanceMorpher::DumpFormatFor(const Class& cls) const {
   THR_Print("%s\n", cls.ToCString());
@@ skipping 1142 matching lines @@
     }
     ASSERT(index == count);
   }
 
   // This is important: The saved class table (describing before objects)
   // must be zapped to prevent the forwarding in GetClassForHeapWalkAt.
   // Instance will from now be described by the isolate's class table.
   free(saved_class_table_);
   saved_class_table_ = NULL;
   Become::ElementsForwardIdentity(before, after);
+
+  // Run new field initializers on all instances.
+  for (intptr_t i = 0; i < instance_morphers_.length(); i++) {
+    instance_morphers_.At(i)->RunNewFieldInitializers();

[rmacnak, 2016/11/09 00:36:32]

fail stop

[Cutch, 2016/11/09 23:20:58]

Acknowledged.

+  }
 }
 
 
 bool IsolateReloadContext::ValidateReload() {
   TIMELINE_SCOPE(ValidateReload);
   if (reload_aborted()) return false;
 
   TIR_Print("---- VALIDATING RELOAD\n");
 
   // Validate libraries.
@@ skipping 384 matching lines @@
         ASSERT(!super_cls.IsNull());
         super_cls.AddDirectSubclass(cls);
       }
     }
   }
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart