anchor.diff:    LazyExpression and(LazyExpression lhs, LazyExpression rhs) {
       return () {
         var expr = _Expression();
  -      flow.logicalBinaryOp_rightBegin(lhs(), isAnd: true);
  -      flow.logicalBinaryOp_end(expr, rhs(), isAnd: true);
  +      _flow.logicalBinaryOp_rightBegin(lhs(), isAnd: true);
  +      _flow.logicalBinaryOp_end(expr, rhs(), isAnd: true);
         return expr;
       };
     }
  
positive.code:       LazyExpression cond, LazyExpression ifTrue, LazyExpression ifFalse) {
      return () {
        var expr = _Expression();
        flow.conditional_thenBegin(cond());
        flow.conditional_elseBegin(ifTrue());
        flow.conditional_end(expr, ifFalse());
        return expr;
      };
    }
  
    /// Creates a [LazyExpression] representing an `== null` check performed on
  
negative.code:       // x, y, and z.  We promote x and y in the break path, and x and z in the
        // condition-false path.  After the loop, only x should be promoted.
        var h = _Harness();
        var x = h.addVar('x', 'int?');
        var y = h.addVar('y', 'int?');
        var z = h.addVar('z', 'int?');
        h.run((flow) {
          h.declare(x, initialized: true);
          h.declare(y, initialized: true);
          h.declare(z, initialized: true);
          var stmt = _Statement();
          flow.for_conditionBegin({});
          flow.for_bodyBegin(stmt, h.or(h.eqNull(x), h.eqNull(z))());
          h.if_(h.expr, () {
            h.promote(x, 'int');
            h.promote(y, 'int');
            flow.handleBreak(stmt);
          });
          flow.for_updaterBegin();
          flow.for_end();
          expect(flow.promotedType(x).type, 'int');
          expect(flow.promotedType(y), isNull);
          expect(flow.promotedType(z), isNull);
        });
      });
  
      test('forEach_bodyBegin() un-promotes', () {
        var h = _Harness();
        var x = h.addVar('x', 'int?');
        h.run((flow) {
          h.declare(x, initialized: true);
          h.promote(x, 'int');
          expect(flow.promotedType(x).type, 'int');
          flow.forEach_bodyBegin({x});
          expect(flow.promotedType(x), isNull);
          flow.forEach_end();
        });
      });
  
      test('forEach_end() restores state before loop', () {
        var h = _Harness();
        var x = h.addVar('x', 'int?');
        h.run((flow) {
          h.declare(x, initialized: true);
          flow.forEach_bodyBegin({});
          h.promote(x, 'int');
          expect(flow.promotedType(x).type, 'int');
          flow.forEach_end();
          expect(flow.promotedType(x), isNull);
        });
      });
  
      test('ifStatement_end(false) keeps else branch if then branch exits', () {
        var h = _Harness();
        var x = h.addVar('x', 'int?');
        h.run((flow) {
          h.declare(x, initialized: true);
          flow.ifStatement_thenBegin(h.eqNull(x)());
          flow.handleExit();
          flow.ifStatement_end(false);
          expect(flow.promotedType(x).type, 'int');
        });
      });
  
      void _checkIs(String declaredType, String tryPromoteType,
          String expectedPromotedType) {
        var h = _Harness();
        var x = h.addVar('x', 'int?');
        h.run((flow) {
          h.declare(x, initialized: true);
          var expr = _Expression();
          flow.isExpression_end(expr, x, false, _Type(tryPromoteType));
          flow.ifStatement_thenBegin(expr);
          if (expectedPromotedType == null) {
            expect(flow.promotedType(x), isNull);
          } else {
            expect(flow.promotedType(x).type, expectedPromotedType);
          }
          flow.ifStatement_elseBegin();
          expect(flow.promotedType(x), isNull);
          flow.ifStatement_end(true);
        });
      }
  
      test('isExpression_end promotes to a subtype', () {
  