Fix errors in summary_builder.dart.

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';
@@ skipping 24 matching lines @@
   'var': _var_flag,
 };
 
 // bit-masks to encode modifiers as bits on an int.
 
 const _star_flag = 1 << 2;
 
 const _static_flag = 1 << 3;
 const _sync_flag = 1 << 1;
 const _var_flag = 0;
+
 /// Retrieve the operator from an assignment operator (e.g. + from +=).
 /// Operators are encoded using the scanner token kind id.
 int opForAssignOp(int kind) {
   switch (kind) {
     case AMPERSAND_EQ_TOKEN:
       return AMPERSAND_TOKEN;
     // TODO(paulberry): add support for &&=
     // case AMPERSAND_AMPERSAND_EQ_TOKEN: return AMPERSAND_AMPERSAND_TOKEN;
     case BAR_EQ_TOKEN:
       return BAR_TOKEN;
@@ skipping 18 matching lines @@
     case STAR_EQ_TOKEN:
       return STAR_TOKEN;
     case TILDE_SLASH_EQ_TOKEN:
       return TILDE_SLASH_TOKEN;
     case PLUS_EQ_TOKEN:
       return PLUS_TOKEN;
     default:
       throw "Unhandled kind $kind";
   }
 }
+
 /// Create an unlinked summary given a null-terminated byte buffer with the
 /// contents of a file.
 UnlinkedUnit summarize(Uri uri, List<int> contents) {
   var listener = new SummaryBuilder(uri);
   var parser = new ClassMemberParser(listener);
   parser.parseUnit(scan(contents).tokens);
   return listener.topScope.unit;
 }
+
 /// Builder for constant expressions.
 ///
 /// Any invalid subexpression is denoted with [Invalid].
 class ConstExpressionBuilder extends ExpressionListener {
   final Uri uri;
   Parser parser;
   ConstExpressionBuilder(this.uri) {
     parser = new Parser(this, asyncAwaitKeywordsEnabled: true);
   }
   bool get forConst => true;
@@ skipping 187 matching lines @@
   }
 
   void endLiteralMapEntry(colon, token) {
     debugEvent('MapEntry');
     if (ignore) return;
     var value = pop();
     var key = pop();
     push(new KeyValuePair(key, value));
   }
 
-  void endLiteralString(int interpolationCount) {
+  void endLiteralString(int interpolationCount, Token endToken) {
     debugEvent("endLiteralString");
     if (interpolationCount != 0) {
       popList(2 * interpolationCount + 1);
       push(new StringLiteral("<interpolate $interpolationCount>"));
     }
   }
 
   void endLiteralSymbol(token, int dots) {
     debugEvent('LiteralSymbol');
     if (ignore) return;
@@ skipping 154 matching lines @@
     var typeArgs = pop() ?? const <TypeRef>[];
     // ignore: strong_mode_down_cast_composite
     push(new MapLiteral(typeArgs, values, constKeyword != null));
   }
 
   void handleLiteralNull(Token token) {
     debugEvent("LiteralNull");
     if (ignore) return;
     push(new NullLiteral());
   }
+
   void handleModifier(Token token) {
     debugEvent("Modifier");
     assert(ignore);
   }
 
   // TODO(sigmund): remove
   void handleModifiers(int count) {
     debugEvent("Modifiers");
     assert(ignore);
   }
+
   // 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) {
     debugEvent("NoFormalParameters");
     assert(ignore);
   }
 
   void handleNoFunctionBody(Token token) {
     debugEvent("NoFunctionBody");
     assert(ignore);
   }
 
   void handleNoInitializer() {}
 
   void handleNoInitializers() {
     debugEvent("NoInitializers");
     assert(ignore);
   }
+
   void handleNoType(Token token) {
     debugEvent("NoType");
     if (ignore) return;
     push(NullValue.Type);
   }
 
   void handleNoTypeArguments(Token token) {
     debugEvent("NoTypeArguments");
     if (ignore) return;
     push(NullValue.TypeArguments);
   }
 
   void handleNoTypeVariables(Token token) {
     debugEvent("NoTypeVariables");
     if (ignore) return;
     push(_invariantCheckToken);
   }
