Support generic method syntax (fixes #25869).

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 2031 matching lines @@
         if (IsIdentifier() || (CurrentToken() == Token::kTHIS)) {
           found_type = true;
         }
       }
     }
     if (found_type) {
       // The types of formal parameters are never ignored, even in unchecked
       // mode, because they are part of the function type of closurized
       // functions appearing in type tests with typedefs.
       parameter.has_explicit_type = true;
+      // It is too early to resolve the type here, since it can be a result type
+      // referring to a not yet declared function type parameter.
       parameter.type = &AbstractType::ZoneHandle(Z,
-          ParseType(is_top_level_ ? ClassFinalizer::kResolveTypeParameters :
-                                    ClassFinalizer::kCanonicalize));
+          ParseType(ClassFinalizer::kDoNotResolve));
     } else {
       // If this is an initializing formal, its type will be set to the type of
       // the respective field when the constructor is fully parsed.
       parameter.type = &Object::dynamic_type();
     }
   }
   if (!this_seen && (CurrentToken() == Token::kTHIS)) {
     ConsumeToken();
     ExpectToken(Token::kPERIOD);
     this_seen = true;
@@ skipping 29 matching lines @@
   if (IsParameterPart()) {
     // This parameter is probably a closure. If we saw the keyword 'var'
     // or 'final', a closure is not legal here and we ignore the
     // opening parens.
     // TODO(hausner): The language spec appears to allow var and final
     // in signature types when used with initializing formals:
     // fieldFormalParameter:
     // metadata finalConstVarOrType? this ‘.’ identifier formalParameterList? ;
     if (!var_seen && !final_seen) {
       // The parsed parameter type is actually the function result type.
-      const AbstractType& result_type =
+      AbstractType& result_type =
           AbstractType::Handle(Z, parameter.type->raw());
 
+      // In top-level and mixin functions, the source may be in a different
+      // script than the script of the current class. However, we never reparse
+      // signature functions (except typedef signature functions), therefore
+      // we do not need to keep the correct script via a patch class. Use the
+      // actual current class as owner of the signature function.
+      const Function& signature_function = Function::Handle(Z,
+          Function::NewSignatureFunction(current_class(),
+                                         TokenPosition::kNoSource));
+      signature_function.set_parent_function(innermost_function());
+      innermost_function_ = signature_function.raw();
+
       // Finish parsing the function type parameter.
       if (CurrentToken() == Token::kLT) {
-        // TODO(hausner): handle generic function types.
         if (!FLAG_generic_method_syntax) {
           ReportError("generic function types not supported");
         }
-        TokenPosition type_param_pos = TokenPos();
-        if (!TryParseTypeParameters()) {
-          ReportError(type_param_pos, "error in type parameters");
-        }
+        ParseTypeParameters(false);  // Not parameterizing class, but function.
       }
 
+      // Now that type parameters are declared, the result type can be resolved.
+      ResolveType(ClassFinalizer::kResolveTypeParameters, &result_type);
+
       ASSERT(CurrentToken() == Token::kLPAREN);
       ParamList func_params;
 
       // Add implicit closure object parameter.
       func_params.AddFinalParameter(
           TokenPos(),
           &Symbols::ClosureParameter(),
           &Object::dynamic_type());
 
       const bool no_explicit_default_values = false;
       ParseFormalParameterList(no_explicit_default_values, false, &func_params);
 
-      // In top-level and mixin functions, the source may be in a different
-      // script than the script of the current class. However, we never reparse
-      // signature functions (except typedef signature functions), therefore
-      // we do not need to keep the correct script via a patch class. Use the
-      // actual current class as owner of the signature function.
-      const Function& signature_function = Function::Handle(Z,
-          Function::NewSignatureFunction(current_class(),
-                                         TokenPosition::kNoSource));
       signature_function.set_result_type(result_type);
       AddFormalParamsToFunction(&func_params, signature_function);
+
+      ASSERT(innermost_function().raw() == signature_function.raw());
+      innermost_function_ = signature_function.parent_function();
+      signature_function.set_data(Object::Handle());

[siva, 2016/09/19 23:23:46]

Handle(Z) possible here?

[regis, 2016/09/23 00:35:23]

Done.

+
       Type& signature_type =
           Type::ZoneHandle(Z, signature_function.SignatureType());
       if (!is_top_level_) {
         signature_type ^= ClassFinalizer::FinalizeType(
             current_class(), signature_type, ClassFinalizer::kCanonicalize);
         signature_function.SetSignatureType(signature_type);
       }
       ASSERT(is_top_level_ || signature_type.IsFinalized());
       // A signature type itself cannot be malformed or malbounded, only its
       // signature function's result type or parameter types may be.
       ASSERT(!signature_type.IsMalformed());
       ASSERT(!signature_type.IsMalbounded());
       // The type of the parameter is now the signature type.
       parameter.type = &signature_type;
     }
+  } else {
+    if (!parameter.type->IsFinalized()) {
+      AbstractType& type = AbstractType::ZoneHandle(Z, parameter.type->raw());
+      ResolveType(ClassFinalizer::kResolveTypeParameters, &type);
+      if (!is_top_level_) {
+        type = ClassFinalizer::FinalizeType(
+            Class::Handle(Z, innermost_function().origin()),
+            type,
+            ClassFinalizer::kCanonicalize);
+      }
+      parameter.type = &type;
+    }
   }
 
   if ((CurrentToken() == Token::kASSIGN) || (CurrentToken() == Token::kCOLON)) {
     if ((!params->has_optional_positional_parameters &&
          !params->has_optional_named_parameters) ||
         !allow_explicit_default_value) {
       ReportError("parameter must not specify a default value");
     }
     if (params->has_optional_positional_parameters) {
       ExpectToken(Token::kASSIGN);
@@ skipping 1224 matching lines @@
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
 // Parser is at the opening parenthesis of the formal parameter
 // declaration of the function or constructor.
 // Parse the formal parameters and code.
 SequenceNode* Parser::ParseFunc(const Function& func, bool check_semicolon) {
   TRACE_PARSER("ParseFunc");
-  Function& saved_innermost_function =
-      Function::Handle(Z, innermost_function().raw());
-  innermost_function_ = func.raw();
+  ASSERT(innermost_function().raw() == func.raw());
 
   // Save current try index. Try index starts at zero for each function.
   intptr_t saved_try_index = last_used_try_index_;
   last_used_try_index_ = 0;
 
   // In case of nested async functions we also need to save the scope where
   // temporaries are added.
   LocalScope* saved_async_temp_scope = async_temp_scope_;
 
   if (func.IsGenerativeConstructor()) {
     SequenceNode* statements = ParseConstructor(func);
-    innermost_function_ = saved_innermost_function.raw();
     last_used_try_index_ = saved_try_index;
     return statements;
   }
 
   ASSERT(!func.IsGenerativeConstructor());
   OpenFunctionBlock(func);  // Build local scope for function.
 
   ParamList params;
   // An instance closure function may capture and access the receiver, but via
   // the context and not via the first formal parameter.
@@ skipping 215 matching lines @@
   } else if (func.IsSyncGenClosure()) {
     // body is unchanged.
   } else if (func.IsAsyncGenerator()) {
     body = CloseAsyncGeneratorFunction(generated_body_closure, body);
     generated_body_closure.set_end_token_pos(end_token_pos);
   } else if (func.IsAsyncGenClosure()) {
     body = CloseAsyncGeneratorClosure(body);
   }
   EnsureHasReturnStatement(body, end_token_pos);
   current_block_->statements->Add(body);
-  innermost_function_ = saved_innermost_function.raw();
   last_used_try_index_ = saved_try_index;
   async_temp_scope_ = saved_async_temp_scope;
   return CloseBlock();
 }
 
 
 void Parser::AddEqualityNullCheck() {
   AstNode* argument =
       new LoadLocalNode(TokenPosition::kNoSource,
                         current_block_->scope->parent()->VariableAt(1));
@@ skipping 75 matching lines @@
   // not a library prefix.
   LibraryPrefix& prefix =
       LibraryPrefix::Handle(Z, library_.LookupLocalLibraryPrefix(ident));
   if (prefix.IsNull()) {
     return LibraryPrefix::null();
   }
 
   // A library prefix with the name exists. Now check whether it is
   // shadowed by a local definition.
   if (!is_top_level_ &&
-      ResolveIdentInLocalScope(TokenPos(), ident, NULL)) {
+      ResolveIdentInLocalScope(TokenPos(), ident, NULL, NULL)) {
     return LibraryPrefix::null();
   }
-  // Check whether the identifier is shadowed by a type parameter.
+  // Check whether the identifier is shadowed by a function type parameter.
+  // TODO(regis): Shortcut this lookup if no generic functions in scope.
+  if (!innermost_function().IsNull() &&
+      (innermost_function().LookupTypeParameter(ident, NULL) !=
+       TypeParameter::null())) {
+    return LibraryPrefix::null();
+  }
+  // Check whether the identifier is shadowed by a class type parameter.
   ASSERT(!current_class().IsNull());
   if (current_class().LookupTypeParameter(ident) != TypeParameter::null()) {
     return LibraryPrefix::null();
   }
 
   // We have a name that is not shadowed, followed by a period or #.
   // Consume the identifier, let the caller consume the . or #.
   ConsumeToken();
   return prefix.raw();
 }
 
 
 void Parser::ParseMethodOrConstructor(ClassDesc* members, MemberDesc* method) {
   TRACE_PARSER("ParseMethodOrConstructor");
   // We are at the beginning of the formal parameters list.
   ASSERT(CurrentToken() == Token::kLPAREN ||
          CurrentToken() == Token::kLT ||
          method->IsGetter());
-  ASSERT(method->type != NULL);
+  ASSERT(method->type != NULL);  // May still be unresolved.
   ASSERT(current_member_ == method);
 
   if (method->has_var) {
     ReportError(method->name_pos, "keyword var not allowed for methods");
   }
   if (method->has_final) {
     ReportError(method->name_pos, "'final' not allowed for methods");
   }
   if (method->has_abstract && method->has_static) {
     ReportError(method->name_pos,
                 "static method '%s' cannot be abstract",
                 method->name->ToCString());
      }
   if (method->has_const && !method->IsFactoryOrConstructor()) {
     ReportError(method->name_pos, "'const' not allowed for methods");
   }
   if (method->has_abstract && method->IsFactoryOrConstructor()) {
     ReportError(method->name_pos, "constructor cannot be abstract");
   }
   if (method->has_const && method->IsConstructor()) {
     current_class().set_is_const();
   }
 
+  Function& func = Function::Handle(Z,
+      Function::New(*method->name,  // May change.
+                    method->kind,
+                    method->has_static,
+                    method->has_const,
+                    method->has_abstract,  // May change.
+                    method->has_external,
+                    method->has_native,  // May change.
+                    current_class(),
+                    method->decl_begin_pos));
+
+  ASSERT(innermost_function().IsNull());
+  innermost_function_ = func.raw();
+
   if (CurrentToken() == Token::kLT) {
-    // Parse type parameters, but ignore them.
-    // TODO(hausner): handle type parameters.
     if (!FLAG_generic_method_syntax) {
       ReportError("generic type arguments not supported.");
     }
     TokenPosition type_param_pos = TokenPos();
     if (method->IsFactoryOrConstructor()) {
       ReportError(method->name_pos, "constructor cannot be generic");
     }
     if (method->IsGetter() || method->IsSetter()) {
       ReportError(type_param_pos, "%s cannot be generic",
           method->IsGetter() ? "getter" : "setter");
     }
-    if (!TryParseTypeParameters()) {
-      ReportError(type_param_pos, "error in type parameters");
-    }
+    ParseTypeParameters(false);  // Not parameterizing class, but function.
+  }
+
+  // Now that type parameters are declared, the result type can be resolved.
+  if (!method->type->IsResolved()) {
+    AbstractType& type = AbstractType::ZoneHandle(Z, method->type->raw());
+    ResolveType(ClassFinalizer::kResolveTypeParameters, &type);
+    method->type = &type;
   }
 
   // Parse the formal parameters.
   const bool are_implicitly_final = method->has_const;
   const bool allow_explicit_default_values = true;
   const TokenPosition formal_param_pos = TokenPos();
   method->params.Clear();
   // Static functions do not have a receiver.
   // The first parameter of a factory is the TypeArguments vector of
   // the type of the instance to be allocated.
@@ skipping 253 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());
   }
 
-  RawFunction::Kind function_kind;
-  if (method->IsFactoryOrConstructor()) {
-    function_kind = RawFunction::kConstructor;
-  } else if (method->IsGetter()) {
-    function_kind = RawFunction::kGetterFunction;
-  } else if (method->IsSetter()) {
-    function_kind = RawFunction::kSetterFunction;
-  } else {
-    function_kind = RawFunction::kRegularFunction;
-  }
-  Function& func = Function::Handle(Z,
-      Function::New(*method->name,
-                    function_kind,
-                    method->has_static,
-                    method->has_const,
-                    method->has_abstract,
-                    method->has_external,
-                    method->has_native,
-                    current_class(),
-                    method->decl_begin_pos));
+  // 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);
   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
@@ skipping 12 matching lines @@
     ASSERT(func.IsFactory());
     func.SetRedirectionType(redirection_type);
     if (!redirection_identifier.IsNull()) {
       func.SetRedirectionIdentifier(redirection_identifier);
     }
   }
 
   // No need to resolve parameter types yet, or add parameters to local scope.
   ASSERT(is_top_level_);
   AddFormalParamsToFunction(&method->params, func);
