// Copyright (c) 2018, 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.

import 'package:front_end/src/fasta/messages.dart';
import 'package:front_end/src/fasta/parser.dart';
import 'package:front_end/src/fasta/parser/type_info.dart';
import 'package:front_end/src/fasta/scanner.dart';
import 'package:front_end/src/scanner/token.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';

main() {
  defineReflectiveSuite(() {
    defineReflectiveTests(TokenInfoTest);
  });
}

@reflectiveTest
class TokenInfoTest {
  void test_noType() {
    TypeInfo typeInfo = noTypeInfo;
    Token start = scanString('before ;').tokens;
    Token expectedEnd = start;
    expect(typeInfo.skipType(start), expectedEnd);

    TypeInfoListener listener = new TypeInfoListener();
    expect(typeInfo.parseType(start, new Parser(listener)), expectedEnd);
    expect(listener.calls, ['handleNoType before']);
  }

  void test_voidType() {
    TypeInfo typeInfo = voidTypeInfo;
    Token start = scanString('before void ;').tokens;
    Token expectedEnd = start.next;
    expect(typeInfo.skipType(start), expectedEnd);

    TypeInfoListener listener = new TypeInfoListener();
    expect(typeInfo.parseType(start, new Parser(listener)), expectedEnd);
    expect(listener.calls, ['handleVoidKeyword void']);
  }

  void test_prefixedTypeInfo() {
    TypeInfo typeInfo = prefixedTypeInfo;
    Token start = scanString('before C.a ;').tokens;
    Token expectedEnd = start.next.next.next;
    expect(typeInfo.skipType(start), expectedEnd);

    TypeInfoListener listener = new TypeInfoListener();
    expect(typeInfo.parseType(start, new Parser(listener)), expectedEnd);
    expect(listener.calls, [
      'handleIdentifier C prefixedTypeReference',
      'handleIdentifier a typeReferenceContinuation',
      'handleQualified .',
      'handleNoTypeArguments ;',
      'handleType C ;',
    ]);
  }

  void test_simpleTypeInfo() {
    TypeInfo typeInfo = simpleTypeInfo;
    Token start = scanString('before C ;').tokens;
    Token expectedEnd = start.next;
    expect(typeInfo.skipType(start), expectedEnd);

    TypeInfoListener listener = new TypeInfoListener();
    expect(typeInfo.parseType(start, new Parser(listener)), expectedEnd);
    expect(listener.calls, [
      'handleIdentifier C typeReference',
      'handleNoTypeArguments ;',
      'handleType C ;',
    ]);
  }

  void test_simpleTypeArgumentsInfo() {
    TypeInfo typeInfo = simpleTypeArgumentsInfo;
    Token start = scanString('before C<T> ;').tokens;
    Token expectedEnd = start.next.next.next.next;
    expect(typeInfo.skipType(start), expectedEnd);

    TypeInfoListener listener = new TypeInfoListener();
    expect(typeInfo.parseType(start, new Parser(listener)), expectedEnd);
    expect(listener.calls, [
      'handleIdentifier C typeReference',
      'beginTypeArguments <',
      'handleIdentifier T typeReference',
      'handleNoTypeArguments >',
      'handleType T >',
      'endTypeArguments 1 < >',
      'handleType C ;',
    ]);
  }

  void test_computeType_basic() {
    expectInfo(noTypeInfo, '');
    expectInfo(noTypeInfo, ';');
    expectInfo(noTypeInfo, '( foo');
    expectInfo(noTypeInfo, '< foo');
    expectInfo(noTypeInfo, '= foo');
    expectInfo(noTypeInfo, '* foo');
    expectInfo(noTypeInfo, 'do foo');
    expectInfo(noTypeInfo, 'get foo');
    expectInfo(noTypeInfo, 'set foo');
    expectInfo(noTypeInfo, 'operator *');
  }

