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

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, 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 <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 1267 matching lines @@
   ASSERT(!klass.IsNull());
   // Note that if cls is _Closure, the returned type will be _Closure,
   // and not the signature type.
   Type& type = Type::ZoneHandle(Z, klass.CanonicalType());
   if (!type.IsNull()) {
     return type;
   }
   type = Type::New(klass, TypeArguments::Handle(Z, klass.type_parameters()),
                    klass.token_pos());
   if (klass.is_type_finalized()) {
-    type ^= ClassFinalizer::FinalizeType(
-        klass, type, ClassFinalizer::kCanonicalizeWellFormed);
+    type ^= ClassFinalizer::FinalizeType(klass, type);
     // Note that the receiver type may now be a malbounded type.
     klass.SetCanonicalType(type);
   }
   return type;
 }
 
 
 void TranslationHelper::ReportError(const char* format, ...) {
   const Script& null_script = Script::Handle(Z);
 
@@ skipping 3064 matching lines @@
       result_ = AbstractType::dynamic_type().raw();
     }
     parameter_types.SetAt(pos, result_);
     parameter_names.SetAt(pos, H.DartSymbol(tuple->first()));
   }
 
   Type& signature_type =
       Type::ZoneHandle(Z, signature_function.SignatureType());
 
   if (finalize_) {
-    signature_type ^= ClassFinalizer::FinalizeType(
-        *active_class_->klass, signature_type, ClassFinalizer::kCanonicalize);
+    signature_type ^=
+        ClassFinalizer::FinalizeType(*active_class_->klass, signature_type);
     // Do not refer to signature_function anymore, since it may have been
     // replaced during canonicalization.
     signature_function = Function::null();
   }
 
   result_ = signature_type.raw();
 }
 
 
 static intptr_t FindTypeParameterIndex(List<TypeParameter>* parameters,
@@ skipping 80 matching lines @@
   //   => We therefore ignore errors in `A` or `B`.
   const TypeArguments& type_arguments = TranslateTypeArguments(
       node->type_arguments().raw_array(), node->type_arguments().length());
 
 
   dart::Object& klass =
       dart::Object::Handle(Z, H.ToUnresolvedClass(node->klass()));
   result_ = Type::New(klass, type_arguments, TokenPosition::kNoSource);
   if (finalize_) {
     ASSERT(active_class_->klass != NULL);
-    result_ = ClassFinalizer::FinalizeType(*active_class_->klass, result_,
-                                           ClassFinalizer::kCanonicalize);
+    result_ = ClassFinalizer::FinalizeType(*active_class_->klass, result_);
   }
 }
 
 
 void DartTypeTranslator::VisitDynamicType(DynamicType* node) {
   result_ = Object::dynamic_type().raw();
 }
 
 
 void DartTypeTranslator::VisitVoidType(VoidType* node) {
@@ skipping 37 matching lines @@
   const TypeArguments& type_arguments =
       TranslateTypeArguments(receiver_type_arguments, length);
   if (type_arguments.IsNull()) return type_arguments;
 
   // We make a temporary [Type] object and use `ClassFinalizer::FinalizeType` to
   // finalize the argument types.
   // (This can for example make the [type_arguments] vector larger)
   Type& type = Type::Handle(
       Z, Type::New(receiver_class, type_arguments, TokenPosition::kNoSource));
   if (finalize_) {
-    type ^= ClassFinalizer::FinalizeType(
-        *active_class_->klass, type, ClassFinalizer::kCanonicalizeWellFormed);
+    type ^= ClassFinalizer::FinalizeType(*active_class_->klass, type);
   }
 
   const TypeArguments& instantiated_type_arguments =
       TypeArguments::ZoneHandle(Z, type.arguments());
   return instantiated_type_arguments;
 }
 
 
 const Type& DartTypeTranslator::ReceiverType(const dart::Class& klass) {
   ASSERT(!klass.IsNull());
   ASSERT(!klass.IsTypedefClass());
   // Note that if klass is _Closure, the returned type will be _Closure,
   // and not the signature type.
   Type& type = Type::ZoneHandle(Z, klass.CanonicalType());
   if (!type.IsNull()) {
     return type;
   }
   type = Type::New(klass, TypeArguments::Handle(Z, klass.type_parameters()),
                    klass.token_pos());
   if (klass.is_type_finalized()) {
-    type ^= ClassFinalizer::FinalizeType(
-        klass, type, ClassFinalizer::kCanonicalizeWellFormed);
+    type ^= ClassFinalizer::FinalizeType(klass, type);
     klass.SetCanonicalType(type);
   }
   return type;
 }
 
 
 void FlowGraphBuilder::VisitTypeLiteral(TypeLiteral* node) {
   const AbstractType& type = T.TranslateType(node->type());
   if (type.IsMalformed()) H.ReportError("Malformed type literal");
 
@@ skipping 348 matching lines @@
 
   // Check for malbounded-ness of type.
   if (I->type_checks()) {
     List<DartType>& kernel_type_arguments = node->arguments()->types();
     const TypeArguments& type_arguments = T.TranslateInstantiatedTypeArguments(
         klass, kernel_type_arguments.raw_array(),
         kernel_type_arguments.length());
 
     AbstractType& type = AbstractType::Handle(
         Z, Type::New(klass, type_arguments, TokenPosition::kNoSource));
-    type = ClassFinalizer::FinalizeType(klass, type,
-                                        ClassFinalizer::kCanonicalize);
+    type = ClassFinalizer::FinalizeType(klass, type);
 
     if (type.IsMalbounded()) {
       // Evaluate expressions for correctness.
       List<Expression>& positional = node->arguments()->positional();
       List<NamedExpression>& named = node->arguments()->named();
       for (intptr_t i = 0; i < positional.length(); ++i) {
         instructions += TranslateExpression(positional[i]);
         instructions += Drop();
       }
       for (intptr_t i = 0; i < named.length(); ++i) {
@@ skipping 1354 matching lines @@
       const ContextScope& context_scope =
           ContextScope::Handle(Z, scope->PreserveOuterScope(context_depth_));
       function.set_context_scope(context_scope);
       function.set_kernel_function(node);
       KernelReader::SetupFunctionParameters(H, T, dart::Class::Handle(Z),
                                             function, node,
                                             false,  // is_method
                                             true);  // is_closure
       // Finalize function type.
       Type& signature_type = Type::Handle(Z, function.SignatureType());
-      signature_type ^= ClassFinalizer::FinalizeType(
-          *active_class_.klass, signature_type, ClassFinalizer::kCanonicalize);
+      signature_type ^=
+          ClassFinalizer::FinalizeType(*active_class_.klass, signature_type);
       function.SetSignatureType(signature_type);
 
       I->AddClosureFunction(function);
     }
     break;
   }
 
   const dart::Class& closure_class =
       dart::Class::ZoneHandle(Z, I->object_store()->closure_class());
   ASSERT(!closure_class.IsNull());
@@ skipping 123 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)