Implement generalized function types.

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

 // Copyright (c) 2016, 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.
 
 library fasta.body_builder;
 
 import '../fasta_codes.dart'
     show FastaMessage, codeExpectedButGot, codeExpectedFunctionBody;
 
-import '../parser/parser.dart' show FormalParameterType, optional;
+import '../parser/parser.dart' show FormalParameterType, MemberKind, optional;
 
 import '../parser/identifier_context.dart' show IdentifierContext;
 
 import 'package:front_end/src/fasta/builder/ast_factory.dart' show AstFactory;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
     show
         KernelArguments,
         KernelField,
         KernelFunctionDeclaration,
@@ skipping 309 matching lines @@
   @override
   void endTopLevelFields(int count, Token beginToken, Token endToken) {
     debugEvent("TopLevelFields");
     doFields(count);
     // There's no metadata here because of a slight asymmetry between
     // [parseTopLevelMember] and [parseMember]. This asymmetry leads to
     // DietListener discarding top-level member metadata.
   }
 
   @override
-  void endFields(
-      int count, Token covariantKeyword, Token beginToken, Token endToken) {
+  void endFields(int count, Token beginToken, Token endToken) {
     debugEvent("Fields");
     doFields(count);
     pop(); // Metadata.
   }
 
   void doFields(int count) {
     for (int i = 0; i < count; i++) {
       Expression initializer = pop();
       Identifier identifier = pop();
       if (initializer != null) {
@@ skipping 1120 matching lines @@
       if (!isInstanceContext && type.parameter.parent is Class) {
         pop();
         warning("Type variables can only be used in instance methods.",
             beginToken.charOffset);
         push(const DynamicType());
       }
     }
   }
 
   @override
+  void handleFunctionType(Token functionToken, Token endToken) {
+    FormalParameters formals = pop();
+    ignore(Unhandled.TypeVariables);
+    DartType returnType = pop();
+    push(formals.toFunctionType(returnType));
+  }
+
+  @override
   void handleVoidKeyword(Token token) {
     debugEvent("VoidKeyword");
     push(const VoidType());
   }
 
   @override
   void handleAsOperator(Token operator, Token endToken) {
     debugEvent("AsOperator");
     DartType type = pop();
     Expression expression = popForValue();
@@ skipping 31 matching lines @@
     Expression expression = popForValue();
     if (constantExpressionRequired) {
       push(buildCompileTimeError(
           "Not a constant expression.", throwToken.charOffset));
     } else {
       push(astFactory.throwExpression(throwToken, expression));
     }
   }
 
   @override
-  void endFormalParameter(Token covariantKeyword, Token thisKeyword,
-      Token nameToken, FormalParameterType kind) {
+  void endFormalParameter(Token thisKeyword, Token nameToken,
+      FormalParameterType kind, MemberKind memberKind) {
     debugEvent("FormalParameter");
-    // TODO(ahe): Need beginToken here.
-    int charOffset = thisKeyword?.charOffset;
     if (thisKeyword != null) {
       if (!inConstructor) {
         addCompileTimeError(thisKeyword.charOffset,
             "'this' parameters can only be used on constructors.");
         thisKeyword = null;
       }
     }
     Identifier name = pop();
     DartType type = pop();
     int modifiers = Modifier.validate(pop());
     if (inCatchClause) {
       modifiers |= finalMask;
     }
     bool isConst = (modifiers & constMask) != 0;
     bool isFinal = (modifiers & finalMask) != 0;
     ignore(Unhandled.Metadata);
     VariableDeclaration variable;
-    if (!inCatchClause && functionNestingLevel == 0) {
-      dynamic builder = formalParameterScope.lookup(name.name, charOffset, uri);
+    if (!inCatchClause &&
+        functionNestingLevel == 0 &&
+        memberKind != MemberKind.GeneralizedFunctionType) {
+      dynamic builder = formalParameterScope.lookup(
+          name.name, offsetForToken(name.token), uri);
       if (builder == null) {
         if (thisKeyword == null) {
           internalError("Internal error: formal missing for '${name.name}'");
         } else {
           addCompileTimeError(thisKeyword.charOffset,
               "'${name.name}' isn't a field in this class.");
           thisKeyword = null;
         }
       } else if (thisKeyword == null) {
         variable = builder.build(library);
@@ skipping 36 matching lines @@
   }
 
   @override
   void beginFunctionTypedFormalParameter(Token token) {
     debugEvent("beginFunctionTypedFormalParameter");
     functionNestingLevel++;
   }
 
   @override
   void endFunctionTypedFormalParameter(
-      Token covariantKeyword, Token thisKeyword, FormalParameterType kind) {
+      Token thisKeyword, FormalParameterType kind) {
     debugEvent("FunctionTypedFormalParameter");
     if (inCatchClause || functionNestingLevel != 0) {
       exitLocalScope();
     }
     FormalParameters formals = pop();
     ignore(Unhandled.TypeVariables);
     Identifier name = pop();
     DartType returnType = pop();
     push(formals.toFunctionType(returnType));
     push(name);
     functionNestingLevel--;
   }
 
   @override
   void handleValuedFormalParameter(Token equals, Token token) {
     debugEvent("ValuedFormalParameter");
     Expression initializer = popForValue();
     Identifier name = pop();
     push(new InitializedIdentifier(name.token, initializer));
   }
 
   @override
   void handleFormalParameterWithoutValue(Token token) {
     debugEvent("FormalParameterWithoutValue");
   }
 
   @override
-  void endFormalParameters(int count, Token beginToken, Token endToken) {
+  void endFormalParameters(
+      int count, Token beginToken, Token endToken, MemberKind kind) {
     debugEvent("FormalParameters");
     OptionalFormals optional;
     if (count > 0 && peek() is OptionalFormals) {
       optional = pop();
       count--;
     }
     FormalParameters formals = new FormalParameters(
         popList(count) ?? <VariableDeclaration>[],
         optional,
         beginToken.charOffset);
@@ skipping 868 matching lines @@
   @override
   void handleModifiers(int count) {
     debugEvent("Modifiers");
     // TODO(ahe): Copied from outline_builder.dart.
     push(popList(count) ?? NullValue.Modifiers);
   }
 
   @override
   void handleRecoverableError(Token token, FastaMessage message) {
     bool silent = hasParserError;
-    super.handleRecoverableError(token, message);
     addCompileTimeError(message.charOffset, message.message, silent: silent);
   }
 
   @override
   Token handleUnrecoverableError(Token token, FastaMessage message) {
     if (isDartLibrary && message.code == codeExpectedFunctionBody) {
       Token recover = library.loader.target.skipNativeClause(token);
       if (recover != null) return recover;
     } else if (message.code == codeExpectedButGot) {
       String expected = message.arguments["string"];
@@ skipping 597 matching lines @@
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
   } else if (node is FastaAccessor) {
     return node.plainNameForRead;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }