VM: Re-format to use at most one newline between functions

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/hash_table.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/program_visitor.h"
 #include "vm/runtime_entry.h"
 #include "vm/symbols.h"
 #include "vm/timeline.h"
 #include "vm/type_table.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_classes, false, "Prints details about loaded classes.");
 DEFINE_FLAG(bool, reify, true, "Reify type arguments of generic types.");
 DEFINE_FLAG(bool, trace_class_finalization, false, "Trace class finalization.");
 DEFINE_FLAG(bool, trace_type_finalization, false, "Trace type finalization.");
 
-
 bool ClassFinalizer::AllClassesFinalized() {
   ObjectStore* object_store = Isolate::Current()->object_store();
   const GrowableObjectArray& classes =
       GrowableObjectArray::Handle(object_store->pending_classes());
   return classes.Length() == 0;
 }
 
-
 // Removes optimized code once we load more classes, since CHA based
 // optimizations may have become invalid.
 // Only methods which owner classes where subclasses can be invalid.
 // TODO(srdjan): Be even more precise by recording the exact CHA optimization.
 static void RemoveCHAOptimizedCode(
     const Class& subclass,
     const GrowableArray<intptr_t>& added_subclass_to_cids) {
   ASSERT(FLAG_use_cha_deopt);
   if (added_subclass_to_cids.is_empty()) {
     return;
   }
   // Switch all functions' code to unoptimized.
   const ClassTable& class_table = *Isolate::Current()->class_table();
   Class& cls = Class::Handle();
   for (intptr_t i = 0; i < added_subclass_to_cids.length(); i++) {
     intptr_t cid = added_subclass_to_cids[i];
     cls = class_table.At(cid);
     ASSERT(!cls.IsNull());
     cls.DisableCHAOptimizedCode(subclass);
   }
 }
 
-
 void AddSuperType(const AbstractType& type,
                   GrowableArray<intptr_t>* finalized_super_classes) {
   ASSERT(type.HasResolvedTypeClass());
   ASSERT(!type.IsDynamicType());
   if (type.IsObjectType()) {
     return;
   }
   const Class& cls = Class::Handle(type.type_class());
   ASSERT(cls.is_finalized());
   const intptr_t cid = cls.id();
   for (intptr_t i = 0; i < finalized_super_classes->length(); i++) {
     if ((*finalized_super_classes)[i] == cid) {
       // Already added.
       return;
     }
   }
   finalized_super_classes->Add(cid);
   const AbstractType& super_type = AbstractType::Handle(cls.super_type());
   AddSuperType(super_type, finalized_super_classes);
 }
 
-
 // Use array instead of set since we expect very few subclassed classes
 // to occur.
 static void CollectFinalizedSuperClasses(
     const Class& cls_,
     GrowableArray<intptr_t>* finalized_super_classes) {
   Class& cls = Class::Handle(cls_.raw());
   AbstractType& super_type = Type::Handle();
   super_type = cls.super_type();
   if (!super_type.IsNull()) {
     if (!super_type.IsMalformed() && super_type.HasResolvedTypeClass()) {
       cls ^= super_type.type_class();
       if (cls.is_finalized()) {
         AddSuperType(super_type, finalized_super_classes);
       }
     }
   }
 }
 
-
 static void CollectImmediateSuperInterfaces(const Class& cls,
                                             GrowableArray<intptr_t>* cids) {
   const Array& interfaces = Array::Handle(cls.interfaces());
   Class& ifc = Class::Handle();
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < interfaces.Length(); ++i) {
     type ^= interfaces.At(i);
     if (type.IsMalformed()) continue;
     if (!type.HasResolvedTypeClass()) continue;
     ifc ^= type.type_class();
     for (intptr_t j = 0; j < cids->length(); ++j) {
       if ((*cids)[j] == ifc.id()) {
         // Already added.
         return;
       }
     }
     cids->Add(ifc.id());
   }
 }
 
-
 // Processing ObjectStore::pending_classes_ occurs:
 // a) when bootstrap process completes (VerifyBootstrapClasses).
 // b) after the user classes are loaded (dart_api).
 bool ClassFinalizer::ProcessPendingClasses(bool from_kernel) {
   Thread* thread = Thread::Current();
   NOT_IN_PRODUCT(TimelineDurationScope tds(thread, Timeline::GetIsolateStream(),
                                            "ProcessPendingClasses"));
   Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
   HANDLESCOPE(thread);
@@ skipping 46 matching lines @@
     VerifyImplicitFieldOffsets();  // Verification after an error may fail.
 
     return true;
   } else {
     return false;
   }
   UNREACHABLE();
   return true;
 }
 
-
 // Adds all interfaces of cls into 'collected'. Duplicate entries may occur.
 // No cycles are allowed.
 void ClassFinalizer::CollectInterfaces(const Class& cls,
                                        GrowableArray<const Class*>* collected) {
   Zone* zone = Thread::Current()->zone();
   const Array& interface_array = Array::Handle(zone, cls.interfaces());
   AbstractType& interface = AbstractType::Handle(zone);
   Class& interface_class = Class::Handle(zone);
   for (intptr_t i = 0; i < interface_array.Length(); i++) {
     interface ^= interface_array.At(i);
     interface_class = interface.type_class();
     collected->Add(&Class::ZoneHandle(zone, interface_class.raw()));
     CollectInterfaces(interface_class, collected);
   }
 }
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 void ClassFinalizer::VerifyBootstrapClasses() {
   if (FLAG_trace_class_finalization) {
     OS::Print("VerifyBootstrapClasses START.\n");
   }
   ObjectStore* object_store = Isolate::Current()->object_store();
 
   Class& cls = Class::Handle();
 #if defined(DEBUG)
   // Basic checking.
@@ skipping 48 matching lines @@
                  err.ToErrorCString());
     OS::Exit(255);
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("VerifyBootstrapClasses END.\n");
   }
   Isolate::Current()->heap()->Verify();
 }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