  void test_computeType_gft() {
    expectComplexInfo('Function()', expectedCalls: [
      'handleNoTypeVariables (',
      'beginFunctionType Function',
      'handleNoType ',
      'beginFormalParameters ( MemberKind.GeneralizedFunctionType',
      'endFormalParameters 0 ( ) MemberKind.GeneralizedFunctionType',
      'endFunctionType Function ',
    ]);
    expectComplexInfo('Function<T>()', expectedCalls: [
      'beginTypeVariables <',
      'beginTypeVariable T',
      'beginMetadataStar T',
      'endMetadataStar 0',
      'handleIdentifier T typeVariableDeclaration',
      'handleNoType T',
      'endTypeVariable > null',
      'endTypeVariables 1 < >',
      'beginFunctionType Function',
      'handleNoType ',
      'beginFormalParameters ( MemberKind.GeneralizedFunctionType',
      'endFormalParameters 0 ( ) MemberKind.GeneralizedFunctionType',
      'endFunctionType Function ',
    ]);
    expectComplexInfo('Function(int)', expectedCalls: [
      'handleNoTypeVariables (',
      'beginFunctionType Function',
      'handleNoType ',
      'beginFormalParameters ( MemberKind.GeneralizedFunctionType',
      'beginMetadataStar int',
      'endMetadataStar 0',
      'beginFormalParameter int MemberKind.GeneralizedFunctionType',
      'handleModifiers 0',
      'handleIdentifier int typeReference',
      'handleNoTypeArguments )',
      'handleType int )',
      'handleNoName )',
      'handleFormalParameterWithoutValue )',
      'beginTypeVariables null null ) FormalParameterKind.mandatory '
          'MemberKind.GeneralizedFunctionType',
      'endFormalParameters 1 ( ) MemberKind.GeneralizedFunctionType',
      'endFunctionType Function ',
    ]);
    expectComplexInfo('Function<T>(int)', expectedCalls: [
      'beginTypeVariables <',
      'beginTypeVariable T',
      'beginMetadataStar T',
      'endMetadataStar 0',
      'handleIdentifier T typeVariableDeclaration',
      'handleNoType T',
      'endTypeVariable > null',
      'endTypeVariables 1 < >',
      'beginFunctionType Function',
      'handleNoType ',
      'beginFormalParameters ( MemberKind.GeneralizedFunctionType',
      'beginMetadataStar int',
      'endMetadataStar 0',
      'beginFormalParameter int MemberKind.GeneralizedFunctionType',
      'handleModifiers 0',
      'handleIdentifier int typeReference',
      'handleNoTypeArguments )',
      'handleType int )',
      'handleNoName )',
      'handleFormalParameterWithoutValue )',
      'beginTypeVariables null null ) FormalParameterKind.mandatory MemberKind.GeneralizedFunctionType',
      'endFormalParameters 1 ( ) MemberKind.GeneralizedFunctionType',
      'endFunctionType Function ',
    ]);
    expectComplexInfo('Function(int x)');
    expectComplexInfo('Function<T>(int x)');
    expectComplexInfo('Function<T>(int x) Function<T>(int x)');
  }

  void test_computeType_identifier() {
    expectInfo(noTypeInfo, 'C', required: false);
    expectInfo(noTypeInfo, 'C;', required: false);
    expectInfo(noTypeInfo, 'C(', required: false);
    expectInfo(noTypeInfo, 'C<', required: false);
    expectInfo(noTypeInfo, 'C.', required: false);
    expectInfo(noTypeInfo, 'C=', required: false);
    expectInfo(noTypeInfo, 'C*', required: false);
    expectInfo(noTypeInfo, 'C do', required: false);

    expectInfo(simpleTypeInfo, 'C', required: true);
    expectInfo(simpleTypeInfo, 'C;', required: true);
    expectInfo(simpleTypeInfo, 'C(', required: true);
    expectInfo(simpleTypeInfo, 'C<', required: true);
    expectInfo(simpleTypeInfo, 'C.', required: true);
    expectInfo(simpleTypeInfo, 'C=', required: true);
    expectInfo(simpleTypeInfo, 'C*', required: true);
    expectInfo(simpleTypeInfo, 'C do', required: true);

    expectInfo(simpleTypeInfo, 'C foo');
    expectInfo(simpleTypeInfo, 'C get');
    expectInfo(simpleTypeInfo, 'C set');
    expectInfo(simpleTypeInfo, 'C operator');
    expectInfo(simpleTypeInfo, 'C this');
    expectInfo(simpleTypeInfo, 'C Function');
  }

