Remember owner class of patch code

runtime/vm/object.cc

 // Copyright (c) 2012, 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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 1769 matching lines @@
   return result;
 }
 
 
 // Apply the members from the patch class to the original class.
 const char* Class::ApplyPatch(const Class& patch) const {
   ASSERT(!is_finalized());
   // Shared handles used during the iteration.
   String& member_name = String::Handle();
 
-  const Script& patch_script = Script::Handle(patch.script());
-  const PatchClass& patch_class = PatchClass::Handle(
-      PatchClass::New(*this, patch_script));
+  const PatchClass& patch_class =
+      PatchClass::Handle(PatchClass::New(*this, patch));
 
   Array& orig_list = Array::Handle(functions());
   intptr_t orig_len = orig_list.Length();
   Array& patch_list = Array::Handle(patch.functions());
   intptr_t patch_len = patch_list.Length();
 
   // TODO(iposva): Verify that only patching existing methods and adding only
   // new private methods.
   Function& func = Function::Handle();
   Function& orig_func = Function::Handle();
@@ skipping 14 matching lines @@
       return FormatPatchError("mismatched parameters: %s", member_name);
     }
   }
   for (intptr_t i = 0; i < patch_len; i++) {
     func ^= patch_list.At(i);
     func.set_owner(patch_class);
     new_functions.Add(func);
   }
   Array& new_list = Array::Handle(Array::MakeArray(new_functions));
   SetFunctions(new_list);
 

[Ivan Posva, 2013/02/05 21:14:02]

At this point the functions in the patch class are not needed any longer. You
should
patch.SetFunctions(Array::Handle());

[Ivan Posva, 2013/02/05 21:16:08]

Correction your honor!

patch.SetFunctions(Object::empty_array());

   // Merge the two list of fields. Raise an error when duplicates are found or
   // when a public field is being added.
   orig_list = fields();
   orig_len = orig_list.Length();
   patch_list = patch.fields();
   patch_len = patch_list.Length();
 
   Field& field = Field::Handle();
   Field& orig_field = Field::Handle();
   new_list = Array::New(patch_len + orig_len);
   for (intptr_t i = 0; i < patch_len; i++) {
     field ^= patch_list.At(i);
     field.set_owner(*this);
     member_name = field.name();
     // TODO(iposva): Verify non-public fields only.
 
     // Verify no duplicate additions.
     orig_field ^= LookupField(member_name);
     if (!orig_field.IsNull()) {
       return FormatPatchError("duplicate field: %s", member_name);
     }
     new_list.SetAt(i, field);
   }
   for (intptr_t i = 0; i < orig_len; i++) {
     field ^= orig_list.At(i);
     new_list.SetAt(patch_len + i, field);
   }
   SetFields(new_list);

[Ivan Posva, 2013/02/05 21:14:02]

ditto for the fields:
patch.SetFields(Array::Handle());

[Ivan Posva, 2013/02/05 21:16:08]

ditto

   return NULL;
 }
 
 
 void Class::SetFields(const Array& value) const {
   ASSERT(!value.IsNull());
 #if defined(DEBUG)
   // Verify that all the fields in the array have this class as owner.
   Field& field = Field::Handle();
   intptr_t len = value.Length();
@@ skipping 1373 matching lines @@
   const Class& cls = Class::Handle(patched_class());
   const char* cls_name = cls.ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, cls_name) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, cls_name);
   return chars;
 }
 
 
 RawPatchClass* PatchClass::New(const Class& patched_class,
-                               const Script& script) {
+                               const Class& source_class) {
   const PatchClass& result = PatchClass::Handle(PatchClass::New());
   result.set_patched_class(patched_class);
-  result.set_script(script);
+  result.set_source_class(source_class);
   return result.raw();
 }
 
 
 RawPatchClass* PatchClass::New() {
   ASSERT(Object::patch_class_class() != Class::null());
   RawObject* raw = Object::Allocate(PatchClass::kClassId,
                                     PatchClass::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawPatchClass*>(raw);
 }
 
 
+RawScript* PatchClass::Script() const {
+  const Class& source_class = Class::Handle(this->source_class());
+  return source_class.script();
+}
+
+
 void PatchClass::set_patched_class(const Class& value) const {
   StorePointer(&raw_ptr()->patched_class_, value.raw());
 }
 
 
-void PatchClass::set_script(const Script& value) const {
-  StorePointer(&raw_ptr()->script_, value.raw());
+void PatchClass::set_source_class(const Class& value) const {
+  StorePointer(&raw_ptr()->source_class_, value.raw());
 }
 
 
 bool Function::HasBreakpoint() const {
   return Isolate::Current()->debugger()->HasBreakpoint(*this);
 }
 
 
 void Function::SetCode(const Code& value) const {
   StorePointer(&raw_ptr()->code_, value.raw());
@@ skipping 1085 matching lines @@
   return PatchClass::Cast(obj).patched_class();
 }
 
 
 RawScript* Function::script() const {
   const Object& obj = Object::Handle(raw_ptr()->owner_);
   if (obj.IsClass()) {
     return Class::Cast(obj).script();
   }
   ASSERT(obj.IsPatchClass());
-  return PatchClass::Cast(obj).script();
+  return PatchClass::Cast(obj).Script();
 }
 
 
 bool Function::HasOptimizedCode() const {
   return HasCode() && Code::Handle(raw_ptr()->code_).is_optimized();
 }
 
 
 RawString* Function::UserVisibleName() const {
   const String& str = String::Handle(name());
@@ skipping 8399 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart