clang-format runtime/vm

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/code_generator.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
@@ skipping 60 matching lines @@
   }
   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) {
+    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) {
+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()) {
@@ skipping 57 matching lines @@
   } 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) {
+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);
   }
@@ skipping 76 matching lines @@
   const UnresolvedClass& unresolved_class =
       UnresolvedClass::Handle(type.unresolved_class());
   const LibraryPrefix& prefix =
       LibraryPrefix::Handle(unresolved_class.library_prefix());
   return prefix.IsNull() || prefix.is_loaded();
 }
 
 
 // Resolve unresolved_class in the library of cls, or return null.
 RawClass* ClassFinalizer::ResolveClass(
-      const Class& cls,
-      const UnresolvedClass& unresolved_class) {
+    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_prefix() == LibraryPrefix::null()) {
     lib = cls.library();
     ASSERT(!lib.IsNull());
     resolved_class = lib.LookupClass(class_name);
   } else {
     LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
     lib_prefix = unresolved_class.library_prefix();
     ASSERT(!lib_prefix.IsNull());
     resolved_class = lib_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);
     }
@@ skipping 44 matching lines @@
   }
   type ^= FinalizeType(cls, type, kCanonicalize);
   factory.SetRedirectionType(type);
   if (type.IsMalformedOrMalbounded()) {
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
   ASSERT(!type.IsTypeParameter());  // Resolved in parser.
   if (type.IsDynamicType()) {
     // Replace the type with a malformed type and compile a throw when called.
-    type = NewFinalizedMalformedType(
-        Error::Handle(),  // No previous error.
-        Script::Handle(cls.script()),
-        factory.token_pos(),
-        "factory may not redirect to 'dynamic'");
+    type = NewFinalizedMalformedType(Error::Handle(),  // No previous error.
+                                     Script::Handle(cls.script()),
+                                     factory.token_pos(),
+                                     "factory may not redirect to 'dynamic'");
     factory.SetRedirectionType(type);
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
   const Class& target_class = Class::Handle(type.type_class());
   String& target_class_name = String::Handle(target_class.Name());
-  String& target_name = String::Handle(
-      String::Concat(target_class_name, Symbols::Dot()));
+  String& target_name =
+      String::Handle(String::Concat(target_class_name, Symbols::Dot()));
   const String& identifier = String::Handle(factory.RedirectionIdentifier());
   if (!identifier.IsNull()) {
     target_name = String::Concat(target_name, identifier);
   }
 
   // Verify that the target constructor of the redirection exists.
   target = target_class.LookupConstructor(target_name);
   if (target.IsNull()) {
     target = target_class.LookupFactory(target_name);
   }
   if (target.IsNull()) {
     const String& user_visible_target_name =
         identifier.IsNull() ? target_class_name : target_name;
     // Replace the type with a malformed type and compile a throw when called.
     type = NewFinalizedMalformedType(
         Error::Handle(),  // No previous error.
-        Script::Handle(target_class.script()),
-        factory.token_pos(),
+        Script::Handle(target_class.script()), factory.token_pos(),
         "class '%s' has no constructor or factory named '%s'",
-        target_class_name.ToCString(),
-        user_visible_target_name.ToCString());
+        target_class_name.ToCString(), user_visible_target_name.ToCString());
     factory.SetRedirectionType(type);
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
 
   if (Isolate::Current()->error_on_bad_override()) {
     // Verify that the target is compatible with the redirecting factory.
     Error& error = Error::Handle();
     if (!target.HasCompatibleParametersWith(factory, &error)) {
       const Script& script = Script::Handle(target_class.script());
@@ skipping 33 matching lines @@
   Type& target_type = Type::Handle(target.RedirectionType());
   Function& target_target = Function::Handle(target.RedirectionTarget());
   if (target_target.IsNull()) {
     ASSERT(target_type.IsMalformed());
   } else {
     // If the target type refers to type parameters, substitute them with the
     // type arguments of the redirection type.
     if (!target_type.IsInstantiated()) {
       const TypeArguments& type_args = TypeArguments::Handle(type.arguments());
       Error& bound_error = Error::Handle();
-      target_type ^= target_type.InstantiateFrom(
-          type_args, &bound_error, NULL, NULL, Heap::kOld);
+      target_type ^= target_type.InstantiateFrom(type_args, &bound_error, NULL,
+                                                 NULL, Heap::kOld);
       if (bound_error.IsNull()) {
         target_type ^= FinalizeType(cls, target_type, kCanonicalize);
       } else {
         ASSERT(target_type.IsInstantiated() && type_args.IsInstantiated());
         const Script& script = Script::Handle(target_class.script());
         FinalizeMalformedType(bound_error, script, target_type,
                               "cannot resolve redirecting factory");
         target_target = Function::null();
       }
     }
@@ skipping 21 matching lines @@
   // Lookup the type class if necessary.
   Class& type_class = Class::Handle();
   if (type.HasResolvedTypeClass()) {
     type_class = type.type_class();
   } else {
     const UnresolvedClass& unresolved_class =
         UnresolvedClass::Handle(type.unresolved_class());
     type_class = ResolveClass(cls, unresolved_class);
     if (type_class.IsNull()) {
       // The type class could not be resolved. The type is malformed.
-      FinalizeMalformedType(
-          Error::Handle(),  // No previous error.
-          Script::Handle(cls.script()),
-          type,
-          "cannot resolve class '%s' from '%s'",
-          String::Handle(unresolved_class.Name()).ToCString(),
-          String::Handle(cls.Name()).ToCString());
+      FinalizeMalformedType(Error::Handle(),  // No previous error.
+                            Script::Handle(cls.script()), type,
+                            "cannot resolve class '%s' from '%s'",
+                            String::Handle(unresolved_class.Name()).ToCString(),
+                            String::Handle(cls.Name()).ToCString());
       return;
     }
     // Replace unresolved class with resolved type class.
     type.set_type_class(type_class);
   }
   // Promote the type to a function type in case its type class is a typedef.
   // Note that the type may already be a function type if it was parsed as a
   // formal parameter function type.
-  if (!type.IsFunctionType() &&
-      type_class.IsTypedefClass() &&
+  if (!type.IsFunctionType() && type_class.IsTypedefClass() &&
       !type.IsMalformedOrMalbounded()) {
     type.set_signature(Function::Handle(type_class.signature_function()));
   }
   ASSERT(!type_class.IsTypedefClass() ||
          (type.signature() != Function::null()));
 }
 
 
 void ClassFinalizer::ResolveType(const Class& cls, const AbstractType& type) {
   if (type.IsResolved()) {
@@ skipping 28 matching lines @@
     const Class& scope_class = Class::Handle(type.type_class());
     if (scope_class.IsTypedefClass()) {
       ResolveSignature(scope_class, signature);
     } else {
       ResolveSignature(cls, signature);
     }
   }
 }
 
 
-void ClassFinalizer::FinalizeTypeParameters(
-    const Class& cls,
-    PendingTypes* pending_types) {
+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_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.
 void ClassFinalizer::CheckRecursiveType(const Class& cls,
                                         const AbstractType& type,
                                         PendingTypes* pending_types) {
   Zone* zone = Thread::Current()->zone();
   if (FLAG_trace_type_finalization) {
     THR_Print("Checking recursive type '%s': %s\n",
-              String::Handle(type.Name()).ToCString(),
-              type.ToCString());
+              String::Handle(type.Name()).ToCString(), type.ToCString());
   }
   const Class& type_cls = Class::Handle(zone, type.type_class());
   const TypeArguments& arguments =
       TypeArguments::Handle(zone, type.arguments());
   // A type can only be recursive via its type arguments.
   ASSERT(!arguments.IsNull());
   const intptr_t num_type_args = arguments.Length();
   ASSERT(num_type_args > 0);
   ASSERT(num_type_args == type_cls.NumTypeArguments());
   const intptr_t num_type_params = type_cls.NumTypeParameters();
@@ skipping 11 matching lines @@
   // uninstantiated type parameters.
   TypeArguments& pending_arguments = TypeArguments::Handle(zone);
   const intptr_t num_pending_types = pending_types->length();
   for (intptr_t i = num_pending_types - 1; i >= 0; i--) {
     const AbstractType& pending_type = pending_types->At(i);
     if (FLAG_trace_type_finalization) {
       THR_Print("  Comparing with pending type '%s': %s\n",
                 String::Handle(pending_type.Name()).ToCString(),
                 pending_type.ToCString());
     }
-    if ((pending_type.raw() != type.raw()) &&
-        pending_type.IsType() &&
+    if ((pending_type.raw() != type.raw()) && pending_type.IsType() &&
         (pending_type.type_class() == type_cls.raw())) {
       pending_arguments = pending_type.arguments();
-      if (!pending_arguments.IsSubvectorEquivalent(arguments,
-                                                   first_type_param,
+      if (!pending_arguments.IsSubvectorEquivalent(arguments, first_type_param,
                                                    num_type_params) &&
           !pending_arguments.IsSubvectorInstantiated(first_type_param,
                                                      num_type_params)) {
         // Reject the non-contractive recursive type.
         const String& type_name = String::Handle(zone, type.Name());
-        ReportError(cls, type.token_pos(),
-                    "illegal recursive type '%s'", type_name.ToCString());
+        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,
@@ skipping 51 matching lines @@
   // type arguments, followed by the parsed type arguments.
   TypeArguments& full_arguments = TypeArguments::Handle(zone);
   if (FLAG_reify && (num_type_arguments > 0)) {
     // If no type arguments were parsed and if the super types do not prepend
     // type arguments to the vector, we can leave the vector as null.
     if (!arguments.IsNull() || (num_type_arguments > num_type_parameters)) {
       full_arguments = TypeArguments::New(num_type_arguments);
       // Copy the parsed type arguments at the correct offset in the full type
       // argument vector.
       const intptr_t offset = num_type_arguments - num_type_parameters;
-      AbstractType& type_arg =
-          AbstractType::Handle(zone, Type::DynamicType());
+      AbstractType& type_arg = AbstractType::Handle(zone, Type::DynamicType());
       // Leave the temporary type arguments at indices [0..offset[ as null.
       for (intptr_t i = 0; i < num_type_parameters; i++) {
         // If no type parameters were provided, a raw type is desired, so we
         // create a vector of dynamic.
         if (!arguments.IsNull()) {
           type_arg = arguments.TypeAt(i);
           // The parsed type_arg may or may not be finalized.
         }
         full_arguments.SetTypeAt(offset + i, type_arg);
       }
@@ skipping 13 matching lines @@
           if (type_arg.IsMalformed()) {
             // Malformed type arguments are mapped to dynamic.
             type_arg = Type::DynamicType();
           }
           full_arguments.SetTypeAt(offset + i, type_arg);
         }
       }
       if (offset > 0) {
         TrailPtr instantiation_trail = new Trail(zone, 4);
         Error& bound_error = Error::Handle(zone);
-        FinalizeTypeArguments(type_class, full_arguments, offset,
-                              &bound_error, pending_types, instantiation_trail);
+        FinalizeTypeArguments(type_class, full_arguments, offset, &bound_error,
+                              pending_types, instantiation_trail);
       }
       if (full_arguments.IsRaw(0, num_type_arguments)) {
         // The parameterized_type is raw. Set its argument vector to null, which
         // is more efficient in type tests.
         full_arguments = TypeArguments::null();
       }
       type.set_arguments(full_arguments);
     } else {
       ASSERT(full_arguments.IsNull());  // Use null vector for raw type.
     }
@@ skipping 42 matching lines @@
 //             cls = C, arguments = [dynamic, String, double],
 //             num_uninitialized_arguments = 1,
 //             i.e. cls_args = [String, double], offset = 1, length = 2.
 //   Output:   arguments = [int, String, double]
 //
 // It is too early to canonicalize the type arguments of the vector, because
 // several type argument vectors may be mutually recursive and finalized at the
 // same time. Canonicalization happens when pending types are processed.
 // The trail is required to correctly instantiate a recursive type argument
 // of the super type.
-void ClassFinalizer::FinalizeTypeArguments(
-    const Class& cls,
-    const TypeArguments& arguments,
-    intptr_t num_uninitialized_arguments,
-    Error* bound_error,
-    PendingTypes* pending_types,
-    TrailPtr instantiation_trail) {
+void ClassFinalizer::FinalizeTypeArguments(const Class& cls,
+                                           const TypeArguments& arguments,
+                                           intptr_t num_uninitialized_arguments,
+                                           Error* bound_error,
+                                           PendingTypes* pending_types,
+                                           TrailPtr instantiation_trail) {
   ASSERT(arguments.Length() >= cls.NumTypeArguments());
   if (!cls.is_type_finalized()) {
     FinalizeTypeParameters(cls, pending_types);
     ResolveUpperBounds(cls);
   }
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
     const intptr_t num_super_type_params = super_class.NumTypeParameters();
     const intptr_t num_super_type_args = super_class.NumTypeArguments();
     ASSERT(num_super_type_args ==
            (cls.NumTypeArguments() - cls.NumOwnTypeArguments()));
     if (!super_type.IsFinalized() && !super_type.IsBeingFinalized()) {
-      super_type ^= FinalizeType(
-          cls, super_type, kFinalize, pending_types);
+      super_type ^= FinalizeType(cls, super_type, kFinalize, pending_types);
       cls.set_super_type(super_type);
     }
-    TypeArguments& super_type_args = TypeArguments::Handle(
-        super_type.arguments());
+    TypeArguments& super_type_args =
+        TypeArguments::Handle(super_type.arguments());
     // Offset of super type's type parameters in cls' type argument vector.
     const intptr_t super_offset = num_super_type_args - num_super_type_params;
     AbstractType& super_type_arg = AbstractType::Handle(Type::DynamicType());
     for (intptr_t i = super_offset; i < num_uninitialized_arguments; i++) {
       if (!super_type_args.IsNull()) {
         super_type_arg = super_type_args.TypeAt(i);
         if (!super_type_arg.IsTypeRef()) {
           if (super_type_arg.IsBeingFinalized()) {
             ASSERT(super_type_arg.IsType());
             CheckRecursiveType(cls, super_type_arg, pending_types);
             if (FLAG_trace_type_finalization) {
               THR_Print("Creating TypeRef '%s': '%s'\n",
                         String::Handle(super_type_arg.Name()).ToCString(),
                         super_type_arg.ToCString());
             }
             super_type_arg = TypeRef::New(super_type_arg);
             super_type_args.SetTypeAt(i, super_type_arg);
           } else {
             if (!super_type_arg.IsFinalized()) {
-              super_type_arg ^= FinalizeType(
-                  cls, super_type_arg, kFinalize, pending_types);
+              super_type_arg ^=
+                  FinalizeType(cls, super_type_arg, kFinalize, pending_types);
               super_type_args.SetTypeAt(i, super_type_arg);
               // Note that super_type_arg may still not be finalized here, in
               // which case it is a TypeRef to a legal recursive type.
             }
           }
         }
         // Instantiate super_type_arg with the current argument vector.
         if (!super_type_arg.IsInstantiated()) {
           if (FLAG_trace_type_finalization && super_type_arg.IsTypeRef()) {
-            AbstractType& ref_type = AbstractType::Handle(
-                TypeRef::Cast(super_type_arg).type());
-            THR_Print("Instantiating TypeRef '%s': '%s'\n"
-                      "  instantiator: '%s'\n",
-                      String::Handle(super_type_arg.Name()).ToCString(),
-                      ref_type.ToCString(),
-                      arguments.ToCString());
+            AbstractType& ref_type =
+                AbstractType::Handle(TypeRef::Cast(super_type_arg).type());
+            THR_Print(
+                "Instantiating TypeRef '%s': '%s'\n"
+                "  instantiator: '%s'\n",
+                String::Handle(super_type_arg.Name()).ToCString(),
+                ref_type.ToCString(), arguments.ToCString());
           }
           Error& error = Error::Handle();
           super_type_arg = super_type_arg.InstantiateFrom(
               arguments, &error, instantiation_trail, NULL, Heap::kOld);
           if (!error.IsNull()) {
             // InstantiateFrom does not report an error if the type is still
             // uninstantiated. Instead, it will return a new BoundedType so
             // that the check is postponed to run time.
             ASSERT(super_type_arg.IsInstantiated());
             // Keep only the first bound error.
             if (bound_error->IsNull()) {
               *bound_error = error.raw();
             }
           }
           if (!super_type_arg.IsFinalized() &&
               !super_type_arg.IsBeingFinalized()) {
             // The super_type_arg was instantiated from a type being finalized.
             // We need to finish finalizing its type arguments.
             if (super_type_arg.IsTypeRef()) {
               super_type_arg = TypeRef::Cast(super_type_arg).type();
             }
             Type::Cast(super_type_arg).SetIsBeingFinalized();
             pending_types->Add(super_type_arg);
             const Class& cls = Class::Handle(super_type_arg.type_class());
             FinalizeTypeArguments(
-                cls,
-                TypeArguments::Handle(super_type_arg.arguments()),
-                cls.NumTypeArguments() - cls.NumTypeParameters(),
-                bound_error,
-                pending_types,
-                instantiation_trail);
+                cls, TypeArguments::Handle(super_type_arg.arguments()),
+                cls.NumTypeArguments() - cls.NumTypeParameters(), bound_error,
+                pending_types, instantiation_trail);
             Type::Cast(super_type_arg).SetIsFinalized();
           }
         }
       }
       arguments.SetTypeAt(i, super_type_arg);
     }
-    FinalizeTypeArguments(super_class, arguments, super_offset,
-                          bound_error, pending_types, instantiation_trail);
+    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,
@@ skipping 69 matching lines @@
       // 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 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());
+          AbstractType& bound =
+              AbstractType::Handle(TypeParameter::Cast(type_arg).bound());
           if (!bound.IsFinalized() && !bound.IsBeingFinalized()) {
             bound = FinalizeType(type_arg_cls, bound, kCanonicalize);
             TypeParameter::Cast(type_arg).set_bound(bound);
           }
         }
         // This may be called only if type needs to be finalized, therefore
         // seems OK to allocate finalized types in old space.
-        if (!type_param.CheckBound(type_arg, instantiated_bound,
-                                   &error, NULL, Heap::kOld) &&
+        if (!type_param.CheckBound(type_arg, instantiated_bound, &error, NULL,
+                                   Heap::kOld) &&
             error.IsNull()) {
           // The bound cannot be checked at compile time; postpone to run time.
           type_arg = BoundedType::New(type_arg, instantiated_bound, type_param);
           arguments.SetTypeAt(offset + i, type_arg);
         }
       }
       if (!error.IsNull() && bound_error->IsNull()) {
         *bound_error = error.raw();
       }
     }
@@ skipping 25 matching lines @@
   Error& bound_error = Error::Handle(zone);
   CheckTypeArgumentBounds(type_class, arguments, &bound_error);
   // CheckTypeArgumentBounds may have indirectly canonicalized this type.
   if (!type.IsCanonical()) {
     type.set_arguments(arguments);
     // If a bound error occurred, mark the type as malbounded.
     // The bound error will be ignored in production mode.
     if (!bound_error.IsNull()) {
       // No compile-time error during finalization.
       const String& type_name = String::Handle(zone, type.UserVisibleName());
-      FinalizeMalboundedType(bound_error,
-                             Script::Handle(zone, cls.script()),
-                             type,
-                             "type '%s' has an out of bound type argument",
-                             type_name.ToCString());
+      FinalizeMalboundedType(
+          bound_error, Script::Handle(zone, cls.script()), type,
+          "type '%s' has an out of bound type argument", type_name.ToCString());
       if (FLAG_trace_type_finalization) {
         THR_Print("Marking type '%s' as malbounded: %s\n",
                   String::Handle(zone, type.Name()).ToCString(),
                   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());
+              String::Handle(zone, type.Name()).ToCString(), type.ToCString());
   }
 }
 
 
-RawAbstractType* ClassFinalizer::FinalizeType(
-    const Class& cls,
-    const AbstractType& type,
-    FinalizationKind finalization,
-    PendingTypes* pending_types) {
+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.
-    if ((finalization >= kCanonicalize) &&
-        !type.IsMalformed() &&
-        !type.IsCanonical() &&
-        type.IsType()) {
+    if ((finalization >= kCanonicalize) && !type.IsMalformed() &&
+        !type.IsCanonical() && type.IsType()) {
       CheckTypeBounds(cls, type);
       return type.Canonicalize();
     }
     return type.raw();
   }
   ASSERT(finalization >= kFinalize);
 
   if (type.IsTypeRef()) {
     // The referenced type will be finalized later by the code that set the
     // is_being_finalized mark bit.
@@ skipping 88 matching lines @@
     if (scope_class.IsTypedefClass()) {
       FinalizeSignature(scope_class, signature);
     } else {
       FinalizeSignature(cls, signature);
     }
   }
 
   if (FLAG_trace_type_finalization) {
     THR_Print("Done finalizing type '%s' with %" Pd " type args: %s\n",
               String::Handle(zone, type.Name()).ToCString(),
-              num_expanded_type_arguments,
-              type.ToCString());
+              num_expanded_type_arguments, type.ToCString());
   }
 
   if (finalization >= kCanonicalize) {
     if (FLAG_trace_type_finalization) {
       THR_Print("Canonicalizing type '%s'\n",
                 String::Handle(zone, type.Name()).ToCString());
       AbstractType& canonical_type =
           AbstractType::Handle(zone, type.Canonicalize());
       THR_Print("Done canonicalizing type '%s'\n",
                 String::Handle(zone, canonical_type.Name()).ToCString());
@@ skipping 76 matching lines @@
 
 
 // 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() &&
+    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.
@@ skipping 78 matching lines @@
     name = field.name();
     if (field.is_static()) {
       getter_name = Field::GetterSymbol(name);
       super_class = FindSuperOwnerOfInstanceMember(cls, name, getter_name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(zone, cls.Name());
         const String& super_cls_name = String::Handle(zone, super_class.Name());
         ReportError(cls, field.token_pos(),
                     "static field '%s' of class '%s' conflicts with "
                     "instance member '%s' of super class '%s'",
-                    name.ToCString(),
-                    class_name.ToCString(),
-                    name.ToCString(),
+                    name.ToCString(), class_name.ToCString(), name.ToCString(),
                     super_cls_name.ToCString());
       }
       // An implicit setter is not generated for a static field, therefore, we
       // cannot rely on the code below handling the static setter case to report
       // a conflict with an instance setter. So we check explicitly here.
       setter_name = Field::SetterSymbol(name);
       super_class = FindSuperOwnerOfFunction(cls, setter_name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(zone, cls.Name());
         const String& super_cls_name = String::Handle(zone, super_class.Name());
         ReportError(cls, field.token_pos(),
                     "static field '%s' of class '%s' conflicts with "
                     "instance setter '%s=' of super class '%s'",
-                    name.ToCString(),
-                    class_name.ToCString(),
-                    name.ToCString(),
+                    name.ToCString(), class_name.ToCString(), name.ToCString(),
                     super_cls_name.ToCString());
       }
 
     } else {
       // Instance field. Check whether the field overrides a method
       // (but not getter).
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(zone, cls.Name());
         const String& super_cls_name = String::Handle(zone, super_class.Name());
         ReportError(cls, field.token_pos(),
                     "field '%s' of class '%s' conflicts with method '%s' "
                     "of super class '%s'",
-                    name.ToCString(),
-                    class_name.ToCString(),
-                    name.ToCString(),
+                    name.ToCString(), class_name.ToCString(), name.ToCString(),
                     super_cls_name.ToCString());
       }
     }
-    if (field.is_static() &&
-        (field.StaticValue() != Object::null()) &&
+    if (field.is_static() && (field.StaticValue() != Object::null()) &&
         (field.StaticValue() != Object::sentinel().raw())) {
       // The parser does not preset the value if the type is a type parameter or
       // is parameterized unless the value is null.
       Error& error = Error::Handle(zone);
       if (type.IsMalformedOrMalbounded()) {
         error = type.error();
       } else {
         ASSERT(type.IsInstantiated());
       }
-      const Instance& const_value =
-          Instance::Handle(zone, field.StaticValue());
+      const Instance& const_value = Instance::Handle(zone, field.StaticValue());
       if (!error.IsNull() ||
           (!type.IsDynamicType() &&
-           !const_value.IsInstanceOf(type,
-                                     Object::null_type_arguments(),
+           !const_value.IsInstanceOf(type, Object::null_type_arguments(),
                                      &error))) {
         if (Isolate::Current()->error_on_bad_type()) {
-          const AbstractType& const_value_type = AbstractType::Handle(
-              zone, const_value.GetType());
-          const String& const_value_type_name = String::Handle(
-              zone, const_value_type.UserVisibleName());
-          const String& type_name = String::Handle(
-              zone, type.UserVisibleName());
+          const AbstractType& const_value_type =
+              AbstractType::Handle(zone, const_value.GetType());
+          const String& const_value_type_name =
+              String::Handle(zone, const_value_type.UserVisibleName());
+          const String& type_name =
+              String::Handle(zone, type.UserVisibleName());
           ReportErrors(error, cls, field.token_pos(),
                        "error initializing static %s field '%s': "
                        "type '%s' is not a subtype of type '%s'",
-                       field.is_const() ? "const" : "final",
-                       name.ToCString(),
+                       field.is_const() ? "const" : "final", name.ToCString(),
                        const_value_type_name.ToCString(),
                        type_name.ToCString());
         } else {
           // Do not report an error yet, even in checked mode, since the field
           // may not actually be used.
           // Also, we may be generating a snapshot in production mode that will
           // later be executed in checked mode, in which case an error needs to
           // be reported, should the field be accessed.
           // Therefore, we undo the optimization performed by the parser, i.e.
           // we create an implicit static final getter and reset the field value
           // to the sentinel value.
           const Function& getter = Function::Handle(
-              zone,
-              Function::New(getter_name,
-                            RawFunction::kImplicitStaticFinalGetter,
-                            /* is_static = */ true,
-                            /* is_const = */ field.is_const(),
-                            /* is_abstract = */ false,
-                            /* is_external = */ false,
-                            /* is_native = */ false,
-                            cls,
-                            field.token_pos()));
+              zone, Function::New(
+                        getter_name, RawFunction::kImplicitStaticFinalGetter,
+                        /* is_static = */ true,
+                        /* is_const = */ field.is_const(),
+                        /* is_abstract = */ false,
+                        /* is_external = */ false,
+                        /* is_native = */ false, cls, field.token_pos()));
           getter.set_result_type(type);
           getter.set_is_debuggable(false);
           cls.AddFunction(getter);
           field.SetStaticValue(Object::sentinel(), true);
         }
       }
     }
   }
   // Collect interfaces, super interfaces, and super classes of this class.
   GrowableArray<const Class*> interfaces(zone, 4);
@@ skipping 10 matching lines @@
   array = cls.functions();
   Function& function = Function::Handle(zone);
   Function& overridden_function = Function::Handle(zone);
   const intptr_t num_functions = array.Length();
   Error& error = Error::Handle(zone);
   for (intptr_t i = 0; i < num_functions; i++) {
     function ^= array.At(i);
     FinalizeSignature(cls, function);
     name = function.name();
     // Report signature conflicts only.
-    if (Isolate::Current()->error_on_bad_override() &&
-        !function.is_static() && !function.IsGenerativeConstructor()) {
+    if (Isolate::Current()->error_on_bad_override() && !function.is_static() &&
+        !function.IsGenerativeConstructor()) {
       // A constructor cannot override anything.
       for (intptr_t i = 0; i < interfaces.length(); i++) {
         const Class* super_class = interfaces.At(i);
         // Finalize superclass since overrides check relies on all members
         // of the superclass to be finalized.
         FinalizeClass(*super_class);
         overridden_function = super_class->LookupDynamicFunction(name);
         if (!overridden_function.IsNull() &&
             !function.HasCompatibleParametersWith(overridden_function,
                                                   &error)) {
           const String& class_name = String::Handle(zone, cls.Name());
           const String& super_cls_name =
               String::Handle(zone, super_class->Name());
           ReportErrors(error, cls, function.token_pos(),
                        "class '%s' overrides method '%s' of super "
                        "class '%s' with incompatible parameters",
-                       class_name.ToCString(),
-                       name.ToCString(),
+                       class_name.ToCString(), name.ToCString(),
                        super_cls_name.ToCString());
         }
       }
     }
     if (function.IsSetterFunction() || function.IsImplicitSetterFunction()) {
       if (function.is_static()) {
         super_class = FindSuperOwnerOfFunction(cls, name);
         if (!super_class.IsNull()) {
           const String& class_name = String::Handle(zone, cls.Name());
           const String& super_cls_name =
               String::Handle(zone, super_class.Name());
           ReportError(cls, function.token_pos(),
                       "static setter '%s=' of class '%s' conflicts with "
                       "instance setter '%s=' of super class '%s'",
-                      name.ToCString(),
-                      class_name.ToCString(),
-                      name.ToCString(),
-                      super_cls_name.ToCString());
+                      name.ToCString(), class_name.ToCString(),
+                      name.ToCString(), super_cls_name.ToCString());
         }
       }
       continue;
     }
     if (function.IsGetterFunction() || function.IsImplicitGetterFunction()) {
       getter_name = name.raw();
       name = Field::NameFromGetter(getter_name);
     } else {
       getter_name = Field::GetterSymbol(name);
     }
     if (function.is_static()) {
       super_class = FindSuperOwnerOfInstanceMember(cls, name, getter_name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(zone, cls.Name());
         const String& super_cls_name = String::Handle(zone, super_class.Name());
-        ReportError(cls, function.token_pos(),
-                    "static %s '%s' of class '%s' conflicts with "
-                    "instance member '%s' of super class '%s'",
-                    (function.IsGetterFunction() ||
-                     function.IsImplicitGetterFunction()) ? "getter" : "method",
-                    name.ToCString(),
-                    class_name.ToCString(),
-                    name.ToCString(),
-                    super_cls_name.ToCString());
+        ReportError(
+            cls, function.token_pos(),
+            "static %s '%s' of class '%s' conflicts with "
+            "instance member '%s' of super class '%s'",
+            (function.IsGetterFunction() || function.IsImplicitGetterFunction())
+                ? "getter"
+                : "method",
+            name.ToCString(), class_name.ToCString(), name.ToCString(),
+            super_cls_name.ToCString());
       }
       if (function.IsRedirectingFactory()) {
         // The function may be a still unresolved redirecting factory. Do not
         // yet try to resolve it in order to avoid cycles in class finalization.
         // However, the redirection type should be finalized.
         // If the redirection type is from a deferred library and is not
         // yet loaded, do not attempt to resolve.
         Type& type = Type::Handle(zone, function.RedirectionType());
         if (IsLoaded(type)) {
           type ^= FinalizeType(cls, type, kCanonicalize);
           function.SetRedirectionType(type);
         }
       }
     } else if (function.IsGetterFunction() ||
                function.IsImplicitGetterFunction()) {
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(zone, cls.Name());
         const String& super_cls_name = String::Handle(zone, super_class.Name());
         ReportError(cls, function.token_pos(),
                     "getter '%s' of class '%s' conflicts with "
                     "method '%s' of super class '%s'",
-                    name.ToCString(),
-                    class_name.ToCString(),
-                    name.ToCString(),
+                    name.ToCString(), class_name.ToCString(), name.ToCString(),
                     super_cls_name.ToCString());
       }
     } else if (!function.IsSetterFunction() &&
                !function.IsImplicitSetterFunction()) {
       // A function cannot conflict with a setter, since they cannot
       // have the same name. Thus, we do not need to check setters.
       super_class = FindSuperOwnerOfFunction(cls, getter_name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(zone, cls.Name());
         const String& super_cls_name = String::Handle(zone, super_class.Name());
         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(),
+                    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> { }
 //   class C<E extends BE> extends S<E> with M<List<E>> { }
 // results in
 //   class S&M<T`, T extends BT> extends S<T`> implements M<T> { }
 //   class C<E extends BE> extends S&M<E, List<E>> { }
 // CloneMixinAppTypeParameters decorates class S&M with type parameters T` and
 // T, and use them as type arguments in S<T`> and M<T>.
 // Note that the bound BT on T of S is not applied to T` of S&M. However, the
 // bound BT on T of M is applied to T of S&M. See comments below.
 void ClassFinalizer::CloneMixinAppTypeParameters(const Class& mixin_app_class) {
   ASSERT(mixin_app_class.type_parameters() == TypeArguments::null());
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
-  const AbstractType& super_type = AbstractType::Handle(zone,
-      mixin_app_class.super_type());
+  const AbstractType& super_type =
+      AbstractType::Handle(zone, mixin_app_class.super_type());
   ASSERT(super_type.IsResolved());
   const Class& super_class = Class::Handle(zone, super_type.type_class());
   const intptr_t num_super_type_params = super_class.NumTypeParameters();
   const Type& mixin_type = Type::Handle(zone, mixin_app_class.mixin());
   const Class& mixin_class = Class::Handle(zone, mixin_type.type_class());
   const intptr_t num_mixin_type_params = mixin_class.NumTypeParameters();
 
   // The mixin type (in raw form) should have been added to the interfaces
   // implemented by the mixin application class. This is necessary so that cycle
   // check works at compile time (type arguments are ignored) and so that
@@ skipping 15 matching lines @@
       for (intptr_t i = name.Length() - 1; i > 0; --i) {
         if (name.CharAt(i) == '&') {
           if (name.CharAt(i - 1) == '&') {
             share_type_params = true;
           }
           break;
         }
       }
     }
 
-    const TypeArguments& cloned_type_params = TypeArguments::Handle(zone,
+    const TypeArguments& cloned_type_params = TypeArguments::Handle(
+        zone,
         TypeArguments::New((share_type_params ? 0 : num_super_type_params) +
                            num_mixin_type_params));
     TypeParameter& param = TypeParameter::Handle(zone);
     TypeParameter& cloned_param = TypeParameter::Handle(zone);
     String& param_name = String::Handle(zone);
     AbstractType& param_bound = AbstractType::Handle(zone);
     Function& null_function = Function::Handle(zone);
     intptr_t cloned_index = 0;
 
     // First, clone the super class type parameters. Rename them so that
     // there can be no name conflict between the parameters of the super
     // class and the mixin class.
     if (!share_type_params && (num_super_type_params > 0)) {
       const TypeArguments& super_type_params =
           TypeArguments::Handle(zone, super_class.type_parameters());
-      const TypeArguments& super_type_args = TypeArguments::Handle(zone,
-          TypeArguments::New(num_super_type_params));
+      const TypeArguments& super_type_args = TypeArguments::Handle(
+          zone, TypeArguments::New(num_super_type_params));
       // The cloned super class type parameters do not need to repeat their
       // bounds, since the bound checks will be performed at the super class
       // level. As a consequence, if this mixin application is used itself as a
       // mixin in another mixin application, the bounds will be ignored, which
       // is correct, because the other mixin application does not inherit from
       // the super class of its mixin. Note also that the other mixin
       // application will only mixin the last mixin type listed in the first
       // mixin application it is mixing in.
       param_bound = thread->isolate()->object_store()->object_type();
       for (intptr_t i = 0; i < num_super_type_params; i++) {
         param ^= super_type_params.TypeAt(i);
         param_name = param.name();
-        param_name = Symbols::FromConcat(thread,
-                                         param_name, Symbols::Backtick());
-        cloned_param = TypeParameter::New(mixin_app_class,
-                                          null_function,
-                                          cloned_index,
-                                          param_name,
-                                          param_bound,
-                                          param.token_pos());
+        param_name =
+            Symbols::FromConcat(thread, param_name, Symbols::Backtick());
+        cloned_param =
+            TypeParameter::New(mixin_app_class, null_function, cloned_index,
+                               param_name, param_bound, param.token_pos());
         cloned_type_params.SetTypeAt(cloned_index, cloned_param);
         // Change the type arguments of the super type to refer to the
         // cloned type parameters of the mixin application class.
         super_type_args.SetTypeAt(cloned_index, cloned_param);
         cloned_index++;
       }
       // The super type may have a BoundedType as type argument, but cannot be
       // a BoundedType itself.
       Type::Cast(super_type).set_arguments(super_type_args);
       ASSERT(!super_type.IsFinalized());
     }
 
     // Second, clone the type parameters of the mixin class.
     // We need to retain the parameter names of the mixin class
     // since the code that will be compiled in the context of the
     // mixin application class may refer to the type parameters
     // with that name. We also retain the type parameter bounds.
     if (num_mixin_type_params > 0) {
       const TypeArguments& mixin_params =
           TypeArguments::Handle(zone, mixin_class.type_parameters());
       const intptr_t offset =
           mixin_class.NumTypeArguments() - mixin_class.NumTypeParameters();
-      const TypeArguments& mixin_type_args = TypeArguments::Handle(zone,
-          TypeArguments::New(num_mixin_type_params));
+      const TypeArguments& mixin_type_args = TypeArguments::Handle(
+          zone, TypeArguments::New(num_mixin_type_params));
       instantiator ^= TypeArguments::New(offset + num_mixin_type_params);
       bool has_uninstantiated_bounds = false;
       for (intptr_t i = 0; i < num_mixin_type_params; i++) {
         param ^= mixin_params.TypeAt(i);
         param_name = param.name();
         param_bound = param.bound();  // The bound will be adjusted below.
         if (!param_bound.IsInstantiated()) {
           has_uninstantiated_bounds = true;
         }
-        cloned_param = TypeParameter::New(mixin_app_class,
-                                          null_function,
-                                          cloned_index,  // Unfinalized index.
-                                          param_name,
-                                          param_bound,
-                                          param.token_pos());
+        cloned_param =
+            TypeParameter::New(mixin_app_class, null_function,
+                               cloned_index,  // Unfinalized index.
+                               param_name, param_bound, param.token_pos());
         cloned_type_params.SetTypeAt(cloned_index, cloned_param);
         mixin_type_args.SetTypeAt(i, cloned_param);  // Unfinalized length.
         instantiator.SetTypeAt(offset + i, cloned_param);  // Finalized length.
         cloned_index++;
       }
 
       // Third, replace the type parameters appearing in the bounds of the mixin
       // type parameters, if any, by the cloned type parameters. This can be
       // done by instantiating each bound using the instantiator built above.
       // If the mixin class extends a generic super class, its first finalized
       // type parameter has a non-zero index, therefore, the instantiator
       // requires shifting by the offset calculated above.
       // Unfinalized type parameters replace finalized type parameters, which
       // is not a problem since they will get finalized shortly as the mixin
       // application class gets finalized.
       if (has_uninstantiated_bounds) {
         Error& bound_error = Error::Handle(zone);
         for (intptr_t i = 0; i < num_mixin_type_params; i++) {
           param ^= mixin_type_args.TypeAt(i);
           param_bound = param.bound();
           if (!param_bound.IsInstantiated()) {
             // Make sure the bound is finalized before instantiating it.
-            if (!param_bound.IsFinalized() &&
-                !param_bound.IsBeingFinalized()) {
+            if (!param_bound.IsFinalized() && !param_bound.IsBeingFinalized()) {
               param_bound =
                   FinalizeType(mixin_app_class, param_bound, kCanonicalize);
               param.set_bound(param_bound);  // In case part of recursive type.
             }
             param_bound = param_bound.InstantiateFrom(
                 instantiator, &bound_error, NULL, NULL, Heap::kOld);
             // The instantiator contains only TypeParameter objects and no
             // BoundedType objects, so no bound error may occur.
             ASSERT(!param_bound.IsBoundedType());
             ASSERT(bound_error.IsNull());
@@ skipping 95 matching lines @@
 This is done in the recursive call to CloneMixinAppTypeParameters and does not
 require specific code in ApplyMixinAppAlias.
 */
 void ClassFinalizer::ApplyMixinAppAlias(const Class& mixin_app_class,
                                         const TypeArguments& instantiator) {
   // If this mixin alias is aliasing another mixin alias, another class
   // will be inserted via recursion. No need to check here.
   // The mixin type may or may not be finalized yet.
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
-  AbstractType& super_type = AbstractType::Handle(zone,
-                                                  mixin_app_class.super_type());
+  AbstractType& super_type =
+      AbstractType::Handle(zone, mixin_app_class.super_type());
   const Type& mixin_type = Type::Handle(zone, mixin_app_class.mixin());
   const Class& mixin_class = Class::Handle(zone, mixin_type.type_class());
   ASSERT(mixin_class.is_mixin_app_alias());
-  const Class& aliased_mixin_app_class = Class::Handle(zone,
-      mixin_class.SuperClass());
+  const Class& aliased_mixin_app_class =
+      Class::Handle(zone, mixin_class.SuperClass());
   // Note that the super class of aliased_mixin_app_class can itself be a
   // mixin application class (this happens if the alias is mixing more than one
   // type). Instead of trying to recursively insert yet another class as the
   // super class of this inserted class, we apply the composition rules of the
   // spec and only mixin the members of aliased_mixin_app_class, not those of
   // its super class. In other words, we only mixin the last mixin of the alias.
-  const Type& aliased_mixin_type = Type::Handle(zone,
-      aliased_mixin_app_class.mixin());
+  const Type& aliased_mixin_type =
+      Type::Handle(zone, aliased_mixin_app_class.mixin());
   // The name of the inserted mixin application class is the name of mixin
   // class name with a backtick added.
   String& inserted_class_name = String::Handle(zone, mixin_app_class.Name());
-  inserted_class_name = String::Concat(inserted_class_name,
-                                       Symbols::Backtick());
+  inserted_class_name =
+      String::Concat(inserted_class_name, Symbols::Backtick());
   const Library& library = Library::Handle(zone, mixin_app_class.library());
-  Class& inserted_class = Class::Handle(zone,
-      library.LookupLocalClass(inserted_class_name));
+  Class& inserted_class =
+      Class::Handle(zone, library.LookupLocalClass(inserted_class_name));
   if (inserted_class.IsNull()) {
     inserted_class_name = Symbols::New(thread, inserted_class_name);
     const Script& script = Script::Handle(zone, mixin_app_class.script());
-    inserted_class = Class::New(
-        library, inserted_class_name, script, mixin_app_class.token_pos());
+    inserted_class = Class::New(library, inserted_class_name, script,
+                                mixin_app_class.token_pos());
     inserted_class.set_is_synthesized_class();
     library.AddClass(inserted_class);
 
     if (FLAG_trace_class_finalization) {
       THR_Print("Creating mixin application alias %s\n",
                 inserted_class.ToCString());
     }
 
     // The super type of the inserted class is identical to the super type of
     // this mixin application class, except that it must refer to the type
     // parameters of the inserted class rather than to those of the mixin
     // application class.
     // The type arguments of the super type will be set properly when calling
     // CloneMixinAppTypeParameters on the inserted class, as long as the super
     // type class is set properly.
     inserted_class.set_super_type(super_type);  // Super class only is used.
 
     // The mixin type and interface type must also be set before calling
     // CloneMixinAppTypeParameters.
     // After FinalizeTypesInClass, if the mixin type and interface type are
     // generic, their type arguments will refer to the type parameters of
     // inserted_class.
-    const Type& inserted_class_mixin_type = Type::Handle(zone,
-        Type::New(Class::Handle(zone, aliased_mixin_type.type_class()),
-                  Object::null_type_arguments(),
-                  aliased_mixin_type.token_pos()));
+    const Type& inserted_class_mixin_type = Type::Handle(
+        zone, Type::New(Class::Handle(zone, aliased_mixin_type.type_class()),
+                        Object::null_type_arguments(),
+                        aliased_mixin_type.token_pos()));
     inserted_class.set_mixin(inserted_class_mixin_type);
     // Add the mixin type to the list of interfaces that the mixin application
     // class implements. This is necessary so that cycle check work at
     // compile time (type arguments are ignored by that check).
     const Array& interfaces = Array::Handle(Array::New(1));
     interfaces.SetAt(0, inserted_class_mixin_type);
     ASSERT(inserted_class.interfaces() == Object::empty_array().raw());
     inserted_class.set_interfaces(interfaces);
     // The type arguments of the interface, if any, will be set in
     // CloneMixinAppTypeParameters, which is called indirectly from
@@ skipping 19 matching lines @@
   ASSERT(mixin_app_class.SuperClass() == super_class.raw());  // Will change.
   const intptr_t num_super_type_params = super_class.NumTypeParameters();
   AbstractType& type = AbstractType::Handle(zone);
   // The instantiator is mapping finalized type parameters of mixin_class to
   // unfinalized type parameters of mixin_app_class. Therefore, the type
   // arguments of mixin_class_super_type must be finalized, since they get
   // instantiated by this instantiator. Finalizing the types in mixin_class
   // will finalize mixin_class_super_type.
   // The aliased_mixin_type does not need to be finalized, but only resolved.
   ASSERT(aliased_mixin_type.IsResolved());
-  const Class& aliased_mixin_type_class = Class::Handle(zone,
-      aliased_mixin_type.type_class());
+  const Class& aliased_mixin_type_class =
+      Class::Handle(zone, aliased_mixin_type.type_class());
   FinalizeTypesInClass(mixin_class);
   const intptr_t num_aliased_mixin_type_params =
       aliased_mixin_type_class.NumTypeParameters();
   ASSERT(inserted_class.NumTypeParameters() ==
          (num_super_type_params + num_aliased_mixin_type_params));
   const AbstractType& mixin_class_super_type =
       AbstractType::Handle(zone, mixin_class.super_type());
   ASSERT(mixin_class_super_type.IsFinalized());
   // The aliased_mixin_type may be raw.
   const TypeArguments& mixin_class_super_type_args =
@@ skipping 15 matching lines @@
         // be instantiated separately. Instantiating a BoundedType would wrap
         // the BoundedType in another BoundedType.
         if (type.IsBoundedType()) {
           bounded_type = BoundedType::Cast(type).type();
           bounded_type = bounded_type.InstantiateFrom(
               instantiator, &bound_error, NULL, NULL, Heap::kOld);
           // The instantiator contains only TypeParameter objects and no
           // BoundedType objects, so no bound error may occur.
           ASSERT(bound_error.IsNull());
           upper_bound = BoundedType::Cast(type).bound();
-          upper_bound = upper_bound.InstantiateFrom(
-              instantiator, &bound_error, NULL, NULL, Heap::kOld);
+          upper_bound = upper_bound.InstantiateFrom(instantiator, &bound_error,
+                                                    NULL, NULL, Heap::kOld);
           ASSERT(bound_error.IsNull());
           type_parameter = BoundedType::Cast(type).type_parameter();
           // The type parameter that declared the bound does not change.
           type = BoundedType::New(bounded_type, upper_bound, type_parameter);
         } else {
-          type = type.InstantiateFrom(
-              instantiator, &bound_error, NULL, NULL, Heap::kOld);
+          type = type.InstantiateFrom(instantiator, &bound_error, NULL, NULL,
+                                      Heap::kOld);
           ASSERT(bound_error.IsNull());
         }
       }
       new_mixin_type_args.SetTypeAt(i, type);
     }
   }
   TypeArguments& new_super_type_args = TypeArguments::Handle(zone);
   if ((num_super_type_params + num_aliased_mixin_type_params) > 0) {
     new_super_type_args = TypeArguments::New(num_super_type_params +
                                              num_aliased_mixin_type_params);
     const TypeArguments& type_params =
         TypeArguments::Handle(zone, mixin_app_class.type_parameters());
     for (intptr_t i = 0; i < num_super_type_params; i++) {
       type = type_params.TypeAt(i);
       new_super_type_args.SetTypeAt(i, type);
     }
     for (intptr_t i = 0; i < num_aliased_mixin_type_params; i++) {
       if (new_mixin_type_args.IsNull()) {
         type = Type::DynamicType();
       } else {
         type = new_mixin_type_args.TypeAt(i);
       }
       new_super_type_args.SetTypeAt(num_super_type_params + i, type);
     }
   }
-  super_type = Type::New(inserted_class,
-                         new_super_type_args,
+  super_type = Type::New(inserted_class, new_super_type_args,
                          mixin_app_class.token_pos());
   mixin_app_class.set_super_type(super_type);
 
   // Mark this mixin application class as being an alias.
   mixin_app_class.set_is_mixin_app_alias();
   ASSERT(!mixin_app_class.is_type_finalized());
   ASSERT(!mixin_app_class.is_mixin_type_applied());
   if (FLAG_trace_class_finalization) {
-    THR_Print("Inserting class '%s' %s\n"
-              "  as super type '%s' with %" Pd " type args: %s\n"
-              "  of mixin application alias '%s' %s\n",
-              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());
+    THR_Print(
+        "Inserting class '%s' %s\n"
+        "  as super type '%s' with %" Pd
+        " type args: %s\n"
+        "  of mixin application alias '%s' %s\n",
+        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());
@@ skipping 19 matching lines @@
 
   // Copy type parameters to mixin application class.
   CloneMixinAppTypeParameters(mixin_app_class);
 
   // Verify that no restricted class is used as a mixin by checking the
   // interfaces of the mixin application class, which implements its mixin.
   GrowableArray<intptr_t> visited_interfaces;
   ResolveSuperTypeAndInterfaces(mixin_app_class, &visited_interfaces);
 
   if (FLAG_trace_class_finalization) {
-    THR_Print("Done applying mixin type '%s' to class '%s' %s extending '%s'\n",
-              String::Handle(mixin_type.Name()).ToCString(),
-              String::Handle(mixin_app_class.Name()).ToCString(),
-              TypeArguments::Handle(
-                  mixin_app_class.type_parameters()).ToCString(),
-              AbstractType::Handle(mixin_app_class.super_type()).ToCString());
+    THR_Print(
+        "Done applying mixin type '%s' to class '%s' %s extending '%s'\n",
+        String::Handle(mixin_type.Name()).ToCString(),
+        String::Handle(mixin_app_class.Name()).ToCString(),
+        TypeArguments::Handle(mixin_app_class.type_parameters()).ToCString(),
+        AbstractType::Handle(mixin_app_class.super_type()).ToCString());
   }
   // Mark the application class as having been applied its mixin type in order
   // to avoid cycles while finalizing its mixin type.
   mixin_app_class.set_is_mixin_type_applied();
   // Finalize the mixin type, which may have been changed in case
   // mixin_app_class is an alias.
   mixin_type = mixin_app_class.mixin();
   ASSERT(!mixin_type.IsBeingFinalized());
   mixin_type ^=
       FinalizeType(mixin_app_class, mixin_type, kFinalize, pending_types);
@@ skipping 16 matching lines @@
   const String& super_name = String::Handle(Z, super_class.Name());
   const Array& functions = Array::Handle(Z, super_class.functions());
   const intptr_t num_functions = functions.Length();
   Function& func = Function::Handle(Z);
   for (intptr_t i = 0; i < num_functions; i++) {
     func ^= functions.At(i);
     if (func.IsGenerativeConstructor()) {
       // Build constructor name from mixin application class name
       // and name of cloned super class constructor.
       const String& ctor_name = String::Handle(Z, func.name());
-      String& clone_name = String::Handle(Z,
-          String::SubString(ctor_name, super_name.Length()));
+      String& clone_name =
+          String::Handle(Z, String::SubString(ctor_name, super_name.Length()));
       clone_name = Symbols::FromConcat(T, mixin_name, clone_name);
 
       if (FLAG_trace_class_finalization) {
-        THR_Print("Cloning constructor '%s' as '%s'\n",
-                  ctor_name.ToCString(),
+        THR_Print("Cloning constructor '%s' as '%s'\n", ctor_name.ToCString(),
                   clone_name.ToCString());
       }
 
       // The owner of the forwarding constructor is the mixin application
       // class. The source is the mixin class. The source may be needed
       // to parse field initializer expressions in the mixin class.
       const PatchClass& owner =
           PatchClass::Handle(Z, PatchClass::New(mixin_app, mixin_cls));
 
-      const Function& clone = Function::Handle(Z,
-          Function::New(clone_name,
-                        func.kind(),
-                        func.is_static(),
-                        false,  // Not const.
-                        false,  // Not abstract.
-                        false,  // Not external.
-                        false,  // Not native.
-                        owner,
-                        mixin_cls.token_pos()));
+      const Function& clone = Function::Handle(
+          Z, Function::New(clone_name, func.kind(), func.is_static(),
+                           false,  // Not const.
+                           false,  // Not abstract.
+                           false,  // Not external.
+                           false,  // Not native.
+                           owner, mixin_cls.token_pos()));
       clone.set_num_fixed_parameters(func.num_fixed_parameters());
       clone.SetNumOptionalParameters(func.NumOptionalParameters(),
                                      func.HasOptionalPositionalParameters());
       clone.set_result_type(Object::dynamic_type());
       clone.set_is_debuggable(false);
 
       const intptr_t num_parameters = func.NumParameters();
       // The cloned ctor shares the parameter names array with the
       // original.
       const Array& parameter_names = Array::Handle(Z, func.parameter_names());
@@ skipping 21 matching lines @@
   // apply here. A new synthesized class representing the aliased mixin
   // application class was inserted in the super chain of this mixin application
   // class. Members of the actual mixin class will be applied when visiting
   // the mixin application class referring to the actual mixin.
   ASSERT(!mixin_cls.is_mixin_app_alias() ||
          Class::Handle(zone, cls.SuperClass()).IsMixinApplication());
   // A default constructor will be created for the mixin app alias class.
 
   if (FLAG_trace_class_finalization) {
     THR_Print("Applying mixin members of %s to %s at pos %s\n",
-              mixin_cls.ToCString(),
-              cls.ToCString(),
+              mixin_cls.ToCString(), cls.ToCString(),
               cls.token_pos().ToCString());
   }
 
   const GrowableObjectArray& cloned_funcs =
       GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
 
   CreateForwardingConstructors(cls, mixin_cls, cloned_funcs);
 
   Array& functions = Array::Handle(zone);
   Function& func = Function::Handle(zone);
   // The parser creates the mixin application class with no functions.
   ASSERT((functions = cls.functions(), functions.Length() == 0));
   // Now clone the functions from the mixin class.
   functions = mixin_cls.functions();
   const intptr_t num_functions = functions.Length();
   for (intptr_t i = 0; i < num_functions; i++) {
     func ^= functions.At(i);
     if (func.IsGenerativeConstructor()) {
       // A mixin class must not have explicit constructors.
       if (!func.IsImplicitConstructor()) {
         const Script& script = Script::Handle(cls.script());
-        const Error& error = Error::Handle(
-            LanguageError::NewFormatted(Error::Handle(),
-                script, func.token_pos(), Report::AtLocation,
-                Report::kError, Heap::kNew,
-                "constructor '%s' is illegal in mixin class %s",
-                String::Handle(func.UserVisibleName()).ToCString(),
-                String::Handle(zone, mixin_cls.Name()).ToCString()));
+        const Error& error = Error::Handle(LanguageError::NewFormatted(
+            Error::Handle(), script, func.token_pos(), Report::AtLocation,
+            Report::kError, Heap::kNew,
+            "constructor '%s' is illegal in mixin class %s",
+            String::Handle(func.UserVisibleName()).ToCString(),
+            String::Handle(zone, mixin_cls.Name()).ToCString()));
 
         ReportErrors(error, cls, cls.token_pos(),
                      "mixin class '%s' must not have constructors",
                      String::Handle(zone, mixin_cls.Name()).ToCString());
       }
       continue;  // Skip the implicit constructor.
     }
-    if (!func.is_static() &&
-        !func.IsMethodExtractor() &&
-        !func.IsNoSuchMethodDispatcher() &&
-        !func.IsInvokeFieldDispatcher()) {
+    if (!func.is_static() && !func.IsMethodExtractor() &&
+        !func.IsNoSuchMethodDispatcher() && !func.IsInvokeFieldDispatcher()) {
       func = func.Clone(cls);
       cloned_funcs.Add(func);
     }
   }
   functions = Array::MakeArray(cloned_funcs);
   cls.SetFunctions(functions);
 
   // Now clone the fields from the mixin class. There should be no
   // existing fields in the mixin application class.
   ASSERT(Array::Handle(cls.fields()).Length() == 0);
   const Array& fields = Array::Handle(zone, mixin_cls.fields());
   const intptr_t num_fields = fields.Length();
   Field& field = Field::Handle(zone);
   GrowableArray<const Field*> cloned_fields(num_fields);
   for (intptr_t i = 0; i < num_fields; i++) {
     field ^= fields.At(i);
     // Static fields are shared between the mixin class and the mixin
     // application class.
     if (!field.is_static()) {
       const Field& cloned = Field::ZoneHandle(zone, field.Clone(cls));
       cloned_fields.Add(&cloned);
     }
   }
   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());
+              mixin_cls.ToCString(), cls.ToCString());
   }
 }
 
 
 void ClassFinalizer::FinalizeTypesInClass(const Class& cls) {
   Thread* thread = Thread::Current();
   HANDLESCOPE(thread);
   if (cls.is_type_finalized()) {
     return;
   }
@@ skipping 42 matching lines @@
   }
   if (cls.IsTypedefClass()) {
     const Function& signature = Function::Handle(cls.signature_function());
     Type& type = Type::Handle(signature.SignatureType());
 
     // Check for illegal self references.
     GrowableArray<intptr_t> visited_aliases;
     if (!IsTypedefCycleFree(cls, type, &visited_aliases)) {
       const String& name = String::Handle(cls.Name());
       ReportError(cls, cls.token_pos(),
-                  "typedef '%s' illegally refers to itself",
-                  name.ToCString());
+                  "typedef '%s' illegally refers to itself", name.ToCString());
     }
     cls.set_is_type_finalized();
 
     // Resolve and finalize the result and parameter types of the signature
     // function of this typedef class.
     FinalizeSignature(cls, signature);  // Does not modify signature type.
     ASSERT(signature.SignatureType() == type.raw());
 
     // Resolve and finalize the signature type of this typedef.
     type ^= FinalizeType(cls, type, kCanonicalizeWellFormed);
@@ skipping 107 matching lines @@
     const Class& mixin_app_class = Class::Handle(cls.SuperClass());
     const Type& mixin_type = Type::Handle(mixin_app_class.mixin());
     const Class& mixin_cls = Class::Handle(mixin_type.type_class());
 
     CreateForwardingConstructors(cls, mixin_cls, cloned_funcs);
     const Array& functions = Array::Handle(Array::MakeArray(cloned_funcs));
     cls.SetFunctions(functions);
   }
   // Every class should have at least a constructor, unless it is a top level
   // class or a typedef class.
-  ASSERT(cls.IsTopLevel() ||
-         cls.IsTypedefClass() ||
+  ASSERT(cls.IsTopLevel() || cls.IsTypedefClass() ||
          (Array::Handle(cls.functions()).Length() > 0));
   // Resolve and finalize all member types.
   ResolveAndFinalizeMemberTypes(cls);
   // Run additional checks after all types are finalized.
   if (cls.is_const()) {
     CheckForLegalConstClass(cls);
   }
   if (FLAG_use_cha_deopt) {
     GrowableArray<intptr_t> cids;
     CollectFinalizedSuperClasses(cls, &cids);
@@ skipping 11 matching lines @@
 // 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 =
       Field::Handle(zone, enum_cls.LookupInstanceField(Symbols::Index()));
   ASSERT(!index_field.IsNull());
-  const Field& name_field = Field::Handle(zone,
-        enum_cls.LookupInstanceFieldAllowPrivate(Symbols::_name()));
+  const Field& name_field = Field::Handle(
+      zone, enum_cls.LookupInstanceFieldAllowPrivate(Symbols::_name()));
   ASSERT(!name_field.IsNull());
   const Field& values_field =
       Field::Handle(zone, enum_cls.LookupStaticField(Symbols::Values()));
   ASSERT(!values_field.IsNull());
   ASSERT(Instance::Handle(zone, values_field.StaticValue()).IsArray());
-  Array& values_list = Array::Handle(
-      zone, Array::RawCast(values_field.StaticValue()));
+  Array& values_list =
+      Array::Handle(zone, Array::RawCast(values_field.StaticValue()));
 
   const Array& fields = Array::Handle(zone, enum_cls.fields());
   Field& field = Field::Handle(zone);
   Instance& ordinal_value = Instance::Handle(zone);
   Instance& enum_value = Instance::Handle(zone);
 
   const String& enum_name = String::Handle(enum_cls.ScrubbedName());
   const String& name_prefix =
       String::Handle(String::Concat(enum_name, Symbols::Dot()));
 
@@ skipping 33 matching lines @@
   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()) {
+  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();
     }
   }
@@ skipping 12 matching lines @@
   if (type.IsType() && !type.IsMalformed()) {
     AbstractType& other_type = AbstractType::Handle();
     if (type.IsFunctionType()) {
       const Class& scope_class = Class::Handle(type.type_class());
       const Function& signature_function =
           Function::Handle(Type::Cast(type).signature());
       // The signature function of this function type may be a local signature
       // function used in a formal parameter type of the typedef signature, but
       // not the typedef signature function itself, thus not qualifying as an
       // illegal self reference.
-      if (!scope_class.is_type_finalized() &&
-          scope_class.IsTypedefClass() &&
+      if (!scope_class.is_type_finalized() && scope_class.IsTypedefClass() &&
           (scope_class.signature_function() == signature_function.raw())) {
         checking_typedef = true;
         const intptr_t scope_class_id = scope_class.id();
         ASSERT(visited != NULL);
         for (intptr_t i = 0; i < visited->length(); i++) {
           if ((*visited)[i] == scope_class_id) {
             // We have already visited alias 'scope_class'. We found a cycle.
             return false;
           }
         }
@@ skipping 127 matching lines @@
   const GrowableObjectArray& type_args =
       GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
   AbstractType& mixin_super_type =
       AbstractType::Handle(zone, mixin_app_type.super_type());
   ResolveType(cls, mixin_super_type);
   ASSERT(mixin_super_type.HasResolvedTypeClass());  // Even if malformed.
   if (mixin_super_type.IsMalformedOrMalbounded()) {
     ReportError(Error::Handle(zone, mixin_super_type.error()));
   }
   if (mixin_super_type.IsDynamicType()) {
-    ReportError(cls, cls.token_pos(),
-                "class '%s' may not extend 'dynamic'",
+    ReportError(cls, cls.token_pos(), "class '%s' may not extend 'dynamic'",
                 String::Handle(zone, cls.Name()).ToCString());
   }
   // The super type may have a BoundedType as type argument, but cannot be
   // a BoundedType itself.
   CollectTypeArguments(cls, Type::Cast(mixin_super_type), type_args);
   AbstractType& mixin_type = AbstractType::Handle(zone);
   Class& mixin_type_class = Class::Handle(zone);
   Class& mixin_app_class = Class::Handle(zone);
   String& mixin_app_class_name = String::Handle(zone);
   String& mixin_type_class_name = String::Handle(zone);
   AbstractType& super_type_arg = AbstractType::Handle(zone);
   AbstractType& mixin_type_arg = AbstractType::Handle(zone);
   const intptr_t depth = mixin_app_type.Depth();
   for (intptr_t i = 0; i < depth; i++) {
     mixin_type = mixin_app_type.MixinTypeAt(i);
     ASSERT(!mixin_type.IsNull());
     ResolveType(cls, mixin_type);
     ASSERT(mixin_type.HasResolvedTypeClass());  // Even if malformed.
     ASSERT(mixin_type.IsType());
     const intptr_t num_super_type_args = type_args.Length();
     CollectTypeArguments(cls, Type::Cast(mixin_type), type_args);
 
     // If the mixin type has identical type arguments as the super type, they
     // can share the same type parameters of the mixin application class,
     // thereby allowing for further optimizations, such as instantiator vector
     // reuse or sharing of type arguments with the super class.
     bool share_type_params = (num_super_type_args > 0) &&
-        (type_args.Length() == 2*num_super_type_args);
+                             (type_args.Length() == 2 * num_super_type_args);
     if (share_type_params) {
       for (intptr_t i = 0; i < num_super_type_args; i++) {
         super_type_arg ^= type_args.At(i);
         mixin_type_arg ^= type_args.At(num_super_type_args + i);
         if (!super_type_arg.Equals(mixin_type_arg)) {
           share_type_params = false;
           break;
         }
       }
       if (share_type_params) {
         // Cut the type argument vector in half.
         type_args.SetLength(num_super_type_args);
       }
     }
 
     // The name of the mixin application class is a combination of
     // the super class name and mixin class name.
     mixin_app_class_name = mixin_super_type.ClassName();
-    mixin_app_class_name = String::Concat(mixin_app_class_name,
-                                          Symbols::Ampersand());
+    mixin_app_class_name =
+        String::Concat(mixin_app_class_name, Symbols::Ampersand());
     // If the type parameters are shared between the super type and the mixin
     // type, use two ampersand symbols, so that the class has a different name
     // and is not reused in a context where this optimization is not possible.
     if (share_type_params) {
-      mixin_app_class_name = String::Concat(mixin_app_class_name,
-                                            Symbols::Ampersand());
+      mixin_app_class_name =
+          String::Concat(mixin_app_class_name, Symbols::Ampersand());
     }
     mixin_type_class_name = mixin_type.ClassName();
-    mixin_app_class_name = String::Concat(mixin_app_class_name,
-                                          mixin_type_class_name);
+    mixin_app_class_name =
+        String::Concat(mixin_app_class_name, mixin_type_class_name);
     mixin_app_class = library.LookupLocalClass(mixin_app_class_name);
     if (mixin_app_class.IsNull()) {
       mixin_app_class_name = Symbols::New(thread, mixin_app_class_name);
-      mixin_app_class = Class::New(library,
-                                   mixin_app_class_name,
-                                   script,
+      mixin_app_class = Class::New(library, mixin_app_class_name, script,
                                    mixin_type.token_pos());
       mixin_app_class.set_super_type(mixin_super_type);
       mixin_type_class = mixin_type.type_class();
-      const Type& generic_mixin_type = Type::Handle(zone,
-          Type::New(mixin_type_class,
-                    Object::null_type_arguments(),
-                    mixin_type.token_pos()));
+      const Type& generic_mixin_type = Type::Handle(
+          zone, Type::New(mixin_type_class, Object::null_type_arguments(),
+                          mixin_type.token_pos()));
       mixin_app_class.set_mixin(generic_mixin_type);
       // Add the mixin type to the list of interfaces that the mixin application
       // class implements. This is necessary so that cycle check work at
       // compile time (type arguments are ignored by that check).
       const Array& interfaces = Array::Handle(zone, Array::New(1));
       interfaces.SetAt(0, generic_mixin_type);
       ASSERT(mixin_app_class.interfaces() == Object::empty_array().raw());
       mixin_app_class.set_interfaces(interfaces);
       mixin_app_class.set_is_synthesized_class();
       library.AddClass(mixin_app_class);
 
       // No need to add the new class to pending_classes, since it will be
       // processed via the super_type chain of a pending class.
 
       if (FLAG_trace_class_finalization) {
         THR_Print("Creating mixin application %s\n",
                   mixin_app_class.ToCString());
       }
     }
     // This mixin application class becomes the type class of the super type of
     // the next mixin application class. It is however too early to provide the
     // correct super type arguments. We use the raw type for now.
-    mixin_super_type = Type::New(mixin_app_class,
-                                 Object::null_type_arguments(),
+    mixin_super_type = Type::New(mixin_app_class, Object::null_type_arguments(),
                                  mixin_type.token_pos());
   }
   TypeArguments& mixin_app_args = TypeArguments::Handle(zone);
   if (type_args.Length() > 0) {
     mixin_app_args = TypeArguments::New(type_args.Length());
     AbstractType& type_arg = AbstractType::Handle(zone);
     for (intptr_t i = 0; i < type_args.Length(); i++) {
       type_arg ^= type_args.At(i);
       mixin_app_args.SetTypeAt(i, type_arg);
     }
@@ skipping 13 matching lines @@
 
 
 // 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) {
+    const Class& cls,
+    GrowableArray<intptr_t>* visited) {
   if (cls.is_cycle_free()) {
     return;
   }
   ASSERT(visited != NULL);
   if (FLAG_trace_class_finalization) {
     THR_Print("Resolving super and interfaces: %s\n", cls.ToCString());
   }
   Zone* zone = Thread::Current()->zone();
   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 class 'cls'. We found a cycle.
       const String& class_name = String::Handle(zone, cls.Name());
-      ReportError(cls, cls.token_pos(),
-                  "cyclic reference found for class '%s'",
+      ReportError(cls, cls.token_pos(), "cyclic reference found for class '%s'",
                   class_name.ToCString());
     }
   }
 
   // If the class/interface has no explicit super class/interfaces
   // and is not a mixin application, we are done.
   AbstractType& super_type = AbstractType::Handle(zone, cls.super_type());
   Array& super_interfaces = Array::Handle(zone, cls.interfaces());
   if ((super_type.IsNull() || super_type.IsObjectType()) &&
       (super_interfaces.Length() == 0)) {
@@ skipping 19 matching lines @@
   visited->Add(cls_index);
   AbstractType& interface = AbstractType::Handle(zone);
   Class& interface_class = Class::Handle(zone);
 
   // Resolve super type. Failures lead to a longjmp.
   ResolveType(cls, super_type);
   if (super_type.IsMalformedOrMalbounded()) {
     ReportError(Error::Handle(zone, super_type.error()));
   }
   if (super_type.IsDynamicType()) {
-    ReportError(cls, cls.token_pos(),
-                "class '%s' may not extend 'dynamic'",
+    ReportError(cls, cls.token_pos(), "class '%s' may not extend 'dynamic'",
                 String::Handle(zone, cls.Name()).ToCString());
   }
   interface_class = super_type.type_class();
   if (interface_class.IsTypedefClass()) {
     ReportError(cls, cls.token_pos(),
                 "class '%s' may not extend function type alias '%s'",
                 String::Handle(zone, cls.Name()).ToCString(),
-                String::Handle(zone,
-                               super_type.UserVisibleName()).ToCString());
+                String::Handle(zone, super_type.UserVisibleName()).ToCString());
   }
   if (interface_class.is_enum_class()) {
-    ReportError(cls, cls.token_pos(),
-                "class '%s' may not extend enum '%s'",
+    ReportError(cls, cls.token_pos(), "class '%s' may not extend enum '%s'",
                 String::Handle(zone, cls.Name()).ToCString(),
                 String::Handle(zone, interface_class.Name()).ToCString());
   }
 
   // If cls belongs to core lib or to core lib's implementation, restrictions
   // about allowed interfaces are lifted.
   if (!cls_belongs_to_core_lib) {
     // Prevent extending core implementation classes.
     bool is_error = false;
     switch (interface_class.id()) {
       case kNumberCid:
       case kIntegerCid:  // Class Integer, not int.
       case kSmiCid:
       case kMintCid:
       case kBigintCid:
       case kDoubleCid:  // Class Double, not double.
       case kOneByteStringCid:
       case kTwoByteStringCid:
       case kExternalOneByteStringCid:
       case kExternalTwoByteStringCid:
       case kBoolCid:
       case kNullCid:
       case kArrayCid:
       case kImmutableArrayCid:
       case kGrowableObjectArrayCid:
 #define DO_NOT_EXTEND_TYPED_DATA_CLASSES(clazz)                                \
-      case kTypedData##clazz##Cid:                                             \
-      case kTypedData##clazz##ViewCid:                                         \
-      case kExternalTypedData##clazz##Cid:
-      CLASS_LIST_TYPED_DATA(DO_NOT_EXTEND_TYPED_DATA_CLASSES)
+  case kTypedData##clazz##Cid:                                                 \
+  case kTypedData##clazz##ViewCid:                                             \
+  case kExternalTypedData##clazz##Cid:
+        CLASS_LIST_TYPED_DATA(DO_NOT_EXTEND_TYPED_DATA_CLASSES)
 #undef DO_NOT_EXTEND_TYPED_DATA_CLASSES
       case kByteDataViewCid:
       case kWeakPropertyCid:
         is_error = true;
         break;
       default: {
         // Special case: classes for which we don't have a known class id.
-        if (super_type.IsDoubleType() ||
-            super_type.IsIntType() ||
+        if (super_type.IsDoubleType() || super_type.IsIntType() ||
             super_type.IsStringType()) {
           is_error = true;
         }
         break;
       }
     }
     if (is_error) {
-      const String& interface_name = String::Handle(zone,
-                                                    interface_class.Name());
-      ReportError(cls, cls.token_pos(),
-                  "'%s' is not allowed to extend '%s'",
+      const String& interface_name =
+          String::Handle(zone, interface_class.Name());
+      ReportError(cls, cls.token_pos(), "'%s' is not allowed to extend '%s'",
                   String::Handle(zone, cls.Name()).ToCString(),
                   interface_name.ToCString());
     }
   }
   // Now resolve the super interfaces of the super type.
   ResolveSuperTypeAndInterfaces(interface_class, visited);
 
   // Resolve interfaces. Failures lead to a longjmp.
   for (intptr_t i = 0; i < super_interfaces.Length(); i++) {
     interface ^= super_interfaces.At(i);
     ResolveType(cls, interface);
     ASSERT(!interface.IsTypeParameter());  // Should be detected by parser.
     // A malbounded interface is only reported when involved in a type test.
     if (interface.IsMalformed()) {
       ReportError(Error::Handle(zone, interface.error()));
     }
     if (interface.IsDynamicType()) {
       ReportError(cls, cls.token_pos(),
                   "'dynamic' may not be used as interface");
     }
     interface_class = interface.type_class();
     if (interface_class.IsTypedefClass()) {
-      const String& interface_name = String::Handle(zone,
-                                                    interface_class.Name());
+      const String& interface_name =
+          String::Handle(zone, interface_class.Name());
       ReportError(cls, cls.token_pos(),
                   "function type alias '%s' may not be used as interface",
                   interface_name.ToCString());
     }
     if (interface_class.is_enum_class()) {
-      const String& interface_name = String::Handle(zone,
-                                                    interface_class.Name());
+      const String& interface_name =
+          String::Handle(zone, interface_class.Name());
       ReportError(cls, cls.token_pos(),
                   "enum '%s' may not be used as interface",
                   interface_name.ToCString());
     }
     // Verify that unless cls belongs to core lib, it cannot extend, implement,
     // or mixin any of Null, bool, num, int, double, String, dynamic.
     if (!cls_belongs_to_core_lib) {
-      if (interface.IsBoolType() ||
-          interface.IsNullType() ||
-          interface.IsNumberType() ||
-          interface.IsIntType() ||
-          interface.IsDoubleType() ||
-          interface.IsStringType() ||
+      if (interface.IsBoolType() || interface.IsNullType() ||
+          interface.IsNumberType() || interface.IsIntType() ||
+          interface.IsDoubleType() || interface.IsStringType() ||
           interface.IsDynamicType()) {
-        const String& interface_name = String::Handle(zone,
-                                                      interface_class.Name());
+        const String& interface_name =
+            String::Handle(zone, interface_class.Name());
         if (cls.IsMixinApplication()) {
-          ReportError(cls, cls.token_pos(),
-                      "illegal mixin of '%s'",
+          ReportError(cls, cls.token_pos(), "illegal mixin of '%s'",
                       interface_name.ToCString());
         } else {
           ReportError(cls, cls.token_pos(),
                       "'%s' is not allowed to extend or implement '%s'",
                       String::Handle(zone, cls.Name()).ToCString(),
                       interface_name.ToCString());
         }
       }
     }
     interface_class.set_is_implemented();
@@ skipping 26 matching lines @@
 }
 
 
 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(),
+    THR_Print(" library '%s%s':\n", String::Handle(library.url()).ToCString(),
               String::Handle(library.private_key()).ToCString());
   } else {
     THR_Print(" (null library):\n");
   }
   const AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (super_type.IsNull()) {
     THR_Print("  Super: NULL");
   } else {
     const String& super_name = String::Handle(super_type.Name());
     THR_Print("  Super: %s", super_name.ToCString());
@@ skipping 24 matching lines @@
     THR_Print("  %s\n", field.ToCString());
   }
 }
 
 // Either report an error or mark the type as malformed.
 void ClassFinalizer::MarkTypeMalformed(const Error& prev_error,
                                        const Script& script,
                                        const Type& type,
                                        const char* format,
                                        va_list args) {
-  LanguageError& error = LanguageError::Handle(
-      LanguageError::NewFormattedV(
-          prev_error, script, type.token_pos(), Report::AtLocation,
-          Report::kMalformedType, Heap::kOld,
-          format, args));
+  LanguageError& error = LanguageError::Handle(LanguageError::NewFormattedV(
+      prev_error, script, type.token_pos(), Report::AtLocation,
+      Report::kMalformedType, Heap::kOld, format, args));
   if (Isolate::Current()->error_on_bad_type()) {
     ReportError(error);
   }
   type.set_error(error);
   // Make the type raw, since it may not be possible to
   // properly finalize its type arguments.
   type.set_type_class(Class::Handle(Object::dynamic_class()));
   type.set_arguments(Object::null_type_arguments());
   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, ...) {
+                                                   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 UnresolvedClass& unresolved_class =
+      UnresolvedClass::Handle(UnresolvedClass::New(LibraryPrefix::Handle(),
+                                                   Symbols::Empty(), type_pos));
   const Type& type = Type::Handle(
       Type::New(unresolved_class, TypeArguments::Handle(), 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, ...) {
+                                           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, ...) {
+                                            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));
+  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, ...) {
+                                  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, ...) {
+                                 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);
+  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);
   String& expected_name = String::Handle(zone);
   Error& error = Error::Handle(zone);
 
   // First verify field offsets of all the TypedDataView classes.
   for (intptr_t cid = kTypedDataInt8ArrayViewCid;
-       cid <= kTypedDataFloat32x4ArrayViewCid;
-       cid++) {
+       cid <= kTypedDataFloat32x4ArrayViewCid; cid++) {
     cls = class_table.At(cid);  // Get the TypedDataView class.
     error = cls.EnsureIsFinalized(thread);
     ASSERT(error.IsNull());
     cls = cls.SuperClass();  // Get it's super class '_TypedListView'.
     cls = cls.SuperClass();
     fields_array ^= cls.fields();
     ASSERT(fields_array.Length() == TypedDataView::NumberOfFields());
     field ^= fields_array.At(0);
     ASSERT(field.Offset() == TypedDataView::data_offset());
     name ^= field.name();
@@ skipping 38 matching lines @@
   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
 }
 
 }  // namespace dart