Refactor type finalization in VM so that the parser only resolves type

runtime/vm/parser.cc

 // Copyright (c) 2012, 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/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 3499 matching lines @@
       FinalizeFormalParameterTypes(&params);
     }
 
     // The number of parameters and their type are not yet set in local
     // functions, since they are not 'top-level' parsed.
     // However, they are already set when the local function is compiled, since
     // the local function was parsed when its parent was compiled.
     if (func.parameter_types() == Object::empty_array().raw()) {
       AddFormalParamsToFunction(&params, func);
     }
-    ResolveSignature(ClassFinalizer::kResolveTypeParameters, func);
+    ResolveSignature(func);
     if (!is_top_level_) {
-      ClassFinalizer::FinalizeSignature(current_class(), func);
+      ClassFinalizer::FinalizeSignature(Class::Handle(Z, func.origin()), func);
     }
     SetupDefaultsForOptionalParams(params);
     ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
 
     // Populate function scope with the formal parameters.
     AddFormalParamsToScope(&params, current_block_->scope);
 
     if (I->type_checks() && (FunctionLevel() > 0)) {
       // We are parsing, but not compiling, a local function.
       // The instantiator may be required at run time for generic type checks.
@@ skipping 585 matching lines @@
     func.SetRedirectionType(redirection_type);
     if (!redirection_identifier.IsNull()) {
       func.SetRedirectionIdentifier(redirection_identifier);
     }
   }
 
   ASSERT(is_top_level_);
   AddFormalParamsToFunction(&method->params, func);
   ASSERT(innermost_function().raw() == func.raw());
   innermost_function_ = Function::null();
-  ResolveSignature(ClassFinalizer::kResolveTypeParameters, func);
+  ResolveSignature(func);
   members->AddFunction(func);
 }
 
 
 void Parser::ParseFieldDefinition(ClassDesc* members, MemberDesc* field) {
   TRACE_PARSER("ParseFieldDefinition");
   // The parser has read the first field name and is now at the token
   // after the field name.
   ASSERT(CurrentToken() == Token::kSEMICOLON ||
          CurrentToken() == Token::kCOMMA || CurrentToken() == Token::kASSIGN);
@@ skipping 119 matching lines @@
                              /* is_abstract = */ false,
                              /* is_external = */ false,
                              /* is_native = */ false, current_class(),
                              field->name_pos);
       ParamList params;
       ASSERT(current_class().raw() == getter.Owner());
       params.AddReceiver(ReceiverType(current_class()), field->name_pos);
       getter.set_result_type(*field->type);
       getter.set_is_debuggable(false);
       AddFormalParamsToFunction(&params, getter);
-      ResolveSignature(ClassFinalizer::kResolveTypeParameters, getter);
+      ResolveSignature(getter);
       members->AddFunction(getter);
       if (!field->has_final) {
         // Build a setter accessor for non-const fields.
         String& setter_name =
             String::Handle(Z, Field::SetterSymbol(*field->name));
         setter = Function::New(setter_name, RawFunction::kImplicitSetter,
                                field->has_static, field->has_final,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                /* is_native = */ false, current_class(),
                                field->name_pos);
         ParamList params;
         ASSERT(current_class().raw() == setter.Owner());
         params.AddReceiver(ReceiverType(current_class()), field->name_pos);
         params.AddFinalParameter(TokenPos(), &Symbols::Value(), field->type);
         setter.set_result_type(Object::void_type());
         setter.set_is_debuggable(false);
         if (library_.is_dart_scheme() && library_.IsPrivate(*field->name)) {
           setter.set_is_reflectable(false);
         }
         AddFormalParamsToFunction(&params, setter);
-        ResolveSignature(ClassFinalizer::kResolveTypeParameters, setter);
+        ResolveSignature(setter);
         members->AddFunction(setter);
       }
     }
 
     if (CurrentToken() != Token::kCOMMA) {
       break;
     }
     ConsumeToken();
     field->name_pos = this->TokenPos();
     field->name = ExpectIdentifier("field name expected");
@@ skipping 249 matching lines @@
       } else {
         ReportError(
             "missing 'var', 'final', 'const' or type"
             " in field declaration");
       }
     } else if (member.type->IsVoidType()) {
       ReportError(member.name_pos, "field may not be 'void'");
     }
     if (!member.type->IsResolved()) {
       AbstractType& type = AbstractType::ZoneHandle(Z, member.type->raw());
-      ResolveType(ClassFinalizer::kResolveTypeParameters, &type);
+      ResolveType(&type);
       member.type = &type;
     }
     ParseFieldDefinition(members, &member);
   } else {
     UnexpectedToken();
   }
   current_member_ = NULL;
   CheckMemberNameConflict(members, &member);
   members->AddMember(member);
 }
@@ skipping 298 matching lines @@
     if (!orig_class.ApplyPatch(cls, &error)) {
       Report::LongJumpF(error, script_, class_pos, "applying patch failed");
     }
   }
 }
 
 
 void Parser::ParseEnumDefinition(const Class& cls) {
   TRACE_PARSER("ParseEnumDefinition");
   INC_STAT(thread(), num_classes_parsed, 1);
-
+  set_current_class(cls);
   const Class& helper_class =
       Class::Handle(Z, Library::LookupCoreClass(Symbols::_EnumHelper()));
   ASSERT(!helper_class.IsNull());
 
   SkipMetadata();
   ExpectToken(Token::kENUM);
 
   const String& enum_name = String::Handle(Z, cls.ScrubbedName());
   ClassDesc enum_members(Z, cls, enum_name, false, cls.token_pos());
 
@@ skipping 16 matching lines @@
                          /* is_static = */ false,
                          /* is_const = */ true,
                          /* is_abstract = */ false,
                          /* is_external = */ false,
                          /* is_native = */ false, cls, cls.token_pos());
   getter.set_result_type(int_type);
   getter.set_is_debuggable(false);
   ParamList params;
   params.AddReceiver(&Object::dynamic_type(), cls.token_pos());
   AddFormalParamsToFunction(&params, getter);
