[VM generic function types] Properly set the scope function after parsing a

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 2184 matching lines @@
                                     &Object::dynamic_type());
 
       const bool use_function_type_syntax = false;
       const bool allow_explicit_default_values = false;
       const bool evaluate_metadata = false;
       ParseFormalParameterList(use_function_type_syntax,
                                allow_explicit_default_values, evaluate_metadata,
                                &func_params);
 
       signature_function.set_result_type(result_type);
+      // The result type may refer to the signature function's type parameters,
+      // but was not parsed in the scope of the signature function. Adjust.
+      result_type.SetScopeFunction(signature_function);
       AddFormalParamsToFunction(&func_params, signature_function);
 
       ASSERT(innermost_function().raw() == signature_function.raw());
       innermost_function_ = signature_function.parent_function();
 
       Type& signature_type =
           Type::ZoneHandle(Z, signature_function.SignatureType());
 
       // A signature type itself cannot be malformed or malbounded, only its
       // signature function's result type or parameter types may be.
@@ skipping 1359 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(func);
+    ResolveSignatureTypeParameters(func);
     if (!is_top_level_) {
       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);
   }
 
@@ skipping 571 matching lines @@
   if (method->has_abstract && (async_modifier != RawFunction::kNoModifier)) {
     ReportError(modifier_pos,
                 "abstract function '%s' may not be async, async* or sync*",
                 method->name->ToCString());
   }
 
   // Update function object.
   func.set_name(*method->name);
   func.set_is_abstract(method->has_abstract);
   func.set_is_native(method->has_native);
-  func.set_result_type(*method->type);  // May set parent_function in type.
+  func.set_result_type(*method->type);
+  // The result type may refer to func's type parameters,
+  // but was not parsed in the scope of func. Adjust.
+  method->type->SetScopeFunction(func);
+
   func.set_end_token_pos(method_end_pos);
   func.set_is_redirecting(is_redirecting);
   func.set_modifier(async_modifier);
   if (library_.is_dart_scheme() && library_.IsPrivate(*method->name)) {
     func.set_is_reflectable(false);
   }
   if (is_patch_source() && IsPatchAnnotation(method->metadata_pos)) {
     // Currently, we just ignore the patch annotation. If the function
     // name already exists in the patched class, this function will replace
     // the one in the patched class.
@@ skipping 12 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(func);
+  ResolveSignatureTypeParameters(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);
   ASSERT(field->type != NULL);
@@ skipping 118 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(getter);
+      ResolveSignatureTypeParameters(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(setter);
+        ResolveSignatureTypeParameters(setter);
         members->AddFunction(setter);
       }
     }
 
     if (CurrentToken() != Token::kCOMMA) {
       break;
     }
     ConsumeToken();
     field->name_pos = this->TokenPos();
     field->name = ExpectIdentifier("field name expected");
@@ skipping 237 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(&type);
+      ResolveTypeParameters(&type);
       member.type = &type;
     }
     ParseFieldDefinition(members, &member);
   } else {
     UnexpectedToken();
   }
   current_member_ = NULL;
   CheckMemberNameConflict(members, &member);
   members->AddMember(member);
 }
