anchor.diff:  
   import 'package:kernel/ast.dart';
   
  +/// An [Accessor] represents a subexpression for which we can't yet build a
  +/// kernel [Expression] because we don't yet know the context in which it is
  +/// used.
  +///
  +/// Once the context is known, an [Accessor] can be converted into an
  +/// [Expression] by calling a "build" method.
  +///
  +/// For example, when building a kernel representation for `a[x] = b`, after
  +/// parsing `a[x]` but before parsing `= b`, we don't yet know whether to
  +/// generate an invocation of `operator[]` or `operator[]=`, so we generate an
  +/// [Accessor] object.  Later, after `= b` is parsed, [buildAssignment] will be
  +/// called.
   abstract class Accessor {
  +  /// Builds an [Expression] representing a read from the accessor.
     Expression buildSimpleRead() {
       return _finish(_makeSimpleRead());
     }
   
  -  /// Returns an assignment to the accessor.
  +  /// Builds an [Expression] representing an assignment with the accessor on
  +  /// the LHS and [value] on the RHS.
     ///
     /// The returned expression evaluates to the assigned value, unless
     /// [voidContext] is true, in which case it may evaluate to anything.
  
positive.code:     return _finish(_makeSimpleWrite(value, voidContext));
    }
  
    Expression buildNullAwareAssignment(Expression value, DartType type,
        {bool voidContext: false}) {
      if (voidContext) {
  
negative.code: 
    Expression _finish(Expression body) => body;
  
    /// Returns an [Expression] representing a compile-time error.
    ///
    /// At runtime, an exception will be thrown.
    makeInvalidRead() => new InvalidExpression();
  
    /// Returns an [Expression] representing a compile-time error wrapping
    /// [value].
    ///
    /// At runtime, [value] will be evaluated before throwing an exception.
    makeInvalidWrite(Expression value) => wrapInvalid(value);
  }
  
  