-  ResolveSignature(ClassFinalizer::kResolveTypeParameters, getter);
+  ResolveSignature(getter);
   enum_members.AddFunction(getter);
 
   ASSERT(IsIdentifier());
   ASSERT(CurrentLiteral()->raw() == cls.Name());
 
   ConsumeToken();  // Enum type name.
   ExpectToken(Token::kLBRACE);
   Field& enum_value = Field::Handle(Z);
   intptr_t i = 0;
   GrowableArray<String*> declared_names(8);
@@ skipping 52 matching lines @@
   }
   ExpectToken(Token::kRBRACE);
 
   const Class& array_class = Class::Handle(Z, I->object_store()->array_class());
   TypeArguments& values_type_args =
       TypeArguments::ZoneHandle(Z, TypeArguments::New(1));
   const Type& enum_type = Type::Handle(Type::NewNonParameterizedType(cls));
   values_type_args.SetTypeAt(0, enum_type);
   Type& values_type = Type::ZoneHandle(
       Z, Type::New(array_class, values_type_args, cls.token_pos(), Heap::kOld));
-  values_type ^= ClassFinalizer::FinalizeType(cls, values_type,
-                                              ClassFinalizer::kCanonicalize);
+  values_type ^= CanonicalizeType(values_type);
   values_type_args = values_type.arguments();  // Get canonical type arguments.
   // Add static field 'const List<E> values'.
   Field& values_field = Field::ZoneHandle(Z);
   values_field = Field::New(Symbols::Values(),
                             /* is_static = */ true,
                             /* is_final = */ true,
                             /* is_const = */ true,
                             /* is_reflectable = */ true, cls, values_type,
                             cls.token_pos());
   enum_members.AddField(values_field);
@@ skipping 34 matching lines @@
                               /* is_static = */ false,
                               /* is_const = */ true,
                               /* is_abstract = */ false,
                               /* is_external = */ false,
                               /* is_native = */ false, cls, cls.token_pos());
   name_getter.set_result_type(string_type);
   name_getter.set_is_debuggable(false);
   ParamList name_params;
   name_params.AddReceiver(&Object::dynamic_type(), cls.token_pos());
   AddFormalParamsToFunction(&name_params, name_getter);
-  ResolveSignature(ClassFinalizer::kResolveTypeParameters, name_getter);
+  ResolveSignature(name_getter);
   enum_members.AddFunction(name_getter);
 
   // Clone the toString() function from the helper class.
   Function& to_string_func = Function::Handle(
       Z, helper_class.LookupDynamicFunctionAllowPrivate(Symbols::toString()));
   ASSERT(!to_string_func.IsNull());
   to_string_func = to_string_func.Clone(cls);
   enum_members.AddFunction(to_string_func);
 
   // Clone the hashCode getter function from the helper class.
@@ skipping 30 matching lines @@
     ctor.set_is_reflectable(false);
   }
 
   ParamList params;
   // Add implicit 'this' parameter.
   const AbstractType* receiver_type = ReceiverType(cls);
   params.AddReceiver(receiver_type, cls.token_pos());
 
   AddFormalParamsToFunction(&params, ctor);
   ctor.set_result_type(Object::dynamic_type());
-  ResolveSignature(ClassFinalizer::kResolveTypeParameters, ctor);
+  ResolveSignature(ctor);
   // The body of the constructor cannot modify the type of the constructed
   // instance, which is passed in as the receiver.
   ctor.set_result_type(*receiver_type);
   cls.AddFunction(ctor);
 }
 
 
 // Check for cycles in constructor redirection.
 void Parser::CheckConstructors(ClassDesc* class_desc) {
   // Check for cycles in constructor redirection.
@@ skipping 203 matching lines @@
 
   // Set the signature function in the function type alias class.
   function_type_alias.set_signature_function(signature_function);
 
   // At this point, all function type parameters have been parsed and the class
   // function_type_alias is recognized as a typedef, so we can resolve all type
   // parameters in the signature type defined by the typedef.
   AbstractType& function_type =
       Type::Handle(Z, signature_function.SignatureType());
   ASSERT(current_class().raw() == function_type_alias.raw());
-  ResolveType(ClassFinalizer::kResolveTypeParameters, &function_type);
+  ResolveType(&function_type);
   // Resolving does not replace type or signature.
   ASSERT(function_type_alias.signature_function() ==
          Type::Cast(function_type).signature());
 
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing function type alias '%s'\n",
               String::Handle(Z, signature_function.Signature()).ToCString());
   }
   // The alias should not be marked as finalized yet, since it needs to be
   // checked in the class finalizer for illegal self references.
@@ skipping 184 matching lines @@
       current_class().set_type_parameters(type_parameters);
     } else {
       innermost_function().set_type_parameters(type_parameters);
     }
     // Try to resolve the upper bounds, which will at least resolve the
     // referenced type parameters.
     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_bound = type_parameter.bound();
