More cleanup to avoid creation of redundant handles

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 79 matching lines @@
     const GrowableObjectArray& pending_classes,
     GrowableArray<intptr_t>* finalized_super_classes) {
   Class& cls = Class::Handle();
   AbstractType& super_type = Type::Handle();
   for (intptr_t i = 0; i < pending_classes.Length(); i++) {
     cls ^= pending_classes.At(i);
     ASSERT(!cls.is_finalized());
     super_type = cls.super_type();
     if (!super_type.IsNull()) {
       if (!super_type.IsMalformed() &&
-          super_type.HasResolvedTypeClass() &&
-          Class::Handle(super_type.type_class()).is_finalized()) {
-        AddSuperType(super_type, finalized_super_classes);
+          super_type.HasResolvedTypeClass()) {
+        cls ^= super_type.type_class();
+        if (cls.is_finalized()) {
+          AddSuperType(super_type, finalized_super_classes);
+        }
       }
     }
   }
 }
 
 
 // Class finalization occurs:
 // a) when bootstrap process completes (VerifyBootstrapClasses).
 // b) after the user classes are loaded (dart_api).
 bool ClassFinalizer::FinalizePendingClasses() {
@@ skipping 254 matching lines @@
     const Script& script = Script::Handle(cls.script());
     ReportError(script, factory.token_pos(),
                 "constructor '%s' must be const as required by redirecting"
                 "const factory '%s'",
                 String::Handle(target.name()).ToCString(),
                 String::Handle(factory.name()).ToCString());
   }
 
   // Update redirection data with resolved target.
   factory.SetRedirectionTarget(target);
-  factory.SetRedirectionIdentifier(String::Handle());  // Not needed anymore.
+  // Not needed anymore.
+  factory.SetRedirectionIdentifier(String::null_object());
   if (!target.IsRedirectingFactory()) {
     return;
   }
 
   // The target is itself a redirecting factory. Recursively resolve its own
   // target and update the current redirection data to point to the end target
   // of the redirection chain.
   ResolveRedirectingFactoryTarget(target_class, target, visited_factories);
   Type& target_type = Type::Handle(target.RedirectionType());
   Function& target_target = Function::Handle(target.RedirectionTarget());
@@ skipping 487 matching lines @@
         parameterized_type.UserVisibleName());
     const Type& malformed_bound = Type::Handle(
         NewFinalizedMalformedType(bound_error,
                                   cls,
                                   parameterized_type.token_pos(),
                                   bound_finalization,
                                   "type '%s' has an out of bound type argument",
                                   parameterized_type_name.ToCString()));
     return BoundedType::New(parameterized_type,
                             malformed_bound,
-                            TypeParameter::Handle());
+                            TypeParameter::null_object());
   }
 
   if (finalization >= kCanonicalize) {
     return parameterized_type.Canonicalize();
   } else {
     return parameterized_type.raw();
   }
 }
 
 
@@ skipping 535 matching lines @@
     ResolveAndFinalizeSignature(cls, sig_function);
 
     // Resolve and finalize the signature type of this signature class.
     const Type& sig_type = Type::Handle(cls.SignatureType());
     FinalizeType(cls, sig_type, kCanonicalizeWellFormed);
     return;
   }
   // Finalize interface types (but not necessarily interface classes).
   Array& interface_types = Array::Handle(cls.interfaces());
   AbstractType& interface_type = AbstractType::Handle();
+  AbstractType& seen_interf = AbstractType::Handle();
   for (intptr_t i = 0; i < interface_types.Length(); i++) {
     interface_type ^= interface_types.At(i);
     interface_type = FinalizeType(cls, interface_type, kCanonicalizeWellFormed);
     interface_types.SetAt(i, interface_type);
 
     // Check whether the interface is duplicated. We need to wait with
     // this check until the super type and interface types are finalized,
     // so that we can use Type::Equals() for the test.
     ASSERT(interface_type.IsFinalized());
     ASSERT(super_type.IsNull() || super_type.IsFinalized());
     if (!super_type.IsNull() && interface_type.Equals(super_type)) {
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_pos(),
                   "super type '%s' may not be listed in "
                   "implements clause of class '%s'",
                   String::Handle(super_type.Name()).ToCString(),
                   String::Handle(cls.Name()).ToCString());
     }