+  ASSERT(innermost_function().raw() == func.raw());
+  innermost_function_ = Function::null();
   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 ||
@@ skipping 281 matching lines @@
       if (TryParseReturnType()) {
         if (IsIdentifier() ||
            (CurrentToken() == Token::kGET) ||
            (CurrentToken() == Token::kSET) ||
            (CurrentToken() == Token::kOPERATOR)) {
           found_type = true;
         }
       }
     }
     if (found_type) {
+      // It is too early to resolve the type here, since it can be a result type
+      // referring to a not yet declared function type parameter.
       member.type = &AbstractType::ZoneHandle(Z,
-          ParseType(ClassFinalizer::kResolveTypeParameters));
+          ParseType(ClassFinalizer::kDoNotResolve));
     }
   }
 
   // Optionally parse a (possibly named) constructor name or factory.
   if (IsIdentifier() &&
       (CurrentLiteral()->Equals(members->class_name()) || member.has_factory)) {
     member.name_pos = TokenPos();
     member.name = CurrentLiteral();  // Unqualified identifier.
     ConsumeToken();
     if (member.has_factory) {
@@ skipping 92 matching lines @@
     ReportError("identifier expected");
   }
 
   ASSERT(member.name != NULL);
   if (IsParameterPart() || member.IsGetter()) {
     // Constructor or method.
     if (member.type == NULL) {
       member.type = &Object::dynamic_type();
     }
     ASSERT(member.IsFactory() == member.has_factory);
+    // Note that member.type may still be unresolved.
     ParseMethodOrConstructor(members, &member);
   } else if (CurrentToken() ==  Token::kSEMICOLON ||
              CurrentToken() == Token::kCOMMA ||
              CurrentToken() == Token::kASSIGN) {
     // Field definition.
     if (member.has_const) {
       // const fields are implicitly final.
       member.has_final = true;
     }
     if (member.type == NULL) {
       if (member.has_final) {
         member.type = &Object::dynamic_type();
       } 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);
+      member.type = &type;
+    }
     ParseFieldDefinition(members, &member);
   } else {
     UnexpectedToken();
   }
   current_member_ = NULL;
   CheckMemberNameConflict(members, &member);
   members->AddMember(member);
 }
 
 