-
 static bool IsLoaded(const Type& type) {
   if (type.HasResolvedTypeClass()) {
     return true;
   }
   const UnresolvedClass& unresolved_class =
       UnresolvedClass::Handle(type.unresolved_class());
   const Object& prefix =
       Object::Handle(unresolved_class.library_or_library_prefix());
   if (prefix.IsNull()) {
     return true;
   } else if (prefix.IsLibraryPrefix()) {
     return LibraryPrefix::Cast(prefix).is_loaded();
   } else {
     return true;
   }
 }
 
-
 // Resolve unresolved_class in the library of cls, or return null.
 RawClass* ClassFinalizer::ResolveClass(
     const Class& cls,
     const UnresolvedClass& unresolved_class) {
   const String& class_name = String::Handle(unresolved_class.ident());
   Library& lib = Library::Handle();
   Class& resolved_class = Class::Handle();
   if (unresolved_class.library_or_library_prefix() == Object::null()) {
     lib = cls.library();
     ASSERT(!lib.IsNull());
     resolved_class = lib.LookupClass(class_name);
   } else {
     const Object& prefix =
         Object::Handle(unresolved_class.library_or_library_prefix());
 
     if (prefix.IsLibraryPrefix()) {
       resolved_class = LibraryPrefix::Cast(prefix).LookupClass(class_name);
     } else {
       resolved_class = Library::Cast(prefix).LookupClass(class_name);
     }
   }
   return resolved_class.raw();
 }
 
-
 void ClassFinalizer::ResolveRedirectingFactory(const Class& cls,
                                                const Function& factory) {
   const Function& target = Function::Handle(factory.RedirectionTarget());
   if (target.IsNull()) {
     Type& type = Type::Handle(factory.RedirectionType());
     if (!type.IsMalformed() && IsLoaded(type)) {
       const GrowableObjectArray& visited_factories =
           GrowableObjectArray::Handle(GrowableObjectArray::New());
       ResolveRedirectingFactoryTarget(cls, factory, visited_factories);
     }
     if (factory.is_const()) {
       type = factory.RedirectionType();
       if (type.IsMalformedOrMalbounded()) {
         ReportError(Error::Handle(type.error()));
       }
     }
   }
 }
 
-
 void ClassFinalizer::ResolveRedirectingFactoryTarget(
     const Class& cls,
     const Function& factory,
     const GrowableObjectArray& visited_factories) {
   ASSERT(factory.IsRedirectingFactory());
 
   // Check for redirection cycle.
   for (intptr_t i = 0; i < visited_factories.Length(); i++) {
     if (visited_factories.At(i) == factory.raw()) {
       // A redirection cycle is reported as a compile-time error.
@@ skipping 128 matching lines @@
         FinalizeMalformedType(bound_error, script, target_type,
                               "cannot resolve redirecting factory");
         target_target = Function::null();
       }
     }
   }
   factory.SetRedirectionType(target_type);
   factory.SetRedirectionTarget(target_target);
 }
 
-
 void ClassFinalizer::ResolveTypeClass(const Class& cls, const Type& type) {
   if (type.IsFinalized()) {
     return;
   }
   if (FLAG_trace_type_finalization) {
     THR_Print("Resolve type class of '%s'\n",
               String::Handle(type.Name()).ToCString());
   }
 
   // Type parameters are always resolved in the parser in the correct
@@ skipping 33 matching lines @@
          (type.signature() != Function::null()));
 
   // Replace FutureOr<T> type of async library with dynamic.
   if ((type_class.library() == Library::AsyncLibrary()) &&
       (type_class.Name() == Symbols::FutureOr().raw())) {
     Type::Cast(type).set_type_class(Class::Handle(Object::dynamic_class()));
     type.set_arguments(Object::null_type_arguments());
   }
 }
 
-
 void ClassFinalizer::ResolveType(const Class& cls, const AbstractType& type) {
   if (type.IsResolved()) {
     return;
   }
   if (FLAG_trace_type_finalization) {
     THR_Print("Resolve type '%s'\n", String::Handle(type.Name()).ToCString());
   }
   if (type.IsType()) {
     ResolveTypeClass(cls, Type::Cast(type));
     if (type.IsMalformed()) {
@@ skipping 56 matching lines @@
           if (!scope_class.IsTypedefClass()) {
             signature.set_owner(Object::Handle());
             signature.set_token_pos(TokenPosition::kNoSource);
           }
         }
       }
     }
   }
 }
 
-
 void ClassFinalizer::FinalizeTypeParameters(const Class& cls,
                                             PendingTypes* pending_types) {
   if (FLAG_trace_type_finalization) {
     THR_Print("Finalizing type parameters of '%s'\n",
               String::Handle(cls.Name()).ToCString());
   }
   if (cls.IsMixinApplication()) {
     // Setup the type parameters of the mixin application and finalize the
     // mixin type.
     ApplyMixinType(cls, pending_types);
   }
   // The type parameter bounds are not finalized here.
   const TypeArguments& type_parameters =
       TypeArguments::Handle(cls.type_parameters());
   if (!type_parameters.IsNull()) {
     TypeParameter& type_parameter = TypeParameter::Handle();
     const intptr_t num_types = type_parameters.Length();
     for (intptr_t i = 0; i < num_types; i++) {
       type_parameter ^= type_parameters.TypeAt(i);
       type_parameter ^=
           FinalizeType(cls, type_parameter, kFinalize, pending_types);
       type_parameters.SetTypeAt(i, type_parameter);
     }
   }
 }
 