-    AbstractType& seen_interf = AbstractType::Handle();
     for (intptr_t j = 0; j < i; j++) {
       seen_interf ^= interface_types.At(j);
       if (interface_type.Equals(seen_interf)) {
         const Script& script = Script::Handle(cls.script());
         ReportError(script, cls.token_pos(),
                     "interface '%s' appears twice in "
                     "implements clause of class '%s'",
                     String::Handle(interface_type.Name()).ToCString(),
                     String::Handle(cls.Name()).ToCString());
       }
@@ skipping 146 matching lines @@
   // Resolve super type and all mixin types.
   const GrowableObjectArray& type_args =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   AbstractType& type = AbstractType::Handle(mixin_app.super_type());
   ResolveType(cls, type, kCanonicalizeWellFormed);
   ASSERT(type.HasResolvedTypeClass());
   // TODO(hausner): May need to handle BoundedType here.
   ASSERT(type.IsType());
   CollectTypeArguments(cls, Type::Cast(type), type_args);
   const Array& mixins = Array::Handle(mixin_app.mixin_types());
+  Class& mixin_app_class = Class::Handle();
   for (int i = 0; i < mixins.Length(); i++) {
     type ^= mixins.At(i);
     ASSERT(type.HasResolvedTypeClass());  // Newly created class in parser.
-    const Class& mixin_app_class = Class::Handle(type.type_class());
+    mixin_app_class ^= type.type_class();
     type = mixin_app_class.mixin();
     ASSERT(!type.IsNull());
     ResolveType(cls, type, kCanonicalizeWellFormed);
     ASSERT(type.HasResolvedTypeClass());
     ASSERT(type.IsType());
     CollectTypeArguments(cls, Type::Cast(type), type_args);
   }
   const TypeArguments& mixin_app_args =
     TypeArguments::Handle(TypeArguments::New(type_args.Length()));
   for (int i = 0; i < type_args.Length(); i++) {
     type ^= type_args.At(i);
     mixin_app_args.SetTypeAt(i, type);
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("ResolveMixinAppType: mixin appl type args: %s\n",
               mixin_app_args.ToCString());
   }
   // The last element in the mixins array is the lowest mixin application
   // type in the mixin chain. Build a new super type with its type class
   // and the collected type arguments from the super type and all
   // mixin types. This super type replaces the MixinAppType object
   // in the class that extends the mixin application.
   type ^= mixins.At(mixins.Length() - 1);
-  const Class& resolved_mixin_app_class = Class::Handle(type.type_class());
-  Type& resolved_mixin_app_type = Type::Handle();
-  resolved_mixin_app_type = Type::New(resolved_mixin_app_class,
-                                      mixin_app_args,
-                                      mixin_app.token_pos());
-  return resolved_mixin_app_type.raw();
+  mixin_app_class ^= type.type_class();
+  return Type::New(mixin_app_class,
+                   mixin_app_args,
+                   mixin_app.token_pos());
 }
 
 
 // Recursively walks the graph of explicitly declared super type and
 // interfaces, resolving unresolved super types and interfaces.
 // Reports an error if there is an interface reference that cannot be
 // resolved, or if there is a cycle in the graph. We detect cycles by
 // remembering interfaces we've visited in each path through the
 // graph. If we visit an interface a second time on a given path,
 // we found a loop.
@@ skipping 239 matching lines @@
     }
   }
   // In checked mode, always mark the type as malformed.
   // In production mode, mark the type as malformed only if its type class is
   // not resolved.
   // In both mode, make the type raw, since it may not be possible to
   // properly finalize its type arguments.
   if (FLAG_enable_type_checks || !type.HasResolvedTypeClass()) {
     type.set_malformed_error(error);
   }
-  type.set_arguments(AbstractTypeArguments::Handle());
+  type.set_arguments(AbstractTypeArguments::null_object());
   if (!type.IsFinalized()) {
     type.SetIsFinalized();
     // Do not canonicalize malformed types, since they may not be resolved.
   } 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());
   }
 }
 
@@ skipping 113 matching lines @@
   expected_name ^= String::New("_offset");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
   field ^= fields_array.At(2);
   ASSERT(field.Offset() == TypedDataView::length_offset());
   name ^= field.name();
   ASSERT(name.Equals("length"));
 #endif
 }
 
 }  // namespace dart