Implement generalized function types.

pkg/front_end/lib/src/fasta/source/diet_listener.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.diet_listener;
 
 import 'package:front_end/src/fasta/kernel/kernel_ast_factory.dart'
     show KernelAstFactory;
 
 import 'package:front_end/src/fasta/type_inference/type_inference_engine.dart'
     show TypeInferenceEngine;
 
 import 'package:front_end/src/fasta/type_inference/type_inference_listener.dart'
     show TypeInferenceListener;
 
 import 'package:kernel/ast.dart' show AsyncMarker;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 
 import 'package:kernel/core_types.dart' show CoreTypes;
 
 import '../fasta_codes.dart' show FastaMessage, codeExpectedBlockToSkip;
 
-import '../parser/parser.dart' show Parser, optional;
+import '../parser/parser.dart' show MemberKind, Parser, optional;
 
 import '../scanner/token.dart' show BeginGroupToken;
 
 import '../../scanner/token.dart' show Token;
 
 import '../parser/dart_vm_native.dart' show removeNativeClause;
 
 import '../util/link.dart' show Link;
 
 import '../errors.dart' show Crash, InputError, inputError, internalError;
@@ skipping 112 matching lines @@
   void handleNoFieldInitializer(Token token) {
     debugEvent("NoFieldInitializer");
   }
 
   @override
   void handleNoTypeVariables(Token token) {
     debugEvent("NoTypeVariables");
   }
 
   @override
