anchor.diff:  
   /// Class with an `async` implementation of `operator >>>`
   class Async {
  -  Future<C> operator>>>(C other) async => other;
  +  Future<C> operator >>>(C value) async => value;
  +}
  +
  +/// Class with an `async*` implementation of `operator >>>`
  +class AsyncStar {
  +  Stream<C> operator >>>(C value) async* {
  +    yield value;
  +  }
  +}
  +
  +/// Class with a `sync*` implementation of `operator >>>`
  +class SyncStar {
  +  Iterable<C> operator >>>(C value) sync* {
  +    yield value;
  +  }
   }
   
   /// Helper class to record precedence and associativity of operators.
   class Assoc {
     final String ops;
     Assoc(this.ops);
  -  Assoc operator~() => Assoc("(~${this}}");
  -  Assoc operator+(Assoc other) => Assoc("(${this}+$other)");
  -  Assoc operator/(Assoc other) => Assoc("(${this}/$other)");
  -  Assoc operator&(Assoc other) => Assoc("(${this}&$other)");
  -  Assoc operator|(Assoc other) => Assoc("(${this}|$other)");
  -  Assoc operator^(Assoc other) => Assoc("(${this}^$other)");
  -  Assoc operator>(Assoc other) => Assoc("(${this}>$other)");
  -  Assoc operator>>(Assoc other) => Assoc("(${this}>>$other)");
  -  Assoc operator>>>(Assoc other) => Assoc("(${this}>>>$other)");
  +  Assoc operator ~() => Assoc("(~${this})");
  +  Assoc operator +(Assoc other) => Assoc("(${this}+$other)");
  +  Assoc operator /(Assoc other) => Assoc("(${this}/$other)");
  +  Assoc operator &(Assoc other) => Assoc("(${this}&$other)");
  +  Assoc operator |(Assoc other) => Assoc("(${this}|$other)");
  +  Assoc operator ^(Assoc other) => Assoc("(${this}^$other)");
  +  Assoc operator >(Assoc other) => Assoc("(${this}>$other)");
  +  Assoc operator >>(Assoc other) => Assoc("(${this}>>$other)");
  +  Assoc operator >>>(Assoc other) => Assoc("(${this}>>>$other)");
  +  Assoc operator <(Assoc other) => Assoc("(${this}<$other)");
  +  Assoc operator >=(Assoc other) => Assoc("(${this}>=$other)");
  +  Assoc operator <=(Assoc other) => Assoc("(${this}<=$other)");
     String toString() => ops;
   }
  
positive.code:   Expect.isFalse(invocation.isAccessor);
    Expect.equals(#>>>, invocation.memberName);
    Expect.equals(1, invocation.positionalArguments.length);
    Expect.identical(c2, invocation.positionalArguments[1]);
    Expect.equals(0, invocation.namedArguments.length);
  
    invocation = (nsm >>>= c2);
  
negative.code:     Expect.identical(c2, (await fc1) >>> (await fc2));
      /// The operator itself can be async.
      var async = Async();
      Expect.identical(c1, await (async >>> c1));
  
      var asyncStar = AsyncStar();
      int count = 0;
      await for (var v in asyncStar >>> c1) {
        count++;
        Expect.identical(c1, v);
      }
      Expect.equals(1, count);
      asyncEnd();
    }();
  
    {
      var syncStar = SyncStar();
      int count = 0;
      for (var v in syncStar >>> c1) {
        count++;
        Expect.identical(c1, v);
      }
      Expect.equals(1, count);
    }
  
    // >>> has same precedence as >> (and <<), is left associative.
    // Binds weaker than addition/multiplication, stronger than other bitwise
  