anchor.diff:    }
   
     void test_missingAssignableSelector_prefix_minusMinus_literal() {
  -    parseExpression("--0",
  -        codes: [ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR]);
  +    parseExpression("--0", errors: [
  +      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 2, 1)
  +    ]);
     }
   
     void test_missingAssignableSelector_prefix_plusPlus_literal() {
  -    parseExpression("++0",
  -        codes: [ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR]);
  +    parseExpression("++0", errors: [
  +      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 2, 1)
  +    ]);
     }
   
     void test_missingAssignableSelector_selector() {
  
positive.code:     // TODO(brianwilkerson) When this test starts to pass, remove the test
      // test_illegalAssignmentToNonAssignable_superAssigned.
      parseExpression("super = x;",
          codes: [ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE]);
    }
  
    void test_implementsBeforeExtends() {
      parseCompilationUnit("class A implements B extends C {}",
          codes: [ParserErrorCode.IMPLEMENTS_BEFORE_EXTENDS]);
    }
  
    void test_implementsBeforeWith() {
      parseCompilationUnit("class A extends B implements C with D {}",
          codes: [ParserErrorCode.IMPLEMENTS_BEFORE_WITH]);
    }
  
    void test_importDirectiveAfterPartDirective() {
      parseCompilationUnit("part 'a.dart'; import 'b.dart';",
          codes: [ParserErrorCode.IMPORT_DIRECTIVE_AFTER_PART_DIRECTIVE]);
    }
  
    void test_initializedVariableInForEach() {
      Statement statement = parseStatement('for (int a = 0 in foo) {}');
      expectNotNullIfNoErrors(statement);
      listener.assertErrorsWithCodes(
          [ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH]);
    }
  
    void test_invalidAwaitInFor() {
      Statement statement = parseStatement('await for (; ;) {}');
      expectNotNullIfNoErrors(statement);
      listener.assertErrorsWithCodes([ParserErrorCode.INVALID_AWAIT_IN_FOR]);
    }
  
    void test_invalidCodePoint() {
      StringLiteral literal = parseExpression("'\\u{110000}'",
          codes: [ParserErrorCode.INVALID_CODE_POINT]);
      expectNotNullIfNoErrors(literal);
    }
  
  
negative.code:     FormalParameter parameter =
          parser.parseFormalParameterList(inFunctionType: true).parameters[0];
      expectNotNullIfNoErrors(parameter);
      listener.assertErrors([
        expectedError(ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE, 8, 1),
        expectedError(ParserErrorCode.MISSING_NAME_FOR_NAMED_PARAMETER, 7, 1)
      ]);
      expect(parameter.identifier, isNotNull);
    }
  