@@ skipping 98 matching lines @@
                     class_name.ToCString());
       }
       // Pre-registered classes need their scripts connected at this time.
       cls.set_script(script_);
       cls.set_token_pos(declaration_pos);
     }
   }
   ASSERT(!cls.IsNull());
   ASSERT(cls.functions() == Object::empty_array().raw());
   set_current_class(cls);
-  ParseTypeParameters(cls);
+  ParseTypeParameters(true);  // Parameterizing current class.
   if (is_patch) {
     // Check that the new type parameters are identical to the original ones.
     const TypeArguments& new_type_parameters =
         TypeArguments::Handle(Z, cls.type_parameters());
     const int new_type_params_count =
         new_type_parameters.IsNull() ? 0 : new_type_parameters.Length();
     const int orig_type_params_count =
         orig_type_parameters.IsNull() ? 0 : orig_type_parameters.Length();
     if (new_type_params_count != orig_type_params_count) {
       ReportError(classname_pos,
@@ skipping 443 matching lines @@
   if (!obj.IsNull()) {
     ReportError(classname_pos, "'%s' is already defined",
                 class_name.ToCString());
   }
   const Class& mixin_application =
       Class::Handle(Z, Class::New(library_, class_name,
                                   script_, classname_pos));
   mixin_application.set_is_mixin_app_alias();
   library_.AddClass(mixin_application);
   set_current_class(mixin_application);
-  ParseTypeParameters(mixin_application);
+  ParseTypeParameters(true);  // Parameterizing current class.
 
   ExpectToken(Token::kASSIGN);
 
   if (CurrentToken() == Token::kABSTRACT) {
     mixin_application.set_is_abstract();
     ConsumeToken();
   }
 
   const TokenPosition type_pos = TokenPos();
   AbstractType& type =
@@ skipping 107 matching lines @@
   // to be properly finalized, need to be associated to this scope class as
   // they are parsed.
   const Class& function_type_alias =
       Class::Handle(Z, Class::New(
           library_, *alias_name, script_, declaration_pos));
   function_type_alias.set_is_synthesized_class();
   function_type_alias.set_is_abstract();
   function_type_alias.set_is_prefinalized();
   library_.AddClass(function_type_alias);
   set_current_class(function_type_alias);
-  // Parse the type parameters of the function type.
-  ParseTypeParameters(function_type_alias);
+  // Parse the type parameters of the typedef class.
+  ParseTypeParameters(true);  // Parameterizing current class.
   // At this point, the type parameters have been parsed, so we can resolve the
   // result type.
   if (!result_type.IsNull()) {
-    ResolveTypeFromClass(function_type_alias,
-                         ClassFinalizer::kResolveTypeParameters,
-                         &result_type);
+    ResolveType(ClassFinalizer::kResolveTypeParameters, &result_type);
   }
   // Parse the formal parameters of the function type.
   CheckToken(Token::kLPAREN, "formal parameter list expected");
   ParamList func_params;
 
   // Add implicit closure object parameter.
   func_params.AddFinalParameter(
       TokenPos(),
       &Symbols::ClosureParameter(),
       &Object::dynamic_type());
 
   // Mark the current class as a typedef class (by setting its signature
   // function field to a non-null function) before parsing its formal parameters
   // so that parsed function types are aware that their owner class is a
   // typedef class.
   Function& signature_function =
       Function::Handle(Z, Function::NewSignatureFunction(function_type_alias,
                                                          alias_name_pos));
+  ASSERT(innermost_function().IsNull());
+  innermost_function_ = signature_function.raw();
   // Set the signature function in the function type alias class.
   function_type_alias.set_signature_function(signature_function);
 
   const bool no_explicit_default_values = false;
   ParseFormalParameterList(no_explicit_default_values, false, &func_params);
   ExpectSemicolon();
   signature_function.set_result_type(result_type);
   AddFormalParamsToFunction(&func_params, signature_function);
 
+  ASSERT(innermost_function().raw() == signature_function.raw());
+  innermost_function_ = Function::null();
+
   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.
   ASSERT(!function_type_alias.is_finalized());
   pending_classes.Add(function_type_alias, Heap::kOld);
   if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
     library_.AddClassMetadata(function_type_alias,
@@ skipping 79 matching lines @@
     ExpectIdentifier("type name expected");
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       ExpectIdentifier("name expected");
     }
     SkipTypeArguments();
   }
 }
 
 
-void Parser::ParseTypeParameters(const Class& cls) {
+void Parser::ParseTypeParameters(bool parameterizing_class) {
   TRACE_PARSER("ParseTypeParameters");
   if (CurrentToken() == Token::kLT) {
     GrowableArray<AbstractType*> type_parameters_array(Z, 2);
     intptr_t index = 0;
     TypeParameter& type_parameter = TypeParameter::Handle(Z);
     TypeParameter& existing_type_parameter = TypeParameter::Handle(Z);
     String& existing_type_parameter_name = String::Handle(Z);
     AbstractType& type_parameter_bound = Type::Handle(Z);
     do {
       ConsumeToken();
       const TokenPosition metadata_pos = SkipMetadata();
       const TokenPosition type_parameter_pos = TokenPos();
       const TokenPosition declaration_pos =
           metadata_pos.IsReal() ? metadata_pos : type_parameter_pos;
       String& type_parameter_name =
           *ExpectUserDefinedTypeIdentifier("type parameter expected");
       // Check for duplicate type parameters.
       for (intptr_t i = 0; i < index; i++) {
         existing_type_parameter ^= type_parameters_array.At(i)->raw();
         existing_type_parameter_name = existing_type_parameter.name();
         if (existing_type_parameter_name.Equals(type_parameter_name)) {
           ReportError(type_parameter_pos, "duplicate type parameter '%s'",
                       type_parameter_name.ToCString());
         }
       }
-      if (CurrentToken() == Token::kEXTENDS) {
+      if ((CurrentToken() == Token::kEXTENDS) ||
+          (!parameterizing_class && (CurrentToken() == Token::kSUPER))) {
         ConsumeToken();
+        // TODO(regis): Handle 'super' differently than 'extends'.
         // A bound may refer to the owner of the type parameter it applies to,
-        // i.e. to the class or interface currently being parsed.
-        // Postpone resolution in order to avoid resolving the class and its
+        // i.e. to the class or function currently being parsed.
+        // Postpone resolution in order to avoid resolving the owner and its
         // type parameters, as they are not fully parsed yet.
         type_parameter_bound = ParseType(ClassFinalizer::kDoNotResolve);
       } else {
         type_parameter_bound = I->object_store()->object_type();
       }
-      type_parameter = TypeParameter::New(cls,
-                                          index,
-                                          type_parameter_name,
-                                          type_parameter_bound,
-                                          declaration_pos);
+      type_parameter = TypeParameter::New(
+          parameterizing_class ? current_class() : Class::Handle(Z),
+          parameterizing_class ? Function::Handle(Z) : innermost_function(),
+          index,
+          type_parameter_name,
+          type_parameter_bound,
+          declaration_pos);
       type_parameters_array.Add(
           &AbstractType::ZoneHandle(Z, type_parameter.raw()));
       if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
         library_.AddTypeParameterMetadata(type_parameter, metadata_pos);
       }
       index++;
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ReportError("right angle bracket expected");
     }
     const TypeArguments& type_parameters =
-        TypeArguments::Handle(Z,
-                              NewTypeArguments(type_parameters_array));
-    cls.set_type_parameters(type_parameters);
+        TypeArguments::Handle(Z, NewTypeArguments(type_parameters_array));
+    if (parameterizing_class) {
+      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();
-      ResolveTypeFromClass(cls,
-                           ClassFinalizer::kResolveTypeParameters,
-                           &type_parameter_bound);
+      ResolveType(ClassFinalizer::kResolveTypeParameters,
+                  &type_parameter_bound);
       type_parameter.set_bound(type_parameter_bound);
     }
   }
 }
 
 
 RawTypeArguments* Parser::ParseTypeArguments(
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseTypeArguments");
   if (CurrentToken() == Token::kLT) {
@@ skipping 195 matching lines @@
   return RawFunction::kNoModifier;
 }
 
 
 void Parser::ParseTopLevelFunction(TopLevel* top_level,
                                    const Object& owner,
                                    TokenPosition metadata_pos) {
   TRACE_PARSER("ParseTopLevelFunction");
   const TokenPosition decl_begin_pos = TokenPos();
   AbstractType& result_type = Type::Handle(Z, Type::DynamicType());
-  const bool is_static = true;
   bool is_external = false;
   bool is_patch = false;
   if (is_patch_source() && IsPatchAnnotation(metadata_pos)) {
     is_patch = true;
     metadata_pos = TokenPosition::kNoSource;
   } else if (CurrentToken() == Token::kEXTERNAL) {
     ConsumeToken();
     is_external = true;
   }
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else {
     // Parse optional type.
     if (IsFunctionReturnType()) {
-      result_type = ParseType(ClassFinalizer::kResolveTypeParameters);
+      // It is too early to resolve the type here, since it can be a result type
+      // referring to a not yet declared function type parameter.
+      result_type = ParseType(ClassFinalizer::kDoNotResolve);
     }
   }
   const TokenPosition name_pos = TokenPos();
   const String& func_name = *ExpectIdentifier("function name expected");
 
   bool found = library_.LookupLocalObject(func_name) != Object::null();
   if (found && !is_patch) {
     ReportError(name_pos, "'%s' is already defined", func_name.ToCString());
   } else if (!found && is_patch) {
     ReportError(name_pos, "missing '%s' cannot be patched",
                 func_name.ToCString());
   }
   String& accessor_name = String::Handle(Z, Field::GetterName(func_name));
   if (library_.LookupLocalObject(accessor_name) != Object::null()) {
     ReportError(name_pos, "'%s' is already defined as getter",
                 func_name.ToCString());
   }
   // A setter named x= may co-exist with a function named x, thus we do
   // not need to check setters.
 
+  Function& func = Function::Handle(Z,
+      Function::New(func_name,
+                    RawFunction::kRegularFunction,
+                    /* is_static = */ true,
+                    /* is_const = */ false,
+                    /* is_abstract = */ false,
+                    is_external,
+                    /* is_native = */ false,  // May change.
+                    owner,
+                    decl_begin_pos));
+
+  ASSERT(innermost_function().IsNull());
+  innermost_function_ = func.raw();
+
   if (CurrentToken() == Token::kLT) {
-    // Type parameters of generic function.
-    // TODO(hausner): handle type parameters.
     if (!FLAG_generic_method_syntax) {
       ReportError("generic functions not supported");
     }
-    TokenPosition type_arg_pos = TokenPos();
-    if (!TryParseTypeParameters()) {
-      ReportError(type_arg_pos, "error in type parameters");
-    }
+    ParseTypeParameters(false);  // Not parameterizing class, but function.
+  }
+  // At this point, the type parameters have been parsed, so we can resolve the
+  // result type.
+  if (!result_type.IsNull()) {
+    ResolveType(ClassFinalizer::kResolveTypeParameters, &result_type);
   }
 
   CheckToken(Token::kLPAREN);
   const TokenPosition function_pos = TokenPos();
   ParamList params;
   const bool allow_explicit_default_values = true;
   ParseFormalParameterList(allow_explicit_default_values, false, &params);
 
   const TokenPosition modifier_pos = TokenPos();
   RawFunction::AsyncModifier func_modifier = ParseFunctionModifier();
@@ skipping 17 matching lines @@
     BoolScope allow_await(&this->await_is_keyword_,
                           func_modifier != RawFunction::kNoModifier);
     SkipExpr();
     function_end_pos = TokenPos();
     ExpectSemicolon();
   } 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");
   }
-  Function& func = Function::Handle(Z,
-      Function::New(func_name,
-                    RawFunction::kRegularFunction,
-                    is_static,
-                    /* is_const = */ false,
-                    /* is_abstract = */ false,
-                    is_external,
-                    is_native,
-                    owner,
-                    decl_begin_pos));
   func.set_result_type(result_type);
   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();
   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 1823 matching lines @@
 
 void Parser::CaptureInstantiator() {
   ASSERT(FunctionLevel() > 0);
   const String* variable_name = current_function().IsInFactoryScope() ?
       &Symbols::TypeArgumentsParameter() : &Symbols::This();
   current_block_->scope->CaptureVariable(
       current_block_->scope->LookupVariable(*variable_name, true));
 }
 
 
+void Parser::CaptureFunctionInstantiator() {
+  ASSERT(FunctionLevel() > 0);
+  const String* variable_name = &Symbols::FunctionInstantiatorVar();
+  current_block_->scope->CaptureVariable(
+      current_block_->scope->LookupVariable(*variable_name, true));
+}
+
+
 AstNode* Parser::LoadReceiver(TokenPosition token_pos) {
   // A nested function may access 'this', referring to the receiver of the
   // outermost enclosing function.
   const bool kTestOnly = false;
   LocalVariable* receiver = LookupReceiver(current_block_->scope, kTestOnly);
   if (receiver == NULL) {
     ReportError(token_pos, "illegal implicit access to receiver 'this'");
   }
   return new(Z) LoadLocalNode(TokenPos(), receiver);
 }
@@ skipping 179 matching lines @@
   TokenPosition metadata_pos = TokenPosition::kNoSource;
   if (is_literal) {
     ASSERT(CurrentToken() == Token::kLPAREN || CurrentToken() == Token::kLT);
     function_name = &Symbols::AnonymousClosure();
   } else {
     metadata_pos = SkipMetadata();
     if (CurrentToken() == Token::kVOID) {
       ConsumeToken();
       result_type = Type::VoidType();
     } else if (IsFunctionReturnType()) {
-      result_type = ParseType(ClassFinalizer::kCanonicalize);
+      // It is too early to resolve the type here, since it can be a result type
+      // referring to a not yet declared function type parameter.
+      result_type = ParseType(ClassFinalizer::kDoNotResolve);
     }
     const TokenPosition name_pos = TokenPos();
     variable_name = ExpectIdentifier("function name expected");
     function_name = variable_name;
 
     // Check that the function name has not been referenced
     // before this declaration.
     ASSERT(current_block_ != NULL);
     const TokenPosition previous_pos =
         current_block_->scope->PreviousReferencePos(*function_name);
     if (previous_pos.IsReal()) {
       ASSERT(!script_.IsNull());
       intptr_t line_number;
       script_.GetTokenLocation(previous_pos, &line_number, NULL);
       ReportError(name_pos,
                   "identifier '%s' previously used in line %" Pd "",
                   function_name->ToCString(),
                   line_number);
     }
   }
 
-  if (CurrentToken() == Token::kLT) {
-    if (!FLAG_generic_method_syntax) {
-      ReportError("generic functions not supported");
-    }
-    TokenPosition type_arg_pos = TokenPos();
-    // TODO(hausner): handle type parameters of generic function.
-    if (!TryParseTypeParameters()) {
-      ReportError(type_arg_pos, "error in type parameters");
-    }
-  }
-
-  CheckToken(Token::kLPAREN);
-
   // Check whether we have parsed this closure function before, in a previous
   // compilation. If so, reuse the function object, else create a new one
   // and register it in the current class.
   // Note that we cannot share the same closure function between the closurized
   // and non-closurized versions of the same parent function.
   Function& function = Function::ZoneHandle(Z);
   bool found_func = true;
   // TODO(hausner): There could be two different closures at the given
   // function_pos, one enclosed in a closurized function and one enclosed in the
   // 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);
     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) {
+      ReportError("generic functions not supported");
+    }
+    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::kResolveTypeParameters, &result_type);
+    result_type = ClassFinalizer::FinalizeType(
+        current_class(), result_type, ClassFinalizer::kCanonicalize);
+    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;
   Type& function_type = Type::ZoneHandle(Z);
   if (variable_name != NULL) {
     // Since the function type depends on the signature of the closure function,
     // it cannot be determined before the formal parameter list of the closure
     // function is parsed. Therefore, we set the function type to a new
@@ skipping 27 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.
 
+    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);
     function.SetSignatureType(signature_type);
   } else {
     // The local function was parsed before. The captured variables are
@@ skipping 65 matching lines @@
   // since further closure functions may capture more variables.
   // This Scope object is constructed after all variables have been allocated.
   // The local scope of the parsed function can be pruned, since contained
   // variables are not relevant for the compilation of the enclosing function.
   // This pruning is done by omitting to hook the local scope in its parent
   // scope in the constructor of LocalScope.
   AstNode* closure =
       new(Z) ClosureNode(function_pos, function, NULL,
                          statements != NULL ? statements->scope() : NULL);
 
+  ASSERT(innermost_function_.raw() == function.raw());
+  innermost_function_ = function.parent_function();
+
   if (function_variable == NULL) {
     ASSERT(is_literal);
     return closure;
   } else {
     AstNode* initialization = new(Z) StoreLocalNode(
         function_pos, function_variable, closure);
     return initialization;
   }
 }
 
