Update Listener implementations.

pkg/analyzer/lib/src/summary/fasta/summary_builder.dart

 // Copyright (c) 2017, 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.
 
 /// Logic to build unlinked summaries.
 library summary.src.summary_builder;
 
-import 'package:front_end/src/fasta/parser/class_member_parser.dart';
-import 'package:front_end/src/fasta/parser/identifier_context.dart';
-import 'package:front_end/src/fasta/parser/parser.dart';
-import 'package:front_end/src/fasta/scanner.dart';
+import 'package:front_end/src/fasta/parser.dart'
+    show
+        ClassMemberParser,
+        FormalParameterType,
+        IdentifierContext,
+        MemberKind,
+        Parser;
+
+import 'package:front_end/src/fasta/scanner.dart' show Token, scan;
+
 import 'package:front_end/src/fasta/scanner/token_constants.dart';
 
 import 'expression_serializer.dart';
 import 'model.dart';
 import 'stack_listener.dart';
 
 const _abstract_flag = 1 << 2;
 
 const _async_flag = 1;
 
@@ skipping 232 matching lines @@
   void endConstructorReference(
       Token start, Token periodBeforeName, Token endToken) {
     debugEvent("ConstructorReference $start $periodBeforeName");
     Ref ctorName = popIfNotNull(periodBeforeName);
     assert(ctorName?.prefix == null);
     List<TypeRef> typeArgs = pop();
     Ref type = pop();
     push(new ConstructorName(new TypeRef(type, typeArgs), ctorName?.name));
   }
 
-  void endFormalParameter(Token covariantKeyword, Token thisKeyword,
-      Token nameToken, FormalParameterType kind) {
+  void endFormalParameter(Token thisKeyword, Token nameToken,
+      FormalParameterType kind, MemberKind memberKind) {
     debugEvent("FormalParameter");
     assert(ignore);
   }
 
-  void endFormalParameters(int c, begin, end) {
+  void endFormalParameters(
+      int count, Token beginToken, Token endToken, MemberKind kind) {
     debugEvent("FormalParameters");
     assert(ignore);
   }
 
   void endBlockFunctionBody(int count, Token begin, Token end) {
     debugEvent("BlockFunctionBody");
     assert(ignore);
   }
 
   void endFunctionDeclaration(token) {
@@ skipping 201 matching lines @@
 
   // type-variables are the declared parameters on declarations.
   void handleNoArguments(Token token) {
     debugEvent("NoArguments");
     if (ignore) return;
     var typeArguments = pop();
     assert(typeArguments == null);
     push(NullValue.Arguments);
   }
 
-  void handleNoFormalParameters(Token token) {
+  void handleNoFormalParameters(Token token, MemberKind kind) {
     debugEvent("NoFormalParameters");
     assert(ignore);
   }
 
   void handleNoFunctionBody(Token token) {
     debugEvent("NoFunctionBody");
     assert(ignore);
   }
 
   void handleNoInitializer() {}
@@ skipping 282 matching lines @@
     if (needInitializer) {
       parsed++;
       if (inConstContext) {
         push(constBuilder.computeExpression(token.next, scope));
       } else {
         push(initializerBuilder.computeExpression(token.next, scope));
       }
     }
   }
 
-  void beginFormalParameters(Token begin) {
+  void beginFormalParameters(Token token, MemberKind kind) {
     _nextParamKind = UnlinkedParamKind.required;
   }
 
   void beginFunctionTypeAlias(Token token) {
     debugEvent('beginFunctionTypeAlias');
     // TODO: use a single scope
     scope = new TypeParameterScope(scope);
   }
 
   beginInitializer(Token token) {
@@ skipping 178 matching lines @@
     debugEvent("FieldInitializer $typeSeen $assignmentOperator");
     // This is a variable initializer and it's ignored for now. May also be
     // constructor initializer.
     var initializer =
         needInitializer && assignmentOperator != null ? pop() : null;
     var name = pop();
     push(new _InitializedName(
         name, new UnlinkedExecutableBuilder(bodyExpr: initializer)));
   }
 
-  void endFields(
-      int count, Token covariantKeyword, Token beginToken, Token endToken) {
+  void endFields(int count, Token beginToken, Token endToken) {
     debugEvent("Fields");
     var s = scope;
     if (s is ClassScope) {
       _endFields(count, s.currentClass.fields, false);
     } else {
       throw new UnimplementedError(); // TODO(paulberry): does this ever occur?
       // _endFields(count, s.currentEnum.values, false);
     }
   }
 
-  void endFormalParameter(Token covariantKeyword, Token thisKeyword,
-      Token nameToken, FormalParameterType kind) {
+  void endFormalParameter(Token thisKeyword, Token nameToken,
+      FormalParameterType kind, MemberKind memberKind) {
     debugEvent("FormalParameter");
     // TODO(sigmund): clean up?
     var nameOrFormal = pop();
     if (nameOrFormal is String) {
       EntityRef type = pop();
       pop(); // Modifiers
       List metadata = pop();
       push(new UnlinkedParamBuilder(
           name: nameOrFormal,
           kind: _nextParamKind,
           inheritsCovariantSlot: slotIf(type == null),
           annotations: metadata,
           isInitializingFormal: thisKeyword != null,
           type: type));
     } else {
       push(nameOrFormal);
     }
   }
 
-  void endFormalParameters(int count, Token beginToken, Token endToken) {
+  void endFormalParameters(
+      int count, Token beginToken, Token endToken, MemberKind kind) {
     debugEvent("FormalParameters");
     List formals = popList(count);
     if (formals != null && formals.isNotEmpty) {
       var last = formals.last;
       if (last is List) {
         var newList = new List(formals.length - 1 + last.length);
         newList.setRange(0, formals.length - 1, formals);
         newList.setRange(formals.length - 1, newList.length, last);
         for (int i = 0; i < last.length; i++) {
           newList[i + formals.length - 1] = last[i];
@@ skipping 20 matching lines @@
         name: name,
         typeParameters: typeVariables,
         returnType: returnType,
         parameters: formals,
         annotations: metadata));
 
     _addNameIfPublic(name, ReferenceKind.typedef, typeVariables.length);
   }
 
   void endFunctionTypedFormalParameter(
-      Token covariantKeyword, Token thisKeyword, FormalParameterType kind) {
+      Token thisKeyword, FormalParameterType kind) {
     debugEvent("FunctionTypedFormalParameter");
     List<UnlinkedParamBuilder> formals = pop();
     if (formals != null) formals.forEach((p) => p.inheritsCovariantSlot = null);
 
     /* List typeVariables = */ pop();
     String name = pop();
     EntityRef returnType = pop();
     /* int modifiers = */ pop();
     List metadata = pop();
 
@@ skipping 472 matching lines @@
 }
 
 /// Internal representation of an initialized name.
 class _InitializedName {
   final String name;
   final UnlinkedExecutableBuilder initializer;
   _InitializedName(this.name, this.initializer);
 
   toString() => "II:" + (initializer != null ? "$name = $initializer" : name);
 }