Implement generalized function types.

pkg/compiler/lib/src/parser/partial_elements.dart

 // Copyright (c) 2015, 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 dart2js.parser.partial_elements;
 
 import '../common.dart';
 import '../common/resolution.dart' show ParsingContext, Resolution;
 import '../elements/resolution_types.dart' show ResolutionDynamicType;
 import '../elements/elements.dart'
@@ skipping 17 matching lines @@
         MetadataAnnotationX,
         MethodElementX,
         SetterElementX,
         TypedefElementX,
         VariableList;
 import '../elements/visitor.dart' show ElementVisitor;
 import 'package:front_end/src/fasta/scanner.dart' show Token;
 import 'package:front_end/src/fasta/scanner.dart' as Tokens show EOF_TOKEN;
 import '../tree/tree.dart';
 import 'package:front_end/src/fasta/parser.dart'
-    show ClassMemberParser, Listener, Parser, ParserError;
+    show ClassMemberParser, Listener, MemberKind, Parser, ParserError;
 import 'member_listener.dart' show MemberListener;
 import 'node_listener.dart' show NodeListener;
 
 class ClassElementParser extends ClassMemberParser {
   ClassElementParser(Listener listener) : super(listener);
 
-  Token parseFormalParameters(Token token, {bool inFunctionType: false}) {
-    return skipFormalParameters(token);
+  Token parseFormalParameters(Token token, MemberKind kind) {
+    return skipFormalParameters(token, kind);
   }
 }
 
 abstract class PartialElement implements DeclarationSite {
   Token beginToken;
   Token endToken;
 
   bool hasParseError = false;
 
   bool get isMalformed => hasParseError;
@@ skipping 31 matching lines @@
     assert(invariant(this, cachedNode != null,
         message: "Node has not been computed for $this."));
     return cachedNode;
   }
 
   FunctionExpression parseNode(ParsingContext parsing) {
     if (cachedNode != null) return cachedNode;
     parseFunction(Parser p) {
       if (isClassMember && modifiers.isFactory) {
         p.parseFactoryMethod(beginToken);
+      } else if (isClassMember) {
+        p.parseMember(beginToken);
       } else {
-        p.parseFunction(beginToken, getOrSet);
+        p.parseTopLevelMember(beginToken);
       }
     }
 
     cachedNode = parse(parsing, this, declarationSite, parseFunction);
     return cachedNode;
   }
 
   Token get position => _position;
 
   void reusePartialFunctionMixin() {
@@ skipping 342 matching lines @@
       } on ParserError catch (e) {
         partial.hasParseError = true;
         return new ErrorNode(element.position, e.message);
       }
       Node node = listener.popNode();
       assert(listener.nodes.isEmpty);
       return node;
     });
   });
 }