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

package com.google.dart.compiler.parser;

import static com.google.dart.compiler.parser.ParserEventsTest.Mark.ArrayLiteral;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.BinaryExpression;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.Block;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.BreakStatement;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.CatchClause;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.CatchParameter;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.ClassBody;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.ClassMember;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.CompilationUnit;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.ConditionalExpression;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.ConstExpression;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.ConstructorName;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.ContinueStatement;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.DoStatement;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.EmptyStatement;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.Expression;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.ExpressionList;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.ExpressionStatement;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.FieldInitializerOrRedirectedConstructor;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.FinalDeclaration;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.ForInitialization;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.ForStatement;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.FormalParameterList;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.FunctionDeclaration;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.FunctionLiteral;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.FunctionTypeInterface;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.Identifier;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.IfStatement;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.Initializer;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.Label;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.Literal;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.MapLiteral;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.MapLiteralEntry;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.MethodName;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.NativeBody;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.NewExpression;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.OperatorName;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.ParenthesizedExpression;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.PostfixExpression;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.QualifiedIdentifier;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.ReturnStatement;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.SelectorExpression;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.SpreadExpression;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.StringInterpolation;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.StringSegment;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.SuperExpression;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.SuperInitializer;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.SwitchMember;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.SwitchStatement;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.ThisExpression;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.ThrowStatement;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.TopLevelElement;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.TryStatement;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.TypeAnnotation;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.TypeArguments;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.TypeExpression;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.TypeFunctionOrVarable;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.TypeParameter;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.UnaryExpression;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.VarDeclaration;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.VariableDeclaration;
import static com.google.dart.compiler.parser.ParserEventsTest.Mark.WhileStatement;

import com.google.common.collect.Sets;
import com.google.dart.compiler.DartCompilerListener;
import com.google.dart.compiler.Source;
import com.google.dart.compiler.metrics.CompilerMetrics;

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

public class ParserEventsTest extends AbstractParserTest {

  /**
   * A collection of marks representing interesting parser states. Copied from
   * com.google.dart.tools.core.internal.completion.
   * <p>
   * TODO(messick) Find a way to share the implementation of Mark.
   */
  static enum Mark {
    // some elements are roots of the kind-of relationships, they must be first
    Block,
    Expression,
    Literal(Expression),
    FormalParameterList,
    Statement,
    // all others are alphabetical
    ArrayLiteral(Literal),
    BinaryExpression(Expression),
    BreakStatement(Statement),
    CatchClause,
    CatchParameter,
    ClassBody(Block),
    ClassMember,
    CompilationUnit,
    ConditionalExpression(Expression),
    FinalDeclaration,
    ConstExpression(Expression),
    ConstructorName,
    ContinueStatement(Statement),
    DoStatement(Statement),
    EmptyStatement(Statement),
    ExpressionList,
    ExpressionStatement(Statement),
    FieldInitializerOrRedirectedConstructor,
    ForInitialization,
     ForStatement(Statement),
    FunctionDeclaration,
    FunctionLiteral(Literal),
    FunctionTypeInterface,
    Identifier(Expression),
    IfStatement(Statement),
    Initializer,
    TypeExpression(Expression),
    Label,
    MapLiteral(Literal),
    MapLiteralEntry,
    MethodName,
    NativeBody,
    NewExpression(Expression),
    OperatorName,
    ParenthesizedExpression(Expression),
    PostfixExpression(Expression),
    QualifiedIdentifier,
    ReturnStatement(Statement),
    SelectorExpression(Expression),
    SpreadExpression(Expression),
    StringInterpolation,
    StringSegment,
    SuperExpression(Expression),
    SuperInitializer,
    SwitchMember,
    SwitchStatement(Statement),
    ThisExpression(Expression),
    ThrowStatement(Statement),
    TopLevelElement,
    TryStatement(Statement),
    TypeAnnotation,
    TypeArguments,
    TypeFunctionOrVarable,
    TypeParameter,
    UnaryExpression(Expression),
    VarDeclaration,
    VariableDeclaration,
    WhileStatement(Statement);

    public final Mark kind;

    private Mark() {
      kind = null;
    }

    private Mark(Mark kind) {
      this.kind = kind;
    }

    /**
     * Return <code>true</code> if this Mark has a kind-of relation to the given Mark.
     *
     * @param other the Mark to test for a kind-of relation
     * @return <code>true</code> if the test succeeds
     */
    public boolean isKindOf(Mark other) {
      if (this == other) {
        return true;
      }
      if (kind == null) {
        return false;
      }
      return kind.isKindOf(other);
    }
  }

  private static class ParserEventRecorder extends DartParser {
    private LinkedHashSet<Mark> marks;

    @Override
    protected void rollback() {
      super.rollback();
      Mark lastMark = null;
      for (Mark mark: marks) {
        lastMark = mark;
      }
      if (lastMark != null) {
        marks.remove(lastMark);
      }
    }

    public ParserEventRecorder(Source source,
        String sourceCode,
        boolean isDietParse,
        Set<String> prefixes,
        DartCompilerListener listener,
        CompilerMetrics compilerMetrics) {
      super(source, sourceCode, isDietParse, prefixes, listener, compilerMetrics);
      marks = new LinkedHashSet<Mark>();
    }

    @SuppressWarnings({"unchecked", "rawtypes"})
    public HashSet<Mark> copyMarks() {
      return (HashSet) marks.clone();
    }

    @Override
    protected void beginArrayLiteral() {
      super.beginArrayLiteral();
      recordMark(ArrayLiteral);
    }

    @Override
    protected void beginBinaryExpression() {
      super.beginBinaryExpression();
      recordMark(BinaryExpression);
    }

    @Override
    protected void beginBlock() {
      super.beginBlock();
      recordMark(Block);
    }

    @Override
    protected void beginBreakStatement() {
      super.beginBreakStatement();
      recordMark(BreakStatement);
    }

    @Override
    protected void beginCatchClause() {
      super.beginCatchClause();
      recordMark(CatchClause);
    }

    @Override
    protected void beginCatchParameter() {
      super.beginFormalParameter();
      recordMark(CatchParameter);
    }

    @Override
    protected void beginClassBody() {
      super.beginClassBody();
      recordMark(ClassBody);
    }

    @Override
    protected void beginClassMember() {
      super.beginClassMember();
      recordMark(ClassMember);
    }

    @Override
    protected void beginCompilationUnit() {
      super.beginCompilationUnit();
      recordMark(CompilationUnit);
    }

    @Override
    protected void beginConditionalExpression() {
      super.beginConditionalExpression();
      recordMark(ConditionalExpression);
    }

    @Override
    protected void beginConstExpression() {
      super.beginConstExpression();
      recordMark(ConstExpression);
    }

    @Override
    protected void beginConstructor() {
      super.beginConstructor();
      recordMark(ConstructorName);
    }

    @Override
    protected void beginContinueStatement() {
      super.beginContinueStatement();
      recordMark(ContinueStatement);
    }

    @Override
    protected void beginDoStatement() {
      super.beginDoStatement();
      recordMark(DoStatement);
    }

    @Override
    protected void beginEmptyStatement() {
      super.beginEmptyStatement();
      recordMark(EmptyStatement);
    }

    @Override
    protected void beginEntryPoint() {
      super.beginEntryPoint();
      // TODO(messick): add recording
    }

    @Override
    protected void beginExpression() {
      super.beginExpression();
      recordMark(Expression);
    }

    @Override
    protected void beginExpressionList() {
      super.beginExpressionList();
      recordMark(ExpressionList);
    }

    @Override
    protected void beginExpressionStatement() {
      super.beginExpressionStatement();
      recordMark(ExpressionStatement);
    }

    @Override
    protected void beginFieldInitializerOrRedirectedConstructor() {
      super.beginFieldInitializerOrRedirectedConstructor();
      recordMark(FieldInitializerOrRedirectedConstructor);
    }

    @Override
    protected void beginFinalDeclaration() {
      super.beginFinalDeclaration();
      recordMark(FinalDeclaration);
    }

    @Override
    protected void beginForInitialization() {
      super.beginForInitialization();
      recordMark(ForInitialization);
    }

    @Override
    protected void beginFormalParameterList() {
      super.beginFormalParameterList();
      recordMark(FormalParameterList);
    }

    @Override
    protected void beginForStatement() {
      super.beginForStatement();
      recordMark(ForStatement);
    }

    @Override
    protected void beginFunctionDeclaration() {
      super.beginFunctionDeclaration();
      recordMark(FunctionDeclaration);
    }

    @Override
    protected void beginFunctionLiteral() {
      super.beginFunctionLiteral();
      recordMark(FunctionLiteral);
    }

    @Override
    protected void beginFunctionTypeInterface() {
      super.beginFunctionTypeInterface();
      recordMark(FunctionTypeInterface);
    }

    @Override
    protected void beginIdentifier() {
      super.beginIdentifier();
      recordMark(Identifier);
    }

    @Override
    protected void beginIfStatement() {
      super.beginIfStatement();
      recordMark(IfStatement);
    }

    @Override
    protected void beginInitializer() {
      super.beginInitializer();
      recordMark(Initializer);
    }

    @Override
    protected void beginTypeExpression() {
      super.beginTypeExpression();
      recordMark(TypeExpression);
    }

    @Override
    protected void beginLabel() {
      super.beginLabel();
      recordMark(Label);
    }

    @Override
    protected void beginLiteral() {
      super.beginLiteral();
      recordMark(Literal);
    }

    @Override
    protected void beginMapLiteral() {
      super.beginMapLiteral();
      recordMark(MapLiteral);
    }

    @Override
    protected void beginMapLiteralEntry() {
      super.beginMapLiteralEntry();
      recordMark(MapLiteralEntry);
    }

    @Override
    protected void beginMethodName() {
      super.beginMethodName();
      recordMark(MethodName);
    }

    @Override
    protected void beginNativeBody() {
      super.beginNativeBody();
      recordMark(NativeBody);
    }

    @Override
    protected void beginNewExpression() {
      super.beginNewExpression();
      recordMark(NewExpression);
    }

    @Override
    protected void beginOperatorName() {
      super.beginOperatorName();
      recordMark(OperatorName);
    }

    @Override
    protected void beginParameter() {
      super.beginParameter();
      // TODO(messick): add recording
    }

    @Override
    protected void beginParameterName() {
      super.beginParameterName();
      // TODO(messick): add recording
    }

    @Override
    protected void beginParenthesizedExpression() {
      super.beginParenthesizedExpression();
      recordMark(ParenthesizedExpression);
    }

    @Override
    protected void beginPostfixExpression() {
      super.beginPostfixExpression();
      recordMark(PostfixExpression);
    }

    @Override
    protected void beginQualifiedIdentifier() {
      super.beginQualifiedIdentifier();
      recordMark(QualifiedIdentifier);
    }

    @Override
    protected void beginReturnStatement() {
      super.beginReturnStatement();
      recordMark(ReturnStatement);
    }

    @Override
    protected void beginReturnType() {
      super.beginReturnType();
      // TODO(messick): add recording
    }

    @Override
    protected void beginSelectorExpression() {
      super.beginSelectorExpression();
      recordMark(SelectorExpression);
    }

    @Override
    protected void beginSpreadExpression() {
      super.beginSpreadExpression();
      recordMark(SpreadExpression);
    }

    @Override
    protected void beginStringInterpolation() {
      super.beginStringInterpolation();
      recordMark(StringInterpolation);
    }

    @Override
    protected void beginStringSegment() {
      super.beginStringSegment();
      recordMark(StringSegment);
    }

    @Override
    protected void beginSuperExpression() {
      super.beginSuperExpression();
      recordMark(SuperExpression);
    }

    @Override
    protected void beginSuperInitializer() {
      super.beginSuperInitializer();
      recordMark(SuperInitializer);
    }

    @Override
    protected void beginSwitchMember() {
      super.beginSwitchMember();
      recordMark(SwitchMember);
    }

    @Override
    protected void beginSwitchStatement() {
      super.beginSwitchStatement();
      recordMark(SwitchStatement);
    }

    @Override
    protected void beginThisExpression() {
      super.beginThisExpression();
      recordMark(ThisExpression);
    }

    @Override
    protected void beginThrowExpression() {
      super.beginThrowExpression();
      recordMark(ThrowStatement);
    }

    @Override
    protected void beginTopLevelElement() {
      super.beginTopLevelElement();
      recordMark(TopLevelElement);
    }

    @Override
    protected void beginTryStatement() {
      super.beginTryStatement();
      recordMark(TryStatement);
    }

    @Override
    protected void beginTypeAnnotation() {
      super.beginTypeAnnotation();
      recordMark(TypeAnnotation);
    }

    @Override
    protected void beginTypeArguments() {
      super.beginTypeArguments();
      recordMark(TypeArguments);
    }

    @Override
    protected void beginTypeFunctionOrVariable() {
      super.beginTypeFunctionOrVariable();
      recordMark(TypeFunctionOrVarable);
    }

    @Override
    protected void beginTypeParameter() {
      super.beginTypeParameter();
      recordMark(TypeParameter);
    }

    @Override
    protected void beginUnaryExpression() {
      super.beginUnaryExpression();
      recordMark(UnaryExpression);
    }

    @Override
    protected void beginVarDeclaration() {
      super.beginVarDeclaration();
      recordMark(VarDeclaration);
    }

    @Override
    protected void beginVariableDeclaration() {
      super.beginVariableDeclaration();
      recordMark(VariableDeclaration);
    }

    @Override
    protected void beginWhileStatement() {
      super.beginWhileStatement();
      recordMark(WhileStatement);
    }

    private void recordMark(Mark mark) {
      marks.add(mark);
    }
  }

  private ParserEventRecorder recorder = null;

  @Override
  public void testListObjectLiterals() {
    parseUnit("ListObjectLiterals.dart");
  }

  @Override
  public void testCatchFinally() {
    parseUnit("CatchFinally.dart");
  }

  @Override
  public void testClasses() {
    parseUnit("ClassesInterfaces.dart");
    compareMarks(ReturnStatement, TopLevelElement, Block,
        ForStatement, ClassBody, FunctionLiteral, ParenthesizedExpression, TypeExpression,
        MethodName, ConditionalExpression, BinaryExpression, FormalParameterList,
        FunctionDeclaration, BreakStatement, PostfixExpression, SuperInitializer, TypeAnnotation,
        ClassMember, VarDeclaration, SwitchMember, CompilationUnit, Expression,
        TypeFunctionOrVarable, TypeParameter, ExpressionList, Identifier,
        IfStatement, QualifiedIdentifier, SwitchStatement,
        SelectorExpression, ForInitialization, CatchClause, CatchParameter,
        FieldInitializerOrRedirectedConstructor, ContinueStatement, Label, TryStatement, Literal,
        SpreadExpression, VariableDeclaration, TypeArguments, ExpressionStatement, ThrowStatement,
        WhileStatement, Initializer);
  }

  @Override
  public void testFormalParameters() {
    parseUnit("FormalParameters.dart");
    compareMarks(TopLevelElement, ClassMember, CompilationUnit,
        BinaryExpression, NativeBody, Identifier, TypeAnnotation, ClassBody,
        Literal, Block, PostfixExpression, MethodName, Expression, QualifiedIdentifier,
        FormalParameterList, ConditionalExpression);
  }

  @Override
  public void testFunctionInterfaces() {
    parseUnit("FunctionInterfaces.dart");
    compareMarks(TypeAnnotation, TopLevelElement, CompilationUnit,
        FormalParameterList, QualifiedIdentifier, Identifier, FunctionTypeInterface);
  }

  @Override
  public void testFunctionTypes() {
    parseUnit("FunctionTypes.dart");
    compareMarks(Identifier, TypeAnnotation, MethodName, CompilationUnit, ClassMember,
        TopLevelElement, NativeBody, QualifiedIdentifier, FormalParameterList, ClassBody, Block,
        VariableDeclaration);
  }

  @Override
  public void testGenericTypes() {
    parseUnit("GenericTypes.dart");
    compareMarks(NativeBody, MethodName, ClassBody, ExpressionStatement, FormalParameterList,
        Literal, ReturnStatement, Expression, TypeParameter,
        PostfixExpression, TopLevelElement, ConditionalExpression, ThisExpression, ConstructorName,
        NewExpression, QualifiedIdentifier, CompilationUnit, Block,
        Identifier, VariableDeclaration, BinaryExpression, ClassMember, TypeAnnotation);
  }

  @Override
  public void testMethodSignatures() {
    parseUnit("MethodSignatures.dart");
    compareMarks(TopLevelElement, ClassMember, TypeAnnotation,
        CompilationUnit, MethodName, QualifiedIdentifier, Identifier,
        ClassBody, FormalParameterList);
  }

  @Override
  public void testNewWithPrefix() {
    parseUnit("NewWithPrefix.dart");
    compareMarks(VarDeclaration, ClassMember, ConstructorName,
        ConditionalExpression, ConstExpression, Literal, NewExpression, Identifier, TypeAnnotation,
        PostfixExpression, FormalParameterList, QualifiedIdentifier, TopLevelElement,
        BinaryExpression, NativeBody, ClassBody, ExpressionStatement, MethodName, CompilationUnit,
        VariableDeclaration, Block, Expression);
  }

  @Override
  public void testRedirectedConstructor() {
    parseUnit("RedirectedConstructor.dart");
    compareMarks(BinaryExpression, CompilationUnit, FormalParameterList, ConditionalExpression,
        Expression, PostfixExpression, ClassBody, ThisExpression,
        Initializer, TopLevelElement, NativeBody, Block, MethodName, SuperInitializer, Literal,
        ClassMember, Identifier, QualifiedIdentifier, FieldInitializerOrRedirectedConstructor,
        TypeAnnotation, VariableDeclaration);
  }

  @Override
  public void testShifting() {
    parseUnit("Shifting.dart");
    compareMarks(Expression, ClassBody, TypeFunctionOrVarable, VariableDeclaration,
        CompilationUnit, ConditionalExpression, Identifier, ClassMember,
        Block, QualifiedIdentifier, NativeBody, OperatorName, TypeAnnotation, TypeArguments,
        PostfixExpression, BinaryExpression, FormalParameterList, TopLevelElement, Literal,
        ReturnStatement);
  }

  @Override
  public void testStringBuffer() {
    parseUnit("StringBuffer.dart");
    compareMarks(ClassBody, ConstructorName, TypeAnnotation,
        TypeFunctionOrVarable, NativeBody, SelectorExpression, TopLevelElement, Block,
        NewExpression, MethodName, Literal, Expression, CompilationUnit, Identifier,
        ThrowStatement, PostfixExpression, BinaryExpression, ClassMember, VariableDeclaration,
        ConditionalExpression, ExpressionStatement, ReturnStatement, IfStatement,
        QualifiedIdentifier, FormalParameterList, FunctionLiteral);
  }

  @Override
  public void testStrings() {
    parseUnit("Strings.dart");
    compareMarks(Expression, MethodName, ExpressionStatement, Block, ConditionalExpression,
        ClassBody, TopLevelElement, VariableDeclaration, CompilationUnit, ClassMember,
        PostfixExpression, BinaryExpression, VarDeclaration, Identifier, Literal,
        FormalParameterList, NativeBody);
  }

  @Override
  public void testStringsErrors() {
    parseUnitErrors("StringsErrorsNegativeTest.dart",
        "Unexpected token 'ILLEGAL'", 7, 13,
        "Unexpected token 'ILLEGAL'", 9, 9,
        "Unexpected token 'ILLEGAL'", 11, 9);
    compareMarks(NativeBody, TopLevelElement, PostfixExpression, ClassMember, CompilationUnit,
        VariableDeclaration, Identifier, BinaryExpression, ClassBody,
        ConditionalExpression, Literal, Expression, MethodName, ExpressionStatement, Block,
        FormalParameterList, VarDeclaration);
  }

  @Override
  public void testSuperCalls() {
    parseUnit("SuperCalls.dart");
    compareMarks(ExpressionStatement, ClassMember, SelectorExpression,
        VariableDeclaration, BinaryExpression, Literal, Identifier, SuperExpression,
        FormalParameterList, TopLevelElement, PostfixExpression, NativeBody, ClassBody, MethodName,
        CompilationUnit, Expression, VarDeclaration, Block, ConditionalExpression);
  }

  @Override
  public void testTiming() {
    // do nothing except stop broken superclass method from printing to console
  }

  @Override
  public void testTopLevel() {
    parseUnit("TopLevel.dart");
    compareMarks(ArrayLiteral, CompilationUnit, PostfixExpression, NativeBody, Literal, Identifier,
        ClassMember, Block, MethodName, TopLevelElement, TypeAnnotation, Expression,
        QualifiedIdentifier, ConditionalExpression, BinaryExpression, VariableDeclaration,
        FormalParameterList);
  }
  
  @Override
  protected DartParser makeParser(Source src, String sourceCode, DartCompilerListener listener) {
    recorder = new ParserEventRecorder(src, sourceCode, false, Sets.<String>newHashSet(), listener, null);
    return recorder;
  }

  private void compareMarks(Mark... expectedMarks) {
    HashSet<Mark> recordedMarks = recorder.copyMarks();
    for (Mark m : expectedMarks) {
      assertNotNull("Missing mark: " + m.name(), recordedMarks.remove(m));
    }
    for (Mark m : recordedMarks) {
      fail("Unexpected mark: " + m.name());
    }
  }
}