-      ResolveType(ClassFinalizer::kResolveTypeParameters,
-                  &type_parameter_bound);
+      ResolveType(&type_parameter_bound);
       type_parameter.set_bound(type_parameter_bound);
     }
   }
 }
 
 
 RawTypeArguments* Parser::ParseTypeArguments(
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseTypeArguments");
   if (CurrentToken() == Token::kLT) {
@@ skipping 302 matching lines @@
   func.set_modifier(func_modifier);
   if (library_.is_dart_scheme() && library_.IsPrivate(func_name)) {
     func.set_is_reflectable(false);
   }
   if (is_native) {
     func.set_native_name(*native_name);
   }
   AddFormalParamsToFunction(&params, func);
   ASSERT(innermost_function().raw() == func.raw());
   innermost_function_ = Function::null();
-  ResolveSignature(ClassFinalizer::kResolveTypeParameters, func);
+  ResolveSignature(func);
   top_level->AddFunction(func);
   if (!is_patch) {
     library_.AddObject(func, func_name);
   } else {
     // Need to remove the previously added function that is being patched.
     const Class& toplevel_cls = Class::Handle(Z, library_.toplevel_class());
     const Function& replaced_func =
         Function::Handle(Z, toplevel_cls.LookupStaticFunction(func_name));
     ASSERT(!replaced_func.IsNull());
     toplevel_cls.RemoveFunction(replaced_func);
@@ skipping 134 matching lines @@
   func.set_end_token_pos(accessor_end_pos);
   func.set_modifier(func_modifier);
   if (is_native) {
     func.set_is_debuggable(false);
     func.set_native_name(*native_name);
   }
   if (library_.is_dart_scheme() && library_.IsPrivate(accessor_name)) {
     func.set_is_reflectable(false);
   }
   AddFormalParamsToFunction(&params, func);
-  ResolveSignature(ClassFinalizer::kResolveTypeParameters, func);
+  ResolveSignature(func);
   top_level->AddFunction(func);
   if (!is_patch) {
     library_.AddObject(func, accessor_name);
   } else {
     // Need to remove the previously added accessor that is being patched.
     const Class& toplevel_cls = Class::Handle(
         Z, owner.IsClass() ? Class::Cast(owner).raw()
                            : PatchClass::Cast(owner).patched_class());
     const Function& replaced_func =
         Function::Handle(Z, toplevel_cls.LookupFunction(accessor_name));
@@ skipping 830 matching lines @@
     body.set_result_type(Object::dynamic_type());
     is_new_closure = true;
   }
 
   ParamList closure_params;
   AddSyncGenClosureParameters(&closure_params);
 
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
     AddFormalParamsToFunction(&closure_params, body);
-    ResolveSignature(ClassFinalizer::kResolveTypeParameters, body);
+    ResolveSignature(body);
     // Finalize function type.
     Type& signature_type = Type::Handle(Z, body.SignatureType());
-    signature_type ^= ClassFinalizer::FinalizeType(
-        current_class(), signature_type, ClassFinalizer::kCanonicalize);
+    signature_type ^= CanonicalizeType(signature_type);
     body.SetSignatureType(signature_type);
     ASSERT(AbstractType::Handle(Z, body.result_type()).IsResolved());
     ASSERT(body.NumParameters() == closure_params.parameters->length());
   }
 
   OpenFunctionBlock(body);
   AddFormalParamsToScope(&closure_params, current_block_->scope);
   async_temp_scope_ = current_block_->scope;
   return body.raw();
 }
@@ skipping 103 matching lines @@
     closure.set_is_generated_body(true);
     closure.set_result_type(Object::dynamic_type());
     is_new_closure = true;
   }
   // Create the parameter list for the async body closure.
   ParamList closure_params;
   AddAsyncClosureParameters(&closure_params);
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
     AddFormalParamsToFunction(&closure_params, closure);
-    ResolveSignature(ClassFinalizer::kResolveTypeParameters, closure);
+    ResolveSignature(closure);
 
     // Finalize function type.
     Type& signature_type = Type::Handle(Z, closure.SignatureType());
-    signature_type ^= ClassFinalizer::FinalizeType(
-        current_class(), signature_type, ClassFinalizer::kCanonicalize);
+    signature_type ^= CanonicalizeType(signature_type);
     closure.SetSignatureType(signature_type);
     ASSERT(AbstractType::Handle(Z, closure.result_type()).IsResolved());
     ASSERT(closure.NumParameters() == closure_params.parameters->length());
   }
   OpenFunctionBlock(closure);
   AddFormalParamsToScope(&closure_params, current_block_->scope);
   async_temp_scope_ = current_block_->scope;
 
   // Capture instantiator in case it may be needed to generate the type
   // check of the return value. (C.f. handling of Token::kRETURN.)
@@ skipping 104 matching lines @@
     closure.set_result_type(Object::dynamic_type());
     is_new_closure = true;
   }
 
   ParamList closure_params;
   AddAsyncGenClosureParameters(&closure_params);
 
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
     AddFormalParamsToFunction(&closure_params, closure);
-    ResolveSignature(ClassFinalizer::kResolveTypeParameters, closure);
+    ResolveSignature(closure);
 
     // Finalize function type.
     Type& signature_type = Type::Handle(Z, closure.SignatureType());
-    signature_type ^= ClassFinalizer::FinalizeType(
-        current_class(), signature_type, ClassFinalizer::kCanonicalize);
+    signature_type ^= CanonicalizeType(signature_type);
     closure.SetSignatureType(signature_type);
     ASSERT(AbstractType::Handle(Z, closure.result_type()).IsResolved());
     ASSERT(closure.NumParameters() == closure_params.parameters->length());
   }
 
   OpenFunctionBlock(closure);
   AddFormalParamsToScope(&closure_params, current_block_->scope);
   async_temp_scope_ = current_block_->scope;
   return closure.raw();
 }