-
 // This function reports a compilation error if the recursive 'type' T being
 // finalized is a non-contractive type, i.e. if the induced type set S of P is
 // not finite, where P is the instantiation of T with its own type parameters.
 // The induced type set S consists of the super types of any type in S as well
 // as the type arguments of any parameterized type in S.
 // The Dart Language Specification does not disallow the declaration and use of
 // non-contractive types (this may change). They are nevertheless disallowed
 // as an implementation restriction in the VM since they cause divergence.
 // A non-contractive type can be detected by looking at the queue of types
 // pending finalization that are mutually recursive with the checked type.
@@ skipping 58 matching lines @@
                 instantiated_arguments, first_type_param, num_type_params)) {
           const String& type_name = String::Handle(zone, type.Name());
           ReportError(cls, type.token_pos(), "illegal recursive type '%s'",
                       type_name.ToCString());
         }
       }
     }
   }
 }
 
-
 // Expand the type arguments of the given type and finalize its full type
 // argument vector. Return the number of type arguments (0 for a raw type).
 intptr_t ClassFinalizer::ExpandAndFinalizeTypeArguments(
     const Class& cls,
     const AbstractType& type,
     PendingTypes* pending_types) {
   Zone* zone = Thread::Current()->zone();
   // The type class does not need to be finalized in order to finalize the type,
   // however, it must at least be resolved (this was done as part of resolving
   // the type itself, a precondition to calling FinalizeType).
@@ skipping 99 matching lines @@
     } else {
       ASSERT(full_arguments.IsNull());  // Use null vector for raw type.
     }
   }
 
   ASSERT(full_arguments.IsNull() ||
          !full_arguments.IsRaw(0, num_type_arguments));
   return full_arguments.IsNull() ? 0 : full_arguments.Length();
 }
 
-
 // Finalize the type argument vector 'arguments' of the type defined by the
 // class 'cls' parameterized with the type arguments 'cls_args'.
 // The vector 'cls_args' is already initialized as a subvector at the correct
 // position in the passed in 'arguments' vector.
 // The subvector 'cls_args' has length cls.NumTypeParameters() and starts at
 // offset cls.NumTypeArguments() - cls.NumTypeParameters() of the 'arguments'
 // vector.
 // The type argument vector of cls may overlap the type argument vector of its
 // super class. In case of an overlap, the overlapped type arguments of the
 // super class are already initialized. The still uninitialized ones have an
@@ skipping 144 matching lines @@
           }
         }
       }
       arguments.SetTypeAt(i, super_type_arg);
     }
     FinalizeTypeArguments(super_class, arguments, super_offset, bound_error,
                           pending_types, instantiation_trail);
   }
 }
 
-
 // Check the type argument vector 'arguments' against the corresponding bounds
 // of the type parameters of class 'cls' and, recursively, of its superclasses.
 // Replace a type argument that cannot be checked at compile time by a
 // BoundedType, thereby postponing the bound check to run time.
 // Return a bound error if a type argument is not within bound at compile time.
 void ClassFinalizer::CheckTypeArgumentBounds(const Class& cls,
                                              const TypeArguments& arguments,
                                              Error* bound_error) {
   if (!cls.is_type_finalized()) {
     FinalizeTypeParameters(cls);
@@ skipping 58 matching lines @@
         // bound check to run time, when the bound will be finalized.
         // The bound may not necessarily be 'IsBeingFinalized' yet, as is the
         // case with a pair of type parameters of the same class referring to
         // each other via their bounds.
         type_arg = BoundedType::New(type_arg, instantiated_bound, type_param);
         arguments.SetTypeAt(offset + i, type_arg);
         continue;
       }
       // Shortcut the special case where we check a type parameter against its
       // declared upper bound.
-      if (error.IsNull() &&
-          !(type_arg.Equals(type_param) &&
-            instantiated_bound.Equals(declared_bound))) {
+      if (error.IsNull() && !(type_arg.Equals(type_param) &&
+                              instantiated_bound.Equals(declared_bound))) {
         // If type_arg is a type parameter, its declared bound may not be
         // finalized yet.
         if (type_arg.IsTypeParameter()) {
           const Class& type_arg_cls = Class::Handle(
               TypeParameter::Cast(type_arg).parameterized_class());
           AbstractType& bound =
               AbstractType::Handle(TypeParameter::Cast(type_arg).bound());
           if (!bound.IsFinalized() && !bound.IsBeingFinalized()) {
             bound = FinalizeType(type_arg_cls, bound);
             TypeParameter::Cast(type_arg).set_bound(bound);
@@ skipping 14 matching lines @@
       }
     }
   }
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
     CheckTypeArgumentBounds(super_class, arguments, bound_error);
   }
 }
 
-
 void ClassFinalizer::CheckTypeBounds(const Class& cls,
                                      const AbstractType& type) {
   Zone* zone = Thread::Current()->zone();
   ASSERT(type.IsType());
   ASSERT(type.IsFinalized());
   ASSERT(!type.IsCanonical());
   TypeArguments& arguments = TypeArguments::Handle(zone, type.arguments());
   if (arguments.IsNull()) {
     return;
   }
@@ skipping 22 matching lines @@
                   bound_error.ToErrorCString());
       }
     }
   }
   if (FLAG_trace_type_finalization) {
     THR_Print("Done checking bounds of type '%s': %s\n",
               String::Handle(zone, type.Name()).ToCString(), type.ToCString());
   }
 }
 
