Prevent expensive and unnecessary error formatting in the case a bound check is

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 489 matching lines @@
 //             i.e. cls_args = [String, double], offset = 2, length = 2.
 //   Output:   arguments = [int, double, String, double]
 void ClassFinalizer::FinalizeTypeArguments(
     const Class& cls,
     const AbstractTypeArguments& arguments,
     FinalizationKind finalization,
     Error* bound_error) {
   ASSERT(arguments.Length() >= cls.NumTypeArguments());
   if (!cls.is_finalized()) {
     FinalizeTypeParameters(cls);
+    ResolveUpperBounds(cls);
   }
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
     AbstractTypeArguments& super_type_args = AbstractTypeArguments::Handle();
     if (super_type.IsBeingFinalized()) {
       // This type references itself via its type arguments. This is legal, but
       // we must avoid endless recursion. We therefore map the innermost
       // super type to dynamic.
       // Note that a direct self-reference via the super class chain is illegal
@@ skipping 47 matching lines @@
 // Check the type argument vector 'arguments' against the corresponding bounds
 // of the type parameters of class 'cls' and, recursively, of its superclasses.
 // Replace a type argument that cannot be checked at compile time by a
 // BoundedType, thereby postponing the bound check to run time.
 // Return a bound error if a type argument is not within bound at compile time.
 void ClassFinalizer::CheckTypeArgumentBounds(
     const Class& cls,
     const AbstractTypeArguments& arguments,
     Error* bound_error) {
   if (!cls.is_finalized()) {
-    ResolveAndFinalizeUpperBounds(cls);
+    FinalizeUpperBounds(cls);
   }
   // Note that when finalizing a type, we need to verify the bounds in both
   // production mode and checked mode, because the finalized type may be written
   // to a snapshot. It would be wrong to ignore bounds when generating the
   // snapshot in production mode and then use the unchecked type in checked mode
   // after reading it from the snapshot.
   // However, we do not immediately report a bound error, which would be wrong
   // in production mode, but simply postpone the bound checking to runtime.
   const intptr_t num_type_params = cls.NumTypeParameters();
   const intptr_t offset = cls.NumTypeArguments() - num_type_params;
@@ skipping 12 matching lines @@
     }
     cls_type_param = cls_type_params.TypeAt(i);
     const TypeParameter& type_param = TypeParameter::Cast(cls_type_param);
     ASSERT(type_param.IsFinalized());
     declared_bound = type_param.bound();
     if (!declared_bound.IsObjectType() && !declared_bound.IsDynamicType()) {
       Error& malformed_error = Error::Handle();
       // Note that the bound may be malformed, in which case the bound check
       // will return an error and the bound check will be postponed to run time.
       // Note also that the bound may still be unfinalized.
-      if (!declared_bound.IsFinalized()) {
-        ASSERT(declared_bound.IsBeingFinalized());
-        // The bound refers to type parameters, creating a cycle; postpone
-        // bound check to run time, when the bound will be finalized.
-        // TODO(regis): Do we need to instantiate an uninstantiated bound here?
-        type_arg = BoundedType::New(type_arg, declared_bound, type_param);
-        arguments.SetTypeAt(offset + i, type_arg);
-        continue;
-      }
       if (declared_bound.IsInstantiated()) {
         instantiated_bound = declared_bound.raw();
       } else {
         instantiated_bound =
             declared_bound.InstantiateFrom(arguments, &malformed_error);
       }
+      if (!instantiated_bound.IsFinalized()) {
+        // The bound refers to type parameters, creating a cycle; postpone
+        // bound check to run time, when the bound will be finalized.
+        // The bound may not necessarily be 'IsBeingFinalized' yet, as is the
+        // case with a pair of type parameters of the same class referring to
+        // each other via their bounds.
+        type_arg = BoundedType::New(type_arg, instantiated_bound, type_param);
+        arguments.SetTypeAt(offset + i, type_arg);
+        continue;
+      }
       // TODO(regis): We could simplify this code if we could differentiate
       // between a failed bound check and a bound check that is undecidable at
       // compile time.
       // Shortcut the special case where we check a type parameter against its
       // declared upper bound.
+      bool below_bound = true;
       if (malformed_error.IsNull() &&
           (!type_arg.Equals(type_param) ||
            !instantiated_bound.Equals(declared_bound))) {
-        type_param.CheckBound(type_arg, instantiated_bound, &malformed_error);
+        // Pass NULL to prevent expensive and unnecessary error formatting in
+        // the case the bound check is postponed to run time.
+        below_bound = type_param.CheckBound(type_arg, instantiated_bound, NULL);
       }
-      if (!malformed_error.IsNull()) {
+      if (!malformed_error.IsNull() || !below_bound) {
         if (!type_arg.IsInstantiated() ||
             !instantiated_bound.IsInstantiated()) {
           type_arg = BoundedType::New(type_arg, instantiated_bound, type_param);
           arguments.SetTypeAt(offset + i, type_arg);
         } else if (bound_error->IsNull()) {
+          if (malformed_error.IsNull()) {
+            // Call CheckBound again to format error message.
+            type_param.CheckBound(type_arg,
+                                  instantiated_bound,
+                                  &malformed_error);
+          }
+          ASSERT(!malformed_error.IsNull());
           *bound_error = malformed_error.raw();
         }
       }
     }
   }
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
     CheckTypeArgumentBounds(super_class, arguments, bound_error);
   }
@@ skipping 59 matching lines @@
   parameterized_type.set_is_being_finalized();
 
   // The type class does not need to be finalized in order to finalize the type,
   // however, it must at least be resolved (this was done as part of resolving
   // the type itself, a precondition to calling FinalizeType).
   // Also, the interfaces of the type class must be resolved and the type
   // parameters of the type class must be finalized.
   Class& type_class = Class::Handle(parameterized_type.type_class());
   if (!type_class.is_finalized()) {
     FinalizeTypeParameters(type_class);
+    ResolveUpperBounds(type_class);
   }
 
   // Finalize the current type arguments of the type, which are still the
   // parsed type arguments.
   AbstractTypeArguments& arguments =
       AbstractTypeArguments::Handle(parameterized_type.arguments());
   if (!arguments.IsNull()) {
     intptr_t num_arguments = arguments.Length();
     AbstractType& type_argument = AbstractType::Handle();
     for (intptr_t i = 0; i < num_arguments; i++) {
@@ skipping 241 matching lines @@
         !function.is_static() &&
         !function.IsMethodExtractor()) {
       return super_class.raw();
     }
     super_class = super_class.SuperClass();
   }
   return Class::null();
 }
 
 
