Make all reload zone allocations use the same zone

runtime/vm/object_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/object.h"
 
 #include "vm/hash_table.h"
 #include "vm/isolate_reload.h"
 #include "vm/log.h"
 #include "vm/resolver.h"
@@ skipping 347 matching lines @@
       ASSERT(owner.raw() == this->raw());
       field.set_owner(patch);
     }
     field.ForceDynamicGuardedCidAndLength();
   }
 }
 
 
 class EnumClassConflict : public ClassReasonForCancelling {
  public:
-  EnumClassConflict(const Class& from, const Class& to)
-      : ClassReasonForCancelling(from, to) { }
+  EnumClassConflict(Zone* zone, const Class& from, const Class& to)
+      : ClassReasonForCancelling(zone, from, to) { }
 
   RawString* ToString() {
     return String::NewFormatted(
         from_.is_enum_class()
         ? "Enum class cannot be redefined to be a non-enum class: %s"
         : "Class cannot be redefined to be a enum class: %s",
         from_.ToCString());
   }
 };
 
 
 class EnsureFinalizedError : public ClassReasonForCancelling {
  public:
-  EnsureFinalizedError(const Class& from, const Class& to, const Error& error)
-      : ClassReasonForCancelling(from, to), error_(error) { }
+  EnsureFinalizedError(Zone* zone,
+                       const Class& from,
+                       const Class& to,
+                       const Error& error)
+      : ClassReasonForCancelling(zone, from, to), error_(error) { }
 
  private:
   const Error& error_;
 
   RawError* ToError() { return error_.raw(); }
 
   RawString* ToString() {
     return String::New(error_.ToErrorCString());
   }
 };
 
 
 class NativeFieldsConflict : public ClassReasonForCancelling {
  public:
-  NativeFieldsConflict(const Class& from, const Class& to)
-      : ClassReasonForCancelling(from, to) { }
+  NativeFieldsConflict(Zone* zone, const Class& from, const Class& to)
+      : ClassReasonForCancelling(zone, from, to) { }
 
  private:
   RawString* ToString() {
     return String::NewFormatted(
         "Number of native fields changed in %s", from_.ToCString());
   }
 };
 
 
 class TypeParametersChanged : public ClassReasonForCancelling {
  public:
-  TypeParametersChanged(const Class& from, const Class& to)
-      : ClassReasonForCancelling(from, to) {}
+  TypeParametersChanged(Zone* zone, const Class& from, const Class& to)
+      : ClassReasonForCancelling(zone, from, to) {}
 
   RawString* ToString() {
     return String::NewFormatted(
         "Limitation: type parameters have changed for %s", from_.ToCString());
   }
 
   void AppendTo(JSONArray* array) {
     JSONObject jsobj(array);
     jsobj.AddProperty("type", "ReasonForCancellingReload");
     jsobj.AddProperty("kind", "TypeParametersChanged");
     jsobj.AddProperty("class", to_);
     jsobj.AddProperty("message",
                       "Limitation: changing type parameters "
                       "does not work with hot reload.");
   }
 };
 
 
 class PreFinalizedConflict :  public ClassReasonForCancelling {
  public:
-  PreFinalizedConflict(const Class& from, const Class& to)
-      : ClassReasonForCancelling(from, to) {}
+  PreFinalizedConflict(Zone* zone, const Class& from, const Class& to)
+      : ClassReasonForCancelling(zone, from, to) {}
 
  private:
   RawString* ToString() {
     return String::NewFormatted(
         "Original class ('%s') is prefinalized and replacement class "
         "('%s') is not ",
         from_.ToCString(), to_.ToCString());
   }
 };
 
 
 class InstanceSizeConflict :  public ClassReasonForCancelling {
  public:
-  InstanceSizeConflict(const Class& from, const Class& to)
-      : ClassReasonForCancelling(from, to) {}
+  InstanceSizeConflict(Zone* zone, const Class& from, const Class& to)
+      : ClassReasonForCancelling(zone, from, to) {}
 
  private:
   RawString* ToString() {
     return String::NewFormatted(
         "Instance size mismatch between '%s' (%" Pd ") and replacement "
         "'%s' ( %" Pd ")",
         from_.ToCString(),
         from_.instance_size(),
         to_.ToCString(),
         to_.instance_size());
   }
 };
 
 
 class UnimplementedDeferredLibrary : public ReasonForCancelling {
  public:
-  UnimplementedDeferredLibrary(const Library& from,
+  UnimplementedDeferredLibrary(Zone* zone,
+                               const Library& from,
                                const Library& to,
                                const String& name)
-      : ReasonForCancelling(), from_(from), to_(to), name_(name) {}
+      : ReasonForCancelling(zone), from_(from), to_(to), name_(name) {}
 
  private:
   const Library& from_;
   const Library& to_;
   const String& name_;
 
   RawString* ToString() {
     const String& lib_url = String::Handle(to_.url());
     from_.ToCString();
     return String::NewFormatted(
         "Reloading support for deferred loading has not yet been implemented:"
         " library '%s' has deferred import '%s'",
         lib_url.ToCString(), name_.ToCString());
   }
 };
 
 
 // This is executed before interating over the instances.
 void Class::CheckReload(const Class& replacement,
                         IsolateReloadContext* context) const {
   ASSERT(IsolateReloadContext::IsSameClass(*this, replacement));
 
   // Class cannot change enum property.
   if (is_enum_class() != replacement.is_enum_class()) {
     context->AddReasonForCancelling(
-        new EnumClassConflict(*this, replacement));
+        new(context->zone())
+            EnumClassConflict(context->zone(), *this, replacement));
     return;
   }
 
   if (is_finalized()) {
     // Ensure the replacement class is also finalized.
     const Error& error =
         Error::Handle(replacement.EnsureIsFinalized(Thread::Current()));
     if (!error.IsNull()) {
       context->AddReasonForCancelling(
-          new EnsureFinalizedError(*this, replacement, error));
+          new(context->zone())
+              EnsureFinalizedError(context->zone(), *this, replacement, error));
       return;  // No reason to check other properties.
     }
     TIR_Print("Finalized replacement class for %s\n", ToCString());
   }
 
   // Native field count cannot change.
   if (num_native_fields() != replacement.num_native_fields()) {
       context->AddReasonForCancelling(
-          new NativeFieldsConflict(*this, replacement));
+          new(context->zone())
+              NativeFieldsConflict(context->zone(), *this, replacement));
       return;
   }
 
   // Just checking.
   ASSERT(is_enum_class() == replacement.is_enum_class());
   ASSERT(num_native_fields() == replacement.num_native_fields());
 
   if (is_finalized()) {
     if (!CanReloadFinalized(replacement, context)) return;
   }