  void test_computeType_identifierComplex() {
    expectComplexInfo('C Function()');
    expectComplexInfo('C Function<T>()');
    expectComplexInfo('C Function(int)');
    expectComplexInfo('C Function<T>(int)');
    expectComplexInfo('C Function(int x)');
    expectComplexInfo('C Function<T>(int x)');
    expectComplexInfo('C Function<T>(int x) Function<T>(int x)');
    expectComplexInfo('C Function(', // Scanner inserts synthetic ')'.
        expectedCalls: [
          'handleNoTypeVariables (',
          'beginFunctionType C',
          'handleIdentifier C typeReference',
          'handleNoTypeArguments Function',
          'handleType C Function',
          'beginFormalParameters ( MemberKind.GeneralizedFunctionType',
          'endFormalParameters 0 ( ) MemberKind.GeneralizedFunctionType',
          'endFunctionType Function ',
        ]);
  }

  void test_computeType_identifierTypeArg() {
    expectInfo(noTypeInfo, 'C<T>', required: false);
    expectInfo(noTypeInfo, 'C<T>;', required: false);
    expectInfo(noTypeInfo, 'C<T>(', required: false);
    expectInfo(noTypeInfo, 'C<T> do', required: false);
    expectInfo(noTypeInfo, 'C<void>', required: false);

    expectInfo(simpleTypeArgumentsInfo, 'C<T>', required: true);
    expectInfo(simpleTypeArgumentsInfo, 'C<T>;', required: true);
    expectInfo(simpleTypeArgumentsInfo, 'C<T>(', required: true);
    expectInfo(simpleTypeArgumentsInfo, 'C<T> do', required: true);
    expectComplexInfo('C<void>', required: true, expectedCalls: [
      'handleIdentifier C typeReference',
      'beginTypeArguments <',
      'handleVoidKeyword void',
      'endTypeArguments 1 < >',
      'handleType C ',
    ]);

    expectInfo(simpleTypeArgumentsInfo, 'C<T> foo');
    expectInfo(simpleTypeArgumentsInfo, 'C<T> get');
    expectInfo(simpleTypeArgumentsInfo, 'C<T> set');
    expectInfo(simpleTypeArgumentsInfo, 'C<T> operator');
    expectInfo(simpleTypeArgumentsInfo, 'C<T> Function');
  }

  void test_computeType_identifierTypeArgComplex() {
    expectInfo(noTypeInfo, 'C<S,T>', required: false);
    expectInfo(noTypeInfo, 'C<S<T>>', required: false);
    expectInfo(noTypeInfo, 'C.a<T>', required: false);

    expectComplexInfo('C<S,T>', required: true, expectedCalls: [
      'handleIdentifier C typeReference',
      'beginTypeArguments <',
      'handleIdentifier S typeReference',
      'handleNoTypeArguments ,',
      'handleType S ,',
      'handleIdentifier T typeReference',
      'handleNoTypeArguments >',
      'handleType T >',
      'endTypeArguments 2 < >',
      'handleType C ',
    ]);
    expectComplexInfo('C<S<T>>', required: true, expectedCalls: [
      'handleIdentifier C typeReference',
      'beginTypeArguments <',
      'handleIdentifier S typeReference',
      'beginTypeArguments <',
      'handleIdentifier T typeReference',
      'handleNoTypeArguments >',
      'handleType T >',
      'endTypeArguments 1 < >',
      'handleType S >',
      'endTypeArguments 1 < >',
      'handleType C ',
    ]);
    expectComplexInfo('C<S,T> f', tokenAfter: 'f', expectedCalls: [
      'handleIdentifier C typeReference',
      'beginTypeArguments <',
      'handleIdentifier S typeReference',
      'handleNoTypeArguments ,',
      'handleType S ,',
      'handleIdentifier T typeReference',
      'handleNoTypeArguments >',
      'handleType T >',
      'endTypeArguments 2 < >',
      'handleType C f',
    ]);
    expectComplexInfo('C<S<T>> f', tokenAfter: 'f', expectedCalls: [
      'handleIdentifier C typeReference',
      'beginTypeArguments <',
      'handleIdentifier S typeReference',
      'beginTypeArguments <',
      'handleIdentifier T typeReference',
      'handleNoTypeArguments >',
      'handleType T >',
      'endTypeArguments 1 < >',
      'handleType S >',
      'endTypeArguments 1 < >',
      'handleType C f',
    ]);
  }

