clang-format runtime/vm

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 40 matching lines @@
   ASSERT(!edge_counters_array.IsNull());
   // Fill edge counters array with zeros.
   const Smi& zero = Smi::Handle(Smi::New(0));
   for (intptr_t i = 0; i < edge_counters_array.Length(); i++) {
     edge_counters_array.SetAt(i, zero);
   }
 }
 
 
 void Code::ResetICDatas(Zone* zone) const {
-  // Iterate over the Code's object pool and reset all ICDatas.
+// Iterate over the Code's object pool and reset all ICDatas.
 #ifdef TARGET_ARCH_IA32
   // IA32 does not have an object pool, but, we can iterate over all
   // embedded objects by using the variable length data section.
   if (!is_alive()) {
     return;
   }
   const Instructions& instrs = Instructions::Handle(zone, instructions());
   ASSERT(!instrs.IsNull());
   uword base_address = instrs.PayloadStart();
   Object& object = Object::Handle(zone);
@@ skipping 82 matching lines @@
     const Array& my_constants = Array::Handle(constants());
     ASSERT(my_constants.Length() == 0);
   }
 #endif  // defined(DEBUG).
   // Copy old constants into new class.
   const Array& old_constants = Array::Handle(old_cls.constants());
   if (old_constants.IsNull() || old_constants.Length() == 0) {
     return;
   }
   TIR_Print("Copied %" Pd " canonical constants for class `%s`\n",
-            old_constants.Length(),
-            ToCString());
+            old_constants.Length(), ToCString());
   set_constants(old_constants);
 }
 
 
 void Class::CopyCanonicalType(const Class& old_cls) const {
   const Type& old_canonical_type = Type::Handle(old_cls.canonical_type());
   if (old_canonical_type.IsNull()) {
     return;
   }
   set_canonical_type(old_canonical_type);
@@ skipping 55 matching lines @@
 
   Array& enum_fields = Array::Handle(zone);
   Field& field = Field::Handle(zone);
   String& enum_ident = String::Handle();
   Instance& old_enum_value = Instance::Handle(zone);
   Instance& enum_value = Instance::Handle(zone);
   // The E.values array.
   Instance& old_enum_values = Instance::Handle(zone);
   // The E.values array.
   Instance& enum_values = Instance::Handle(zone);
-  Array& enum_map_storage = Array::Handle(zone,
-      HashTables::New<UnorderedHashMap<EnumMapTraits> >(4));
+  Array& enum_map_storage =
+      Array::Handle(zone, HashTables::New<UnorderedHashMap<EnumMapTraits> >(4));
   ASSERT(!enum_map_storage.IsNull());
 
   TIR_Print("Replacing enum `%s`\n", String::Handle(Name()).ToCString());
 
   {
     UnorderedHashMap<EnumMapTraits> enum_map(enum_map_storage.raw());
     // Build a map of all enum name -> old enum instance.
     enum_fields = old_enum.fields();
     for (intptr_t i = 0; i < enum_fields.Length(); i++) {
       field = Field::RawCast(enum_fields.At(i));
@@ skipping 56 matching lines @@
     enum_map_storage = enum_map.Release().raw();
   }
 
   // Map the old E.values array to the new E.values array.
   ASSERT(!old_enum_values.IsNull());
   ASSERT(!enum_values.IsNull());
   reload_context->AddEnumBecomeMapping(old_enum_values, enum_values);
 
   if (enums_deleted && FLAG_trace_reload_verbose) {
     // TODO(johnmccutchan): Add this to the reload 'notices' list.
-    VTIR_Print("The following enum values were deleted and are forever lost in "
-               "the heap:\n");
+    VTIR_Print(
+        "The following enum values were deleted and are forever lost in "
+        "the heap:\n");
     UnorderedHashMap<EnumMapTraits> enum_map(enum_map_storage.raw());
     UnorderedHashMap<EnumMapTraits>::Iterator it(&enum_map);
     while (it.MoveNext()) {
       const intptr_t entry = it.Current();
       enum_ident = String::RawCast(enum_map.GetKey(entry));
       ASSERT(!enum_ident.IsNull());
     }
     enum_map.Release();
   }
 }
@@ skipping 47 matching lines @@
 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()) {
+    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();
         if (old_closure.IsCanonical()) {
           new_closure.SetCanonical();
         }
         irc->AddBecomeMapping(old_closure, new_closure);
       }
     }
   }
 }
 
 
 class EnumClassConflict : public ClassReasonForCancelling {
  public:
   EnumClassConflict(Zone* zone, const Class& from, const Class& to)
-      : ClassReasonForCancelling(zone, from, 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",
+            ? "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(Zone* zone,
                        const Class& from,
                        const Class& to,
                        const Error& error)
-      : ClassReasonForCancelling(zone, from, to), error_(error) { }
+      : ClassReasonForCancelling(zone, from, to), error_(error) {}
 
  private:
   const Error& error_;
 
   RawError* ToError() { return error_.raw(); }
 
-  RawString* ToString() {
-    return String::New(error_.ToErrorCString());
-  }
+  RawString* ToString() { return String::New(error_.ToErrorCString()); }
 };
 
 
 class NativeFieldsConflict : public ClassReasonForCancelling {
  public:
   NativeFieldsConflict(Zone* zone, const Class& from, const Class& to)
-      : ClassReasonForCancelling(zone, from, to) { }
+      : ClassReasonForCancelling(zone, from, to) {}
 
  private:
   RawString* ToString() {
-    return String::NewFormatted(
-        "Number of native fields changed in %s", from_.ToCString());
+    return String::NewFormatted("Number of native fields changed in %s",
+                                from_.ToCString());
   }
 };
 
 
 class TypeParametersChanged : public ClassReasonForCancelling {
  public:
   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 {
+class PreFinalizedConflict : public ClassReasonForCancelling {
  public:
   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 {
+class InstanceSizeConflict : public ClassReasonForCancelling {
  public:
   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());
+    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(Zone* zone,
                                const Library& from,
                                const Library& to,
                                const String& name)
@@ skipping 15 matching lines @@
 };
 
 
 // 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(context->zone())
-            EnumClassConflict(context->zone(), *this, replacement));
+    context->AddReasonForCancelling(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(context->zone())
+          new (context->zone())
               EnsureFinalizedError(context->zone(), *this, replacement, error));
       return;  // No reason to check other properties.
     }
     ASSERT(replacement.is_finalized());
     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(context->zone())
-              NativeFieldsConflict(context->zone(), *this, replacement));
-      return;
+    context->AddReasonForCancelling(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;
   }
   if (is_prefinalized()) {
     if (!CanReloadPreFinalized(replacement, context)) return;
   }
   ASSERT(is_finalized() == replacement.is_finalized());