@@ skipping 46 matching lines @@
 bool Class::CanReloadFinalized(const Class& replacement,
                                IsolateReloadContext* context) const {
   // Make sure the declaration types matches for the two classes.
   // ex. class A<int,B> {} cannot be replace with class A<B> {}.
 
   const AbstractType& dt = AbstractType::Handle(DeclarationType());
   const AbstractType& replacement_dt =
       AbstractType::Handle(replacement.DeclarationType());
   if (!dt.Equals(replacement_dt)) {
     context->AddReasonForCancelling(
-        new TypeParametersChanged(*this, replacement));
+        new(context->zone())
+            TypeParametersChanged(context->zone(), *this, replacement));
     return false;
   }
   if (RequiresInstanceMorphing(replacement)) {
-    context->AddInstanceMorpher(new InstanceMorpher(*this, replacement));
+    context->AddInstanceMorpher(
+        new(context->zone())
+            InstanceMorpher(context->zone(), *this, replacement));
   }
   return true;
 }
 
 
 bool Class::CanReloadPreFinalized(const Class& replacement,
                                   IsolateReloadContext* context) const {
   // The replacement class must also prefinalized.
   if (!replacement.is_prefinalized()) {
       context->AddReasonForCancelling(
-          new PreFinalizedConflict(*this, replacement));
+          new(context->zone())
+              PreFinalizedConflict(context->zone(), *this, replacement));
       return false;
   }
   // Check the instance sizes are equal.
   if (instance_size() != replacement.instance_size()) {
       context->AddReasonForCancelling(
-          new InstanceSizeConflict(*this, replacement));
+          new(context->zone())
+              InstanceSizeConflict(context->zone(), *this, replacement));
       return false;
   }
   return true;
 }
 
 
 void Library::CheckReload(const Library& replacement,
                           IsolateReloadContext* context) const {
   // TODO(26878): If the replacement library uses deferred loading,
   // reject it.  We do not yet support reloading deferred libraries.
   LibraryPrefix& prefix = LibraryPrefix::Handle();
   LibraryPrefixIterator it(replacement);
   while (it.HasNext()) {
     prefix = it.GetNext();
     if (prefix.is_deferred_load()) {
       const String& prefix_name = String::Handle(prefix.name());
       context->AddReasonForCancelling(
-          new UnimplementedDeferredLibrary(*this, replacement, prefix_name));
+          new(context->zone())
+              UnimplementedDeferredLibrary(context->zone(),
+                                           *this, replacement, prefix_name));
       return;
     }
   }
 }
 
 
 static const Function* static_call_target = NULL;
 
 
 void ICData::Reset() const {
@@ skipping 63 matching lines @@
     }
     ClearAndSetStaticTarget(new_target);
   } else {
     ClearWithSentinel();
   }
 }
 
 #endif  // !PRODUCT
 
 }   // namespace dart.