-// Resolve and finalize the upper bounds of the type parameters of class cls.
-void ClassFinalizer::ResolveAndFinalizeUpperBounds(const Class& cls) {
+// Resolve the upper bounds of the type parameters of class cls.
+void ClassFinalizer::ResolveUpperBounds(const Class& cls) {
   const intptr_t num_type_params = cls.NumTypeParameters();
   TypeParameter& type_param = TypeParameter::Handle();
   AbstractType& bound = AbstractType::Handle();
   const AbstractTypeArguments& type_params =
       AbstractTypeArguments::Handle(cls.type_parameters());
   ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
          (type_params.Length() == num_type_params));
+  // In a first pass, resolve all bounds. This guarantees that finalization
+  // of mutually referencing bounds will not encounter an unresolved bound.
+  for (intptr_t i = 0; i < num_type_params; i++) {
+    type_param ^= type_params.TypeAt(i);
+    bound = type_param.bound();
+    ResolveType(cls, bound, kCanonicalize);
+  }
+}
+
+
+// Finalize the upper bounds of the type parameters of class cls.
+void ClassFinalizer::FinalizeUpperBounds(const Class& cls) {
+  const intptr_t num_type_params = cls.NumTypeParameters();
+  TypeParameter& type_param = TypeParameter::Handle();
+  AbstractType& bound = AbstractType::Handle();
+  const AbstractTypeArguments& type_params =
+      AbstractTypeArguments::Handle(cls.type_parameters());
+  ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
+         (type_params.Length() == num_type_params));
   for (intptr_t i = 0; i < num_type_params; i++) {
     type_param ^= type_params.TypeAt(i);
     bound = type_param.bound();
     if (bound.IsFinalized() || bound.IsBeingFinalized()) {
       // A bound involved in F-bounded quantification may form a cycle.
       continue;
     }
-    ResolveType(cls, bound, kCanonicalize);
     bound = FinalizeType(cls, bound, kCanonicalize);
     type_param.set_bound(bound);
   }
 }
 
 
 void ClassFinalizer::ResolveAndFinalizeMemberTypes(const Class& cls) {
   // Note that getters and setters are explicitly listed as such in the list of
   // functions of a class, so we do not need to consider fields as implicitly
   // generating getters and setters.
@@ skipping 354 matching lines @@
     FinalizeClass(super_class);
   }
   if (cls.mixin() != Type::null()) {
     // Copy instance methods and fields from the mixin class.
     // This has to happen before the check whether the methods of
     // the class conflict with inherited methods.
     ApplyMixin(cls);
   }
   // Finalize type parameters before finalizing the super type.
   FinalizeTypeParameters(cls);
