anchor.diff:    }
   
     noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
  +
  +  @override
  +  Expression parseAdditiveExpression(String code) {
  +    return parseExpression(code);
  +  }
  +
  +  @override
  +  Expression parseAssignableExpression(String code, bool primaryAllowed) {
  +    return parseExpression(code);
  +  }
  +
  +  @override
  +  Expression parseAssignableSelector(String code, bool optional,
  +      {bool allowConditional: true}) {
  +    return parseExpression(code);
  +  }
  +
  +  @override
  +  AwaitExpression parseAwaitExpression(String code) {
  +    return parseExpression(code);
  +  }
  +
  +  @override
  +  Expression parseBitwiseAndExpression(String code) {
  +    return parseExpression(code);
  +  }
  +
  +  @override
  +  Expression parseBitwiseOrExpression(String code) {
  +    return parseExpression(code);
  +  }
  +
  +  @override
  +  Expression parseBitwiseXorExpression(String code) {
  +    return parseExpression(code);
  +  }
  +
  +  @override
  +  Expression parseCascadeSection(String code) {
  +    return parseExpression(code);
  +  }
  +
  +  @override
  +  CompilationUnit parseCompilationUnit(String source,
  +      {List<ErrorCode> codes, List<ExpectedError> errors}) {
  +    throw new UnimplementedError();
  +  }
  +
  +  @override
  +  ConditionalExpression parseConditionalExpression(String code) {
  +    return parseExpression(code);
  +  }
  +
  +  @override
  +  Expression parseConstExpression(String code) {
  +    return parseExpression(code);
  +  }
  +
  +  @override
  +  ConstructorInitializer parseConstructorInitializer(String code) {
  +    throw new UnimplementedError();
  +  }
  +
  +  @override
  +  CompilationUnit parseDirectives(String source,
  +      [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
  +    throw new UnimplementedError();
  +  }
  +
  +  @override
  +  BinaryExpression parseEqualityExpression(String code) {
  +    return parseExpression(code);
  +  }
   
     @override
     Expression parseExpression(String source,
  
positive.code:   }
  
    @failingTest
    void test_parseConstExpression_mapLiteral_untyped() {
      super.test_parseConstExpression_mapLiteral_untyped();
    }
  
    @failingTest
    void test_parseEqualityExpression_normal() {
      super.test_parseEqualityExpression_normal();
    }
  
negative.code:   }
  
    @override
    List<Expression> parseExpressionList(String code) {
      throw new UnimplementedError();
    }
  
    @override
    Expression parseExpressionWithoutCascade(String code) {
      return parseExpression(code);
    }
  
    @override
    FormalParameter parseFormalParameter(String code, ParameterKind kind,
        {List<ErrorCode> errorCodes: const <ErrorCode>[]}) {
      throw new UnimplementedError();
    }
  
    @override
    FormalParameterList parseFormalParameterList(String code,
        {bool inFunctionType: false,
        List<ErrorCode> errorCodes: const <ErrorCode>[],
        List<ExpectedError> errors}) {
      throw new UnimplementedError();
    }
  
    @override
    CompilationUnitMember parseFullCompilationUnitMember() {
      throw new UnimplementedError();
    }
  
    @override
    Directive parseFullDirective() {
      throw new UnimplementedError();
    }
  
    @override
    FunctionExpression parseFunctionExpression(String code) {
      return parseExpression(code);
    }
  
    @override
    InstanceCreationExpression parseInstanceCreationExpression(
        String code, Token newToken) {
      return parseExpression(code);
    }
  
    @override
    ListLiteral parseListLiteral(
        Token token, String typeArgumentsCode, String code) {
      return parseExpression(code);
    }
  
    @override
    TypedLiteral parseListOrMapLiteral(Token modifier, String code) {
      return parseExpression(code);
    }
  
    @override
    Expression parseLogicalAndExpression(String code) {
      return parseExpression(code);
    }
  
    @override
    Expression parseLogicalOrExpression(String code) {
      return parseExpression(code);
    }
  
    @override
    MapLiteral parseMapLiteral(
        Token token, String typeArgumentsCode, String code) {
      return parseExpression(code);
    }
  
    @override
    MapLiteralEntry parseMapLiteralEntry(String code) {
      throw new UnimplementedError();
    }
  
    @override
    Expression parseMultiplicativeExpression(String code) {
      return parseExpression(code);
    }
  
    @override
    InstanceCreationExpression parseNewExpression(String code) {
      return parseExpression(code);
    }
  
    @override
    NormalFormalParameter parseNormalFormalParameter(String code,
        {bool inFunctionType: false,
        List<ErrorCode> errorCodes: const <ErrorCode>[]}) {
      throw new UnimplementedError();
    }
  
    @override
    Expression parsePostfixExpression(String code) {
      return parseExpression(code);
    }
  
    @override
    Identifier parsePrefixedIdentifier(String code) {
      return parseExpression(code);
    }
  
    @override
    Expression parsePrimaryExpression(String code,
        {int expectedEndOffset, List<ExpectedError> errors}) {
      return parseExpression(code,
          expectedEndOffset: expectedEndOffset, errors: errors);
    }
  
    @override
    Expression parseRelationalExpression(String code) {
      return parseExpression(code);
    }
  
    @override
    RethrowExpression parseRethrowExpression(String code) {
      return parseExpression(code);
    }
  
    @override
    BinaryExpression parseShiftExpression(String code) {
      return parseExpression(code);
    }
  
    @override
    SimpleIdentifier parseSimpleIdentifier(String code) {
      return parseExpression(code);
    }
  
    @override
    Statement parseStatement(String source,
        {bool enableLazyAssignmentOperators, int expectedEndOffset}) {
      throw new UnimplementedError();
    }
  
    @override
    Expression parseStringLiteral(String code) {
      return parseExpression(code);
    }
  
    @override
    SymbolLiteral parseSymbolLiteral(String code) {
      return parseExpression(code);
    }
  
    @override
    Expression parseThrowExpression(String code) {
      return parseExpression(code);
    }
  
    @override
    Expression parseThrowExpressionWithoutCascade(String code) {
      return parseExpression(code);
    }
  
    @override
    PrefixExpression parseUnaryExpression(String code) {
      return parseExpression(code);
    }
  
    @override
    VariableDeclarationList parseVariableDeclarationList(String source) {
      throw new UnimplementedError();
    }
  
    Future setUp() async {
  