-
 RawAbstractType* ClassFinalizer::FinalizeType(const Class& cls,
                                               const AbstractType& type,
                                               FinalizationKind finalization,
                                               PendingTypes* pending_types) {
   // Only the 'root' type of the graph can be canonicalized, after all depending
   // types have been bound checked.
   ASSERT((pending_types == NULL) || (finalization < kCanonicalize));
   if (type.IsFinalized()) {
     // Ensure type is canonical if canonicalization is requested, unless type is
     // malformed.
@@ skipping 165 matching lines @@
       THR_Print("Done canonicalizing type '%s'\n",
                 String::Handle(zone, canonical_type.Name()).ToCString());
       return canonical_type.raw();
     }
     return type.Canonicalize();
   } else {
     return type.raw();
   }
 }
 
-
 void ClassFinalizer::ResolveSignature(const Class& cls,
                                       const Function& function) {
   AbstractType& type = AbstractType::Handle();
   // Resolve upper bounds of function type parameters.
   const intptr_t num_type_params = function.NumTypeParameters();
   if (num_type_params > 0) {
     TypeParameter& type_param = TypeParameter::Handle();
     const TypeArguments& type_params =
         TypeArguments::Handle(function.type_parameters());
     for (intptr_t i = 0; i < num_type_params; i++) {
       type_param ^= type_params.TypeAt(i);
       type = type_param.bound();
       ResolveType(cls, type);
     }
   }
   // Resolve result type.
   type = function.result_type();
   // It is not a compile time error if this name does not resolve to a class or
   // interface.
   ResolveType(cls, type);
   // Resolve formal parameter types.
   const intptr_t num_parameters = function.NumParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = function.ParameterTypeAt(i);
     ResolveType(cls, type);
   }
 }
 
-
 void ClassFinalizer::FinalizeSignature(const Class& cls,
                                        const Function& function,
                                        FinalizationKind finalization) {
   AbstractType& type = AbstractType::Handle();
   AbstractType& finalized_type = AbstractType::Handle();
   // Finalize function type parameters and their upper bounds.
   const intptr_t num_parent_type_params = function.NumParentTypeParameters();
   const intptr_t num_type_params = function.NumTypeParameters();
   if (num_type_params > 0) {
     TypeParameter& type_param = TypeParameter::Handle();
@@ skipping 24 matching lines @@
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = function.ParameterTypeAt(i);
     finalized_type = FinalizeType(cls, type, finalization);
     // The parameter type may be malformed or malbounded.
     if (type.raw() != finalized_type.raw()) {
       function.SetParameterTypeAt(i, finalized_type);
     }
   }
 }
 
-
 // Check if an instance field, getter, or method of same name exists
 // in any super class.
 static RawClass* FindSuperOwnerOfInstanceMember(const Class& cls,
                                                 const String& name,
                                                 const String& getter_name) {
   Class& super_class = Class::Handle();
   Function& function = Function::Handle();
   Field& field = Field::Handle();
   super_class = cls.SuperClass();
   while (!super_class.IsNull()) {
     function = super_class.LookupFunction(name);
     if (!function.IsNull() && !function.is_static()) {
       return super_class.raw();
     }
     function = super_class.LookupFunction(getter_name);
     if (!function.IsNull() && !function.is_static()) {
       return super_class.raw();
     }
     field = super_class.LookupField(name);
     if (!field.IsNull() && !field.is_static()) {
       return super_class.raw();
     }
     super_class = super_class.SuperClass();
   }
   return Class::null();
 }
 
-
 // Check if an instance method of same name exists in any super class.
 static RawClass* FindSuperOwnerOfFunction(const Class& cls,
                                           const String& name) {
   Class& super_class = Class::Handle();
   Function& function = Function::Handle();
   super_class = cls.SuperClass();
   while (!super_class.IsNull()) {
     function = super_class.LookupFunction(name);
     if (!function.IsNull() && !function.is_static() &&
         !function.IsMethodExtractor()) {
       return super_class.raw();
     }
     super_class = super_class.SuperClass();
   }
   return Class::null();
 }
 
-
 // Resolve the upper bounds of the type parameters of class cls.
 void ClassFinalizer::ResolveUpperBounds(const Class& cls) {
   const intptr_t num_type_params = cls.NumTypeParameters();
   TypeParameter& type_param = TypeParameter::Handle();
   AbstractType& bound = AbstractType::Handle();
   const TypeArguments& type_params =
       TypeArguments::Handle(cls.type_parameters());
   ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
          (type_params.Length() == num_type_params));
   // In a first pass, resolve all bounds. This guarantees that finalization
   // of mutually referencing bounds will not encounter an unresolved bound.
   for (intptr_t i = 0; i < num_type_params; i++) {
     type_param ^= type_params.TypeAt(i);
     bound = type_param.bound();
     ResolveType(cls, bound);
   }
 }
 
-
 // Finalize the upper bounds of the type parameters of class cls.
 void ClassFinalizer::FinalizeUpperBounds(const Class& cls,
                                          FinalizationKind finalization) {
   const intptr_t num_type_params = cls.NumTypeParameters();
   TypeParameter& type_param = TypeParameter::Handle();
   AbstractType& bound = AbstractType::Handle();
   const TypeArguments& type_params =
       TypeArguments::Handle(cls.type_parameters());
   ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
          (type_params.Length() == num_type_params));
   for (intptr_t i = 0; i < num_type_params; i++) {
     type_param ^= type_params.TypeAt(i);
     bound = type_param.bound();
     // Bound may be finalized, but not canonical yet.
     if (bound.IsCanonical() || bound.IsBeingFinalized()) {
       // A bound involved in F-bounded quantification may form a cycle.
       continue;
     }
     bound = FinalizeType(cls, bound, finalization);
     type_param.set_bound(bound);
   }
 }
 