+  ResolveUpperBounds(cls);
   // Finalize super type.
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     // In case of a bound error in the super type in production mode, the
     // finalized super type will be a BoundedType with a malformed bound.
     // It should not be a problem if the class is written to a snapshot and
     // later executed in checked mode. Note that the finalized type argument
     // vector of any type of the base class will contain a BoundedType for the
     // out of bound type argument.
     super_type = FinalizeType(cls, super_type, kCanonicalizeWellFormed);
     cls.set_super_type(super_type);
   }
   if (cls.IsSignatureClass()) {
     // Check for illegal self references.
     GrowableArray<intptr_t> visited_aliases;
     if (!IsAliasCycleFree(cls, &visited_aliases)) {
       const String& name = String::Handle(cls.Name());
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_pos(),
                   "typedef '%s' illegally refers to itself",
                   name.ToCString());
     }
     cls.Finalize();
     // Signature classes extend Object. No need to add this class to the direct
     // subclasses of Object.
     ASSERT(super_type.IsNull() || super_type.IsObjectType());
 
     // The type parameters of signature classes may have bounds.
-    ResolveAndFinalizeUpperBounds(cls);
+    FinalizeUpperBounds(cls);
 
     // Resolve and finalize the result and parameter types of the signature
     // function of this signature class.
     const Function& sig_function = Function::Handle(cls.signature_function());
     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;
@@ skipping 30 matching lines @@
                     String::Handle(interface_type.Name()).ToCString(),
                     String::Handle(cls.Name()).ToCString());
       }
     }
   }
   // Mark as finalized before resolving type parameter upper bounds and member
   // types in order to break cycles.
   cls.Finalize();
   // Finalize bounds even if running in production mode, so that a snapshot
   // contains them.
-  ResolveAndFinalizeUpperBounds(cls);
+  FinalizeUpperBounds(cls);
   ResolveAndFinalizeMemberTypes(cls);
   // Run additional checks after all types are finalized.
   if (cls.is_const()) {
     CheckForLegalConstClass(cls);
   }
   // Add this class to the direct subclasses of the superclass, unless the
   // superclass is Object.
   if (!super_type.IsNull() && !super_type.IsObjectType()) {
     ASSERT(!super_class.IsNull());
     super_class.AddDirectSubclass(cls);
@@ skipping 473 matching lines @@
 void ClassFinalizer::ReportError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
   va_end(args);
   ReportError(error);
 }
 
 }  // namespace dart