@@ skipping 344 matching lines @@
 }
 
 
 void Parser::FinalizeFormalParameterTypes(const ParamList* params) {
   ASSERT((params != NULL) && (params->parameters != NULL));
   const int num_parameters = params->parameters->length();
   AbstractType& type = AbstractType::Handle(Z);
   for (int i = 0; i < num_parameters; i++) {
     ParamDesc& param_desc = (*params->parameters)[i];
     type = param_desc.type->raw();
-    ResolveType(ClassFinalizer::kCanonicalize, &type);
-    type = ClassFinalizer::FinalizeType(current_class(), type,
-                                        ClassFinalizer::kCanonicalize);
+    ResolveType(&type);
+    type = CanonicalizeType(type);
     if (type.raw() != param_desc.type->raw()) {
       param_desc.type = &AbstractType::ZoneHandle(Z, type.raw());
     }
   }
 }
 
 
 // Populate the parameter type array and parameter name array of the function
 // with the formal parameter types and names.
 void Parser::AddFormalParamsToFunction(const ParamList* params,
@@ skipping 368 matching lines @@
     if (!found_func) {
       ParseTypeParameters(false);  // Not parameterizing class, but function.
     } else {
       TryParseTypeParameters();
     }
   }
 
   if (!found_func && !result_type.IsFinalized()) {
     // Now that type parameters are declared, the result type can be resolved
     // and finalized.
-    ResolveType(ClassFinalizer::kCanonicalize, &result_type);
-    result_type = ClassFinalizer::FinalizeType(current_class(), result_type,
-                                               ClassFinalizer::kCanonicalize);
+    ResolveType(&result_type);
+    result_type = CanonicalizeType(result_type);
     function.set_result_type(result_type);
   }
 
   CheckToken(Token::kLPAREN);
 
   // The function type needs to be finalized at compile time, since the closure
   // may be type checked at run time when assigned to a function variable,
   // passed as a function argument, or returned as a function result.
 
   LocalVariable* function_variable = NULL;
@@ skipping 35 matching lines @@
     // Parse the local function. As a side effect of the parsing, the
     // variables of this function's scope that are referenced by the local
     // function (and its inner nested functions) will be marked as captured.
 
     ASSERT(AbstractType::Handle(Z, function.result_type()).IsResolved());
     statements = Parser::ParseFunc(function, !is_literal);
     INC_STAT(thread(), num_functions_parsed, 1);
 
     // Now that the local function has formal parameters, lookup the signature
     signature_type = function.SignatureType();
-    signature_type ^= ClassFinalizer::FinalizeType(
-        current_class(), signature_type, ClassFinalizer::kCanonicalize);
+    signature_type ^= CanonicalizeType(signature_type);
     function.SetSignatureType(signature_type);
   } else {
     // The local function was parsed before. The captured variables are
     // saved in the function's context scope. Iterate over the context scope
     // and mark its variables as captured.
     const ContextScope& context_scope =
         ContextScope::Handle(Z, function.context_scope());
     ASSERT(!context_scope.IsNull());
     String& var_name = String::Handle(Z);
     for (int i = 0; i < context_scope.num_variables(); i++) {
@@ skipping 2789 matching lines @@
   }
   // Object receiver.
   // If the function is external and dynamic, pass the actual receiver,
   // otherwise, pass a class literal of the unresolved method's owner.
   if ((func != NULL) && !func->IsNull() && func->is_external() &&
       !func->is_static()) {
     arguments->Add(LoadReceiver(func->token_pos()));
   } else {
     AbstractType& type = AbstractType::ZoneHandle(Z);
     type ^= Type::New(cls, TypeArguments::Handle(Z), call_pos, Heap::kOld);
-    type ^= ClassFinalizer::FinalizeType(current_class(), type,
-                                         ClassFinalizer::kCanonicalize);
+    type ^= CanonicalizeType(type);
     arguments->Add(new (Z) LiteralNode(call_pos, type));
   }
   // String memberName.
   arguments->Add(new (Z) LiteralNode(
       call_pos, String::ZoneHandle(Z, Symbols::New(T, function_name))));
   // Smi invocation_type.
   if (cls.IsTopLevel()) {
     ASSERT(im_call == InvocationMirror::kStatic ||
            im_call == InvocationMirror::kTopLevel);
     im_call = InvocationMirror::kTopLevel;
@@ skipping 946 matching lines @@
                   "cannot access type parameter '%s' "
                   "from static function",
                   name.ToCString());
     }
     // TODO(regis): Verify that CaptureInstantiator() was already called
     // and remove call below.
     if (FunctionLevel() > 0) {
       // Make sure that the class instantiator is captured.
       CaptureInstantiator();
     }
-    type_parameter ^= ClassFinalizer::FinalizeType(
-        current_class(), type_parameter, ClassFinalizer::kCanonicalize);
+    type_parameter ^= CanonicalizeType(type_parameter);
     ASSERT(!type_parameter.IsMalformed());
     return new (Z) TypeNode(primary_pos, type_parameter);
   } else {
     ASSERT(type_parameter.IsFunctionTypeParameter());
     // TODO(regis): Verify that CaptureFunctionInstantiator() was already
     // called if necessary.
     // TODO(regis): Finalize type parameter and return as type node.
     // For now, map to dynamic type.
     Type& type = Type::ZoneHandle(Z, Type::DynamicType());
     return new (Z) TypeNode(primary_pos, type);
@@ skipping 98 matching lines @@
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
         const TokenPosition primary_pos = primary_node->token_pos();
         if (primary_node->primary().IsFunction()) {
           array = LoadClosure(primary_node);
         } else if (primary_node->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary_node->primary());
           AbstractType& type = Type::ZoneHandle(
               Z, Type::New(type_class, TypeArguments::Handle(Z), primary_pos,
                            Heap::kOld));
-          type ^= ClassFinalizer::FinalizeType(current_class(), type,
-                                               ClassFinalizer::kCanonicalize);
+          type ^= CanonicalizeType(type);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
           array = new (Z) TypeNode(primary_pos, type);
         } else if (primary_node->primary().IsTypeParameter()) {
           array = LoadTypeParameter(primary_node);
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       }
       selector = new (Z)