-
 void ClassFinalizer::ResolveAndFinalizeMemberTypes(const Class& cls) {
   // Note that getters and setters are explicitly listed as such in the list of
   // functions of a class, so we do not need to consider fields as implicitly
   // generating getters and setters.
   // Most overriding conflicts are only static warnings, i.e. they are not
   // reported as compile-time errors by the vm. However, signature conflicts in
   // overrides can be reported if the flag --error_on_bad_override is specified.
   // Static warning examples are:
   // - a static getter 'v' conflicting with an inherited instance setter 'v='.
   // - a static setter 'v=' conflicting with an inherited instance member 'v'.
@@ skipping 239 matching lines @@
         ReportError(cls, function.token_pos(),
                     "method '%s' of class '%s' conflicts with "
                     "getter '%s' of super class '%s'",
                     name.ToCString(), class_name.ToCString(), name.ToCString(),
                     super_cls_name.ToCString());
       }
     }
   }
 }
 
-
 // Clone the type parameters of the super class and of the mixin class of this
 // mixin application class and use them as the type parameters of this mixin
 // application class. Set the type arguments of the super type, of the mixin
 // type (as well as of the interface type, which is identical to the mixin type)
 // to refer to the respective type parameters of the mixin application class.
 // In other words, decorate this mixin application class with type parameters
 // that forward to the super type and mixin type (and interface type).
 // Example:
 //   class S<T extends BT> { }
 //   class M<T extends BT> { }
@@ skipping 171 matching lines @@
   }
   // If the mixin class is a mixin application alias class, we insert a new
   // synthesized mixin application class in the super chain of this mixin
   // application class. The new class will have the aliased mixin as actual
   // mixin.
   if (mixin_class.is_mixin_app_alias()) {
     ApplyMixinAppAlias(mixin_app_class, instantiator);
   }
 }
 
