anchor.diff:      expect(previewInfo.applyTo(code), 'f(a) => (throw a)..b;');
     }
   
  -  void test_removeAs_lower_precedence_do_not_remove_inner_parens() async {
  +  Future<void>
  +      test_removeAs_lower_precedence_do_not_remove_inner_parens() async {
       await analyze('f(a, b, c) => (a == b) as Null == c;');
       var expr = findNode.binary('a == b');
       var previewInfo = run({expr.parent.parent: const RemoveAs()});
       expect(previewInfo.applyTo(code), 'f(a, b, c) => (a == b) == c;');
     }
   
  -  void test_removeAs_lower_precedence_remove_inner_parens() async {
  +  Future<void> test_removeAs_lower_precedence_remove_inner_parens() async {
       await analyze('f(a, b) => (a == b) as Null;');
       var expr = findNode.binary('a == b');
       var previewInfo = run({expr.parent.parent: const RemoveAs()});
       expect(previewInfo.applyTo(code), 'f(a, b) => a == b;');
     }
   
  -  void test_removeAs_parens_needed_due_to_cascade() async {
  +  Future<void> test_removeAs_parens_needed_due_to_cascade() async {
       // Note: spaces around parens to verify that we don't remove the old parens
       // and create new ones.
       await analyze('f(a, c) => a..b = throw ( c..d ) as int;');
  
positive.code:     expect(previewInfo.applyTo(code), 'f(a, b) => (a = b)..c;');
    }
  
    void test_removeAs_in_cascade_target_parens_needed_throw() async {
      await analyze('f(a) => ((throw a) as dynamic)..b;');
      var throw_ = findNode.throw_('throw a');
      var cast = throw_.parent.parent;
  
negative.code:     expect(previewInfo.applyTo(code), 'f(a, b, d) => a ? (b..c) : d;');
    }
  
    Future<void> test_removeAs_raise_precedence_do_not_remove_parens() async {
      await analyze('f(a, b, c) => a | (b | c as int);');
      var expr = findNode.binary('b | c');
      var previewInfo = run({expr.parent: const RemoveAs()});
      expect(previewInfo.applyTo(code), 'f(a, b, c) => a | (b | c);');
    }
  
    Future<void> test_removeAs_raise_precedence_no_parens_to_remove() async {
      await analyze('f(a, b, c) => a = b | c as int;');
      var expr = findNode.binary('b | c');
      var previewInfo = run({expr.parent: const RemoveAs()});
      expect(previewInfo.applyTo(code), 'f(a, b, c) => a = b | c;');
    }
  
    Future<void> test_removeAs_raise_precedence_remove_parens() async {
      await analyze('f(a, b, c) => a < (b | c as int);');
      var expr = findNode.binary('b | c');
      var previewInfo = run({expr.parent: const RemoveAs()});
  