@@ skipping 73 matching lines @@
             // TODO(regis): Should we throw a type error instead?
             ReportError(primary_pos,
                         "illegal use of function type parameter '%s'",
                         name.ToCString());
           }
         } else if (primary_node->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary_node->primary());
           AbstractType& type = Type::ZoneHandle(
               Z, Type::New(type_class, TypeArguments::Handle(Z), primary_pos,
                            Heap::kOld));
-          type ^= ClassFinalizer::FinalizeType(current_class(), type,
-                                               ClassFinalizer::kCanonicalize);
+          type ^= CanonicalizeType(type);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
           selector = new (Z) TypeNode(primary_pos, type);
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       } else {
         // Left is not a primary node; this must be a closure call.
         AstNode* closure = left;
         selector = ParseClosureCall(closure);
       }
     } else {
       // No (more) selectors to parse.
       left = LoadFieldIfUnresolved(left);
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
         const TokenPosition primary_pos = primary->token_pos();
         if (primary_node->primary().IsFunction()) {
           // Treat as implicit closure.
           left = LoadClosure(primary_node);
         } else if (primary_node->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary_node->primary());
           AbstractType& type = Type::ZoneHandle(
               Z, Type::New(type_class, TypeArguments::Handle(Z), primary_pos,
                            Heap::kOld));
-          type = ClassFinalizer::FinalizeType(current_class(), type,
-                                              ClassFinalizer::kCanonicalize);
+          type = CanonicalizeType(type);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
           left = new (Z) TypeNode(primary_pos, type);
         } else if (primary_node->primary().IsTypeParameter()) {
           left = LoadTypeParameter(primary_node);
         } else if (primary_node->IsSuper()) {
           // Return "super" to handle unary super operator calls,
           // or to report illegal use of "super" otherwise.
           left = primary_node;
         } else {
@@ skipping 199 matching lines @@
     // The result is a pair of the (side effects of the) store followed by
     // the (value of the) initial value temp variable load.
     let_expr->AddNode(store);
     let_expr->AddNode(new (Z) LoadLocalNode(op_pos, temp));
     return let_expr;
   }
   return expr;
 }
 
 
-// Resolve the types of the given signature from the current class according to
-// the given type finalization mode.
-// Not all involved type classes may get resolved yet, but at least type
-// parameters will get resolved, thereby relieving the class
-// finalizer from resolving type parameters out of context.
-// TODO(regis): Refactor this code which is partially duplicated in the class
-// finalizer, paying attention to type parameter resolution and mixin library.
-void Parser::ResolveSignature(ClassFinalizer::FinalizationKind finalization,
-                              const Function& signature) {
+// Resolve the type parameters that may appear in the given signature from the
+// signature function and current class.
+// Unresolved type classes get resolved later by the class finalizer.
+void Parser::ResolveSignature(const Function& signature) {
   const Function& saved_innermost_function =
       Function::Handle(Z, innermost_function().raw());
   innermost_function_ = signature.raw();
   // TODO(regis): Resolve upper bounds of function type parameters.
   AbstractType& type = AbstractType::Handle(signature.result_type());
-  ResolveType(finalization, &type);
+  ResolveType(&type);
   signature.set_result_type(type);
   const intptr_t num_parameters = signature.NumParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = signature.ParameterTypeAt(i);
-    ResolveType(finalization, &type);
+    ResolveType(&type);
     signature.SetParameterTypeAt(i, type);
   }
   innermost_function_ = saved_innermost_function.raw();
 }
 
 