-
 /* Support for mixin alias.
 Consider the following example:
 
 class I<T> { }
 class J<T> { }
 class S<T extends num> { }
 class M<T extends Map> { }
 class A<U, V extends List> = Object with M<Map<U, V>> implements I<V>;
 class C<T, K extends T> = S<T> with A<T, List<K>> implements J<K>;
 
@@ skipping 249 matching lines @@
         String::Handle(inserted_class.Name()).ToCString(),
         TypeArguments::Handle(inserted_class.type_parameters()).ToCString(),
         String::Handle(zone, super_type.Name()).ToCString(),
         num_super_type_params + num_aliased_mixin_type_params,
         super_type.ToCString(),
         String::Handle(mixin_app_class.Name()).ToCString(),
         TypeArguments::Handle(mixin_app_class.type_parameters()).ToCString());
   }
 }
 
-
 void ClassFinalizer::ApplyMixinType(const Class& mixin_app_class,
                                     PendingTypes* pending_types) {
   if (mixin_app_class.is_mixin_type_applied()) {
     return;
   }
   Type& mixin_type = Type::Handle(mixin_app_class.mixin());
   ASSERT(!mixin_type.IsNull());
   ASSERT(mixin_type.HasResolvedTypeClass());
   const Class& mixin_class = Class::Handle(mixin_type.type_class());
 
@@ skipping 38 matching lines @@
   ASSERT(!mixin_type.IsBeingFinalized());
   mixin_type ^=
       FinalizeType(mixin_app_class, mixin_type, kFinalize, pending_types);
   // The mixin type cannot be malbounded, since it merely substitutes the
   // type parameters of the mixin class with those of the mixin application
   // class, but it does not instantiate them.
   ASSERT(!mixin_type.IsMalbounded());
   mixin_app_class.set_mixin(mixin_type);
 }
 
-
 void ClassFinalizer::CreateForwardingConstructors(
     const Class& mixin_app,
     const Class& mixin_cls,
     const GrowableObjectArray& cloned_funcs) {
   Thread* T = Thread::Current();
   Zone* Z = T->zone();
   const String& mixin_name = String::Handle(Z, mixin_app.Name());
   const Class& super_class = Class::Handle(Z, mixin_app.SuperClass());
   const String& super_name = String::Handle(Z, super_class.Name());
   const Array& functions = Array::Handle(Z, super_class.functions());
@@ skipping 42 matching lines @@
       // The parameter types of the cloned constructor are 'dynamic'.
       clone.set_parameter_types(Array::Handle(Z, Array::New(num_parameters)));
       for (intptr_t n = 0; n < num_parameters; n++) {
         clone.SetParameterTypeAt(n, Object::dynamic_type());
       }
       cloned_funcs.Add(clone);
     }
   }
 }
 
-
 void ClassFinalizer::ApplyMixinMembers(const Class& cls) {
   Zone* zone = Thread::Current()->zone();
   const Type& mixin_type = Type::Handle(zone, cls.mixin());
   ASSERT(!mixin_type.IsNull());
   ASSERT(mixin_type.HasResolvedTypeClass());
   const Class& mixin_cls = Class::Handle(zone, mixin_type.type_class());
   FinalizeClass(mixin_cls);
   // If the mixin is a mixin application alias class, there are no members to
   // apply here. A new synthesized class representing the aliased mixin
   // application class was inserted in the super chain of this mixin application
@@ skipping 79 matching lines @@
     }
   }
   cls.AddFields(cloned_fields);
 
   if (FLAG_trace_class_finalization) {
     THR_Print("Done applying mixin members of %s to %s\n",
               mixin_cls.ToCString(), cls.ToCString());
   }
 }
 
-
 void ClassFinalizer::FinalizeTypesInClass(const Class& cls) {
   Thread* thread = Thread::Current();
   HANDLESCOPE(thread);
   if (cls.is_type_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
     THR_Print("Finalize types in %s\n", cls.ToCString());
   }
   if (!IsSuperCycleFree(cls)) {
@@ skipping 138 matching lines @@
     // Marking the bootstrap classes as is_refinalize_after_patch seems cute but
     // it causes other things to fail by violating their assumptions.  Reenable
     // this ASSERT if it's important, remove it if it's just a sanity check and
     // not required for correctness.
     //
     // ASSERT((Array::Handle(cls.functions()).Length() == 0) ||
     //        cls.is_refinalize_after_patch());
   }
 }
 
-
 void ClassFinalizer::FinalizeClass(const Class& cls) {
   Thread* thread = Thread::Current();
   HANDLESCOPE(thread);
   ASSERT(cls.is_type_finalized());
   if (cls.is_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
     THR_Print("Finalize %s\n", cls.ToCString());
   }
@@ skipping 56 matching lines @@
     GrowableArray<intptr_t> cids;
     CollectFinalizedSuperClasses(cls, &cids);
     CollectImmediateSuperInterfaces(cls, &cids);
     RemoveCHAOptimizedCode(cls, cids);
   }
   if (cls.is_enum_class()) {
     AllocateEnumValues(cls);
   }
 }
 
-
 // Allocate instances for each enumeration value, and populate the
 // static field 'values'.
 // By allocating the instances programmatically, we save an implicit final
 // getter function object for each enumeration value and for the
 // values field. We also don't have to generate the code for these getters
 // from thin air (no source code is available).
 void ClassFinalizer::AllocateEnumValues(const Class& enum_cls) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   const Field& index_field =
@@ skipping 60 matching lines @@
     field.RecordStore(enum_value);
     intptr_t ord = Smi::Cast(ordinal_value).Value();
     ASSERT(ord < values_list.Length());
     values_list.SetAt(ord, enum_value);
   }
   values_list.MakeImmutable();
   values_list ^= values_list.CheckAndCanonicalize(thread, &error_msg);
   ASSERT(!values_list.IsNull());
 }
 
-
 bool ClassFinalizer::IsSuperCycleFree(const Class& cls) {
   Class& test1 = Class::Handle(cls.raw());
   Class& test2 = Class::Handle(cls.SuperClass());
   // A finalized class has been checked for cycles.
   // Using the hare and tortoise algorithm for locating cycles.
   while (!test1.is_type_finalized() && !test2.IsNull() &&
          !test2.is_type_finalized()) {
     if (test1.raw() == test2.raw()) {
       // Found a cycle.
       return false;
     }
     test1 = test1.SuperClass();
     test2 = test2.SuperClass();
     if (!test2.IsNull()) {
       test2 = test2.SuperClass();
     }
   }
   // No cycles.
   return true;
 }
 
-
 // Returns false if a function type alias illegally refers to itself.
 bool ClassFinalizer::IsTypedefCycleFree(const Class& cls,
                                         const AbstractType& type,
                                         GrowableArray<intptr_t>* visited) {
   ASSERT(visited != NULL);
   ResolveType(cls, type);
   bool checking_typedef = false;
   if (type.IsType() && !type.IsMalformed()) {
     AbstractType& other_type = AbstractType::Handle();
     if (type.IsFunctionType()) {
@@ skipping 54 matching lines @@
         }
       }
     }
     if (checking_typedef) {
       visited->RemoveLast();
     }
   }
   return true;
 }
 
-
 // Returns false if the mixin illegally refers to itself.
 bool ClassFinalizer::IsMixinCycleFree(const Class& cls,
                                       GrowableArray<intptr_t>* visited) {
   ASSERT(visited != NULL);
   const intptr_t cls_index = cls.id();
   for (intptr_t i = 0; i < visited->length(); i++) {
     if ((*visited)[i] == cls_index) {
       // We have already visited mixin 'cls'. We found a cycle.
       return false;
     }
@@ skipping 11 matching lines @@
       if (!IsMixinCycleFree(mixin_class, visited)) {
         return false;
       }
     }
     super_class = super_class.SuperClass();
   } while (!super_class.IsNull());
   visited->RemoveLast();
   return true;
 }
 
-
 void ClassFinalizer::CollectTypeArguments(
     const Class& cls,
     const Type& type,
     const GrowableObjectArray& collected_args) {
   ASSERT(type.HasResolvedTypeClass());
   Class& type_class = Class::Handle(type.type_class());
   TypeArguments& type_args = TypeArguments::Handle(type.arguments());
   const intptr_t num_type_parameters = type_class.NumTypeParameters();
   const intptr_t num_type_arguments =
       type_args.IsNull() ? 0 : type_args.Length();
@@ skipping 16 matching lines @@
     }
     // Discard provided type arguments and treat type as raw.
   }
   // Fill arguments with type dynamic.
   for (intptr_t i = 0; i < num_type_parameters; i++) {
     arg = Type::DynamicType();
     collected_args.Add(arg);
   }
 }
 
-
 RawType* ClassFinalizer::ResolveMixinAppType(
     const Class& cls,
     const MixinAppType& mixin_app_type) {
   // Lookup or create mixin application classes in the library of cls
   // and resolve super type and mixin types.
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   const Library& library = Library::Handle(zone, cls.library());
   ASSERT(!library.IsNull());
   const Script& script = Script::Handle(zone, cls.script());
@@ skipping 146 matching lines @@
   }
   // The mixin application class at depth k is a subclass of mixin application
   // class at depth k - 1. Build a new super type with the class at the highest
   // depth (the last one processed by the loop above) as the type class and the
   // collected type arguments from the super type and all mixin types.
   // This super type replaces the MixinAppType object in the class that extends
   // the mixin application.
   return Type::New(mixin_app_class, mixin_app_args, mixin_app_type.token_pos());
 }
 
-
 // Recursively walks the graph of explicitly declared super type and
 // interfaces, resolving unresolved super types and interfaces.
 // Reports an error if there is an interface reference that cannot be
 // resolved, or if there is a cycle in the graph. We detect cycles by
 // remembering interfaces we've visited in each path through the
 // graph. If we visit an interface a second time on a given path,
 // we found a loop.
 void ClassFinalizer::ResolveSuperTypeAndInterfaces(
     const Class& cls,
     GrowableArray<intptr_t>* visited) {
@@ skipping 166 matching lines @@
       }
     }
     interface_class.set_is_implemented();
     // Now resolve the super interfaces.
     ResolveSuperTypeAndInterfaces(interface_class, visited);
   }
   visited->RemoveLast();
   cls.set_is_cycle_free();
 }
 
-
 // A class is marked as constant if it has one constant constructor.
 // A constant class can only have final instance fields.
 // Note: we must check for cycles before checking for const properties.
 void ClassFinalizer::CheckForLegalConstClass(const Class& cls) {
   ASSERT(cls.is_const());
   const Array& fields_array = Array::Handle(cls.fields());
   intptr_t len = fields_array.Length();
   Field& field = Field::Handle();
   for (intptr_t i = 0; i < len; i++) {
     field ^= fields_array.At(i);
     if (!field.is_static() && !field.is_final()) {
       const String& class_name = String::Handle(cls.Name());
       const String& field_name = String::Handle(field.name());
       ReportError(cls, field.token_pos(),
                   "const class '%s' has non-final field '%s'",
                   class_name.ToCString(), field_name.ToCString());
     }
   }
 }
 
-
 void ClassFinalizer::PrintClassInformation(const Class& cls) {
   Thread* thread = Thread::Current();
   HANDLESCOPE(thread);
   const String& class_name = String::Handle(cls.Name());
   THR_Print("class '%s'", class_name.ToCString());
   const Library& library = Library::Handle(cls.library());
   if (!library.IsNull()) {
     THR_Print(" library '%s%s':\n", String::Handle(library.url()).ToCString(),
               String::Handle(library.private_key()).ToCString());
   } else {
@@ skipping 53 matching lines @@
   if (!type.IsFinalized()) {
     type.SetIsFinalized();
     // Do not canonicalize malformed types, since they contain an error field.
   } else {
     // The only case where the malformed type was already finalized is when its
     // type arguments are not within bounds. In that case, we have a prev_error.
     ASSERT(!prev_error.IsNull());
   }
 }
 
-
 RawType* ClassFinalizer::NewFinalizedMalformedType(const Error& prev_error,
                                                    const Script& script,
                                                    TokenPosition type_pos,
                                                    const char* format,
                                                    ...) {
   va_list args;
   va_start(args, format);
   const UnresolvedClass& unresolved_class =
       UnresolvedClass::Handle(UnresolvedClass::New(LibraryPrefix::Handle(),
                                                    Symbols::Empty(), type_pos));
   const Type& type = Type::Handle(
       Type::New(unresolved_class, Object::null_type_arguments(), type_pos));
   MarkTypeMalformed(prev_error, script, type, format, args);
   va_end(args);
   ASSERT(type.IsMalformed());
   ASSERT(type.IsFinalized());
   return type.raw();
 }
 
-
 void ClassFinalizer::FinalizeMalformedType(const Error& prev_error,
                                            const Script& script,
                                            const Type& type,
                                            const char* format,
                                            ...) {
   va_list args;
   va_start(args, format);
   MarkTypeMalformed(prev_error, script, type, format, args);
   va_end(args);
 }
 
-
 void ClassFinalizer::FinalizeMalboundedType(const Error& prev_error,
                                             const Script& script,
                                             const AbstractType& type,
                                             const char* format,
                                             ...) {
   va_list args;
   va_start(args, format);
   LanguageError& error = LanguageError::Handle(LanguageError::NewFormattedV(
       prev_error, script, type.token_pos(), Report::AtLocation,
       Report::kMalboundedType, Heap::kOld, format, args));
   va_end(args);
   if (Isolate::Current()->error_on_bad_type()) {
     ReportError(error);
   }
   type.set_error(error);
   if (!type.IsFinalized()) {
     type.SetIsFinalized();
     // Do not canonicalize malbounded types.
   }
 }
 
-
 void ClassFinalizer::ReportError(const Error& error) {
   Report::LongJump(error);
   UNREACHABLE();
 }
 
-
 void ClassFinalizer::ReportErrors(const Error& prev_error,
                                   const Class& cls,
                                   TokenPosition token_pos,
                                   const char* format,
                                   ...) {
   va_list args;
   va_start(args, format);
   const Script& script = Script::Handle(cls.script());
   Report::LongJumpV(prev_error, script, token_pos, format, args);
   va_end(args);
   UNREACHABLE();
 }
 
-
 void ClassFinalizer::ReportError(const Class& cls,
                                  TokenPosition token_pos,
                                  const char* format,
                                  ...) {
   va_list args;
   va_start(args, format);
   const Script& script = Script::Handle(cls.script());
   Report::MessageV(Report::kError, script, token_pos, Report::AtLocation,
                    format, args);
   va_end(args);
   UNREACHABLE();
 }
 
-
 void ClassFinalizer::VerifyImplicitFieldOffsets() {
 #ifdef DEBUG
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   Zone* zone = thread->zone();
   const ClassTable& class_table = *(isolate->class_table());
   Class& cls = Class::Handle(zone);
   Array& fields_array = Array::Handle(zone);
   Field& field = Field::Handle(zone);
   String& name = String::Handle(zone);
@@ skipping 53 matching lines @@
   fields_array ^= cls.fields();
   ASSERT(fields_array.Length() == ByteBuffer::NumberOfFields());
   field ^= fields_array.At(0);
   ASSERT(field.Offset() == ByteBuffer::data_offset());
   name ^= field.name();
   expected_name ^= String::New("_data");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
 #endif
 }
 
-
 void ClassFinalizer::SortClasses() {
   Thread* T = Thread::Current();
   Zone* Z = T->zone();
   Isolate* I = T->isolate();
   ClassTable* table = I->class_table();
   intptr_t num_cids = table->NumCids();
   intptr_t* old_to_new_cid = new intptr_t[num_cids];
   for (intptr_t cid = 0; cid < kNumPredefinedCids; cid++) {
     old_to_new_cid[cid] = cid;  // The predefined classes cannot change cids.
   }
@@ skipping 53 matching lines @@
       }
     }
   }
   ASSERT(next_new_cid == num_cids);
 
   RemapClassIds(old_to_new_cid);
   delete[] old_to_new_cid;
   RehashTypes();  // Types use cid's as part of their hashes.
 }
 
-
 class CidRewriteVisitor : public ObjectVisitor {
  public:
   explicit CidRewriteVisitor(intptr_t* old_to_new_cids)
       : old_to_new_cids_(old_to_new_cids) {}
 
   intptr_t Map(intptr_t cid) {
     ASSERT(cid != -1);
     return old_to_new_cids_[cid];
   }
 
@@ skipping 24 matching lines @@
         // which are write-protected.
         obj->SetClassId(new_cid);
       }
     }
   }
 
  private:
   intptr_t* old_to_new_cids_;
 };
 
-
 void ClassFinalizer::RemapClassIds(intptr_t* old_to_new_cid) {
   Isolate* I = Thread::Current()->isolate();
 
   // Code, ICData, allocation stubs have now-invalid cids.
   ClearAllCode();
 
   {
     HeapIterationScope his;
     I->set_remapping_cids(true);
 
     // Update the class table. Do it before rewriting cids in headers, as the
     // heap walkers load an object's size *after* calling the visitor.
     I->class_table()->Remap(old_to_new_cid);
 
     // Rewrite cids in headers and cids in Classes, Fields, Types and
     // TypeParameters.
     {
       CidRewriteVisitor visitor(old_to_new_cid);
       I->heap()->VisitObjects(&visitor);
     }
     I->set_remapping_cids(false);
   }
 
 #if defined(DEBUG)
   I->class_table()->Validate();
   I->heap()->Verify();
 #endif
 }
 
-
 class ClearTypeHashVisitor : public ObjectVisitor {
  public:
   explicit ClearTypeHashVisitor(Zone* zone)
       : type_param_(TypeParameter::Handle(zone)),
         type_(Type::Handle(zone)),
         type_args_(TypeArguments::Handle(zone)),
         bounded_type_(BoundedType::Handle(zone)) {}
 
   void VisitObject(RawObject* obj) {
     if (obj->IsTypeParameter()) {
@@ skipping 11 matching lines @@
     }
   }
 
  private:
   TypeParameter& type_param_;
   Type& type_;
   TypeArguments& type_args_;
   BoundedType& bounded_type_;
 };
 
-
 void ClassFinalizer::RehashTypes() {
   Thread* T = Thread::Current();
   Zone* Z = T->zone();
   Isolate* I = T->isolate();
 
   // Clear all cached hash values.
   {
     HeapIterationScope his;
     ClearTypeHashVisitor visitor(Z);
     I->heap()->VisitObjects(&visitor);
@@ skipping 46 matching lines @@
       HashTables::New<CanonicalTypeArgumentsSet>(dict_size, Heap::kOld);
   CanonicalTypeArgumentsSet typeargs_table(Z, typeargs_array.raw());
   for (intptr_t i = 0; i < typeargs.Length(); i++) {
     typearg ^= typeargs.At(i);
     bool present = typeargs_table.Insert(typearg);
     ASSERT(!present || typearg.IsRecursive());
   }
   object_store->set_canonical_type_arguments(typeargs_table.Release());
 }
 
-
 void ClassFinalizer::ClearAllCode() {
   class ClearCodeFunctionVisitor : public FunctionVisitor {
     void Visit(const Function& function) {
       function.ClearCode();
       function.ClearICDataArray();
     }
   };
   ClearCodeFunctionVisitor function_visitor;
   ProgramVisitor::VisitFunctions(&function_visitor);
 
   class ClearCodeClassVisitor : public ClassVisitor {
     void Visit(const Class& cls) { cls.DisableAllocationStub(); }
   };
   ClearCodeClassVisitor class_visitor;
   ProgramVisitor::VisitClasses(&class_visitor);
 }
 
 }  // namespace dart