anchor.diff:      ]);
     }
   
  -  test_minus_null() async {
  -    await assertErrorsInCode(r'''
  -m() {
  -  Null x;
  -  x - 3;
  -}
  -''', [
  -      error(CompileTimeErrorCode.UNDEFINED_OPERATOR, 20, 1),
  -    ]);
  -  }
  -
  -  test_minusEq_null() async {
  -    await assertErrorsInCode(r'''
  -m() {
  -  Null x;
  -  x -= 1;
  -}
  -''', [
  -      error(HintCode.UNUSED_LOCAL_VARIABLE, 13, 1),
  -      error(CompileTimeErrorCode.UNDEFINED_OPERATOR, 20, 2),
  -    ]);
  -  }
  -
  -  test_plus_null() async {
  -    await assertErrorsInCode(r'''
  -m() {
  -  Null x;
  -  x + 3;
  -}
  -''', [
  -      error(CompileTimeErrorCode.UNDEFINED_OPERATOR, 20, 1),
  -    ]);
  -  }
  -
     test_plus_undefined() async {
       await assertErrorsInCode(r'''
   class A {}
  
positive.code:     ]);
    }
  
    test_postfixInc_null() async {
      await assertErrorsInCode(r'''
  m() {
    Null x;
    x++;
  }
  ''', [
        error(HintCode.UNUSED_LOCAL_VARIABLE, 13, 1),
        error(CompileTimeErrorCode.UNDEFINED_OPERATOR, 19, 2),
      ]);
    }
  
    test_prefixDec_null() async {
      await assertErrorsInCode(r'''
  m() {
    Null x;
    --x;
  }
  ''', [
        error(HintCode.UNUSED_LOCAL_VARIABLE, 13, 1),
        error(CompileTimeErrorCode.UNDEFINED_OPERATOR, 18, 2),
      ]);
    }
  
    test_prefixExpression() async {
      await assertNoErrorsInCode(r'''
  class A {}
  f(var a) {
    if (a is A) {
      ++a;
    }
  }
  ''');
    }
  
    test_prefixExpression_inSubtype() async {
      await assertNoErrorsInCode(r'''
  class A {}
  class B extends A {
    operator +(B b) {return new B();}
  }
  f(var a) {
    if (a is A) {
      ++a;
    }
  }
  ''');
    }
  
    test_prefixExpression_mixin() async {
      await assertErrorsInCode(r'''
  mixin M {}
  
negative.code: ''', [
        error(CompileTimeErrorCode.UNDEFINED_OPERATOR, 24, 1),
      ]);
    }
  
    test_postfixExpression_mixin() async {
  