Make sure the signature of the call method is finalized before involving it

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/hash_table.h"
 #include "vm/heap.h"
@@ skipping 346 matching lines @@
   if (!target.IsNull()) {
     // Already resolved.
     return;
   }
 
   // Target is not resolved yet.
   if (FLAG_trace_class_finalization) {
     THR_Print("Resolving redirecting factory: %s\n",
               String::Handle(factory.name()).ToCString());
   }
-  type ^= FinalizeType(cls, type, kCanonicalize);
+  type ^= FinalizeType(cls, type);
   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()),
@@ skipping 75 matching lines @@
     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);
       if (bound_error.IsNull()) {
-        target_type ^= FinalizeType(cls, target_type, kCanonicalize);
+        target_type ^= FinalizeType(cls, target_type);
       } 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();
       }
     }
   }
   factory.SetRedirectionType(target_type);
@@ skipping 161 matching lines @@
 // 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) {
+  ASSERT(pending_types != NULL);
   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());
   }
   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());
@@ skipping 80 matching lines @@
                   "wrong number of type arguments for class '%s'",
                   type_class_name.ToCString());
     }
     // Make the type raw and continue without reporting any error.
     // A static warning should have been reported.
     arguments = TypeArguments::null();
     type.set_arguments(arguments);
   }
 
   // Mark the type as being finalized in order to detect self reference and
-  // postpone bound checking until after all types in the graph of
+  // postpone bound checking (if required) until after all types in the graph of
   // mutually recursive types are finalized.
   type.SetIsBeingFinalized();
-  pending_types->Add(type);
+  if (pending_types != NULL) {
+    pending_types->Add(type);
+  }
 
   // The full type argument vector consists of the type arguments of the
   // super types of type_class, which are initialized from the parsed
   // 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);
@@ skipping 244 matching lines @@
         *bound_error = type_arg.error();
         ASSERT(!bound_error->IsNull());
       }
     }
     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()) {
       if (!declared_bound.IsFinalized() && !declared_bound.IsBeingFinalized()) {
-        declared_bound = FinalizeType(cls, declared_bound, kCanonicalize);
+        declared_bound = FinalizeType(cls, declared_bound);
         type_param.set_bound(declared_bound);
       }
       ASSERT(declared_bound.IsFinalized() || declared_bound.IsBeingFinalized());
       Error& 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.
       if (declared_bound.IsInstantiated()) {
         instantiated_bound = declared_bound.raw();
       } else {
         instantiated_bound = declared_bound.InstantiateFrom(
@@ skipping 15 matching lines @@
           !(type_arg.Equals(type_param) &&
             instantiated_bound.Equals(declared_bound))) {
         // If type_arg is a type parameter, its declared bound may not be
         // finalized yet.
         if (type_arg.IsTypeParameter()) {
           const Class& type_arg_cls = Class::Handle(
               TypeParameter::Cast(type_arg).parameterized_class());
           AbstractType& bound =
               AbstractType::Handle(TypeParameter::Cast(type_arg).bound());
           if (!bound.IsFinalized() && !bound.IsBeingFinalized()) {
-            bound = FinalizeType(type_arg_cls, bound, kCanonicalize);
+            bound = FinalizeType(type_arg_cls, bound);
             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) &&
             error.IsNull()) {
           // The bound cannot be checked at compile time; postpone to run time.
           type_arg = BoundedType::New(type_arg, instantiated_bound, type_param);
@@ skipping 131 matching lines @@
     }
 
     // We do not canonicalize type parameters.
     return type_parameter.raw();
   }
 
   // At this point, we can only have a Type.
   ASSERT(type.IsType());
 
   // This type is the root type of the type graph if no pending types queue is
-  // allocated yet.
-  const bool is_root_type = (pending_types == NULL);
+  // allocated yet, and if canonicalization is required.
+  const bool is_root_type =
+      (pending_types == NULL) && (finalization >= kCanonicalize);
   if (is_root_type) {
     pending_types = new PendingTypes(zone, 4);
   }
 
   const intptr_t num_expanded_type_arguments =
       ExpandAndFinalizeTypeArguments(cls, type, pending_types);
 
   // If we are done finalizing a graph of mutually recursive types, check their
   // bounds.
   if (is_root_type) {
@@ skipping 70 matching lines @@
   // Resolve formal parameter types.
   const intptr_t num_parameters = function.NumParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = function.ParameterTypeAt(i);
     ResolveType(cls, type);
   }
 }
 
 
 void ClassFinalizer::FinalizeSignature(const Class& cls,
-                                       const Function& function) {
+                                       const Function& function,
+                                       FinalizationKind finalization) {
   AbstractType& type = AbstractType::Handle();
   AbstractType& finalized_type = AbstractType::Handle();
   // Finalize upper bounds of function type parameters.
   const intptr_t num_type_params = function.NumTypeParameters();
   if (num_type_params > 0) {
     TypeParameter& type_param = TypeParameter::Handle();
     const TypeArguments& type_params =
         TypeArguments::Handle(function.type_parameters());
     for (intptr_t i = 0; i < num_type_params; i++) {
       type_param ^= type_params.TypeAt(i);
       type = type_param.bound();
-      finalized_type = FinalizeType(cls, type, kCanonicalize);
+      finalized_type = FinalizeType(cls, type, finalization);
       if (finalized_type.raw() != type.raw()) {
         type_param.set_bound(finalized_type);
       }
     }
   }
   // Finalize result type.
   type = function.result_type();
-  finalized_type = FinalizeType(cls, type, kCanonicalize);
+  finalized_type = FinalizeType(cls, type, finalization);
   // The result type may be malformed or malbounded.
   if (finalized_type.raw() != type.raw()) {
     function.set_result_type(finalized_type);
   }
   // Finalize formal parameter types.
   const intptr_t num_parameters = function.NumParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = function.ParameterTypeAt(i);
-    finalized_type = FinalizeType(cls, type, kCanonicalize);
+    finalized_type = FinalizeType(cls, type, finalization);
     // The parameter type may be malformed or malbounded.
     if (type.raw() != finalized_type.raw()) {
       function.SetParameterTypeAt(i, finalized_type);
     }
   }
 }
 
 
 // Check if an instance field, getter, or method of same name exists
 // in any super class.