  void test_computeType_identifierTypeArgGFT() {
    expectComplexInfo('C<T> Function(', // Scanner inserts synthetic ')'.
        expectedCalls: [
          'handleNoTypeVariables (',
          'beginFunctionType C',
          'handleIdentifier C typeReference',
          'beginTypeArguments <',
          'handleIdentifier T typeReference',
          'handleNoTypeArguments >',
          'handleType T >',
          'endTypeArguments 1 < >',
          'handleType C Function',
          'beginFormalParameters ( MemberKind.GeneralizedFunctionType',
          'endFormalParameters 0 ( ) MemberKind.GeneralizedFunctionType',
          'endFunctionType Function ',
        ]);
    expectComplexInfo('C<T> Function<T>(int x) Function<T>(int x)');
  }

  void test_computeType_identifierTypeArgRecovery() {
    // TOOD(danrubel): dynamic, do, other keywords, malformed, recovery
    // <T>

    expectComplexInfo('G<int double> g',
        required: true,
        tokenAfter: 'g',
        expectedCalls: [
          'handleIdentifier G typeReference',
          'beginTypeArguments <',
          'handleIdentifier int typeReference',
          'handleNoTypeArguments double',
          'handleType int double',
          'endTypeArguments 1 < >',
          'handleType G double',
        ],
        expectedErrors: [
          error(codeExpectedToken, 6, 6)
        ]);

    expectInfo(noTypeInfo, 'C<>', required: false);
    expectComplexInfo('C<>', required: true, expectedCalls: [
      'handleIdentifier C typeReference',
      'beginTypeArguments <',
      'handleIdentifier  typeReference',
      'handleNoTypeArguments >',
      'handleType > >',
      'endTypeArguments 1 < >',
      'handleType C ',
    ], expectedErrors: [
      error(codeExpectedType, 2, 1)
    ]);
    expectComplexInfo('C<> f', required: true, tokenAfter: 'f', expectedCalls: [
      'handleIdentifier C typeReference',
      'beginTypeArguments <',
      'handleIdentifier  typeReference',
      'handleNoTypeArguments >',
      'handleType > >',
      'endTypeArguments 1 < >',
      'handleType C f',
    ], expectedErrors: [
      error(codeExpectedType, 2, 1)
    ]);

    // Statements that should not have a type
    expectInfo(noTypeInfo, 'C<T ; T>U;', required: false);
    expectInfo(noTypeInfo, 'C<T && T>U;', required: false);
  }

  void test_computeType_prefixed() {
    expectInfo(noTypeInfo, 'C.a', required: false);
    expectInfo(noTypeInfo, 'C.a;', required: false);
    expectInfo(noTypeInfo, 'C.a(', required: false);
    expectInfo(noTypeInfo, 'C.a<', required: false);
    expectInfo(noTypeInfo, 'C.a=', required: false);
    expectInfo(noTypeInfo, 'C.a*', required: false);
    expectInfo(noTypeInfo, 'C.a do', required: false);

    expectInfo(prefixedTypeInfo, 'C.a', required: true);
    expectInfo(prefixedTypeInfo, 'C.a;', required: true);
    expectInfo(prefixedTypeInfo, 'C.a(', required: true);
    expectInfo(prefixedTypeInfo, 'C.a<', required: true);
    expectInfo(prefixedTypeInfo, 'C.a=', required: true);
    expectInfo(prefixedTypeInfo, 'C.a*', required: true);
    expectInfo(prefixedTypeInfo, 'C.a do', required: true);

    expectInfo(prefixedTypeInfo, 'C.a foo');
    expectInfo(prefixedTypeInfo, 'C.a get');
    expectInfo(prefixedTypeInfo, 'C.a set');
    expectInfo(prefixedTypeInfo, 'C.a operator');
    expectInfo(prefixedTypeInfo, 'C.a Function');
  }

  void test_computeType_prefixedGFT() {
    expectComplexInfo('C.a Function(', // Scanner inserts synthetic ')'.
        expectedCalls: [
          'handleNoTypeVariables (',
          'beginFunctionType C',
          'handleIdentifier C prefixedTypeReference',
          'handleIdentifier a typeReferenceContinuation',
          'handleQualified .',
          'handleNoTypeArguments Function',
          'handleType C Function',
          'beginFormalParameters ( MemberKind.GeneralizedFunctionType',
          'endFormalParameters 0 ( ) MemberKind.GeneralizedFunctionType',
          'endFunctionType Function ',
        ]);
    expectComplexInfo('C.a Function<T>(int x) Function<T>(int x)');
  }

  void test_computeType_prefixedTypeArg() {
    expectComplexInfo('C.a<T>', required: true, expectedCalls: [
      'handleIdentifier C prefixedTypeReference',
      'handleIdentifier a typeReferenceContinuation',
      'handleQualified .',
      'beginTypeArguments <',
      'handleIdentifier T typeReference',
      'handleNoTypeArguments >',
      'handleType T >',
      'endTypeArguments 1 < >',
      'handleType C ',
    ]);

    expectComplexInfo('C.a<T> f', tokenAfter: 'f', expectedCalls: [
      'handleIdentifier C prefixedTypeReference',
      'handleIdentifier a typeReferenceContinuation',
      'handleQualified .',
      'beginTypeArguments <',
      'handleIdentifier T typeReference',
      'handleNoTypeArguments >',
      'handleType T >',
      'endTypeArguments 1 < >',
      'handleType C f',
    ]);
  }

  void test_computeType_prefixedTypeArgGFT() {
    expectComplexInfo('C.a<T> Function<T>(int x) Function<T>(int x)',
        expectedCalls: [
          'beginTypeVariables <',
          'beginTypeVariable T',
          'beginMetadataStar T',
          'endMetadataStar 0',
          'handleIdentifier T typeVariableDeclaration',
          'handleNoType T',
          'endTypeVariable > null',
          'endTypeVariables 1 < >',
          'beginFunctionType C',
          'beginTypeVariables <',
          'beginTypeVariable T',
          'beginMetadataStar T',
          'endMetadataStar 0',
          'handleIdentifier T typeVariableDeclaration',
          'handleNoType T',
          'endTypeVariable > null',
          'endTypeVariables 1 < >',
          'beginFunctionType C',
          'handleIdentifier C prefixedTypeReference',
          'handleIdentifier a typeReferenceContinuation',
          'handleQualified .',
          'beginTypeArguments <',
          'handleIdentifier T typeReference',
          'handleNoTypeArguments >',
          'handleType T >',
          'endTypeArguments 1 < >',
          'handleType C Function',
          'beginFormalParameters ( MemberKind.GeneralizedFunctionType',
          'beginMetadataStar int',
          'endMetadataStar 0',
          'beginFormalParameter int MemberKind.GeneralizedFunctionType',
          'handleModifiers 0',
          'handleIdentifier int typeReference',
          'handleNoTypeArguments x',
          'handleType int x',
          'handleIdentifier x formalParameterDeclaration',
          'handleFormalParameterWithoutValue )',
          'beginTypeVariables null null x FormalParameterKind.mandatory '
              'MemberKind.GeneralizedFunctionType',
          'endFormalParameters 1 ( ) MemberKind.GeneralizedFunctionType',
          'endFunctionType Function Function',
          'beginFormalParameters ( MemberKind.GeneralizedFunctionType',
          'beginMetadataStar int',
          'endMetadataStar 0',
          'beginFormalParameter int MemberKind.GeneralizedFunctionType',
          'handleModifiers 0',
          'handleIdentifier int typeReference',
          'handleNoTypeArguments x',
          'handleType int x',
          'handleIdentifier x formalParameterDeclaration',
          'handleFormalParameterWithoutValue )',
          'beginTypeVariables null null x FormalParameterKind.mandatory '
              'MemberKind.GeneralizedFunctionType',
          'endFormalParameters 1 ( ) MemberKind.GeneralizedFunctionType',
          'endFunctionType Function ',
        ]);
  }

  void test_computeType_void() {
    expectInfo(voidTypeInfo, 'void');
    expectInfo(voidTypeInfo, 'void;');
    expectInfo(voidTypeInfo, 'void(');
    expectInfo(voidTypeInfo, 'void<');
    expectInfo(voidTypeInfo, 'void=');
    expectInfo(voidTypeInfo, 'void*');
    expectInfo(voidTypeInfo, 'void<T>');
    expectInfo(voidTypeInfo, 'void do');
    expectInfo(voidTypeInfo, 'void foo');
    expectInfo(voidTypeInfo, 'void get');
    expectInfo(voidTypeInfo, 'void set');
    expectInfo(voidTypeInfo, 'void operator');
    expectInfo(voidTypeInfo, 'void Function');
    expectComplexInfo('void Function(', // Scanner inserts synthetic ')'.
        expectedCalls: [
          'handleNoTypeVariables (',
          'beginFunctionType void',
          'handleVoidKeyword void',
          'beginFormalParameters ( MemberKind.GeneralizedFunctionType',
          'endFormalParameters 0 ( ) MemberKind.GeneralizedFunctionType',
          'endFunctionType Function ',
        ]);
  }

  void test_computeType_voidComplex() {
    expectComplexInfo('void Function()', expectedCalls: [
      'handleNoTypeVariables (',
      'beginFunctionType void',
      'handleVoidKeyword void',
      'beginFormalParameters ( MemberKind.GeneralizedFunctionType',
      'endFormalParameters 0 ( ) MemberKind.GeneralizedFunctionType',
      'endFunctionType Function ',
    ]);
    expectComplexInfo('void Function<T>()');
    expectComplexInfo('void Function(int)');
    expectComplexInfo('void Function<T>(int)');
    expectComplexInfo('void Function(int x)');
    expectComplexInfo('void Function<T>(int x)');
    expectComplexInfo('void Function<T>(int x) Function<T>(int x)');
  }
}

void expectInfo(expectedInfo, String source,
    {bool required,
    String expectedAfter,
    List<String> expectedCalls,
    List<ExpectedError> expectedErrors}) {
  Token start = scan(source);
  if (required == null) {
    compute(expectedInfo, source, start, true, expectedAfter, expectedCalls,
        expectedErrors);
    compute(expectedInfo, source, start, false, expectedAfter, expectedCalls,
        expectedErrors);
  } else {
    compute(expectedInfo, source, start, required, expectedAfter, expectedCalls,
        expectedErrors);
  }
}

void expectComplexInfo(String source,
    {bool required,
    String tokenAfter,
    List<String> expectedCalls,
    List<ExpectedError> expectedErrors}) {
  expectInfo(const isInstanceOf<ComplexTypeInfo>(), source,
      required: required,
      expectedAfter: tokenAfter,
      expectedCalls: expectedCalls,
      expectedErrors: expectedErrors);
}

void compute(
    expectedInfo,
    String source,
    Token start,
    bool required,
    String expectedAfter,
    List<String> expectedCalls,
    List<ExpectedError> expectedErrors) {
  TypeInfo typeInfo = computeType(start, required);
  expect(typeInfo, expectedInfo, reason: source);
  if (typeInfo is ComplexTypeInfo) {
    TypeInfoListener listener = new TypeInfoListener();
    Parser parser = new Parser(listener);
    expect(typeInfo.start, start.next, reason: source);
    expectEnd(expectedAfter, typeInfo.skipType(start));
    expectEnd(expectedAfter, typeInfo.parseType(start, parser));
    if (expectedCalls != null) {
      // TypeInfoListener listener2 = new TypeInfoListener();
      // new Parser(listener2).parseType(start, TypeContinuation.Required);
      // print('[');
      // for (String call in listener2.calls) {
      //   print("'$call',");
      // }
      // print(']');

      expect(listener.calls, expectedCalls, reason: source);
    }
    expect(listener.errors, expectedErrors, reason: source);
  } else {
    assert(expectedErrors == null);
  }
}

void expectEnd(String tokenAfter, Token end) {
  if (tokenAfter == null) {
    expect(end.isEof, isFalse);
    expect(end.next.isEof, isTrue);
  } else {
    expect(end.next.lexeme, tokenAfter);
  }
}

Token scan(String source) {
  Token start = scanString(source).tokens;
  while (start is ErrorToken) {
    start = start.next;
  }
  return new SyntheticToken(TokenType.EOF, 0)..setNext(start);
}

class TypeInfoListener implements Listener {
  List<String> calls = <String>[];
  List<ExpectedError> errors;

  @override
  void beginFormalParameter(Token token, MemberKind kind) {
    calls.add('beginFormalParameter $token $kind');
  }

  @override
  void beginFormalParameters(Token token, MemberKind kind) {
    calls.add('beginFormalParameters $token $kind');
  }

  @override
  void beginFunctionType(Token token) {
    calls.add('beginFunctionType $token');
  }

  @override
  void beginMetadataStar(Token token) {
    calls.add('beginMetadataStar $token');
  }

  @override
  void beginTypeArguments(Token token) {
    calls.add('beginTypeArguments $token');
  }

  @override
  void beginTypeVariable(Token token) {
    calls.add('beginTypeVariable $token');
  }

  @override
  void endFormalParameters(
      int count, Token beginToken, Token endToken, MemberKind kind) {
    calls.add('endFormalParameters $count $beginToken $endToken $kind');
  }

  @override
  void beginTypeVariables(Token token) {
    calls.add('beginTypeVariables $token');
  }

  @override
  void endFormalParameter(Token thisKeyword, Token periodAfterThis,
      Token nameToken, FormalParameterKind kind, MemberKind memberKind) {
    calls.add('beginTypeVariables $thisKeyword $periodAfterThis '
        '$nameToken $kind $memberKind');
  }

  @override
  void endFunctionType(Token functionToken, Token endToken) {
    calls.add('endFunctionType $functionToken $endToken');
  }

  @override
  void endMetadataStar(int count) {
    calls.add('endMetadataStar $count');
  }

  @override
  void endTypeArguments(int count, Token beginToken, Token endToken) {
    calls.add('endTypeArguments $count $beginToken $endToken');
  }

  @override
  void endTypeVariable(Token token, Token extendsOrSuper) {
    calls.add('endTypeVariable $token $extendsOrSuper');
  }

  @override
  void endTypeVariables(int count, Token beginToken, Token endToken) {
    calls.add('endTypeVariables $count $beginToken $endToken');
  }

  @override
  void handleFormalParameterWithoutValue(Token token) {
    calls.add('handleFormalParameterWithoutValue $token');
  }

  @override
  void handleIdentifier(Token token, IdentifierContext context) {
    calls.add('handleIdentifier $token $context');
  }

  @override
  void handleModifiers(int count) {
    calls.add('handleModifiers $count');
  }

  @override
  void handleNoName(Token token) {
    calls.add('handleNoName $token');
  }

  @override
  void handleNoType(Token token) {
    calls.add('handleNoType $token');
  }

  @override
  void handleNoTypeArguments(Token token) {
    calls.add('handleNoTypeArguments $token');
  }

  @override
  void handleNoTypeVariables(Token token) {
    calls.add('handleNoTypeVariables $token');
  }

  @override
  void handleRecoverableError(
      Message message, Token startToken, Token endToken) {
    errors ??= <ExpectedError>[];
    int offset = startToken.charOffset;
    errors.add(error(message.code, offset, endToken.charEnd - offset));
  }

  @override
  void handleQualified(Token token) {
    calls.add('handleQualified $token');
  }

  @override
  void handleType(Token beginToken, Token endToken) {
    calls.add('handleType $beginToken $endToken');
  }

  @override
  void handleVoidKeyword(Token token) {
    calls.add('handleVoidKeyword $token');
  }

  noSuchMethod(Invocation invocation) {
    throw '${invocation.memberName} should not be called.';
  }
}

ExpectedError error(Code code, int start, int length) =>
    new ExpectedError(code, start, length);

class ExpectedError {
  final Code code;
  final int start;
  final int length;

  ExpectedError(this.code, this.start, this.length);

  @override
  bool operator ==(other) =>
      other is ExpectedError &&
      code == other.code &&
      start == other.start &&
      length == other.length;

  @override
  String toString() => 'error(${code.name}, $start, $length)';
}