-  TIR_Print("Class `%s` can be reloaded (%" Pd " and %" Pd ")\n",
-            ToCString(), id(), replacement.id());
+  TIR_Print("Class `%s` can be reloaded (%" Pd " and %" Pd ")\n", ToCString(),
+            id(), replacement.id());
 }
 
 
-
 bool Class::RequiresInstanceMorphing(const Class& replacement) const {
   // Get the field maps for both classes. These field maps walk the class
   // hierarchy.
   const Array& fields = Array::Handle(OffsetToFieldMap());
-  const Array& replacement_fields
-      = Array::Handle(replacement.OffsetToFieldMap());
+  const Array& replacement_fields =
+      Array::Handle(replacement.OffsetToFieldMap());
 
   // Check that the size of the instance is the same.
   if (fields.Length() != replacement_fields.Length()) return true;
 
   // Check that we have the same next field offset. This check is not
   // redundant with the one above because the instance OffsetToFieldMap
   // array length is based on the instance size (which may be aligned up).
   if (next_field_offset() != replacement.next_field_offset()) return true;
 
   // Verify that field names / offsets match across the entire hierarchy.
@@ skipping 19 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(context->zone())
-            TypeParametersChanged(context->zone(), *this, replacement));
+    context->AddReasonForCancelling(new (context->zone()) TypeParametersChanged(
+        context->zone(), *this, replacement));
     return false;
   }
   if (RequiresInstanceMorphing(replacement)) {
-    context->AddInstanceMorpher(
-        new(context->zone())
-            InstanceMorpher(context->zone(), *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(context->zone())
-              PreFinalizedConflict(context->zone(), *this, replacement));
-      return false;
+    context->AddReasonForCancelling(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(context->zone())
-              InstanceSizeConflict(context->zone(), *this, replacement));
-      return false;
+    context->AddReasonForCancelling(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(context->zone())
-              UnimplementedDeferredLibrary(context->zone(),
-                                           *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(Zone* zone) const {
@@ skipping 46 matching lines @@
         cls = cls.SuperClass();
       }
     } else {
       // This can be incorrect if the call site was an unqualified invocation.
       const Class& cls = Class::Handle(zone, old_target.Owner());
       new_target = cls.LookupStaticFunction(selector);
     }
 
     const Array& args_desc_array = Array::Handle(zone, arguments_descriptor());
     ArgumentsDescriptor args_desc(args_desc_array);
-    if (new_target.IsNull() ||
-        !new_target.AreValidArguments(args_desc, NULL)) {
+    if (new_target.IsNull() || !new_target.AreValidArguments(args_desc, NULL)) {
       // TODO(rmacnak): Patch to a NSME stub.
       VTIR_Print("Cannot rebind static call to %s from %s\n",
                  old_target.ToCString(),
                  Object::Handle(zone, Owner()).ToCString());
       return;
     }
     ClearAndSetStaticTarget(new_target);
   } else {
     intptr_t num_args = NumArgsTested();
     if (num_args == 2) {
       ClearWithSentinel();
     } else {
       const Array& data_array =
           Array::Handle(zone, CachedEmptyICDataArray(num_args));
       set_ic_data_array(data_array);
     }
   }
 }
 
 #endif  // !PRODUCT
 
-}   // namespace dart.
+}  // namespace dart.