+
   void handleQualified(period) {
     debugEvent('Qualified');
     if (ignore) return;
     Ref name = pop();
     Ref prefix = pop();
     assert(name.prefix == null);
     assert(prefix.prefix == null);
     push(new Ref(name.name, prefix));
   }
 
@@ skipping 51 matching lines @@
     while (current != end) {
       if (!["(", ",", ")"].contains(current.value)) str.write(' ');
       str.write(current.value);
       current = current.next;
     }
     print('exp: $str');
   }
 
   void _unhandledSend();
 }
+
 /// Builder for initializer expressions. These expressions exclude any nested
 /// expression that is not needed to infer strong mode types.
 class InitializerBuilder extends ExpressionListener {
   final Uri uri;
   Parser parser;
 
   int _inArguments = 0;
 
   InitializerBuilder(this.uri) {
     parser = new Parser(this, asyncAwaitKeywordsEnabled: true);
@@ skipping 51 matching lines @@
     // push(new Opaque(type: new TypeRef(new Ref('bool'))));
   }
 
   void handleNamedArgument(colon) {
     debugEvent("NamedArg");
     if (ignore) return;
     pop();
     pop();
     push(NullValue.Arguments);
   }
+
   void handleNewExpression(Token token) {
     debugEvent("NewExpression");
     if (ignore) return;
     pop(); // args
     /* var ctor = */ pop(); // ctor
     throw new UnimplementedError(); // TODO(paulberry): fix the code below.
     // push(new Opaque(type: ctor.type, hint: "new"));
   }
 
   void handleNoConstructorReferenceContinuationAfterTypeArguments(Token token) {
@@ skipping 20 matching lines @@
 
   // TODO(paulberry): is this needed?
   //void _endCascade() {
   //  push(new OpaqueOp(pop(), hint: 'cascades'));
   //}
 
   void _unhandledSend() {
     push(new Opaque(hint: "call"));
   }
 }
+
 /// A listener of parser events that builds summary information as parsing
 /// progresses.
 class SummaryBuilder extends StackListener {
   static int parsed = 0;
 
   static int total = 0;
 
   /// Whether 'dart:core' was imported explicitly by the current unit.
   bool isDartCoreImported = false;
 
@@ skipping 269 matching lines @@
   void endFieldInitializer(Token assignmentOperator) {
     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) {
     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, FormalParameterType kind) {
     debugEvent("FormalParameter");
     // TODO(sigmund): clean up?
     var nameOrFormal = pop();
     if (nameOrFormal is String) {
       EntityRef type = pop();
       pop(); // Modifiers
       List metadata = pop();
       push(new UnlinkedParamBuilder(
@@ skipping 125 matching lines @@
     debugEvent("endLibraryName");
     String name = pop();
     // ignore: strong_mode_down_cast_composite
     List<UnlinkedExpr> metadata = pop(); // metadata
 
     topScope.unit.libraryName = name;
     topScope.unit.libraryAnnotations = metadata;
     if (name == 'dart.core') isCoreLibrary = true;
   }
 
-  void endLiteralString(int count) {
-    assert(count == 0); // TODO(sigmund): handle interpolation
+  void endLiteralString(int interpolationCount, Token endToken) {
+    assert(interpolationCount == 0); // TODO(sigmund): handle interpolation
   }
 
   void endMember() {
     debugEvent("Member");
   }
 
   // TODO(sigmund): handle metadata (this code is incomplete).
   void endMetadata(Token beginToken, Token periodBeforeName, Token endToken) {
     debugEvent("Metadata");
     List arguments = pop();
@@ skipping 200 matching lines @@
     ));
 
     String normalizedName = getOrSet == 'set' ? '$name=' : name;
     _addNameIfPublic(
         normalizedName,
         getOrSet != null
             ? ReferenceKind.topLevelPropertyAccessor
             : ReferenceKind.topLevelFunction,
         typeVariables?.length ?? 0 /* todo */);
   }
+
   void endTypeArguments(int count, Token beginToken, Token endToken) {
     debugEvent("TypeArguments");
     push(popList(count) ?? const []);
   }
 
   void endTypeList(int count) {
     debugEvent("TypeList");
     push(popList(count) ?? NullValue.TypeList);
   }
 
@@ skipping 192 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);
 }