-// Resolve the given type and its type arguments from the current function and
-// current class according to the given type finalization mode.
-// Not all involved type classes may get resolved yet, but at least type
-// parameters will get resolved, thereby relieving the class
-// finalizer from resolving type parameters out of context.
-// TODO(regis): Refactor this code which is partially duplicated in the class
-// finalizer, paying attention to type parameter resolution and mixin library.
-void Parser::ResolveType(ClassFinalizer::FinalizationKind finalization,
-                         AbstractType* type) {
-  ASSERT(finalization >= ClassFinalizer::kResolveTypeParameters);
+// Resolve the type parameters that may appear in the given type and in its type
+// arguments from the current function and current class.
+// Unresolved type classes get resolved later by the class finalizer.
+void Parser::ResolveType(AbstractType* type) {
   ASSERT(type != NULL);
   if (type->IsResolved()) {
+    // Some types are resolved by definition, such as a TypeParameter.
     return;
   }
-  // Resolve class.
+  // Resolve type class.
   if (!type->HasResolvedTypeClass()) {
     const UnresolvedClass& unresolved_class =
         UnresolvedClass::Handle(Z, type->unresolved_class());
     const String& unresolved_class_name =
         String::Handle(Z, unresolved_class.ident());
-    Class& resolved_type_class = Class::Handle(Z);
     if (unresolved_class.library_or_library_prefix() == Object::null()) {
       // First check if the type is a function type parameter.
       if (!innermost_function().IsNull()) {
         // TODO(regis): Shortcut this lookup if no generic functions in scope.
         TypeParameter& type_parameter = TypeParameter::ZoneHandle(
             Z, innermost_function().LookupTypeParameter(unresolved_class_name,
                                                         NULL));
         if (!type_parameter.IsNull()) {
           // TODO(regis): Check for absence of type arguments.
           // For now, resolve the function type parameter to dynamic.
@@ skipping 22 matching lines @@
           *type = ClassFinalizer::NewFinalizedMalformedType(
               Error::Handle(Z),  // No previous error.
               script_, type_parameter.token_pos(),
               "type parameter '%s' cannot be parameterized",
               String::Handle(Z, type_parameter.name()).ToCString());
           return;
         }
         *type = type_parameter.raw();
         return;
       }
-      // The referenced class may not have been parsed yet. It would be wrong
-      // to resolve it too early to an imported class of the same name. Only
-      // resolve the class when a finalized type is requested.
-      // Note that when compiling a cloned mixin function, library_ may be
-      // different than current_class's library.
-      if (finalization > ClassFinalizer::kResolveTypeParameters) {
-        resolved_type_class = library_.LookupClass(unresolved_class_name);
-      }
-    } else {
-      // Resolve class name in the scope of the library prefix.
-      const Object& prefix =
-          Object::Handle(Z, unresolved_class.library_or_library_prefix());
-      ASSERT(prefix.IsLibraryPrefix());
-      resolved_type_class =
-          LibraryPrefix::Cast(prefix).LookupClass(unresolved_class_name);
     }

[hausner, 2017/02/03 20:27:01]

Is it no longer necessary to look up classes from qualified imported types?

[regis, 2017/02/03 20:36:43]

We do it later in ClassFinalizer::ResolveClass().

-    // At this point, we can only have a parameterized_type.
-    const Type& parameterized_type = Type::Cast(*type);
-    if (!resolved_type_class.IsNull()) {
-      // Replace unresolved class with resolved type class.
-      parameterized_type.set_type_class(resolved_type_class);
-      // Promote type to a function type in case its type class is a typedef.
-      if (resolved_type_class.IsTypedefClass()) {
-        ASSERT(!parameterized_type.IsFunctionType());
-        parameterized_type.set_signature(
-            Function::Handle(Z, resolved_type_class.signature_function()));
-      }
-      // Replace FutureOr<T> type of async library with dynamic.
-      if ((resolved_type_class.library() == Library::AsyncLibrary()) &&
-          (resolved_type_class.Name() == Symbols::FutureOr().raw())) {
-        parameterized_type.set_type_class(
-            Class::Handle(Object::dynamic_class()));
-        parameterized_type.set_arguments(Object::null_type_arguments());
-      }
-    } else if (finalization >= ClassFinalizer::kCanonicalize) {
-      ClassFinalizer::FinalizeMalformedType(
-          Error::Handle(Z),  // No previous error.
-          script_, parameterized_type, "type '%s' is not loaded",
-          String::Handle(Z, parameterized_type.UserVisibleName()).ToCString());
-      return;
-    }
-  }
-  if (finalization > ClassFinalizer::kResolveTypeParameters) {
-    type->SetIsResolved();
   }
   // Resolve type arguments, if any.
   if (type->arguments() != TypeArguments::null()) {
     const TypeArguments& arguments =
         TypeArguments::Handle(Z, type->arguments());
     const intptr_t num_arguments = arguments.Length();
     AbstractType& type_argument = AbstractType::Handle(Z);
     for (intptr_t i = 0; i < num_arguments; i++) {
       type_argument ^= arguments.TypeAt(i);
-      ResolveType(finalization, &type_argument);
+      ResolveType(&type_argument);
       arguments.SetTypeAt(i, type_argument);
     }
   }
   if (type->IsFunctionType()) {
     const Function& signature =
         Function::Handle(Z, Type::Cast(*type).signature());
     Type& signature_type = Type::Handle(Z, signature.SignatureType());
     if (signature_type.raw() != type->raw()) {
-      ResolveType(finalization, &signature_type);
+      ResolveType(&signature_type);
     } else {
-      ResolveSignature(finalization, signature);
-      if (signature.IsSignatureFunction()) {
-        // Drop fields that are not necessary anymore after resolution.
-        // The parent function, owner, and token position of a shared
-        // canonical function type are meaningless, since the canonical
-        // representent is picked arbitrarily.
-        signature.set_parent_function(Function::Handle(Z));
-        // TODO(regis): As long as we support metadata in typedef signatures,
-        // we cannot reset these fields used to reparse a typedef.
-        // Note that the scope class of a typedef function type is always
-        // preserved as the typedef class (not reset to _Closure class), thereby
-        // preventing sharing of canonical function types between typedefs.
-        // Not being shared, these fields are therefore always meaningful for
-        // typedefs.
-      }
-      if (type->HasResolvedTypeClass()) {
-        const Class& scope_class = Class::Handle(Z, type->type_class());
-        if (!scope_class.IsTypedefClass()) {
-          if (signature.IsSignatureFunction()) {
-            signature.set_owner(Object::Handle(Z));
-            signature.set_token_pos(TokenPosition::kNoSource);
-          }
-          if ((type->arguments() != TypeArguments::null()) &&
-              signature.HasInstantiatedSignature()) {
-            ASSERT(scope_class.IsGeneric());
-            // Although the scope class of this function type is generic,
-            // the signature of this function type does not refer to any
-            // of its type parameters. Reset its scope class to _Closure.
-            Type::Cast(*type).set_type_class(Class::Handle(
-                Z, Isolate::Current()->object_store()->closure_class()));
-            type->set_arguments(Object::null_type_arguments());
-          }
-        }
-      }
+      ResolveSignature(signature);
     }
   }
 }
 
 
+RawAbstractType* Parser::CanonicalizeType(const AbstractType& type) {
+  // If the current class is the result of a mixin application, we must
+  // use the class scope of the class from which the function originates.
+  if (current_class().IsMixinApplication()) {
+    return ClassFinalizer::FinalizeType(
+        Class::Handle(Z, parsed_function()->function().origin()), type,
+        ClassFinalizer::kCanonicalize);
+  }
+  return ClassFinalizer::FinalizeType(current_class(), type,
+                                      ClassFinalizer::kCanonicalize);
+}
+
+
 LocalVariable* Parser::LookupLocalScope(const String& ident) {
   if (current_block_ == NULL) {
     return NULL;
   }
   // A found name is treated as accessed and possibly marked as captured.
   const bool kTestOnly = false;
   return current_block_->scope->LookupVariable(ident, kTestOnly);
 }
 
 
@@ skipping 522 matching lines @@
   if (resolved == NULL) {
     // Check whether the identifier is a class type parameter.
     if (!current_class().IsNull()) {
       TypeParameter& type_parameter = TypeParameter::ZoneHandle(
           Z, current_class().LookupTypeParameter(ident));
       if (!type_parameter.IsNull()) {
         if (FunctionLevel() > 0) {
           // Make sure that the class instantiator is captured.
           CaptureInstantiator();
         }
-        type_parameter ^= ClassFinalizer::FinalizeType(
-            current_class(), type_parameter, ClassFinalizer::kCanonicalize);
+        type_parameter ^= CanonicalizeType(type_parameter);
         ASSERT(!type_parameter.IsMalformed());
         return new (Z) TypeNode(ident_pos, type_parameter);
       }
     }
     // Not found in the local scope, and the name is not a type parameter.
     // Try finding the variable in the library scope (current library
     // and all libraries imported by it without a library prefix).
     resolved = ResolveIdentInCurrentLibraryScope(ident_pos, ident);
   }
   if (resolved->IsPrimaryNode()) {
@@ skipping 20 matching lines @@
         resolved = LoadClosure(primary);
       } else {
         ReportError(ident_pos, "illegal reference to method '%s'",
                     ident.ToCString());
       }
     } else if (primary->primary().IsClass()) {
       const Class& type_class = Class::Cast(primary->primary());
       AbstractType& type =
           Type::ZoneHandle(Z, Type::New(type_class, TypeArguments::Handle(Z),
                                         primary_pos, Heap::kOld));
-      type ^= ClassFinalizer::FinalizeType(current_class(), type,
-                                           ClassFinalizer::kCanonicalize);
+      type ^= CanonicalizeType(type);
       // Type may be malbounded, but not malformed.
       ASSERT(!type.IsMalformed());
       resolved = new (Z) TypeNode(primary_pos, type);
     }
   }
   return resolved;
 }
 
 
 RawAbstractType* Parser::ParseType(
@@ skipping 31 matching lines @@
       type = Type::DynamicType();
     }
     // 'type' is the result type of the function type.
     type = ParseFunctionType(type, ClassFinalizer::kDoNotResolve);
   }
   // At this point, all type parameters have been parsed, resolve the type.
   if (finalization == ClassFinalizer::kIgnore) {
     return Type::DynamicType();
   }
   if (finalization >= ClassFinalizer::kResolveTypeParameters) {
-    ResolveType(finalization, &type);
+    ResolveType(&type);
     if (finalization >= ClassFinalizer::kCanonicalize) {
-      type ^= ClassFinalizer::FinalizeType(current_class(), type, finalization);
+      type ^= CanonicalizeType(type);
     }
   }
   return type.raw();
 }
 
 
 // Parses and returns a function type.
 // If 'result_type' is not null, parsing of the result type is skipped.
 RawType* Parser::ParseFunctionType(
     const AbstractType& result_type,
@@ skipping 49 matching lines @@
                              &params);
     AddFormalParamsToFunction(&params, signature_function);
     innermost_function_ = innermost_function_.parent_function();
     type = signature_function.SignatureType();
   } while (IsFunctionTypeSymbol());
   // At this point, all type parameters have been parsed, resolve the type.
   if (finalization == ClassFinalizer::kIgnore) {
     return Type::DynamicType();
   }
   if (finalization >= ClassFinalizer::kResolveTypeParameters) {
-    ResolveType(finalization, &type);
+    ResolveType(&type);
     if (finalization >= ClassFinalizer::kCanonicalize) {
-      type ^= ClassFinalizer::FinalizeType(current_class(), type, finalization);
+      type ^= CanonicalizeType(type);
     }
   }
   return Type::RawCast(type.raw());
 }
 
 
 // Parses type = [ident "."] ident ["<" type { "," type } ">"], then resolve and
 // finalize it according to the given type finalization mode.
 // Returns type and sets prefix.
 RawAbstractType* Parser::ParseType(
@@ skipping 91 matching lines @@
     type_class = UnresolvedClass::New(*prefix, type_name, ident_pos);
   }
   TypeArguments& type_arguments =
       TypeArguments::Handle(Z, ParseTypeArguments(finalization));
   if (finalization == ClassFinalizer::kIgnore) {
     return Type::DynamicType();
   }
   AbstractType& type = AbstractType::Handle(
       Z, Type::New(type_class, type_arguments, ident_pos, Heap::kOld));
   if (finalization >= ClassFinalizer::kResolveTypeParameters) {
-    ResolveType(finalization, &type);
+    ResolveType(&type);
     if (finalization >= ClassFinalizer::kCanonicalize) {
-      type ^= ClassFinalizer::FinalizeType(current_class(), type, finalization);
+      type ^= CanonicalizeType(type);
     }
   }
   return type.raw();
 }
 
 
 void Parser::CheckConstructorCallTypeArguments(
     TokenPosition pos,
     const Function& constructor,
     const TypeArguments& type_arguments) {
@@ skipping 60 matching lines @@
                     "the element type");
       }
       // Ignore type arguments.
       list_type_arguments = TypeArguments::null();
     }
   }
   ASSERT(list_type_arguments.IsNull() || (list_type_arguments.Length() == 1));
   const Class& array_class = Class::Handle(Z, I->object_store()->array_class());
   Type& type = Type::ZoneHandle(
       Z, Type::New(array_class, list_type_arguments, type_pos, Heap::kOld));