-  void endFormalParameters(int count, Token beginToken, Token endToken) {
+  void endFormalParameters(
+      int count, Token beginToken, Token endToken, MemberKind kind) {
     debugEvent("FormalParameters");
     assert(count == 0); // Count is always 0 as the diet parser skips formals.
-    if (identical(peek(), "-") && identical(beginToken.next, endToken)) {
+    if (kind != MemberKind.GeneralizedFunctionType &&
+        identical(peek(), "-") &&
+        identical(beginToken.next, endToken)) {
       pop();
       push("unary-");
     }
     push(beginToken);
   }
 
   @override
-  void handleNoFormalParameters(Token token) {
+  void handleNoFormalParameters(Token token, MemberKind kind) {
     debugEvent("NoFormalParameters");
     if (identical(peek(), "-")) {
       pop();
       push("unary-");
     }
     push(token);
   }
 
   @override
   void handleFunctionType(Token functionToken, Token endToken) {
     debugEvent("FunctionType");
+    discard(1);
   }
 
   @override
   void endFunctionTypeAlias(
       Token typedefKeyword, Token equals, Token endToken) {
     debugEvent("FunctionTypeAlias");
-    if (stack.length == 1) {
-      // TODO(ahe): This happens when recovering from `typedef I = A;`. Find a
-      // different way to track tokens of formal parameters.
+    if (equals != null) {
+      // This is a `typedef NAME = TYPE`.
       discard(1); // Name.
     } else {
       discard(2); // Name + endToken.
     }
     checkEmpty(typedefKeyword.charOffset);
   }
 
   @override
-  void endFields(
-      int count, Token covariantToken, Token beginToken, Token endToken) {
+  void endFields(int count, Token beginToken, Token endToken) {
     debugEvent("Fields");
     List<String> names = popList(count);
     Builder builder = lookupBuilder(beginToken, null, names.first);
     buildFields(beginToken, false, builder);
   }
 
   @override
   void handleAsyncModifier(Token asyncToken, Token startToken) {
     debugEvent("AsyncModifier");
   }
 
   @override
   void endTopLevelMethod(Token beginToken, Token getOrSet, Token endToken) {
     debugEvent("TopLevelMethod");
     Token bodyToken = pop();
     String name = pop();
     checkEmpty(beginToken.charOffset);
-    buildFunctionBody(bodyToken, lookupBuilder(beginToken, getOrSet, name));
+    buildFunctionBody(bodyToken, lookupBuilder(beginToken, getOrSet, name),
+        MemberKind.TopLevelMethod);
   }
 
   @override
   void handleNoFunctionBody(Token token) {
     debugEvent("NoFunctionBody");
   }
 
   @override
   void endTopLevelFields(int count, Token beginToken, Token endToken) {
     debugEvent("TopLevelFields");
@@ skipping 139 matching lines @@
   @override
   void endFactoryMethod(
       Token beginToken, Token factoryKeyword, Token endToken) {
     debugEvent("FactoryMethod");
     BeginGroupToken bodyToken = pop();
     String name = pop();
     checkEmpty(beginToken.charOffset);
     if (bodyToken == null || optional("=", bodyToken.endGroup.next)) {
       return;
     }
-    buildFunctionBody(bodyToken, lookupBuilder(beginToken, null, name));
+    buildFunctionBody(
+        bodyToken, lookupBuilder(beginToken, null, name), MemberKind.Factory);
   }
 
   @override
   void endRedirectingFactoryBody(Token beginToken, Token endToken) {
     debugEvent("RedirectingFactoryBody");
     discard(1); // ConstructorReference.
   }
 
   @override
   void endMethod(Token getOrSet, Token beginToken, Token endToken) {
     debugEvent("Method");
     Token bodyToken = pop();
     String name = pop();
     checkEmpty(beginToken.charOffset);
     if (bodyToken == null) {
       return;
     }
-    buildFunctionBody(bodyToken, lookupBuilder(beginToken, getOrSet, name));
+    ProcedureBuilder builder = lookupBuilder(beginToken, getOrSet, name);
+    buildFunctionBody(
+        bodyToken,
+        builder,
+        builder.isStatic
+            ? MemberKind.StaticMethod
+            : MemberKind.NonStaticMethod);
   }
 
   StackListener createListener(
       MemberBuilder builder, Scope memberScope, bool isInstanceMember,
       [Scope formalParameterScope]) {
     var listener = new TypeInferenceListener();
     var typeInferrer =
         typeInferenceEngine.createLocalTypeInferrer(uri, listener);
     return new BodyBuilder(
         library,
         builder,
         memberScope,
         formalParameterScope,
         hierarchy,
         coreTypes,
         currentClass,
         isInstanceMember,
         uri,
         typeInferrer,
         new KernelAstFactory())
       ..constantExpressionRequired = builder.isConstructor && builder.isConst;
   }
 
-  void buildFunctionBody(Token token, ProcedureBuilder builder) {
+  void buildFunctionBody(
+      Token token, ProcedureBuilder builder, MemberKind kind) {
     Scope typeParameterScope = builder.computeTypeParameterScope(memberScope);
     Scope formalParameterScope =
         builder.computeFormalParameterScope(typeParameterScope);
     assert(typeParameterScope != null);
     assert(formalParameterScope != null);
     parseFunctionBody(
         createListener(builder, typeParameterScope, builder.isInstanceMember,
             formalParameterScope),
-        token);
+        token,
+        kind);
   }
 
   void buildFields(Token token, bool isTopLevel, MemberBuilder builder) {
     // TODO(paulberry): don't re-parse the field if we've already parsed it
     // for type inference.
     parseFields(createListener(builder, memberScope, builder.isInstanceMember),
         token, isTopLevel);
   }
 
   @override
@@ skipping 58 matching lines @@
   }
 
   @override
   Link<Token> handleMemberName(Link<Token> identifiers) {
     if (!isDartLibrary || identifiers.isEmpty) return identifiers;
     return removeNativeClause(identifiers);
   }
 
   AsyncMarker getAsyncMarker(StackListener listener) => listener.pop();
 
-  void parseFunctionBody(StackListener listener, Token token) {
+  void parseFunctionBody(StackListener listener, Token token, MemberKind kind) {
     try {
       Parser parser = new Parser(listener);
-      token = parser.parseFormalParametersOpt(token);
+      token = parser.parseFormalParametersOpt(token, kind);
       var formals = listener.pop();
       listener.checkEmpty(token.charOffset);
       listener.prepareInitializers();
       token = parser.parseInitializersOpt(token);
       token = parser.parseAsyncModifier(token);
       AsyncMarker asyncModifier = getAsyncMarker(listener) ?? AsyncMarker.Sync;
       bool isExpression = false;
       bool allowAbstract = asyncModifier == AsyncMarker.Sync;
       parser.parseFunctionBody(token, isExpression, allowAbstract);
       var body = listener.pop();
@@ skipping 50 matching lines @@
       return inputError(uri, token.charOffset, "Duplicated name: $name");
     }
     return builder;
   }
 
   @override
   void debugEvent(String name) {
     // printEvent(name);
   }
 }