@@ skipping 331 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(getter);
+  ResolveSignatureTypeParameters(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 107 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(name_getter);
+  ResolveSignatureTypeParameters(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 29 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(ctor);
+  ResolveSignatureTypeParameters(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);
 }
 
 void Parser::CheckFinalInitializationConflicts(const ClassDesc* class_desc,
                                                const MemberDesc* member) {
   const ParamList* params = &member->params;
   if (!params->has_field_initializer) {
@@ skipping 225 matching lines @@
                              &Object::dynamic_type());
     const bool allow_explicit_default_values = false;
     const bool evaluate_metadata = false;
     ParseFormalParameterList(use_function_type_syntax,
                              allow_explicit_default_values, evaluate_metadata,
                              &params);
     if (result_type.IsNull()) {
       result_type = Type::DynamicType();
     }
     signature_function.set_result_type(result_type);
+    // The result type may refer to the signature function's type parameters,
+    // but was not parsed in the scope of the signature function. Adjust.
+    result_type.SetScopeFunction(signature_function);
     AddFormalParamsToFunction(&params, signature_function);
     ASSERT(innermost_function().raw() == signature_function.raw());
     innermost_function_ = Function::null();
   }
   ExpectSemicolon();
   ASSERT(innermost_function().IsNull());
   ASSERT(function_type_alias.signature_function() == signature_function.raw());
 
   // 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(&function_type);
+  ResolveTypeParameters(&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 @@
     if (parameterizing_class) {
       current_class().set_type_parameters(type_parameters);
     } else {
       innermost_function().set_type_parameters(type_parameters);
     }
     // Resolve type parameters referenced by upper bounds.
     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(&type_parameter_bound);
+      ResolveTypeParameters(&type_parameter_bound);
       type_parameter.set_bound(type_parameter_bound);
     }
   }
 }
 
 RawTypeArguments* Parser::ParseTypeArguments(
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseTypeArguments");
   if (CurrentToken() == Token::kLT) {
     GrowableArray<AbstractType*> types;
@@ skipping 289 matching lines @@
   } else if (IsSymbol(Symbols::Native())) {
     native_name = &ParseNativeDeclaration();
     function_end_pos = TokenPos();
     ExpectSemicolon();
     is_native = true;
     func.set_is_native(true);
   } else {
     ReportError("function block expected");
   }
   func.set_result_type(result_type);
+  // The result type may refer to func's type parameters,
+  // but was not parsed in the scope of func. Adjust.
+  result_type.SetScopeFunction(func);
   func.set_end_token_pos(function_end_pos);
   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(func);
+  ResolveSignatureTypeParameters(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 124 matching lines @@
   }
   Function& func = Function::Handle(
       Z, Function::New(accessor_name,
                        is_getter ? RawFunction::kGetterFunction
                                  : RawFunction::kSetterFunction,
                        is_static,
                        /* is_const = */ false,
                        /* is_abstract = */ false, is_external, is_native, owner,
                        decl_begin_pos));
   func.set_result_type(result_type);
+  // The result type may refer to func's type parameters,
+  // but was not parsed in the scope of func. Adjust.
+  result_type.SetScopeFunction(func);
   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(func);
+  ResolveSignatureTypeParameters(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 813 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(body);
+    ResolveSignatureTypeParameters(body);
     // Finalize function type.
     Type& signature_type = Type::Handle(Z, body.SignatureType());
     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);
@@ skipping 105 matching lines @@
     // TODO(regis): Handle generic async function.
     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(closure);
+    ResolveSignatureTypeParameters(closure);
 
     // Finalize function type.
     Type& signature_type = Type::Handle(Z, closure.SignatureType());
     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);
@@ skipping 113 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(closure);
+    ResolveSignatureTypeParameters(closure);
 
     // Finalize function type.
     Type& signature_type = Type::Handle(Z, closure.SignatureType());
     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);
@@ skipping 410 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(&type);
+    ResolveTypeParameters(&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 347 matching lines @@
   // non-closurized version of this same function.
   function = I->LookupClosureFunction(innermost_function(), function_pos);
   if (function.IsNull()) {
     // The function will be registered in the lookup table by the
     // EffectGraphVisitor::VisitClosureNode when the newly allocated closure
     // function has been properly setup.
     found_func = false;
     function = Function::NewClosureFunction(*function_name,
                                             innermost_function(), function_pos);
     function.set_result_type(result_type);
+    // The result type may refer to the function's type parameters,
+    // but was not parsed in the scope of the function. Adjust.
+    result_type.SetScopeFunction(function);
     if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
       library_.AddFunctionMetadata(function, metadata_pos);
     }
   }
 
   ASSERT(function.parent_function() == innermost_function_.raw());
   innermost_function_ = function.raw();
 
   if (CurrentToken() == Token::kLT) {
     if (!FLAG_generic_method_syntax) {
@@ skipping 45 matching lines @@
     }
   }
 
   Type& signature_type = Type::ZoneHandle(Z);
   SequenceNode* statements = NULL;
   if (!found_func) {
     // 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.
 
-    ResolveType(&result_type);  // Parameter types are resolved in ParseFunc.
-    function.set_result_type(result_type);
+    ResolveTypeParameters(&result_type);
+    function.set_result_type(result_type);  // Update type without scope change.
+    // Type parameters appearing in parameter types are resolved in ParseFunc.
     statements = Parser::ParseFunc(function, !is_literal);
     INC_STAT(thread(), num_functions_parsed, 1);
 
     // Now that the local function has formal parameters, finalize its signature
     signature_type = function.SignatureType();
     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
@@ skipping 4202 matching lines @@
     let_expr->AddNode(store);
     let_expr->AddNode(new (Z) LoadLocalNode(op_pos, temp));
     return let_expr;
   }
   return expr;
 }
 
 // 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) {
+void Parser::ResolveSignatureTypeParameters(const Function& signature) {
   const Function& saved_innermost_function =
       Function::Handle(Z, innermost_function().raw());
   innermost_function_ = signature.raw();
   AbstractType& type = AbstractType::Handle();
   // Resolve upper bounds of function type parameters.
   const intptr_t num_type_params = signature.NumTypeParameters();
   if (num_type_params > 0) {
     TypeParameter& type_param = TypeParameter::Handle();
     const TypeArguments& type_params =
         TypeArguments::Handle(signature.type_parameters());
     for (intptr_t i = 0; i < num_type_params; i++) {
       type_param ^= type_params.TypeAt(i);
       type = type_param.bound();
-      ResolveType(&type);
+      ResolveTypeParameters(&type);
       type_param.set_bound(type);
     }
   }
   // Resolve result type.
   type = signature.result_type();
-  ResolveType(&type);
-  signature.set_result_type(type);
+  ResolveTypeParameters(&type);
+  signature.set_result_type(type);  // Update type without scope change.
   // Resolve formal parameter types.
   const intptr_t num_parameters = signature.NumParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = signature.ParameterTypeAt(i);
-    ResolveType(&type);
+    ResolveTypeParameters(&type);
     signature.SetParameterTypeAt(i, type);
   }
   innermost_function_ = saved_innermost_function.raw();
 }
 
 // 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) {
+void Parser::ResolveTypeParameters(AbstractType* type) {
   ASSERT(type != NULL);
   if (type->IsResolved()) {
     // Some types are resolved by definition, such as a TypeParameter.
     return;
   }
   // Resolve type class.
   if (!type->HasResolvedTypeClass()) {
     const UnresolvedClass& unresolved_class =
         UnresolvedClass::Handle(Z, type->unresolved_class());
     const String& unresolved_class_name =
@@ skipping 58 matching lines @@
   // Resolve type arguments, if any.
   if (type->arguments() != TypeArguments::null()) {
     const TypeArguments& arguments =
         TypeArguments::Handle(Z, type->arguments());
     // Already resolved if canonical.
     if (!arguments.IsCanonical()) {
       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(&type_argument);
+        ResolveTypeParameters(&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(&signature_type);
+      ResolveTypeParameters(&signature_type);
     } else {
-      ResolveSignature(signature);
+      ResolveSignatureTypeParameters(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);
@@ skipping 622 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(&type);
+    ResolveTypeParameters(&type);
     if (finalization >= ClassFinalizer::kCanonicalize) {
       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(
@@ skipping 17 matching lines @@
   if (!IsSymbol(Symbols::Function())) {
     ReportError("'Function' expected");
   }
   do {
     ConsumeToken();
     const Function& signature_function = Function::Handle(
         Z, Function::NewSignatureFunction(current_class(), innermost_function(),
                                           TokenPosition::kNoSource));
     innermost_function_ = signature_function.raw();
     signature_function.set_result_type(type);
+    // The result type may refer to the signature function's type parameters,
+    // but was not parsed in the scope of the signature function. Adjust.
+    type.SetScopeFunction(signature_function);
     // Parse optional type parameters.
     if (CurrentToken() == Token::kLT) {
       if (!FLAG_generic_method_syntax) {
         ReportError("generic type arguments not supported.");
       }
       ParseTypeParameters(false);  // Not parameterizing class, but function.
     }
     ParamList params;
     // We do not yet allow Function of any arity, so expect parameter list.
     CheckToken(Token::kLPAREN, "formal parameter list expected");
@@ skipping 18 matching lines @@
       // Set it in the typedef class before building the signature type.
       current_class().set_signature_function(signature_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(&type);
+    ResolveTypeParameters(&type);
     if (finalization >= ClassFinalizer::kCanonicalize) {
       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.
@@ skipping 95 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(&type);
+    ResolveTypeParameters(&type);
     if (finalization >= ClassFinalizer::kCanonicalize) {
       type ^= CanonicalizeType(type);
     }
   }
   return type.raw();
 }
 
 void Parser::CheckConstructorCallTypeArguments(
     TokenPosition pos,
     const Function& constructor,
@@ skipping 526 matching lines @@
   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);
   // TODO(regis): Verify that the closure cannot be generic.
   closure.set_result_type(Object::dynamic_type());
   AddFormalParamsToFunction(&params, closure);
-  ResolveSignature(closure);
+  ResolveSignatureTypeParameters(closure);
 
   // Finalize function type.
   Type& signature_type = Type::Handle(Z, closure.SignatureType());
   signature_type ^= CanonicalizeType(signature_type);
   closure.SetSignatureType(signature_type);
   // Finalization would be premature when top-level parsing.
   ASSERT(!is_top_level_);
   return closure.raw();
 }
 
@@ skipping 1278 matching lines @@
 bool Parser::FieldHasFunctionLiteralInitializer(const Field& field,
                                                 TokenPosition* start,
                                                 TokenPosition* end) {
   UNREACHABLE();
   return false;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME