anchor.diff:      createParser('');
       CommentReference reference = parser.parseCommentReference('new 42', 0);
       expectNotNullIfNoErrors(reference);
  -    listener.assertErrorsWithCodes([ParserErrorCode.INVALID_COMMENT_REFERENCE]);
  +    listener.assertErrors(
  +        [expectedError(ParserErrorCode.INVALID_COMMENT_REFERENCE, 0, 6)]);
     }
   
     @failingTest
  
positive.code:     // to parse it as an expression statement. It isn't clear what the best
      // error message is in this case.
      parseStatement("int f { return x;}");
      assertErrorsWithCodes([ParserErrorCode.MISSING_FUNCTION_PARAMETERS]);
    }
  
    @failingTest
  
negative.code:     createParser('1 *');
      BinaryExpression expression = parser.parseMultiplicativeExpression();
      expectNotNullIfNoErrors(expression);
      listener.assertErrors(
          [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 3, 0)]);
    }
  
    void test_missingIdentifier_beforeClosingCurly() {
      createParser('int}');
      ClassMember member = parser.parseClassMember('C');
      expectNotNullIfNoErrors(member);
      listener.assertErrors([
        expectedError(ParserErrorCode.MISSING_IDENTIFIER, 3, 1),
        expectedError(ParserErrorCode.EXPECTED_TOKEN, 4, 1)
      ]);
    }
  
    void test_missingIdentifier_inEnum() {
      createParser('enum E {, TWO}');
      EnumDeclaration declaration = parseFullCompilationUnitMember();
      expectNotNullIfNoErrors(declaration);
      listener.assertErrors(
          [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 1)]);
    }
  
    void test_missingIdentifier_inSymbol_afterPeriod() {
      SymbolLiteral literal = parseSymbolLiteral('#a.');
      expectNotNullIfNoErrors(literal);
      listener.assertErrors(
          [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 3, 1)]);
    }
  
    void test_missingIdentifier_inSymbol_first() {
      SymbolLiteral literal = parseSymbolLiteral('#');
      expectNotNullIfNoErrors(literal);
      listener.assertErrors(
          [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 1, 1)]);
    }
  
    void test_missingIdentifierForParameterGroup() {
      createParser('(,)');
      FormalParameterList list = parser.parseFormalParameterList();
      expectNotNullIfNoErrors(list);
      listener.assertErrors(
          [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 1, 1)]);
    }
  
    void test_missingKeywordOperator() {
      createParser('+(x) {}');
      MethodDeclaration method = parser.parseClassMember('C');
      expectNotNullIfNoErrors(method);
      listener.assertErrors(
          [expectedError(ParserErrorCode.MISSING_KEYWORD_OPERATOR, 0, 1)]);
    }
  
    void test_missingKeywordOperator_parseClassMember() {
      createParser('+() {}');
      ClassMember member = parser.parseClassMember('C');
      expectNotNullIfNoErrors(member);
      listener.assertErrors(
          [expectedError(ParserErrorCode.MISSING_KEYWORD_OPERATOR, 0, 1)]);
    }
  
    void test_missingKeywordOperator_parseClassMember_afterTypeName() {
      createParser('int +() {}');
      ClassMember member = parser.parseClassMember('C');
      expectNotNullIfNoErrors(member);
      listener.assertErrors(
          [expectedError(ParserErrorCode.MISSING_KEYWORD_OPERATOR, 4, 1)]);
    }
  
    void test_missingKeywordOperator_parseClassMember_afterVoid() {
      createParser('void +() {}');
      ClassMember member = parser.parseClassMember('C');
      expectNotNullIfNoErrors(member);
      listener.assertErrors(
          [expectedError(ParserErrorCode.MISSING_KEYWORD_OPERATOR, 5, 1)]);
    }
  
    void test_missingMethodParameters_void_block() {
      createParser('void m {} }');
      ClassMember member = parser.parseClassMember('C');
      expectNotNullIfNoErrors(member);
      listener.assertErrors(
          [expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 7, 1)]);
      expect(member, new isInstanceOf<MethodDeclaration>());
      MethodDeclaration method = member;
      expect(method.parameters, hasLength(0));
  