Implement generic function type syntax in the VM (fixes #27966).

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 45 matching lines @@
             "Enable conditional directives");
 DEFINE_FLAG(bool, generic_method_syntax, true, "Enable generic functions.");
 DEFINE_FLAG(bool,
             initializing_formal_access,
             true,
             "Make initializing formal parameters visible in initializer list.");
 DEFINE_FLAG(bool,
             warn_super,
             false,
             "Warning if super initializer not last in initializer list.");
-DEFINE_FLAG(bool, warn_patch, false, "Warn on old-style patch syntax.");
 DEFINE_FLAG(
     bool,
     await_is_keyword,
     false,
     "await and yield are treated as proper keywords in synchronous code.");
 DEFINE_FLAG(bool,
             assert_initializer,
             false,
             "Allow asserts in initializer lists.");
 
@@ skipping 911 matching lines @@
     Thread* thread = Thread::Current();
     StackZone stack_zone(thread);
     Zone* zone = stack_zone.GetZone();
     const Script& script = Script::Handle(zone, func.script());
     const Class& owner = Class::Handle(zone, func.Owner());
     ASSERT(!owner.IsNull());
     ParsedFunction* parsed_function =
         new ParsedFunction(thread, Function::ZoneHandle(zone, func.raw()));
     Parser parser(script, parsed_function, func.token_pos());
     parser.SkipFunctionPreamble();
+    const bool use_function_type_syntax = false;
+    const bool allow_explicit_default_values = true;
+    const bool evaluate_metadata = true;
     ParamList params;
-    parser.ParseFormalParameterList(true, true, &params);
+    parser.ParseFormalParameterList(use_function_type_syntax,
+                                    allow_explicit_default_values,
+                                    evaluate_metadata, &params);
     ParamDesc* param = params.parameters->data();
     const int param_cnt =
         params.num_fixed_parameters + params.num_optional_parameters;
     const Array& param_descriptor =
         Array::Handle(Array::New(param_cnt * kParameterEntrySize, Heap::kOld));
     for (int i = 0, j = 0; i < param_cnt; i++, j += kParameterEntrySize) {
       param_descriptor.SetAt(j + kParameterIsFinalOffset,
                              param[i].is_final ? Bool::True() : Bool::False());
       param_descriptor.SetAt(j + kParameterDefaultValueOffset,
                              (param[i].default_value == NULL)
@@ skipping 34 matching lines @@
   }
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     const Script& script = Script::Handle(func.script());
     const Class& owner = Class::Handle(func.Owner());
     ASSERT(!owner.IsNull());
     ParsedFunction* parsed_function =
         new ParsedFunction(Thread::Current(), Function::ZoneHandle(func.raw()));
     Parser parser(script, parsed_function, func.token_pos());
     parser.SkipFunctionPreamble();
-    parser.ParseFormalParameterList(true, true, params);
+    const bool use_function_type_syntax = false;
+    const bool allow_explicit_default_values = true;
+    const bool evaluate_metadata = true;
+    parser.ParseFormalParameterList(use_function_type_syntax,
+                                    allow_explicit_default_values,
+                                    evaluate_metadata, params);
     return true;
   } else {
     Thread::Current()->clear_sticky_error();
     params->Clear();
     return false;
   }
   UNREACHABLE();
   return false;
 }
 
@@ skipping 286 matching lines @@
   }
   // The instantiator is not required in a static expression.
   ASSERT(!parser.IsInstantiatorRequired());
 
   return parsed_function;
 }
 
 
 SequenceNode* Parser::ParseStaticFinalGetter(const Function& func) {
   TRACE_PARSER("ParseStaticFinalGetter");
-  ParamList params;
   ASSERT(func.num_fixed_parameters() == 0);  // static.
   ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
-
-  // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
-  AddFormalParamsToScope(&params, current_block_->scope);
-
   TokenPosition ident_pos = TokenPos();
   const String& field_name = *ExpectIdentifier("field name expected");
   const Class& field_class = Class::Handle(Z, func.Owner());
   const Field& field =
       Field::ZoneHandle(Z, field_class.LookupStaticField(field_name));
   ASSERT(!field.IsNull());
 
   // Static final fields must have an initializer.
   ExpectToken(Token::kASSIGN);
 
@@ skipping 173 matching lines @@
   const Function& parent = Function::Handle(func.parent_function());
   if (parent.IsImplicitSetterFunction()) {
     const TokenPosition ident_pos = func.token_pos();
     ASSERT(IsIdentifier());
     params.AddFinalParameter(ident_pos, &Symbols::Value(),
                              &Object::dynamic_type());
     ASSERT(func.num_fixed_parameters() == 2);  // closure, value.
   } else if (!parent.IsGetterFunction() && !parent.IsImplicitGetterFunction()) {
     // NOTE: For the `kernel -> flowgraph` we don't use the parser.
     if (parent.kernel_function() == NULL) {
+      SkipFunctionPreamble();
+      const bool use_function_type_syntax = false;
       const bool allow_explicit_default_values = true;
-      SkipFunctionPreamble();
-      ParseFormalParameterList(allow_explicit_default_values, false, &params);
+      const bool evaluate_metadata = false;
+      ParseFormalParameterList(use_function_type_syntax,
+                               allow_explicit_default_values, evaluate_metadata,
+                               &params);
+      FinalizeFormalParameterTypes(&params);
       SetupDefaultsForOptionalParams(params);
     }
   }
 
   // Populate function scope with the formal parameters.
   LocalScope* scope = current_block_->scope;
   AddFormalParamsToScope(&params, scope);
 
   ArgumentListNode* func_args = new ArgumentListNode(token_pos);
   if (!func.is_static()) {
@@ skipping 354 matching lines @@
 
 // Skips tokens up to and including matching closing parenthesis.
 void Parser::SkipToMatchingParenthesis() {
   ASSERT(CurrentToken() == Token::kLPAREN);
   SkipToMatching();
   ASSERT(CurrentToken() == Token::kRPAREN);
   ConsumeToken();
 }
 
 
-void Parser::ParseFormalParameter(bool allow_explicit_default_value,
+void Parser::ParseFormalParameter(bool use_function_type_syntax,

[hausner, 2017/01/18 18:54:53]

I'd consider to duplicate this function and separate the new syntax into it's
own function. That way, meddling with future language changes and fixing bugs
will be much easier.

[regis, 2017/01/18 20:24:24]

Agreed. I have added a TODO.

+                                  bool allow_explicit_default_value,
                                   bool evaluate_metadata,
                                   ParamList* params) {
   TRACE_PARSER("ParseFormalParameter");
   ParamDesc parameter;
   bool var_seen = false;
   bool final_seen = false;
   bool this_seen = false;
 
-  if (evaluate_metadata && (CurrentToken() == Token::kAT)) {
-    parameter.metadata = &Array::ZoneHandle(Z, EvaluateMetadata());
+  if (use_function_type_syntax) {
+    parameter.has_explicit_type = true;  // The type is required by the syntax.
+    // 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, ParseTypeOrFunctionType(false, ClassFinalizer::kDoNotResolve));
   } else {
-    SkipMetadata();
-  }
-
-  if (CurrentToken() == Token::kCOVARIANT &&
-      (LookaheadToken(1) == Token::kFINAL || LookaheadToken(1) == Token::kVAR ||
-       Token::IsIdentifier(LookaheadToken(1)))) {
-    parameter.is_covariant = true;
-    ConsumeToken();
-  }
-  if (CurrentToken() == Token::kFINAL) {
-    ConsumeToken();
-    final_seen = true;
-    parameter.is_final = true;
-  } else if (CurrentToken() == Token::kVAR) {
-    ConsumeToken();
-    var_seen = true;
-    // The parameter type is the 'dynamic' type.
-    // 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 (CurrentToken() == Token::kTHIS) {
-    ConsumeToken();
-    ExpectToken(Token::kPERIOD);
-    this_seen = true;
-    parameter.is_field_initializer = true;
-    if (FLAG_initializing_formal_access) {
+    if (evaluate_metadata && (CurrentToken() == Token::kAT)) {
+      parameter.metadata = &Array::ZoneHandle(Z, EvaluateMetadata());
+    } else {
+      SkipMetadata();
+    }
+    if (CurrentToken() == Token::kCOVARIANT &&
+        (LookaheadToken(1) == Token::kFINAL ||
+         LookaheadToken(1) == Token::kVAR ||
+         Token::IsIdentifier(LookaheadToken(1)))) {
+      parameter.is_covariant = true;
+      ConsumeToken();
+    }
+    if (CurrentToken() == Token::kFINAL) {
+      ConsumeToken();
+      final_seen = true;
       parameter.is_final = true;
-    }
-  }
-  if ((parameter.type == NULL) && (CurrentToken() == Token::kVOID)) {
-    ConsumeToken();
-    // This must later be changed to a closure type if we recognize
-    // a closure/function type parameter. We check this at the end
-    // of ParseFormalParameter.
-    parameter.type = &Object::void_type();
-  }
-  if (parameter.type == NULL) {
-    // At this point, we must see an identifier for the type or the
-    // function parameter.
-    if (!IsIdentifier()) {
-      ReportError("parameter name or type expected");
-    }
-
-    // Lookahead to determine whether the next tokens are a return type
-    // followed by a parameter name.
-    bool found_type = false;
-    {
-      TokenPosScope saved_pos(this);
-      if (TryParseReturnType()) {
-        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(ClassFinalizer::kDoNotResolve));
-    } else {
+    } else if (CurrentToken() == Token::kVAR) {
+      ConsumeToken();
+      var_seen = true;
+      // The parameter type is the 'dynamic' type.
       // 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;
-    parameter.is_field_initializer = true;
-    if (FLAG_initializing_formal_access) {
-      parameter.is_final = true;
+    if (CurrentToken() == Token::kTHIS) {
+      ConsumeToken();
+      ExpectToken(Token::kPERIOD);
+      this_seen = true;
+      parameter.is_field_initializer = true;
+      if (FLAG_initializing_formal_access) {
+        parameter.is_final = true;
+      }
+    }
+    if ((parameter.type == NULL) && (CurrentToken() == Token::kVOID)) {
+      ConsumeToken();
+      // This must later be changed to a closure type if we recognize
+      // a closure/function type parameter. We check this at the end
+      // of ParseFormalParameter.
+      parameter.type = &Object::void_type();
+    }
+    if (parameter.type == NULL) {
+      // At this point, we must see an identifier for the type or the
+      // function parameter. The identifier may be 'Function'.
+      if (!IsIdentifier()) {
+        ReportError("parameter name or type expected");
+      }
+
+      // Lookahead to determine whether the next tokens are a return type
+      // followed by a parameter name.
+      bool found_type = false;
+      {
+        TokenPosScope saved_pos(this);
+        if (TryParseType(true)) {
+          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, ParseTypeOrFunctionType(true, 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;
+      parameter.is_field_initializer = true;
+      if (FLAG_initializing_formal_access) {
+        parameter.is_final = true;
+      }
     }
   }
 
-  // At this point, we must see an identifier for the parameter name.
-  parameter.name_pos = TokenPos();
-  parameter.name = ExpectIdentifier("parameter name expected");
-  if (parameter.is_field_initializer) {
-    params->has_field_initializer = true;
+  // At this point, we must see an identifier for the parameter name, unless
+  // we are using the function type syntax (in which case the name is optional,
+  // unless we expect optional named parameters).
+  if (IsIdentifier()) {
+    parameter.name_pos = TokenPos();
+    parameter.name = CurrentLiteral();
+    ConsumeToken();
+    if (parameter.is_field_initializer) {
+      ASSERT(!use_function_type_syntax);
+      params->has_field_initializer = true;
+    }
+
+    if (params->has_optional_named_parameters &&
+        (parameter.name->CharAt(0) == Library::kPrivateIdentifierStart)) {
+      ReportError(parameter.name_pos, "named parameter must not be private");
+    }
+
+    // Check for duplicate formal parameters.
+    const intptr_t num_existing_parameters =
+        params->num_fixed_parameters + params->num_optional_parameters;
+    for (intptr_t i = 0; i < num_existing_parameters; i++) {
+      ParamDesc& existing_parameter = (*params->parameters)[i];
+      if (existing_parameter.name->Equals(*parameter.name)) {
+        ReportError(parameter.name_pos, "duplicate formal parameter '%s'",
+                    parameter.name->ToCString());
+      }
+    }
+  } else if (!use_function_type_syntax ||
+             params->has_optional_named_parameters) {
+    ExpectIdentifier("parameter name expected");
+  } else {
+    parameter.name_pos = TokenPos();
+    parameter.name = &Symbols::NotNamed();
   }
 
-  if (params->has_optional_named_parameters &&
-      (parameter.name->CharAt(0) == Library::kPrivateIdentifierStart)) {
-    ReportError(parameter.name_pos, "named parameter must not be private");
-  }
-
-  // Check for duplicate formal parameters.
-  const intptr_t num_existing_parameters =
-      params->num_fixed_parameters + params->num_optional_parameters;
-  for (intptr_t i = 0; i < num_existing_parameters; i++) {
-    ParamDesc& existing_parameter = (*params->parameters)[i];
-    if (existing_parameter.name->Equals(*parameter.name)) {
-      ReportError(parameter.name_pos, "duplicate formal parameter '%s'",
-                  parameter.name->ToCString());
-    }
-  }
-
-  if (IsParameterPart()) {
+  // The function type syntax does not allow the signature type syntax.
+  if (!use_function_type_syntax && 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.
       AbstractType& result_type =
@@ skipping 11 matching lines @@
       innermost_function_ = signature_function.raw();
 
       // Finish parsing the function type parameter.
       if (CurrentToken() == Token::kLT) {
         if (!FLAG_generic_method_syntax) {
           ReportError("generic function types not supported");
         }
         ParseTypeParameters(false);  // Not parameterizing class, but function.
       }
 
-      // Now that type parameters are declared, the result type can be resolved.
-      ResolveType(is_top_level_ ? ClassFinalizer::kResolveTypeParameters
-                                : ClassFinalizer::kCanonicalize,
-                  &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);
+      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);
       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());
-      if (!is_top_level_) {
-        signature_type ^= ClassFinalizer::FinalizeType(
-            current_class(), signature_type, ClassFinalizer::kCanonicalize);
-        // Do not refer to signature_function anymore, since it may have been
-        // replaced during canonicalization.
-        signature_function = Function::null();
-      }
-      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());
-      if (is_top_level_) {
-        ResolveType(ClassFinalizer::kResolveTypeParameters, &type);
-      } else {
-        ResolveType(ClassFinalizer::kCanonicalize, &type);
-        type = ClassFinalizer::FinalizeType(current_class(), 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 28 matching lines @@
     parameter.is_final = true;
   }
   params->parameters->Add(parameter);
   if (parameter.is_covariant) {
     params->has_covariant = true;
   }
 }
 
 
 // Parses a sequence of normal or optional formal parameters.
-void Parser::ParseFormalParameters(bool allow_explicit_default_values,
+void Parser::ParseFormalParameters(bool use_function_type_syntax,
+                                   bool allow_explicit_default_values,
                                    bool evaluate_metadata,
                                    ParamList* params) {
   TRACE_PARSER("ParseFormalParameters");
   // Optional parameter lists cannot be empty.
   // The completely empty parameter list is handled before getting here.
   bool has_seen_parameter = false;
   do {
     ConsumeToken();
     if (!params->has_optional_positional_parameters &&
         !params->has_optional_named_parameters &&
@@ skipping 11 matching lines @@
     }
     Token::Kind terminator = params->has_optional_positional_parameters
                                  ? Token::kRBRACK
                                  : params->has_optional_named_parameters
                                        ? Token::kRBRACE
                                        : Token::kRPAREN;
     if (has_seen_parameter && CurrentToken() == terminator) {
       // Allow a trailing comma.
       break;
     }
-    ParseFormalParameter(allow_explicit_default_values, evaluate_metadata,
+    ParseFormalParameter(use_function_type_syntax,
+                         allow_explicit_default_values, evaluate_metadata,
                          params);
     has_seen_parameter = true;
   } while (CurrentToken() == Token::kCOMMA);
 }
 
 
-void Parser::ParseFormalParameterList(bool allow_explicit_default_values,
+void Parser::ParseFormalParameterList(bool use_function_type_syntax,
+                                      bool allow_explicit_default_values,
                                       bool evaluate_metadata,
                                       ParamList* params) {
   TRACE_PARSER("ParseFormalParameterList");
   ASSERT(CurrentToken() == Token::kLPAREN);
 
   if (LookaheadToken(1) != Token::kRPAREN) {
     // Parse fixed parameters.
-    ParseFormalParameters(allow_explicit_default_values, evaluate_metadata,
+    ParseFormalParameters(use_function_type_syntax,
+                          allow_explicit_default_values, evaluate_metadata,
                           params);
     if (params->has_optional_positional_parameters ||
         params->has_optional_named_parameters) {
       // Parse optional parameters.
-      ParseFormalParameters(allow_explicit_default_values, evaluate_metadata,
+      ParseFormalParameters(use_function_type_syntax,
+                            allow_explicit_default_values, evaluate_metadata,
                             params);
       if (params->has_optional_positional_parameters) {
         CheckToken(Token::kRBRACK, "',' or ']' expected");
       } else {
         CheckToken(Token::kRBRACE, "',' or '}' expected");
       }
       ConsumeToken();  // ']' or '}'.
     }
     if ((CurrentToken() != Token::kRPAREN) &&
         !params->has_optional_positional_parameters &&
@@ skipping 935 matching lines @@
     // The parser adds an implicit default constructor when a class
     // does not have any explicit constructor or factory (see
     // Parser::AddImplicitConstructor).
     // There is no source text to parse. We just build the
     // sequence node by hand.
     return MakeImplicitConstructor(func);
   }
 
   OpenFunctionBlock(func);
   ParamList params;
-  const bool allow_explicit_default_values = true;
   ASSERT(CurrentToken() == Token::kLPAREN);
 
   // Add implicit receiver parameter which is passed the allocated
   // but uninitialized instance to construct.
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(current_class()), func.token_pos());
 
   if (func.is_const()) {
     params.SetImplicitlyFinal();
   }
-  ParseFormalParameterList(allow_explicit_default_values, false, &params);
+  const bool use_function_type_syntax = false;
+  const bool allow_explicit_default_values = true;
+  const bool evaluate_metadata = false;
+  ParseFormalParameterList(use_function_type_syntax,
+                           allow_explicit_default_values, evaluate_metadata,
+                           &params);
+  FinalizeFormalParameterTypes(&params);
 
   SetupDefaultsForOptionalParams(params);
   ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
-  ASSERT(func.NumParameters() == params.parameters->length());
 
   // Now populate function scope with the formal parameters.
   AddFormalParamsToScope(&params, current_block_->scope);
 
   const bool is_redirecting_constructor =
       (CurrentToken() == Token::kCOLON) &&
       ((LookaheadToken(1) == Token::kTHIS) &&
        ((LookaheadToken(2) == Token::kLPAREN) ||
         ((LookaheadToken(2) == Token::kPERIOD) &&
          (LookaheadToken(4) == Token::kLPAREN))));
@@ skipping 157 matching lines @@
     // The first parameter of a factory is the TypeArguments vector of
     // the type of the instance to be allocated.
     params.AddFinalParameter(TokenPos(), &Symbols::TypeArgumentsParameter(),
                              &Object::dynamic_type());
   }
   // Expect the parameter list unless this is a getter function, or the
   // body closure of an async or generator getter function.
   ASSERT((CurrentToken() == Token::kLPAREN) || func.IsGetterFunction() ||
          (func.is_generated_body() &&
           Function::Handle(func.parent_function()).IsGetterFunction()));
-  const bool allow_explicit_default_values = true;
   if (func.IsGetterFunction()) {
     // Populate function scope with the formal parameters. Since in this case
     // we are compiling a getter this will at most populate the receiver.
     AddFormalParamsToScope(&params, current_block_->scope);
   } else if (func.IsAsyncClosure()) {
     AddAsyncClosureParameters(&params);
     SetupDefaultsForOptionalParams(params);
     AddFormalParamsToScope(&params, current_block_->scope);
     ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
     ASSERT(func.NumParameters() == params.parameters->length());
@@ skipping 20 matching lines @@
     AddFormalParamsToScope(&params, current_block_->scope);
     ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
     ASSERT(func.NumParameters() == params.parameters->length());
     if (!Function::Handle(func.parent_function()).IsGetterFunction()) {
       // Skip formal parameters. They are accessed as context variables.
       // Parsing them again (and discarding them) does not work in case of
       // default values with same name as already parsed formal parameter.
       SkipToMatchingParenthesis();
     }
   } else {
-    ParseFormalParameterList(allow_explicit_default_values, false, &params);
+    const bool use_function_type_syntax = false;
+    const bool allow_explicit_default_values = true;
+    const bool evaluate_metadata = false;
+    ParseFormalParameterList(use_function_type_syntax,
+                             allow_explicit_default_values, evaluate_metadata,
+                             &params);
+    if (!is_top_level_) {
+      FinalizeFormalParameterTypes(&params);
+    }
 
     // The number of parameters and their type are not yet set in local
     // functions, since they are not 'top-level' parsed.
     // However, they are already set when the local function is compiled, since
     // the local function was parsed when its parent was compiled.
     if (func.parameter_types() == Object::empty_array().raw()) {
       AddFormalParamsToFunction(&params, func);
     }
+    ResolveSignature(ClassFinalizer::kResolveTypeParameters, func);
+    if (!is_top_level_) {
+      ClassFinalizer::FinalizeSignature(current_class(), func);
+    }
     SetupDefaultsForOptionalParams(params);
     ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
-    ASSERT(func.NumParameters() == params.parameters->length());
 
     // Populate function scope with the formal parameters.
     AddFormalParamsToScope(&params, current_block_->scope);
 
     if (I->type_checks() && (FunctionLevel() > 0)) {
       // We are parsing, but not compiling, a local function.
       // The instantiator may be required at run time for generic type checks.
       if (IsInstantiatorRequired()) {
         // Make sure that the receiver of the enclosing instance function
         // (or implicit first parameter of an enclosing factory) is marked as
@@ skipping 284 matching lines @@
     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");
     }
     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.
   if (!method->has_static || method->IsConstructor()) {
     method->params.AddReceiver(ReceiverType(current_class()), formal_param_pos);
   } else if (method->IsFactory()) {
     method->params.AddFinalParameter(formal_param_pos,
                                      &Symbols::TypeArgumentsParameter(),
                                      &Object::dynamic_type());
   }
-  if (are_implicitly_final) {
+  if (method->has_const) {
     method->params.SetImplicitlyFinal();
   }
   if (!method->IsGetter()) {
-    ParseFormalParameterList(allow_explicit_default_values, false,
+    const bool use_function_type_syntax = false;
+    const bool allow_explicit_default_values = true;
+    const bool evaluate_metadata = false;
+    ParseFormalParameterList(use_function_type_syntax,
+                             allow_explicit_default_values, evaluate_metadata,
                              &method->params);
   }
 
   // Now that we know the parameter list, we can distinguish between the
   // unary and binary operator -.
   if (method->has_operator) {
     if ((method->operator_token == Token::kSUB) &&
         (method->params.num_fixed_parameters == 1)) {
       // Patch up name for unary operator - so it does not clash with the
       // name for binary operator -.
@@ skipping 223 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);
+  func.set_result_type(*method->type);  // May set parent_function in 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
     // the one in the patched class.
     method->metadata_pos = TokenPosition::kNoSource;
   }
   if (FLAG_enable_mirrors && (method->metadata_pos.IsReal())) {
     library_.AddFunctionMetadata(func, method->metadata_pos);
   }
   if (method->has_native) {
     func.set_native_name(*native_name);
   }
 
   // If this method is a redirecting factory, set the redirection information.
   if (!redirection_type.IsNull()) {
     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();
+  ResolveSignature(ClassFinalizer::kResolveTypeParameters, func);
   members->AddFunction(func);
 }
 
 
 void Parser::ParseFieldDefinition(ClassDesc* members, MemberDesc* field) {
   TRACE_PARSER("ParseFieldDefinition");
   // The parser has read the first field name and is now at the token
   // after the field name.
   ASSERT(CurrentToken() == Token::kSEMICOLON ||
          CurrentToken() == Token::kCOMMA || CurrentToken() == Token::kASSIGN);
@@ skipping 119 matching lines @@
                              /* is_abstract = */ false,
                              /* is_external = */ false,
                              /* is_native = */ false, current_class(),
                              field->name_pos);
       ParamList params;
       ASSERT(current_class().raw() == getter.Owner());
       params.AddReceiver(ReceiverType(current_class()), field->name_pos);
       getter.set_result_type(*field->type);
       getter.set_is_debuggable(false);
       AddFormalParamsToFunction(&params, getter);
+      ResolveSignature(ClassFinalizer::kResolveTypeParameters, getter);
       members->AddFunction(getter);
       if (!field->has_final) {
         // Build a setter accessor for non-const fields.
         String& setter_name =
             String::Handle(Z, Field::SetterSymbol(*field->name));
         setter = Function::New(setter_name, RawFunction::kImplicitSetter,
                                field->has_static, field->has_final,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                /* is_native = */ false, current_class(),
                                field->name_pos);
         ParamList params;
         ASSERT(current_class().raw() == setter.Owner());
         params.AddReceiver(ReceiverType(current_class()), field->name_pos);
         params.AddFinalParameter(TokenPos(), &Symbols::Value(), field->type);
         setter.set_result_type(Object::void_type());
         setter.set_is_debuggable(false);
         if (library_.is_dart_scheme() && library_.IsPrivate(*field->name)) {
           setter.set_is_reflectable(false);
         }
         AddFormalParamsToFunction(&params, setter);
+        ResolveSignature(ClassFinalizer::kResolveTypeParameters, setter);
         members->AddFunction(setter);
       }
     }
 
     if (CurrentToken() != Token::kCOMMA) {
       break;
     }
     ConsumeToken();
     field->name_pos = this->TokenPos();
     field->name = ExpectIdentifier("field name expected");
@@ skipping 100 matching lines @@
       ReportError("void not expected");
     }
     ConsumeToken();
     ASSERT(member.type == NULL);
     member.type = &Object::void_type();
   } else {
     bool found_type = false;
     {
       // Lookahead to determine whether the next tokens are a return type.
       TokenPosScope saved_pos(this);
-      if (TryParseReturnType()) {
+      if (TryParseType(true)) {
         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::kDoNotResolve));
+          Z, ParseTypeOrFunctionType(false, 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.
+    // Note that member.type may still be unresolved and may refer to not yet
+    // parsed function type parameters.
     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) {
@@ skipping 358 matching lines @@
                          /* is_static = */ false,
                          /* is_const = */ true,
                          /* is_abstract = */ false,
                          /* is_external = */ false,
                          /* is_native = */ false, cls, cls.token_pos());
   getter.set_result_type(int_type);
   getter.set_is_debuggable(false);
   ParamList params;
   params.AddReceiver(&Object::dynamic_type(), cls.token_pos());
   AddFormalParamsToFunction(&params, getter);
+  ResolveSignature(ClassFinalizer::kResolveTypeParameters, getter);
   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 94 matching lines @@
                               /* is_static = */ false,
                               /* is_const = */ true,
                               /* is_abstract = */ false,
                               /* is_external = */ false,
                               /* is_native = */ false, cls, cls.token_pos());
   name_getter.set_result_type(string_type);
   name_getter.set_is_debuggable(false);
   ParamList name_params;
   name_params.AddReceiver(&Object::dynamic_type(), cls.token_pos());
   AddFormalParamsToFunction(&name_params, name_getter);
+  ResolveSignature(ClassFinalizer::kResolveTypeParameters, name_getter);
   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 @@
   if (library_.is_dart_scheme() && library_.IsPrivate(ctor_name)) {
     ctor.set_is_reflectable(false);
   }
 
   ParamList params;
   // Add implicit 'this' parameter.
   const AbstractType* receiver_type = ReceiverType(cls);
   params.AddReceiver(receiver_type, cls.token_pos());
 
   AddFormalParamsToFunction(&params, ctor);
+  ctor.set_result_type(Object::dynamic_type());
+  ResolveSignature(ClassFinalizer::kResolveTypeParameters, ctor);
   // The body of the constructor cannot modify the type of the constructed
   // instance, which is passed in as the receiver.
   ctor.set_result_type(*receiver_type);
   cls.AddFunction(ctor);
 }
 
 
 // Check for cycles in constructor redirection.
 void Parser::CheckConstructors(ClassDesc* class_desc) {
   // Check for cycles in constructor redirection.
@@ skipping 76 matching lines @@
     ParseInterfaceList(mixin_application);
   }
   ExpectSemicolon();
   pending_classes.Add(mixin_application, Heap::kOld);
   if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
     library_.AddClassMetadata(mixin_application, tl_owner, metadata_pos);
   }
 }
 
 
-// Look ahead to detect if we are seeing ident [ TypeParameters ] "(".
+// Look ahead to detect if we are seeing ident [ TypeParameters ] ("(" | "=").
 // We need this lookahead to distinguish between the optional return type
 // and the alias name of a function type alias.
 // Token position remains unchanged.
-bool Parser::IsFunctionTypeAliasName() {
-  if (IsIdentifier() && (LookaheadToken(1) == Token::kLPAREN)) {
-    return true;
+bool Parser::IsFunctionTypeAliasName(bool* use_function_type_syntax) {
+  if (IsIdentifier()) {
+    const Token::Kind ahead = LookaheadToken(1);
+    if ((ahead == Token::kLPAREN) || (ahead == Token::kASSIGN)) {
+      *use_function_type_syntax = (ahead == Token::kASSIGN);
+      return true;
+    }
   }
   const TokenPosScope saved_pos(this);
   if (IsIdentifier() && (LookaheadToken(1) == Token::kLT)) {
     ConsumeToken();
-    if (TryParseTypeParameters() && (CurrentToken() == Token::kLPAREN)) {
-      return true;
+    if (TryParseTypeParameters()) {
+      const Token::Kind current = CurrentToken();
+      if ((current == Token::kLPAREN) || (current == Token::kASSIGN)) {
+        *use_function_type_syntax = (current == Token::kASSIGN);
+        return true;
+      }
     }
   }
+  *use_function_type_syntax = false;
   return false;
 }
 
 
 void Parser::ParseTypedef(const GrowableObjectArray& pending_classes,
                           const Object& tl_owner,
                           TokenPosition metadata_pos) {
   TRACE_PARSER("ParseTypedef");
   TokenPosition declaration_pos =
       metadata_pos.IsReal() ? metadata_pos : TokenPos();
   ExpectToken(Token::kTYPEDEF);
 
-  // Parse the result type of the function type.
-  AbstractType& result_type = Type::Handle(Z, Type::DynamicType());
+  // Distinguish between two possible typedef forms:
+  // 1) returnType? identifier typeParameters? formalParameterList ’;’
+  // 2) identifier typeParameters? '=' functionType ’;’
+
+  bool use_function_type_syntax;  // Set to false for form 1, true for form 2.
+
+  // If present, parse the result type of the function type.
+  AbstractType& result_type = Type::Handle(Z);
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
-  } else if (!IsFunctionTypeAliasName()) {
+    use_function_type_syntax = false;
+  } else if (!IsFunctionTypeAliasName(&use_function_type_syntax)) {
     // Type annotations in typedef are never ignored, even in production mode.
     // Wait until we have an owner class before resolving the result type.
     result_type = ParseType(ClassFinalizer::kDoNotResolve);
+    ASSERT(!use_function_type_syntax);
   }
 
   const TokenPosition alias_name_pos = TokenPos();
   const String* alias_name =
       ExpectUserDefinedTypeIdentifier("function alias name expected");
 
   // Lookup alias name and report an error if it is already defined in
   // the library scope.
   const Object& obj =
       Object::Handle(Z, library_.LookupLocalObject(*alias_name));
   if (!obj.IsNull()) {
     ReportError(alias_name_pos, "'%s' is already defined",
                 alias_name->ToCString());
   }
 
   // Create the function type alias scope class. It will be linked to its
   // signature function after it has been parsed. The type parameters, in order
   // 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);
+  ASSERT(current_class().IsTopLevel());
   set_current_class(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()) {
-    ResolveType(ClassFinalizer::kResolveTypeParameters, &result_type);
+  Function& signature_function = Function::Handle(Z);
+  ASSERT(innermost_function().IsNull());
+  if (use_function_type_syntax) {
+    ExpectToken(Token::kASSIGN);
+    ASSERT(result_type.IsNull());  // Not parsed yet.
+    // Do not resolve types before the function type alias can be recognized as
+    // a typedef class, so that correct promotion of function types can occur.
+    const Type& function_type = Type::Handle(
+        Z, ParseFunctionType(result_type, ClassFinalizer::kDoNotResolve));
+    signature_function = function_type.signature();
+  } else {
+    signature_function =
+        Function::NewSignatureFunction(function_type_alias, alias_name_pos);
+    innermost_function_ = signature_function.raw();
+    ParamList params;
+    // Parse the formal parameters of the function type.
+    CheckToken(Token::kLPAREN, "formal parameter list expected");
+    // Add implicit closure object parameter.
+    params.AddFinalParameter(TokenPos(), &Symbols::ClosureParameter(),
+                             &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);
+    AddFormalParamsToFunction(&params, signature_function);
+    ASSERT(innermost_function().raw() == signature_function.raw());
+    innermost_function_ = Function::null();
   }
-  // Parse the formal parameters of the function type.
-  CheckToken(Token::kLPAREN, "formal parameter list expected");
-  ParamList func_params;
+  ExpectSemicolon();
+  ASSERT(innermost_function().IsNull());
 
-  // 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();
+  // At this point, all function type parameters have been parsed and the class
+  // function_type_alias is recognized as a typedef, so we can resolve all type
+  // parameters in the signature type defined by the typedef.
+  AbstractType& function_type =
+      Type::Handle(Z, signature_function.SignatureType());
+  ASSERT(current_class().raw() == function_type_alias.raw());
+  ResolveType(ClassFinalizer::kResolveTypeParameters, &function_type);
+  // 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.
   ASSERT(!function_type_alias.is_finalized());
   pending_classes.Add(function_type_alias, Heap::kOld);
   if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
@@ skipping 49 matching lines @@
     }
   }
   return metadata_pos;
 }
 
 
 void Parser::SkipTypeArguments() {
   if (CurrentToken() == Token::kLT) {
     do {
       ConsumeToken();
-      SkipType(false);
+      SkipTypeOrFunctionType(false);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ReportError("right angle bracket expected");
     }
   }
 }
 
 
 void Parser::SkipType(bool allow_void) {
   if (CurrentToken() == Token::kVOID) {
     if (!allow_void) {
       ReportError("'void' not allowed here");
     }
     ConsumeToken();
   } else {
     ExpectIdentifier("type name expected");
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       ExpectIdentifier("name expected");
     }
     SkipTypeArguments();
   }
 }
 
 
+void Parser::SkipTypeOrFunctionType(bool allow_void) {
+  if (CurrentToken() == Token::kVOID) {
+    TokenPosition void_pos = TokenPos();
+    ConsumeToken();
+    // 'void' is always allowed as result type of a function type.
+    if (!allow_void && !IsFunctionTypeSymbol()) {
+      ReportError(void_pos, "'void' not allowed here");
+    }
+  } else if (!IsFunctionTypeSymbol()) {
+    // Including 'Function' not followed by '(' or '<'.
+    SkipType(false);
+  }
+  while (IsSymbol(Symbols::Function())) {
+    ConsumeToken();
+    SkipTypeArguments();
+    if (CurrentToken() == Token::kLPAREN) {
+      SkipToMatchingParenthesis();
+    } else {
+      ReportError("'(' expected");
+    }
+  }
+}
+
+
 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 {
@@ skipping 75 matching lines @@
 
 
 RawTypeArguments* Parser::ParseTypeArguments(
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseTypeArguments");
   if (CurrentToken() == Token::kLT) {
     GrowableArray<AbstractType*> types;
     AbstractType& type = AbstractType::Handle(Z);
     do {
       ConsumeToken();
-      type = ParseType(finalization);
+      type = ParseTypeOrFunctionType(false, finalization);
       // Map a malformed type argument to dynamic.
       if (type.IsMalformed()) {
         type = Type::DynamicType();
       }
       types.Add(&AbstractType::ZoneHandle(Z, type.raw()));
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
@@ skipping 185 matching lines @@
   AbstractType& result_type = Type::Handle(Z, Type::DynamicType());
   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()) {
-      // 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);
-    }
+  // Parse optional result type.
+  if (IsFunctionReturnType()) {
+    // 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 = ParseTypeOrFunctionType(true, 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());
@@ skipping 16 matching lines @@
 
   ASSERT(innermost_function().IsNull());
   innermost_function_ = func.raw();
 
   if (CurrentToken() == Token::kLT) {
     if (!FLAG_generic_method_syntax) {
       ReportError("generic functions not supported");
     }
     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 use_function_type_syntax = false;
   const bool allow_explicit_default_values = true;
-  ParseFormalParameterList(allow_explicit_default_values, false, &params);
+  const bool evaluate_metadata = false;
+  ParseFormalParameterList(use_function_type_syntax,
+                           allow_explicit_default_values, evaluate_metadata,
+                           &params);
 
   const TokenPosition modifier_pos = TokenPos();
   RawFunction::AsyncModifier func_modifier = ParseFunctionModifier();
 
   TokenPosition function_end_pos = function_pos;
   bool is_native = false;
   String* native_name = NULL;
   if (is_external) {
     function_end_pos = TokenPos();
     ExpectSemicolon();
@@ skipping 26 matching lines @@
   func.set_modifier(func_modifier);
   if (library_.is_dart_scheme() && library_.IsPrivate(func_name)) {
     func.set_is_reflectable(false);
   }
   if (is_native) {
     func.set_native_name(*native_name);
   }
   AddFormalParamsToFunction(&params, func);
   ASSERT(innermost_function().raw() == func.raw());
   innermost_function_ = Function::null();
+  ResolveSignature(ClassFinalizer::kResolveTypeParameters, func);
   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 19 matching lines @@
     metadata_pos = TokenPosition::kNoSource;
   } else if (CurrentToken() == Token::kEXTERNAL) {
     ConsumeToken();
     is_external = true;
   }
   bool is_getter = (CurrentToken() == Token::kGET);
   if (CurrentToken() == Token::kGET || CurrentToken() == Token::kSET) {
     ConsumeToken();
     result_type = Type::DynamicType();
   } else {
-    if (CurrentToken() == Token::kVOID) {
-      ConsumeToken();
-      result_type = Type::VoidType();
-    } else {
-      result_type = ParseType(ClassFinalizer::kResolveTypeParameters);
-    }
+    result_type =
+        ParseTypeOrFunctionType(true, ClassFinalizer::kResolveTypeParameters);
     is_getter = (CurrentToken() == Token::kGET);
     if (CurrentToken() == Token::kGET || CurrentToken() == Token::kSET) {
       ConsumeToken();
     } else {
       UnexpectedToken();
     }
   }
   const TokenPosition name_pos = TokenPos();
   const String* field_name = ExpectIdentifier("accessor name expected");
 
   const TokenPosition accessor_pos = TokenPos();
   ParamList params;
 
   if (!is_getter) {
+    const bool use_function_type_syntax = false;
     const bool allow_explicit_default_values = true;
-    ParseFormalParameterList(allow_explicit_default_values, false, &params);
+    const bool evaluate_metadata = false;
+    ParseFormalParameterList(use_function_type_syntax,
+                             allow_explicit_default_values, evaluate_metadata,
+                             &params);
   }
   String& accessor_name = String::ZoneHandle(Z);
   int expected_num_parameters = -1;
   if (is_getter) {
     expected_num_parameters = 0;
     accessor_name = Field::GetterSymbol(*field_name);
   } else {
     expected_num_parameters = 1;
     accessor_name = Field::SetterSymbol(*field_name);
   }
@@ skipping 73 matching lines @@
   func.set_end_token_pos(accessor_end_pos);
   func.set_modifier(func_modifier);
   if (is_native) {
     func.set_is_debuggable(false);
     func.set_native_name(*native_name);
   }
   if (library_.is_dart_scheme() && library_.IsPrivate(accessor_name)) {
     func.set_is_reflectable(false);
   }
   AddFormalParamsToFunction(&params, func);
+  ResolveSignature(ClassFinalizer::kResolveTypeParameters, func);
   top_level->AddFunction(func);
   if (!is_patch) {
     library_.AddObject(func, accessor_name);
   } else {
     // Need to remove the previously added accessor that is being patched.
     const Class& toplevel_cls = Class::Handle(
         Z, owner.IsClass() ? Class::Cast(owner).raw()
                            : PatchClass::Cast(owner).patched_class());
     const Function& replaced_func =
         Function::Handle(Z, toplevel_cls.LookupFunction(accessor_name));
@@ skipping 830 matching lines @@
     body.set_result_type(Object::dynamic_type());
     is_new_closure = true;
   }
 
   ParamList closure_params;
   AddSyncGenClosureParameters(&closure_params);
 
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
     AddFormalParamsToFunction(&closure_params, body);
-
+    ResolveSignature(ClassFinalizer::kResolveTypeParameters, body);
     // Finalize function type.
     Type& signature_type = Type::Handle(Z, body.SignatureType());
     signature_type ^= ClassFinalizer::FinalizeType(
         current_class(), signature_type, ClassFinalizer::kCanonicalize);
     body.SetSignatureType(signature_type);
     ASSERT(AbstractType::Handle(Z, body.result_type()).IsResolved());
     ASSERT(body.NumParameters() == closure_params.parameters->length());
   }
 
   OpenFunctionBlock(body);
@@ skipping 107 matching lines @@
     closure.set_is_generated_body(true);
     closure.set_result_type(Object::dynamic_type());
     is_new_closure = true;
   }
   // Create the parameter list for the async body closure.
   ParamList closure_params;
   AddAsyncClosureParameters(&closure_params);
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
     AddFormalParamsToFunction(&closure_params, closure);
+    ResolveSignature(ClassFinalizer::kResolveTypeParameters, closure);
 
     // Finalize function type.
     Type& signature_type = Type::Handle(Z, closure.SignatureType());
     signature_type ^= ClassFinalizer::FinalizeType(
         current_class(), signature_type, ClassFinalizer::kCanonicalize);
     closure.SetSignatureType(signature_type);
     ASSERT(AbstractType::Handle(Z, closure.result_type()).IsResolved());
     ASSERT(closure.NumParameters() == closure_params.parameters->length());
   }
   OpenFunctionBlock(closure);
@@ skipping 109 matching lines @@
     closure.set_result_type(Object::dynamic_type());
     is_new_closure = true;
   }
 
   ParamList closure_params;
   AddAsyncGenClosureParameters(&closure_params);
 
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
     AddFormalParamsToFunction(&closure_params, closure);
+    ResolveSignature(ClassFinalizer::kResolveTypeParameters, closure);
 
     // Finalize function type.
     Type& signature_type = Type::Handle(Z, closure.SignatureType());
     signature_type ^= ClassFinalizer::FinalizeType(
         current_class(), signature_type, ClassFinalizer::kCanonicalize);
     closure.SetSignatureType(signature_type);
     ASSERT(AbstractType::Handle(Z, closure.result_type()).IsResolved());
     ASSERT(closure.NumParameters() == closure_params.parameters->length());
   }
 
@@ skipping 342 matching lines @@
     for (int i = 0; i < params.num_optional_parameters; i++) {
       const Instance* default_value =
           parameters[i + first_opt_param_offset].default_value;
       default_values->Add(default_value);
     }
     parsed_function()->set_default_parameter_values(default_values);
   }
 }
 
 
+void Parser::FinalizeFormalParameterTypes(const ParamList* params) {
+  ASSERT((params != NULL) && (params->parameters != NULL));
+  const int num_parameters = params->parameters->length();
+  AbstractType& type = AbstractType::Handle(Z);
+  for (int i = 0; i < num_parameters; i++) {
+    ParamDesc& param_desc = (*params->parameters)[i];
+    type = param_desc.type->raw();
+    ResolveType(ClassFinalizer::kCanonicalize, &type);
+    type = ClassFinalizer::FinalizeType(current_class(), type,
+                                        ClassFinalizer::kCanonicalize);
+    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,
                                        const Function& func) {
   ASSERT((params != NULL) && (params->parameters != NULL));
   ASSERT((params->num_optional_parameters > 0) ==
          (params->has_optional_positional_parameters ||
           params->has_optional_named_parameters));
   if (!Utils::IsInt(16, params->num_fixed_parameters) ||
       !Utils::IsInt(16, params->num_optional_parameters)) {
@@ skipping 34 matching lines @@
 
 
 // Populate local scope with the formal parameters.
 void Parser::AddFormalParamsToScope(const ParamList* params,
                                     LocalScope* scope) {
   ASSERT((params != NULL) && (params->parameters != NULL));
   ASSERT(scope != NULL);
   const int num_parameters = params->parameters->length();
   for (int i = 0; i < num_parameters; i++) {
     ParamDesc& param_desc = (*params->parameters)[i];
-    ASSERT(!is_top_level_ || param_desc.type->IsResolved());
     const String* name = param_desc.name;
     LocalVariable* parameter = new (Z) LocalVariable(
         param_desc.name_pos, param_desc.name_pos, *name, *param_desc.type);
     if (!scope->InsertParameterAt(i, parameter)) {
       ReportError(param_desc.name_pos, "name '%s' already exists in scope",
                   param_desc.name->ToCString());
     }
     param_desc.var = parameter;
     if (param_desc.is_final) {
       parameter->set_is_final();
@@ skipping 142 matching lines @@
     ReportError(ident_pos, "identifier '%s' already defined",
                 variable->name().ToCString());
   }
   if (is_final || is_const) {
     variable->set_is_final();
   }
   return initialization;
 }
 
 
 // Parses ('var' | 'final' [type] | 'const' [type] | type).

[hausner, 2017/01/18 18:54:53]

Does the comment need to be updated? Or is the function type a part of the
grammar production [type] ?

[regis, 2017/01/18 20:24:24]

The official spec has not been changed yet, but the unofficial one is redefining
type: typeWithoutFunction | functionType.
It is why I did not change the comment. However, I did not rename ParseType to
ParseTypeWithoutFunction either. So the parser names do not quite match the
production names. It is something we could clean up once the spec is official.

 // The presence of 'final' or 'const' must be detected and remembered
 // before the call. If a type is parsed, it may be resolved and finalized
 // according to the given type finalization mode.
 RawAbstractType* Parser::ParseConstFinalVarOrType(
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseConstFinalVarOrType");
   if (CurrentToken() == Token::kVAR) {
     ConsumeToken();
     return Type::DynamicType();
   }
   bool type_is_optional = false;
   if ((CurrentToken() == Token::kFINAL) || (CurrentToken() == Token::kCONST)) {
     ConsumeToken();
     type_is_optional = true;
   }
+  if ((CurrentToken() == Token::kVOID) || IsFunctionTypeSymbol()) {
+    return ParseFunctionType(AbstractType::Handle(Z), finalization);
+  }
   if (CurrentToken() != Token::kIDENT) {
     if (type_is_optional) {
       return Type::DynamicType();
     } else {
       ReportError("type name expected");
     }
   }
   if (type_is_optional) {
     Token::Kind follower = LookaheadToken(1);
     // We have an identifier followed by a 'follower' token.
     // We either parse a type or return now.
     if ((follower != Token::kLT) &&        // Parameterized type.
         (follower != Token::kPERIOD) &&    // Qualified class name of type.
         !Token::IsIdentifier(follower) &&  // Variable name following a type.
         (follower != Token::kTHIS)) {      // Field parameter following a type.
       return Type::DynamicType();
     }
   }
-  return ParseType(finalization);
+  return ParseTypeOrFunctionType(false, finalization);
 }
 
 
 // Returns ast nodes of the variable initialization. Variables without an
 // explicit initializer are initialized to null. If several variables are
 // declared, the individual initializers are collected in a sequence node.
 AstNode* Parser::ParseVariableDeclarationList() {
   TRACE_PARSER("ParseVariableDeclarationList");
   SkipMetadata();
   bool is_final = (CurrentToken() == Token::kFINAL);
@@ skipping 31 matching lines @@
     }
     sequence->Add(declaration);
     initializers = sequence;
   }
   return initializers;
 }
 
 
 AstNode* Parser::ParseFunctionStatement(bool is_literal) {
   TRACE_PARSER("ParseFunctionStatement");
-  AbstractType& result_type = AbstractType::Handle(Z);
+  AbstractType& result_type = AbstractType::Handle(Z, Type::DynamicType());
   const String* function_name = NULL;
-
-  result_type = Type::DynamicType();
-
   const TokenPosition function_pos = TokenPos();
   TokenPosition function_name_pos = TokenPosition::kNoSource;
   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()) {
+    // Parse optional result type.
+    if (IsFunctionReturnType()) {
       // 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);
+      result_type =
+          ParseTypeOrFunctionType(true, ClassFinalizer::kDoNotResolve);
     }
     function_name_pos = TokenPos();
     function_name = ExpectIdentifier("function name expected");
 
     // 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()) {
@@ skipping 349 matching lines @@
             (CurrentLiteral()->raw() == Symbols::YieldKw().raw())));
 }
 
 
 bool Parser::IsSymbol(const String& symbol) {
   return (CurrentLiteral()->raw() == symbol.raw()) &&
          (CurrentToken() == Token::kIDENT);
 }
 
 
+// Returns true if the current token is 'Function' followed by '<' or '('.
+// 'Function' not followed by '<' or '(' denotes the Function class.
+bool Parser::IsFunctionTypeSymbol() {
+  return IsSymbol(Symbols::Function()) &&
+         ((LookaheadToken(1) == Token::kLPAREN) ||
+          (LookaheadToken(1) == Token::kLT));
+}
+
+
 // Returns true if the next tokens can be parsed as a an optionally
 // qualified identifier: [ident '.'] ident.
 // Current token position is not restored.
 bool Parser::TryParseQualIdent() {
   if (CurrentToken() != Token::kIDENT) {
     return false;
   }
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     if (CurrentToken() != Token::kIDENT) {
       return false;
     }
     ConsumeToken();
   }
   return true;
 }
 
 
 // Returns true if the next tokens can be parsed as a type with optional
 // type parameters. Current token position is not restored.
-bool Parser::TryParseOptionalType() {
-  if (CurrentToken() == Token::kIDENT) {
+// Allow 'void' as type if 'allow_void' is true.
+// Note that 'void Function()' is always allowed, since it is a function type
+// and not the void type.
+bool Parser::TryParseType(bool allow_void) {
+  bool found = false;
+  if (CurrentToken() == Token::kVOID) {
+    ConsumeToken();
+    if (allow_void) {
+      found = true;
+    } else if (!IsFunctionTypeSymbol()) {
+      return false;
+    }
+  } else if ((CurrentToken() == Token::kIDENT) && !IsFunctionTypeSymbol()) {
+    // 'Function' not followed by '(' or '<' means the Function class.
     if (!TryParseQualIdent()) {
       return false;
     }
     if ((CurrentToken() == Token::kLT) && !TryParseTypeParameters()) {
       return false;
     }
+    found = true;
   }
-  return true;
+  while (IsSymbol(Symbols::Function())) {
+    ConsumeToken();
+    if ((CurrentToken() == Token::kLT) && !TryParseTypeParameters()) {
+      return false;
+    }
+    if (CurrentToken() == Token::kLPAREN) {
+      SkipToMatchingParenthesis();
+    } else {
+      return false;
+    }
+    found = true;
+  }
+  return found;
 }
 
 
-// Returns true if the next tokens can be parsed as a type with optional
-// type parameters, or keyword "void".
-// Current token position is not restored.
-bool Parser::TryParseReturnType() {
-  if (CurrentToken() == Token::kVOID) {
-    ConsumeToken();
-    return true;
-  } else if (CurrentToken() == Token::kIDENT) {
-    return TryParseOptionalType();
-  }
-  return false;
-}
-
-
 // Look ahead to detect whether the next tokens should be parsed as
 // a variable declaration. Ignores optional metadata.
 // Returns true if we detect the token pattern:
 //     'var'
 //   | 'final'
 //   | const [type] ident (';' | '=' | ',')
 //   | type ident (';' | '=' | ',')
 // Token position remains unchanged.
 bool Parser::IsVariableDeclaration() {
   if ((CurrentToken() == Token::kVAR) || (CurrentToken() == Token::kFINAL)) {
     return true;
   }
   // Skip optional metadata.
   if (CurrentToken() == Token::kAT) {
     const TokenPosition saved_pos = TokenPos();
     SkipMetadata();
     const bool is_var_decl = IsVariableDeclaration();
     SetPosition(saved_pos);
     return is_var_decl;
   }
-  if ((CurrentToken() != Token::kIDENT) && (CurrentToken() != Token::kCONST)) {
-    // Not a legal type identifier or const keyword or metadata.
+  if ((CurrentToken() != Token::kIDENT) && (CurrentToken() != Token::kVOID) &&
+      (CurrentToken() != Token::kCONST)) {
+    // Not a legal type identifier or void (result type of function type)
+    // or const keyword or metadata.
     return false;
   }
   const TokenPosition saved_pos = TokenPos();
   bool is_var_decl = false;
   bool have_type = false;
   if (CurrentToken() == Token::kCONST) {
     ConsumeToken();
-    have_type = true;  // Type is dynamic.
+    have_type = true;  // Type is dynamic if 'const' is not followed by a type.
   }
-  if (IsIdentifier()) {  // Type or variable name.
+  if ((CurrentToken() == Token::kVOID) || IsFunctionTypeSymbol()) {
+    if (TryParseType(false)) {
+      have_type = true;
+    }
+  } else if (IsIdentifier()) {  // Type or variable name.
     Token::Kind follower = LookaheadToken(1);
     if ((follower == Token::kLT) ||       // Parameterized type.
         (follower == Token::kPERIOD) ||   // Qualified class name of type.
         Token::IsIdentifier(follower)) {  // Variable name following a type.
       // We see the beginning of something that could be a type.
       const TokenPosition type_pos = TokenPos();
-      if (TryParseOptionalType()) {
+      if (TryParseType(false)) {
         have_type = true;
       } else {
         SetPosition(type_pos);
       }
     }
-    if (have_type && IsIdentifier()) {
-      ConsumeToken();
-      if ((CurrentToken() == Token::kSEMICOLON) ||
-          (CurrentToken() == Token::kCOMMA) ||
-          (CurrentToken() == Token::kASSIGN)) {
-        is_var_decl = true;
-      }
+  }
+  if (have_type && IsIdentifier()) {
+    ConsumeToken();
+    if ((CurrentToken() == Token::kSEMICOLON) ||
+        (CurrentToken() == Token::kCOMMA) ||
+        (CurrentToken() == Token::kASSIGN)) {
+      is_var_decl = true;
     }
   }
   SetPosition(saved_pos);
   return is_var_decl;
 }
 
 
 // Look ahead to see if the following tokens are a return type followed
 // by an identifier.
 bool Parser::IsFunctionReturnType() {
   TokenPosScope decl_pos(this);
-  if (TryParseReturnType()) {
+  if (TryParseType(true)) {
     if (IsIdentifier()) {
       // Return type followed by function name.
       return true;
     }
   }
   return false;
 }
 
 
 // Look ahead to detect whether the next tokens should be parsed as
 // a function declaration. Token position remains unchanged.
 bool Parser::IsFunctionDeclaration() {
   bool is_external = false;
   TokenPosScope decl_pos(this);
   SkipMetadata();
   if ((is_top_level_) && (CurrentToken() == Token::kEXTERNAL)) {
     // Skip over 'external' for top-level function declarations.
     is_external = true;
     ConsumeToken();
   }
   const TokenPosition type_or_name_pos = TokenPos();
-  if (TryParseReturnType()) {
+  if (TryParseType(true)) {
     if (!IsIdentifier()) {
       SetPosition(type_or_name_pos);
     }
   } else {
     SetPosition(type_or_name_pos);
   }
   // Check for function name followed by optional type parameters.
   if (!IsIdentifier()) {
     return false;
   }
@@ skipping 19 matching lines @@
 
 
 bool Parser::IsTopLevelAccessor() {
   const TokenPosScope saved_pos(this);
   if (CurrentToken() == Token::kEXTERNAL) {
     ConsumeToken();
   }
   if ((CurrentToken() == Token::kGET) || (CurrentToken() == Token::kSET)) {
     return true;
   }
-  if (TryParseReturnType()) {
+  if (TryParseType(true)) {
     if ((CurrentToken() == Token::kGET) || (CurrentToken() == Token::kSET)) {
       if (Token::IsIdentifier(LookaheadToken(1))) {  // Accessor name.
         return true;
       }
     }
   }
   return false;
 }
 
 
@@ skipping 28 matching lines @@
   // Allow const modifier as well when recognizing a for-in statement
   // pattern. We will get an error later if the loop variable is
   // declared with const.
   if (CurrentToken() == Token::kVAR || CurrentToken() == Token::kFINAL ||
       CurrentToken() == Token::kCONST) {
     ConsumeToken();
   }
   if (IsIdentifier()) {
     if (LookaheadToken(1) == Token::kIN) {
       return true;
-    } else if (TryParseOptionalType()) {
+    } else if (TryParseType(false)) {
       if (IsIdentifier()) {
         ConsumeToken();
       }
       return CurrentToken() == Token::kIN;
     }
   }
   return false;
 }
 
 
@@ skipping 1278 matching lines @@
   while ((CurrentToken() == Token::kCATCH) || IsSymbol(Symbols::On())) {
     // Open a block that contains the if or an unconditional body.  It's
     // closed in the loop that builds the if-then-else nest.
     OpenBlock();
     const TokenPosition catch_pos = TokenPos();
     CatchParamDesc exception_param;
     CatchParamDesc stack_trace_param;
     if (IsSymbol(Symbols::On())) {
       ConsumeToken();
       exception_param.type = &AbstractType::ZoneHandle(
-          Z, ParseType(ClassFinalizer::kCanonicalize));
+          Z, ParseTypeOrFunctionType(false, ClassFinalizer::kCanonicalize));
     } else {
       exception_param.type = &Object::dynamic_type();
     }
     if (CurrentToken() == Token::kCATCH) {
       ConsumeToken();  // Consume the 'catch'.
       ExpectToken(Token::kLPAREN);
       exception_param.token_pos = TokenPos();
       exception_param.name = ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kCOMMA) {
         ConsumeToken();
@@ skipping 1085 matching lines @@
       if ((op_kind != Token::kIS) && (op_kind != Token::kAS)) {
         right_operand = ParseBinaryExpr(current_preced + 1);
       } else {
         // For 'is' and 'as' we expect the right operand to be a type.
         if ((op_kind == Token::kIS) && (CurrentToken() == Token::kNOT)) {
           ConsumeToken();
           op_kind = Token::kISNOT;
         }
         const TokenPosition type_pos = TokenPos();
         const AbstractType& type = AbstractType::ZoneHandle(
-            Z, ParseType(ClassFinalizer::kCanonicalize));
+            Z, ParseTypeOrFunctionType(false, ClassFinalizer::kCanonicalize));
         if (!type.IsInstantiated() && (FunctionLevel() > 0)) {
           // Make sure that the instantiator is captured.
           CaptureInstantiator();
         }
         right_operand = new (Z) TypeNode(type_pos, type);
         // In production mode, the type may be malformed.
         // In checked mode, the type may be malformed or malbounded.
         if (type.IsMalformedOrMalbounded()) {
           // Note that a type error is thrown in a type test or in
           // a type cast even if the tested value is null.
@@ skipping 1308 matching lines @@
     // The result is a pair of the (side effects of the) store followed by
     // the (value of the) initial value temp variable load.
     let_expr->AddNode(store);
     let_expr->AddNode(new (Z) LoadLocalNode(op_pos, temp));
     return let_expr;
   }
   return expr;
 }
 
 
+// Resolve the types of the given signature from the current class according to
+// the given type finalization mode.
+// Not all involved type classes may get resolved yet, but at least type
+// parameters will get resolved, thereby relieving the class
+// finalizer from resolving type parameters out of context.
+// TODO(regis): Refactor this code which is partially duplicated in the class
+// finalizer, paying attention to type parameter resolution and mixin library.
+void Parser::ResolveSignature(ClassFinalizer::FinalizationKind finalization,
+                              const Function& signature) {
+  const Function& saved_innermost_function =
+      Function::Handle(Z, innermost_function().raw());
+  innermost_function_ = signature.raw();
+  // TODO(regis): Resolve upper bounds of function type parameters.
+  AbstractType& type = AbstractType::Handle(signature.result_type());
+  ResolveType(finalization, &type);
+  signature.set_result_type(type);
+  const intptr_t num_parameters = signature.NumParameters();
+  for (intptr_t i = 0; i < num_parameters; i++) {
+    type = signature.ParameterTypeAt(i);
+    ResolveType(finalization, &type);
+    signature.SetParameterTypeAt(i, type);
+  }
+  innermost_function_ = saved_innermost_function.raw();
+}
+
+
 // Resolve the given type and its type arguments from the current function and
 // current class according to the given type finalization mode.
 // Not all involved type classes may get resolved yet, but at least type
 // parameters will get resolved, thereby relieving the class
 // finalizer from resolving type parameters out of context.
 // TODO(regis): Refactor this code which is partially duplicated in the class
 // finalizer, paying attention to type parameter resolution and mixin library.
 void Parser::ResolveType(ClassFinalizer::FinalizationKind finalization,
                          AbstractType* type) {
   ASSERT(finalization >= ClassFinalizer::kResolveTypeParameters);
@@ skipping 107 matching lines @@
       arguments.SetTypeAt(i, type_argument);
     }
   }
   if (type->IsFunctionType()) {
     const Function& signature =
         Function::Handle(Z, Type::Cast(*type).signature());
     Type& signature_type = Type::Handle(Z, signature.SignatureType());
     if (signature_type.raw() != type->raw()) {
       ResolveType(finalization, &signature_type);
     } else {
-      AbstractType& type = AbstractType::Handle(signature.result_type());
-      ResolveType(finalization, &type);
-      signature.set_result_type(type);
-      const intptr_t num_parameters = signature.NumParameters();
-      for (intptr_t i = 0; i < num_parameters; i++) {
-        type = signature.ParameterTypeAt(i);
-        ResolveType(finalization, &type);
-        signature.SetParameterTypeAt(i, type);
-      }
+      ResolveSignature(finalization, signature);
       if (signature.IsSignatureFunction()) {
         // Drop fields that are not necessary anymore after resolution.
         // The parent function, owner, and token position of a shared
         // canonical function type are meaningless, since the canonical
         // representent is picked arbitrarily.
         signature.set_parent_function(Function::Handle(Z));
         // TODO(regis): As long as we support metadata in typedef signatures,
         // we cannot reset these fields used to reparse a typedef.
         // Note that the scope class of a typedef function type is always
         // preserved as the typedef class (not reset to _Closure class), thereby
         // preventing sharing of canonical function types between typedefs.
         // Not being shared, these fields are therefore always meaningful for
         // typedefs.
-        if (type.HasResolvedTypeClass()) {
-          const Class& scope_class = Class::Handle(Z, type.type_class());
+        if (type->HasResolvedTypeClass()) {
+          const Class& scope_class = Class::Handle(Z, type->type_class());
           if (!scope_class.IsTypedefClass()) {
             signature.set_owner(Object::Handle(Z));
             signature.set_token_pos(TokenPosition::kNoSource);
+            if ((type->arguments() != TypeArguments::null()) &&
+                signature.HasInstantiatedSignature()) {
+              ASSERT(scope_class.IsGeneric());
+              // Although the scope class of this function type is generic,
+              // the signature of this function type does not refer to any
+              // of its type parameters. Reset its scope class to _Closure.
+              Type::Cast(*type).set_type_class(Class::Handle(
+                  Z, Isolate::Current()->object_store()->closure_class()));
+              type->set_arguments(Object::null_type_arguments());
+            }
           }
         }
       }
     }
   }
 }
 
 
 LocalVariable* Parser::LookupLocalScope(const String& ident) {
   if (current_block_ == NULL) {
@@ skipping 592 matching lines @@
 
 RawAbstractType* Parser::ParseType(
     ClassFinalizer::FinalizationKind finalization,
     bool allow_deferred_type,
     bool consume_unresolved_prefix) {
   LibraryPrefix& prefix = LibraryPrefix::Handle(Z);
   return ParseType(finalization, allow_deferred_type, consume_unresolved_prefix,
                    &prefix);
 }
 
+
+// Parses and returns a type or a functionType.

[hausner, 2017/01/18 18:54:53]

function type

[regis, 2017/01/18 20:24:24]

Done.

+RawAbstractType* Parser::ParseTypeOrFunctionType(
+    bool allow_void,
+    ClassFinalizer::FinalizationKind finalization) {
+  TRACE_PARSER("ParseTypeOrFunctionType");
+  AbstractType& type = AbstractType::Handle(Z);
+  if (CurrentToken() == Token::kVOID) {
+    TokenPosition void_pos = TokenPos();
+    type = Type::VoidType();
+    ConsumeToken();
+    // 'void' is always allowed as result type of a function type.
+    if (!allow_void && !IsFunctionTypeSymbol()) {
+      ReportError(void_pos, "'void' not allowed here");
+    }
+  } else if (!IsFunctionTypeSymbol()) {
+    // Including 'Function' not followed by '(' or '<'.
+    // It is too early to resolve the type here, since it can
+    // refer to a not yet declared function type parameter.
+    type = ParseType(ClassFinalizer::kDoNotResolve);
+  }
+  while (IsSymbol(Symbols::Function())) {

[hausner, 2017/01/18 18:54:53]

Would it make sense to change this to while(IsFunctionTypeSymbol()) { ... }  ?

[regis, 2017/01/18 20:24:24]

No, I had it that way and changed it to this, because it gives better error
messages. Note that this pattern using 'while (IsSymbol(Symbols::Function()))'
is found 4 times in the parser.

+    if (type.IsNull()) {
+      type = Type::DynamicType();
+    }
+    // 'type' is the result type of the function type.
+    type = ParseFunctionType(type, ClassFinalizer::kDoNotResolve);
+  }
+  // At this point, all type parameters have been parsed, resolve the type.
+  if (finalization == ClassFinalizer::kIgnore) {
+    return Type::DynamicType();
+  }
+  if (finalization >= ClassFinalizer::kResolveTypeParameters) {
+    ResolveType(finalization, &type);
+    if (finalization >= ClassFinalizer::kCanonicalize) {
+      type ^= ClassFinalizer::FinalizeType(current_class(), type, finalization);
+    }
+  }
+  return type.raw();
+}
+
+
+// Parses and returns a function type.
+// If 'result_type' is not null, parsing of the result type is skipped.
+RawType* Parser::ParseFunctionType(
+    const AbstractType& result_type,
+    ClassFinalizer::FinalizationKind finalization) {
+  TRACE_PARSER("ParseFunctionType");
+  AbstractType& type = AbstractType::Handle(Z, result_type.raw());
+  if (type.IsNull()) {
+    if (CurrentToken() == Token::kVOID) {
+      ConsumeToken();
+      type = Type::VoidType();
+    } else if (IsFunctionTypeSymbol()) {
+      type = Type::DynamicType();
+    } else {
+      // Including 'Function' not followed by '(' or '<'.
+      // It is too early to resolve the type here, since it can
+      // refer to a not yet declared function type parameter.
+      type = ParseType(ClassFinalizer::kDoNotResolve);
+    }
+  }
+  if (!IsSymbol(Symbols::Function())) {
+    ReportError("'Function' expected");
+  }
+  do {
+    ConsumeToken();
+    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();
+    signature_function.set_result_type(type);
+    // 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");
+
+    // Add implicit closure object parameter. Do not specify a token position,
+    // since it would make no sense after function type canonicalization.
+    params.AddFinalParameter(TokenPosition::kNoSource,
+                             &Symbols::ClosureParameter(),
+                             &Object::dynamic_type());
+
+    const bool use_function_type_syntax = true;
+    const bool allow_explicit_default_values = false;
+    const bool evaluate_metadata = false;
+    ParseFormalParameterList(use_function_type_syntax,
+                             allow_explicit_default_values, evaluate_metadata,
+                             &params);
+    AddFormalParamsToFunction(&params, signature_function);
+    innermost_function_ = innermost_function_.parent_function();
+    type = signature_function.SignatureType();
+  } while (IsSymbol(Symbols::Function()));
+  // At this point, all type parameters have been parsed, resolve the type.
+  if (finalization == ClassFinalizer::kIgnore) {
+    return Type::DynamicType();
+  }
+  if (finalization >= ClassFinalizer::kResolveTypeParameters) {
+    ResolveType(finalization, &type);
+    if (finalization >= ClassFinalizer::kCanonicalize) {
+      type ^= ClassFinalizer::FinalizeType(current_class(), type, finalization);
+    }
+  }
+  return Type::RawCast(type.raw());
+}
+
+
 // Parses type = [ident "."] ident ["<" type { "," type } ">"], then resolve and
-// finalize it according to the given type finalization mode. Returns prefix.
+// finalize it according to the given type finalization mode.
+// Returns type and sets prefix.
 RawAbstractType* Parser::ParseType(
     ClassFinalizer::FinalizationKind finalization,
     bool allow_deferred_type,
     bool consume_unresolved_prefix,
     LibraryPrefix* prefix) {
   TRACE_PARSER("ParseType");
   CheckToken(Token::kIDENT, "type name expected");
   TokenPosition ident_pos = TokenPos();
   String& type_name = String::Handle(Z);
 
@@ skipping 629 matching lines @@
   // Replace the types parsed from the constructor.
   params.EraseParameterTypes();
 
   closure = Function::NewClosureFunction(closure_name, innermost_function(),
                                          token_pos);
   closure.set_is_generated_body(true);
   closure.set_is_debuggable(false);
   closure.set_is_visible(false);
   closure.set_result_type(Object::dynamic_type());
   AddFormalParamsToFunction(&params, closure);
+  ResolveSignature(ClassFinalizer::kResolveTypeParameters, closure);
 
   // Finalize function type.
   Type& signature_type = Type::Handle(Z, closure.SignatureType());
   signature_type ^= ClassFinalizer::FinalizeType(
       current_class(), signature_type, ClassFinalizer::kCanonicalize);
   closure.SetSignatureType(signature_type);
   // Finalization would be premature when top-level parsing.
   ASSERT(!is_top_level_);
   return closure.raw();
 }
@@ skipping 824 matching lines @@
     value = TryCanonicalize(value, expr_pos);
     CacheConstantValue(expr_pos, value);
     return value;
   }
 }
 
 
 void Parser::SkipFunctionLiteral() {
   if (IsIdentifier()) {
     if (LookaheadToken(1) != Token::kLPAREN) {
-      SkipType(true);
+      SkipTypeOrFunctionType(true);
     }
     ExpectIdentifier("function name expected");
   }
   if (CurrentToken() == Token::kLPAREN) {
     SkipToMatchingParenthesis();
   }
   RawFunction::AsyncModifier async_modifier = ParseFunctionModifier();
   BoolScope allow_await(&this->await_is_keyword_,
                         async_modifier != RawFunction::kNoModifier);
   if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     SkipExpr();
   }
 }
 
 
 // Skips function/method/constructor/getter/setter preambles until the formal
 // parameter list. It is enough to skip the tokens, since we have already
 // previously parsed the function.
 void Parser::SkipFunctionPreamble() {
   while (true) {
     const Token::Kind token = CurrentToken();
+    if (IsFunctionTypeSymbol()) {
+      ConsumeToken();
+      SkipTypeArguments();
+      SkipToMatchingParenthesis();
+      continue;
+    }
     if (token == Token::kLPAREN) {
       return;
     }
     if (token == Token::kGET) {
       if (LookaheadToken(1) == Token::kLPAREN) {
         // Case: Function/method named get.
         ConsumeToken();  // Parse away 'get' (the function's name).
         return;
       }
       // Case: Getter.
@@ skipping 254 matching lines @@
   SkipUnaryExpr();
   const int min_prec = Token::Precedence(Token::kIFNULL);
   const int max_prec = Token::Precedence(Token::kMUL);
   while (((min_prec <= Token::Precedence(CurrentToken())) &&
           (Token::Precedence(CurrentToken()) <= max_prec))) {
     if (CurrentToken() == Token::kIS) {
       ConsumeToken();
       if (CurrentToken() == Token::kNOT) {
         ConsumeToken();
       }
-      SkipType(false);
+      SkipTypeOrFunctionType(false);
     } else if (CurrentToken() == Token::kAS) {
       ConsumeToken();
-      SkipType(false);
+      SkipTypeOrFunctionType(false);
     } else {
       ConsumeToken();
       SkipUnaryExpr();
     }
   }
 }
 
 
 void Parser::SkipConditionalExpr() {
   SkipBinaryExpr();
@@ skipping 135 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