Fix parsing of generic closure formal parameter

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 2014 matching lines @@
     // 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");
     }
-    // We have not seen a parameter type yet, so we check if the next
-    // identifier could represent a type before parsing it.
-    Token::Kind follower = LookaheadToken(1);
-    // We have an identifier followed by a 'follower' token.
-    // We either parse a type or assume that no type is specified.
-    if ((follower == Token::kLT) ||  // Parameterized type.
-        (follower == Token::kPERIOD) ||  // Qualified class name of type.
-        Token::IsIdentifier(follower) ||  // Parameter name following a type.
-        (follower == Token::kTHIS)) {  // Field parameter following a type.
+
+    // 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;
       parameter.type = &AbstractType::ZoneHandle(Z,
           ParseType(is_top_level_ ? ClassFinalizer::kResolveTypeParameters :
                                     ClassFinalizer::kCanonicalize));
     } 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.
@@ skipping 12899 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