-  type ^= ClassFinalizer::FinalizeType(current_class(), type,
-                                       ClassFinalizer::kCanonicalize);
+  type ^= CanonicalizeType(type);
   GrowableArray<AstNode*> element_list;
   // Parse the list elements. Note: there may be an optional extra
   // comma after the last element.
   if (!is_empty_literal) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
     while (CurrentToken() != Token::kRBRACK) {
       const TokenPosition element_pos = TokenPos();
       AstNode* element = ParseExpr(is_const, kConsumeCascades);
       if (I->type_checks() && !is_const && !element_type.IsDynamicType()) {
         element = new (Z) AssignableNode(element_pos, element, element_type,
@@ skipping 61 matching lines @@
       CaptureInstantiator();
     }
     TypeArguments& factory_type_args =
         TypeArguments::ZoneHandle(Z, list_type_arguments.raw());
     // If the factory class extends other parameterized classes, adjust the
     // type argument vector.
     if (!factory_type_args.IsNull() && (factory_class.NumTypeArguments() > 1)) {
       ASSERT(factory_type_args.Length() == 1);
       Type& factory_type = Type::Handle(
           Z, Type::New(factory_class, factory_type_args, type_pos, Heap::kOld));
-      factory_type ^= ClassFinalizer::FinalizeType(
-          current_class(), factory_type, ClassFinalizer::kFinalize);
+      // It is not strictly necessary to canonicalize factory_type, but only its
+      // type argument vector.
+      factory_type ^= CanonicalizeType(factory_type);
       factory_type_args = factory_type.arguments();
       ASSERT(factory_type_args.Length() == factory_class.NumTypeArguments());
+      ASSERT(factory_type_args.IsCanonical());
+    } else {
+      factory_type_args = factory_type_args.Canonicalize();
     }
-    factory_type_args = factory_type_args.Canonicalize();
     ArgumentListNode* factory_param = new (Z) ArgumentListNode(literal_pos);
     if (element_list.length() == 0) {
       LiteralNode* empty_array_literal =
           new (Z) LiteralNode(TokenPos(), Object::empty_array());
       factory_param->Add(empty_array_literal);
     } else {
       ArrayNode* list = new (Z) ArrayNode(TokenPos(), type, element_list);
       factory_param->Add(list);
     }
     return CreateConstructorCallNode(literal_pos, factory_type_args,
@@ skipping 221 matching lines @@
       CaptureInstantiator();
     }
     TypeArguments& factory_type_args =
         TypeArguments::ZoneHandle(Z, map_type_arguments.raw());
     // If the factory class extends other parameterized classes, adjust the
     // type argument vector.
     if (!factory_type_args.IsNull() && (factory_class.NumTypeArguments() > 2)) {
       ASSERT(factory_type_args.Length() == 2);
       Type& factory_type = Type::Handle(
           Z, Type::New(factory_class, factory_type_args, type_pos, Heap::kOld));
-      factory_type ^= ClassFinalizer::FinalizeType(
-          current_class(), factory_type, ClassFinalizer::kFinalize);
+      // It is not strictly necessary to canonicalize factory_type, but only its
+      // type argument vector.
+      factory_type ^= CanonicalizeType(factory_type);
       factory_type_args = factory_type.arguments();
       ASSERT(factory_type_args.Length() == factory_class.NumTypeArguments());
+      ASSERT(factory_type_args.IsCanonical());
+    } else {
+      factory_type_args = factory_type_args.Canonicalize();
     }
-    factory_type_args = factory_type_args.Canonicalize();
     ArgumentListNode* factory_param = new (Z) ArgumentListNode(literal_pos);
     // The kv_pair array is temporary and of element type dynamic. It is passed
     // to the factory to initialize a properly typed map. Pass a pre-allocated
     // array for the common empty map literal case.
     if (kv_pairs_list.length() == 0) {
       LiteralNode* empty_array_literal =
           new (Z) LiteralNode(TokenPos(), Object::empty_array());
       factory_param->Add(empty_array_literal);
     } else {
       ArrayNode* kv_pairs = new (Z) ArrayNode(
@@ skipping 108 matching lines @@
   // Replace the types parsed from the constructor.
   params.EraseParameterTypes();
 
   closure = Function::NewClosureFunction(closure_name, innermost_function(),
                                          token_pos);
   closure.set_is_generated_body(true);
   closure.set_is_debuggable(false);
   closure.set_is_visible(false);
   closure.set_result_type(Object::dynamic_type());
   AddFormalParamsToFunction(&params, closure);
-  ResolveSignature(ClassFinalizer::kResolveTypeParameters, closure);
+  ResolveSignature(closure);
 
   // Finalize function type.
   Type& signature_type = Type::Handle(Z, closure.SignatureType());
-  signature_type ^= ClassFinalizer::FinalizeType(
-      current_class(), signature_type, ClassFinalizer::kCanonicalize);
+  signature_type ^= CanonicalizeType(signature_type);
   closure.SetSignatureType(signature_type);
   // Finalization would be premature when top-level parsing.
   ASSERT(!is_top_level_);
   return closure.raw();
 }
 
 
 static String& BuildConstructorName(Thread* thread,
                                     const String& type_class_name,
                                     const String* named_constructor) {
@@ skipping 1284 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME