RELOAD: Maintain identity of static tear-offs.

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 942 matching lines @@
 
 #ifdef DEBUG
   VerifyMaps();
 #endif
 
   {
     TIMELINE_SCOPE(CopyStaticFieldsAndPatchFieldsAndFunctions);
     // 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();
-
+    Array& functions = Array::Handle();
+    Function& old_func = Function::Handle();
+    String& selector = String::Handle();
+    Function& new_func = Function::Handle();
+    Instance& old_closure = Instance::Handle();
+    Instance& new_closure = Instance::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();
+
+          // Map implicit static closures.
+          functions = old_cls.functions();

[Cutch, 2016/08/01 22:26:04]

please factor this into a function that lives in object_reload.cc

[rmacnak, 2016/08/02 00:43:45]

Done.

+          for (intptr_t i = 0; i < functions.Length(); i++) {
+            old_func ^= functions.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();
+                AddBecomeMapping(old_closure, new_closure);
+              }
+            }
+          }

[turnidge, 2016/08/01 21:04:28]

Perhaps this should be implemented in a separate function on Class.  You might
need to expose AddBecomeMapping.

         }
       }
     }
 
     class_map.Release();
   }
 
   // Copy over certain properties of libraries, e.g. is the library
   // debuggable?
   {
@@ skipping 594 matching lines @@
         ASSERT(!super_cls.IsNull());
         super_cls.AddDirectSubclass(cls);
       }
     }
   }
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart