RELOAD: Maintain identity of static tear-offs.

R=turnidge@google.com

Review URL: https://codereview.chromium.org/2194333002 .

Author: rmacnak-google

runtime/vm/isolate_reload.cc

@@ -970,25 +970,25 @@ void IsolateReloadContext::Commit() {
     // Copy static field values from the old classes to the new classes.
     // Patch fields and functions in the old classes so that they retain
     // the old script.
-    Class& cls = Class::Handle();
+    Class& old_cls = Class::Handle();
     Class& new_cls = Class::Handle();
-
     UnorderedHashMap<ClassMapTraits> class_map(class_map_storage_);
 
     {
       UnorderedHashMap<ClassMapTraits>::Iterator it(&class_map);
       while (it.MoveNext()) {
         const intptr_t entry = it.Current();
         new_cls = Class::RawCast(class_map.GetKey(entry));
-        cls = Class::RawCast(class_map.GetPayload(entry, 0));
-        if (new_cls.raw() != cls.raw()) {
-          ASSERT(new_cls.is_enum_class() == cls.is_enum_class());
+        old_cls = Class::RawCast(class_map.GetPayload(entry, 0));
+        if (new_cls.raw() != old_cls.raw()) {
+          ASSERT(new_cls.is_enum_class() == old_cls.is_enum_class());
           if (new_cls.is_enum_class() && new_cls.is_finalized()) {
-            new_cls.ReplaceEnum(cls);
+            new_cls.ReplaceEnum(old_cls);
           } else {
-            new_cls.CopyStaticFieldValues(cls);
+            new_cls.CopyStaticFieldValues(old_cls);
           }
-          cls.PatchFieldsAndFunctions();
+          old_cls.PatchFieldsAndFunctions();
+          old_cls.MigrateImplicitStaticClosures(this, new_cls);
         }
       }
     }

runtime/vm/isolate_reload_test.cc

@@ -1310,7 +1310,7 @@ TEST_CASE(IsolateReload_PendingSuperCall) {
 }
 
 
-TEST_CASE(IsolateReload_TearOff_Equality) {
+TEST_CASE(IsolateReload_TearOff_Instance_Equality) {
   const char* kScript =
       "import 'test:isolate_reload_helper';\n"
       "class C {\n"
@@ -1349,6 +1349,80 @@ TEST_CASE(IsolateReload_TearOff_Equality) {
 }
 
 
+TEST_CASE(IsolateReload_TearOff_Class_Identity) {
+  const char* kScript =
+      "import 'test:isolate_reload_helper';\n"
+      "class C {\n"
+      "  static foo() => 'old';\n"
+      "}\n"
+      "getFoo() => C.foo;\n"
+      "main() {\n"
+      "  var f1 = getFoo();\n"
+      "  reloadTest();\n"
+      "  var f2 = getFoo();\n"
+      "  return '${f1()} ${f2()} ${f1 == f2} ${identical(f1, f2)}';\n"
+      "}\n";
+
+  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
+  EXPECT_VALID(lib);
+
+  const char* kReloadScript =
+      "import 'test:isolate_reload_helper';\n"
+      "class C {\n"
+      "  static foo() => 'new';\n"
+      "}\n"
+      "getFoo() => C.foo;\n"
+      "main() {\n"
+      "  var f1 = getFoo();\n"
+      "  reloadTest();\n"
+      "  var f2 = getFoo();\n"
+      "  return '${f1()} ${f2()} ${f1 == f2} ${identical(f1, f2)}';\n"
+      "}\n";
+
+  TestCase::SetReloadTestScript(kReloadScript);
+
+  EXPECT_STREQ("new new true true", SimpleInvokeStr(lib, "main"));
+
+  lib = TestCase::GetReloadErrorOrRootLibrary();
+  EXPECT_VALID(lib);
+}
+
+
+TEST_CASE(IsolateReload_TearOff_Library_Identity) {
+  const char* kScript =
+      "import 'test:isolate_reload_helper';\n"
+      "foo() => 'old';\n"
+      "getFoo() => foo;\n"
+      "main() {\n"
+      "  var f1 = getFoo();\n"
+      "  reloadTest();\n"
+      "  var f2 = getFoo();\n"
+      "  return '${f1()} ${f2()} ${f1 == f2} ${identical(f1, f2)}';\n"
+      "}\n";
+
+  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
+  EXPECT_VALID(lib);
+
+  const char* kReloadScript =
+      "import 'test:isolate_reload_helper';\n"
+      "foo() => 'new';\n"
+      "getFoo() => foo;\n"
+      "main() {\n"
+      "  var f1 = getFoo();\n"
+      "  reloadTest();\n"
+      "  var f2 = getFoo();\n"
+      "  return '${f1()} ${f2()} ${f1 == f2} ${identical(f1, f2)}';\n"
+      "}\n";
+
+  TestCase::SetReloadTestScript(kReloadScript);
+
+  EXPECT_STREQ("new new true true", SimpleInvokeStr(lib, "main"));
+
+  lib = TestCase::GetReloadErrorOrRootLibrary();
+  EXPECT_VALID(lib);
+}
+
+
 TEST_CASE(IsolateReload_TearOff_List_Set) {
   const char* kScript =
       "import 'test:isolate_reload_helper';\n"

runtime/vm/object.h

@@ -1401,6 +1401,8 @@ class Class : public Object {
   void ReplaceEnum(const Class& old_enum) const;
   void CopyStaticFieldValues(const Class& old_cls) const;
   void PatchFieldsAndFunctions() const;
+  void MigrateImplicitStaticClosures(IsolateReloadContext* context,
+                                     const Class& new_cls) const;
   void CopyCanonicalConstants(const Class& old_cls) const;
   void CopyCanonicalType(const Class& old_cls) const;
   void CheckReload(const Class& replacement,

runtime/vm/object_reload.cc

@@ -363,6 +363,32 @@ void Class::PatchFieldsAndFunctions() const {
 }
 
 
+void Class::MigrateImplicitStaticClosures(IsolateReloadContext* irc,
+                                          const Class& new_cls) const {
+  const Array& funcs = Array::Handle(functions());
+  Function& old_func = Function::Handle();
+  String& selector = String::Handle();
+  Function& new_func = Function::Handle();
+  Instance& old_closure = Instance::Handle();
+  Instance& new_closure = Instance::Handle();
+  for (intptr_t i = 0; i < funcs.Length(); i++) {
+    old_func ^= funcs.At(i);
+    if (old_func.is_static() &&
+      old_func.HasImplicitClosureFunction()) {
+      selector = old_func.name();
+      new_func = new_cls.LookupFunction(selector);
+      if (!new_func.IsNull() && new_func.is_static()) {
+        old_func = old_func.ImplicitClosureFunction();
+        old_closure = old_func.ImplicitStaticClosure();
+        new_func = new_func.ImplicitClosureFunction();
+        new_closure = new_func.ImplicitStaticClosure();
+        irc->AddBecomeMapping(old_closure, new_closure);
+      }
+    }
+  }
+}
+
+
 class EnumClassConflict : public ClassReasonForCancelling {
  public:
   EnumClassConflict(const Class& from, const Class& to)