@@ skipping 111 matching lines @@
   Field& field = Field::Handle(zone);
   AbstractType& type = AbstractType::Handle(zone);
   String& name = String::Handle(zone);
   String& getter_name = String::Handle(zone);
   String& setter_name = String::Handle(zone);
   Class& super_class = Class::Handle(zone);
   const intptr_t num_fields = array.Length();
   for (intptr_t i = 0; i < num_fields; i++) {
     field ^= array.At(i);
     type = field.type();
-    type = FinalizeType(cls, type, kCanonicalize);
+    type = FinalizeType(cls, type);
     field.SetFieldType(type);
     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 "
@@ skipping 170 matching lines @@
             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);
+          type ^= FinalizeType(cls, type);
           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(),
@@ skipping 169 matching lines @@
       // 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()) {
-              param_bound =
-                  FinalizeType(mixin_app_class, param_bound, kCanonicalize);
+              param_bound = FinalizeType(mixin_app_class, param_bound);
               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());
             ASSERT(!param_bound.IsInstantiated());
             param.set_bound(param_bound);
@@ skipping 533 matching lines @@
   }
   // Finalize type parameters before finalizing the super type.
   FinalizeTypeParameters(cls);  // May change super type.
   super_class = cls.SuperClass();
   ASSERT(super_class.IsNull() || super_class.is_type_finalized());
   // Only resolving rather than finalizing the upper bounds here would result in
   // instantiated type parameters of the super type to temporarily have
   // unfinalized bounds. It is more efficient to finalize them early.
   // Finalize bounds even if running in production mode, so that a snapshot
   // contains them.
-  FinalizeUpperBounds(cls, kCanonicalizeWellFormed);
+  FinalizeUpperBounds(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 have a BoundedType as type argument for the
     // out of bound type argument.
     // 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);
+    super_type = FinalizeType(cls, super_type);
     cls.set_super_type(super_type);
   }
   // Finalize mixin type.
   Type& mixin_type = Type::Handle(cls.mixin());
   if (!mixin_type.IsNull()) {
-    mixin_type ^= FinalizeType(cls, mixin_type, kCanonicalizeWellFormed);
+    mixin_type ^= FinalizeType(cls, mixin_type);
     cls.set_mixin(mixin_type);
   }
   if (cls.IsTypedefClass()) {
     Function& signature = Function::Handle(cls.signature_function());
     Type& type = Type::Handle(signature.SignatureType());
     ASSERT(type.signature() == signature.raw());
 
     // 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());
     }
     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);
+    type ^= FinalizeType(cls, type);
 
     // If a different canonical signature type is returned, update the signature
     // function of the typedef.
     signature = type.signature();
     signature.SetSignatureType(type);
     cls.set_signature_function(signature);
 
     // Closure instances do not refer to this typedef as their class, so there
     // is no need to add this typedef class to the subclasses of _Closure.
     ASSERT(super_type.IsNull() || super_type.IsObjectType());
 
     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_type = FinalizeType(cls, interface_type);
     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.
     // TODO(regis): This restriction about duplicated interfaces may get lifted.
     ASSERT(interface_type.IsFinalized());
     ASSERT(super_type.IsNull() || super_type.IsFinalized());
     if (!super_type.IsNull() && interface_type.Equals(super_type)) {
       ReportError(cls, cls.token_pos(),
@@ skipping 1246 matching lines @@
   ProgramVisitor::VisitFunctions(&function_visitor);
 
   class ClearCodeClassVisitor : public ClassVisitor {
     void Visit(const Class& cls) { cls.DisableAllocationStub(); }
   };
   ClearCodeClassVisitor class_visitor;
   ProgramVisitor::VisitClasses(&class_visitor);
 }
 
 }  // namespace dart