@@ skipping 3747 matching lines @@
                   funcname.ToCString());
     }
     AstNode* receiver = LoadReceiver(primary->token_pos());
     return CallGetter(primary->token_pos(), receiver, funcname);
   }
   UNREACHABLE();
   return NULL;
 }
 
 
+AstNode* Parser::LoadTypeParameter(PrimaryNode* primary) {
+  const TokenPosition primary_pos = primary->token_pos();
+  TypeParameter& type_parameter = TypeParameter::ZoneHandle(Z);
+  type_parameter = TypeParameter::Cast(primary->primary()).raw();
+  if (type_parameter.IsClassTypeParameter()) {
+    if (ParsingStaticMember()) {
+      const String& name = String::Handle(Z, type_parameter.name());
+      ReportError(primary_pos,
+                  "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);
+    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, throw a type error.
+    Type& malformed_type = Type::ZoneHandle(Z);
+    malformed_type = ClassFinalizer::NewFinalizedMalformedType(
+        Error::Handle(Z),  // No previous error.
+        script_,
+        primary_pos,
+        "function type parameter '%s' not yet supported",
+        String::Handle(Z, type_parameter.name()).ToCString());
+    return ThrowTypeError(primary_pos, malformed_type);
+  }
+}
+
+
 AstNode* Parser::ParseSelectors(AstNode* primary, bool is_cascade) {
   AstNode* left = primary;
   while (true) {
     AstNode* selector = NULL;
     if ((CurrentToken() == Token::kPERIOD) ||
         (CurrentToken() == Token::kQM_PERIOD)) {
       // Unconditional or conditional property extraction or method call.
       bool is_conditional = CurrentToken() == Token::kQM_PERIOD;
       ConsumeToken();
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
-        const TokenPosition primary_pos = primary_node->token_pos();
         if (primary_node->primary().IsFunction()) {
           left = LoadClosure(primary_node);
         } else if (primary_node->primary().IsTypeParameter()) {
-          if (ParsingStaticMember()) {
-            const String& name = String::Handle(Z,
-                TypeParameter::Cast(primary_node->primary()).name());
-            ReportError(primary_pos,
-                        "cannot access type parameter '%s' "
-                        "from static function",
-                        name.ToCString());
-          }
-          if (FunctionLevel() > 0) {
-            // Make sure that the instantiator is captured.
-            CaptureInstantiator();
-          }
-          TypeParameter& type_parameter = TypeParameter::ZoneHandle(Z);
-          type_parameter ^= ClassFinalizer::FinalizeType(
-              current_class(),
-              TypeParameter::Cast(primary_node->primary()),
-              ClassFinalizer::kCanonicalize);
-          ASSERT(!type_parameter.IsMalformed());
-          left = new(Z) TypeNode(primary->token_pos(), type_parameter);
+          left = LoadTypeParameter(primary_node);
         } else {
           // Super field access handled in ParseSuperFieldAccess(),
           // super calls handled in ParseSuperCall().
           ASSERT(!primary_node->IsSuper());
           left = LoadFieldIfUnresolved(left);
         }
       }
       const TokenPosition ident_pos = TokenPos();
       String* ident = ExpectIdentifier("identifier expected");
       if (IsArgumentPart()) {
         // Identifier followed by optional type arguments and opening paren:
         // method call.
         if (CurrentToken() == Token::kLT) {
           // Type arguments.
           if (!FLAG_generic_method_syntax) {
             ReportError("generic type arguments not supported.");
           }
-          // TODO(hausner): handle type arguments.
-          ParseTypeArguments(ClassFinalizer::kIgnore);
+          // TODO(regis): Pass type arguments in generic call.
+          // For now, resolve type arguments and ignore.
+          ParseTypeArguments(ClassFinalizer::kCanonicalize);
         }
         if (left->IsPrimaryNode() &&
             left->AsPrimaryNode()->primary().IsClass()) {
           // Static method call prefixed with class name.
           const Class& cls = Class::Cast(left->AsPrimaryNode()->primary());
           selector = ParseStaticCall(cls, *ident, ident_pos);
         } else {
           selector = ParseInstanceCall(left, *ident, ident_pos, is_conditional);
         }
       } else {
@@ skipping 47 matching lines @@
           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 may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
           array = new(Z) TypeNode(primary_pos, type);
         } else if (primary_node->primary().IsTypeParameter()) {
-          if (ParsingStaticMember()) {
-            const String& name = String::ZoneHandle(Z,
-                TypeParameter::Cast(primary_node->primary()).name());
-            ReportError(primary_pos,
-                        "cannot access type parameter '%s' "
-                        "from static function",
-                        name.ToCString());
-          }
-          if (FunctionLevel() > 0) {
-            // Make sure that the instantiator is captured.
-            CaptureInstantiator();
-          }
-          TypeParameter& type_parameter = TypeParameter::ZoneHandle(Z);
-          type_parameter ^= ClassFinalizer::FinalizeType(
-              current_class(),
-              TypeParameter::Cast(primary_node->primary()),
-              ClassFinalizer::kCanonicalize);
-          ASSERT(!type_parameter.IsMalformed());
-          array = new(Z) TypeNode(primary_pos, type_parameter);
+          array = LoadTypeParameter(primary_node);
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       }
       selector =  new(Z) LoadIndexedNode(
           bracket_pos, array, index, Class::ZoneHandle(Z));
     } else if (IsArgumentPart()) {
       if (CurrentToken() == Token::kLT) {
         // Type arguments.
         if (!FLAG_generic_method_syntax) {
           ReportError("generic type arguments not supported.");
         }
-        // TODO(hausner): handle type arguments.
-        ParseTypeArguments(ClassFinalizer::kIgnore);
+        // TODO(regis): Pass type arguments in generic call.
+        // For now, resolve type arguments and ignore.
+        ParseTypeArguments(ClassFinalizer::kCanonicalize);
       }
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
         const TokenPosition primary_pos = primary_node->token_pos();
         if (primary_node->primary().IsFunction()) {
           const Function& func = Function::Cast(primary_node->primary());
           const String& func_name = String::ZoneHandle(Z, func.name());
           if (func.is_static()) {
             // Parse static function call.
             Class& cls = Class::Handle(Z, func.Owner());
@@ skipping 22 matching lines @@
             // The static call will be converted to throwing a NSM error.
             selector = ParseStaticCall(current_class(), name, primary_pos);
           } else {
             // Treat as call to unresolved (instance) method.
             selector = ParseInstanceCall(LoadReceiver(primary_pos),
                                          name,
                                          primary_pos,
                                          false /* is_conditional */);
           }
         } else if (primary_node->primary().IsTypeParameter()) {
-          const String& name = String::ZoneHandle(Z,
-              TypeParameter::Cast(primary_node->primary()).name());
-          if (ParsingStaticMember()) {
-            // Treat as this.T(), because T is in scope.
+          TypeParameter& type_parameter = TypeParameter::ZoneHandle(Z);
+          type_parameter = TypeParameter::Cast(primary_node->primary()).raw();
+          const String& name = String::ZoneHandle(Z, type_parameter.name());
+          if (type_parameter.IsClassTypeParameter()) {
+            if (ParsingStaticMember()) {
+                // Treat as this.T(), because T is in scope.
+                ReportError(primary_pos,
+                            "cannot access type parameter '%s' "
+                            "from static function",
+                            name.ToCString());
+            } else {
+              // Treat as call to unresolved (instance) method.
+              selector = ParseInstanceCall(LoadReceiver(primary_pos),
+                                           name,
+                                           primary_pos,
+                                           false /* is_conditional */);
+            }
+          } else {
+            ASSERT(type_parameter.IsFunctionTypeParameter());
+            // TODO(regis): Should we throw a type error instead?
             ReportError(primary_pos,
-                        "cannot access type parameter '%s' "
-                        "from static function",
+                        "illegal use of function type parameter '%s'",
                         name.ToCString());
-          } else {
-            // Treat as call to unresolved (instance) method.
-            selector = ParseInstanceCall(LoadReceiver(primary_pos),
-                                         name,
-                                         primary_pos,
-                                         false /* is_conditional */);
           }
         } 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 may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
           selector = new(Z) TypeNode(primary_pos, type);
@@ skipping 17 matching lines @@
         } 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 may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
           left = new(Z) TypeNode(primary_pos, type);
         } else if (primary_node->primary().IsTypeParameter()) {
-          if (ParsingStaticMember()) {
-            const String& name = String::ZoneHandle(Z,
-                TypeParameter::Cast(primary_node->primary()).name());
-            ReportError(primary_pos,
-                        "cannot access type parameter '%s' "
-                        "from static function",
-                        name.ToCString());
-          }
-          if (FunctionLevel() > 0) {
-            // Make sure that the instantiator is captured.
-            CaptureInstantiator();
-          }
-          TypeParameter& type_parameter = TypeParameter::ZoneHandle(Z);
-          type_parameter ^= ClassFinalizer::FinalizeType(
-              current_class(),
-              TypeParameter::Cast(primary_node->primary()),
-              ClassFinalizer::kCanonicalize);
-          ASSERT(!type_parameter.IsMalformed());
-          left = new(Z) TypeNode(primary_pos, type_parameter);
+          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 {
           UNREACHABLE();  // Internal parser error.
         }
       }
       // Done parsing selectors.
       return left;
@@ skipping 187 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 given type and its type arguments from the given scope class
-// according to the given type finalization mode.
-// If the given scope class is null, use the current library, but do not try to
-// resolve type parameters.
-// Not all involved type classes may get resolved yet, but at least the type
-// parameters of the given class will get resolved, thereby relieving the class
+// 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.
-void Parser::ResolveTypeFromClass(const Class& scope_class,
-                                  ClassFinalizer::FinalizationKind finalization,
-                                  AbstractType* type) {
+void Parser::ResolveType(ClassFinalizer::FinalizationKind finalization,
+                         AbstractType* type) {
   ASSERT(finalization >= ClassFinalizer::kResolveTypeParameters);
   ASSERT(type != NULL);
   if (type->IsResolved()) {
     return;
   }
   // Resolve 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_prefix() == LibraryPrefix::null()) {
-      if (!scope_class.IsNull()) {
-        // First check if the type is a type parameter of the given scope class.
-        const TypeParameter& type_parameter = TypeParameter::Handle(Z,
-            scope_class.LookupTypeParameter(unresolved_class_name));
+      // 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()) {
-          // A type parameter is considered to be a malformed type when
-          // referenced by a static member.
-          if (ParsingStaticMember()) {
-            ASSERT(scope_class.raw() == current_class().raw());
-            *type = ClassFinalizer::NewFinalizedMalformedType(
-                Error::Handle(Z),  // No previous error.
-                script_,
-                type->token_pos(),
-                "type parameter '%s' cannot be referenced "
-                "from static member",
-                String::Handle(Z, type_parameter.name()).ToCString());
-            return;
-          }
-          // A type parameter cannot be parameterized, so make the type
-          // malformed if type arguments have previously been parsed.
-          if (type->arguments() != TypeArguments::null()) {
-            *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();
+          // TODO(regis): Check for absence of type arguments.
+          // For now, return as malformed type.
+          Type& malformed_type = Type::ZoneHandle(Z);
+          malformed_type = ClassFinalizer::NewFinalizedMalformedType(
+              Error::Handle(Z),  // No previous error.
+              script_,
+              type->token_pos(),
+              "function type parameter '%s' not yet supported",
+              String::Handle(Z, type_parameter.name()).ToCString());
+          *type = malformed_type.raw();
           return;
         }
       }
+      // Then check if the type is a class type parameter.
+      const TypeParameter& type_parameter = TypeParameter::Handle(Z,
+          current_class().LookupTypeParameter(unresolved_class_name));
+      if (!type_parameter.IsNull()) {
+        // A type parameter is considered to be a malformed type when
+        // referenced by a static member.
+        if (ParsingStaticMember()) {
+          *type = ClassFinalizer::NewFinalizedMalformedType(
+              Error::Handle(Z),  // No previous error.
+              script_,
+              type->token_pos(),
+              "type parameter '%s' cannot be referenced "
+              "from static member",
+              String::Handle(Z, type_parameter.name()).ToCString());
+          return;
+        }
+        // A type parameter cannot be parameterized, so make the type
+        // malformed if type arguments have previously been parsed.
+        if (type->arguments() != TypeArguments::null()) {
+          *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.
       if (finalization > ClassFinalizer::kResolveTypeParameters) {
         resolved_type_class = library_.LookupClass(unresolved_class_name);
       }
     } else {
       // Resolve class name in the scope of the library prefix.
       const LibraryPrefix& lib_prefix =
           LibraryPrefix::Handle(Z, unresolved_class.library_prefix());
@@ skipping 15 matching lines @@
     }
   }
   // 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);
-      ResolveTypeFromClass(scope_class, finalization, &type_argument);
+      ResolveType(finalization, &type_argument);
       arguments.SetTypeAt(i, type_argument);
     }
   }
 }
 
 
 LocalVariable* Parser::LookupLocalScope(const String& ident) {
   if (current_block_ == NULL) {
     return NULL;
   }
@@ skipping 261 matching lines @@
     return TryCanonicalize(instance, TokenPos());
   }
 }
 
 
 // Do a lookup for the identifier in the block scope and the class scope
 // return true if the identifier is found, false otherwise.
 // If node is non NULL return an AST node corresponding to the identifier.
 bool Parser::ResolveIdentInLocalScope(TokenPosition ident_pos,
                                       const String &ident,
-                                      AstNode** node) {
+                                      AstNode** node,
+                                      intptr_t* function_level) {
   TRACE_PARSER("ResolveIdentInLocalScope");
   // First try to find the identifier in the nested local scopes.
   LocalVariable* local = LookupLocalScope(ident);
   if (current_block_ != NULL) {
     current_block_->scope->AddReferencedName(ident_pos, ident);
   }
   if (local != NULL) {
     if (node != NULL) {
       *node = new(Z) LoadLocalNode(ident_pos, local);
     }
+    if (function_level != NULL) {
+      *function_level = local->owner()->function_level();
+    }
     return true;
   }
 
   // If we are compiling top-level code, we don't need to look for
   // the identifier in the current (top-level) class. The class scope
   // of the top-level class is part of the library scope.
   if (current_class().IsTopLevel()) {
     if (node != NULL) {
       *node = NULL;
     }
@@ skipping 16 matching lines @@
   field = cls.LookupField(ident);
   if (!field.IsNull()) {
     if (node != NULL) {
       if (!field.is_static()) {
         CheckInstanceFieldAccess(ident_pos, ident);
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       } else {
         *node = GenerateStaticFieldLookup(field, ident_pos);
       }
     }
+    if (function_level != NULL) {
+      *function_level = 0;
+    }
     return true;
   }
 
   // Check if an instance/static function exists.
   func = cls.LookupFunction(ident);
   if (!func.IsNull() &&
       (func.IsDynamicFunction() ||
       func.IsStaticFunction() ||
       func.is_abstract())) {
     if (node != NULL) {
@@ skipping 168 matching lines @@
 // If the name cannot be resolved, turn it into an instance field access
 // if we're compiling an instance method, or generate
 // throw NoSuchMethodError if we're compiling a static method.
 AstNode* Parser::ResolveIdent(TokenPosition ident_pos,
                               const String& ident,
                               bool allow_closure_names) {
   TRACE_PARSER("ResolveIdent");
   // First try to find the variable in the local scope (block scope or
   // class scope).
   AstNode* resolved = NULL;
-  ResolveIdentInLocalScope(ident_pos, ident, &resolved);
+  intptr_t resolved_func_level = 0;
+  ResolveIdentInLocalScope(ident_pos, ident, &resolved, &resolved_func_level);
+  if (!innermost_function().IsNull()) {
+    // TODO(regis): Shortcut this lookup if no generic functions in scope.
+    intptr_t type_param_func_level = FunctionLevel();
+    const TypeParameter& type_parameter = TypeParameter::ZoneHandle(Z,
+        innermost_function().LookupTypeParameter(ident,
+                                                 &type_param_func_level));
+    if (!type_parameter.IsNull()) {
+      if ((resolved == NULL) || (resolved_func_level < type_param_func_level)) {
+        // The identifier is a function type parameter, possibly shadowing
+        // 'resolved'.
+        if (type_param_func_level < FunctionLevel()) {
+          // Make sure that the function instantiator is captured.
+          CaptureFunctionInstantiator();
+        }
+        // TODO(regis): Finalize type parameter and return as type node.
+        // For now, return as malformed type.
+        Type& malformed_type = Type::ZoneHandle(Z);
+        malformed_type = ClassFinalizer::NewFinalizedMalformedType(
+            Error::Handle(Z),  // No previous error.
+            script_,
+            ident_pos,
+            "function type parameter '%s' not yet supported",
+            ident.ToCString());
+        return new(Z) TypeNode(ident_pos, malformed_type);
+      }
+    }
+  }
   if (resolved == NULL) {
-    // Check whether the identifier is a type parameter.
+    // 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 instantiator is captured.
+          // Make sure that the class instantiator is captured.
           CaptureInstantiator();
         }
         type_parameter ^= ClassFinalizer::FinalizeType(
             current_class(), type_parameter, ClassFinalizer::kCanonicalize);
         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
@@ skipping 107 matching lines @@
           script_,
           ident_pos,
           "qualified name '%s' does not refer to a type",
           qualified_name.ToCString());
     }
 
     // If parsing inside a local scope, check whether the type name
     // is shadowed by a local declaration.
     if (!is_top_level_ &&
         (prefix->IsNull()) &&
-        ResolveIdentInLocalScope(ident_pos, type_name, NULL)) {
+        ResolveIdentInLocalScope(ident_pos, type_name, NULL, NULL)) {
       // The type is malformed. Skip over its type arguments.
       ParseTypeArguments(ClassFinalizer::kIgnore);
       return ClassFinalizer::NewFinalizedMalformedType(
           Error::Handle(Z),  // No previous error.
           script_,
           ident_pos,
           "using '%s' in this context is invalid",
           type_name.ToCString());
     }
     if ((!FLAG_load_deferred_eagerly || !allow_deferred_type) &&
@@ skipping 30 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) {
-    ResolveTypeFromClass(current_class(), finalization, &type);
+    ResolveType(finalization, &type);
     if (finalization >= ClassFinalizer::kCanonicalize) {
       type ^= ClassFinalizer::FinalizeType(current_class(), type, finalization);
     }
   }
   return type.raw();
 }
 
 
 void Parser::CheckConstructorCallTypeArguments(
     TokenPosition pos, const Function& constructor,
@@ skipping 1181 matching lines @@
       if (CurrentToken() == Token::kHASH) {
         // Closurization of top-level entity in prefix scope.
         return new(Z) LiteralNode(qual_ident_pos, prefix);
       } else {
         ExpectToken(Token::kPERIOD);
       }
     }
     String& ident = *CurrentLiteral();
     ConsumeToken();
     if (prefix.IsNull()) {
-      if (!ResolveIdentInLocalScope(qual_ident_pos, ident, &primary)) {
+      intptr_t primary_func_level = 0;
+      ResolveIdentInLocalScope(
+          qual_ident_pos, ident, &primary, &primary_func_level);
+      // Check whether the identifier is shadowed by a function type parameter.
+      if (!innermost_function().IsNull()) {
+        // TODO(regis): Shortcut this lookup if no generic functions in scope.
+        intptr_t type_param_func_level = FunctionLevel();
+        TypeParameter& type_param = TypeParameter::ZoneHandle(Z,
+            innermost_function().LookupTypeParameter(ident,
+                                                     &type_param_func_level));
+        if (!type_param.IsNull()) {
+          if ((primary == NULL) ||
+              (primary_func_level < type_param_func_level)) {
+            // The identifier is a function type parameter, possibly shadowing
+            // already resolved 'primary'.
+            if (type_param_func_level < FunctionLevel()) {
+              // Make sure that the function instantiator is captured.
+              CaptureFunctionInstantiator();
+            }
+            return new(Z) PrimaryNode(qual_ident_pos, type_param);
+          }
+        }
+      }
+      if (primary == NULL) {
         // Check whether the identifier is a type parameter.
         if (!current_class().IsNull()) {
           TypeParameter& type_param = TypeParameter::ZoneHandle(Z,
               current_class().LookupTypeParameter(ident));
           if (!type_param.IsNull()) {
             return new(Z) PrimaryNode(qual_ident_pos, type_param);
           }
         }
         // This is a non-local unqualified identifier so resolve the
         // identifier locally in the main app library and all libraries
@@ skipping 675 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