anchor.diff:      boolExpressionVerifier.checkForNonBoolCondition(node.condition,
           whyNotPromoted: whyNotPromoted);
   
  -    Statement body = node.body;
       flowAnalysis.flow?.whileStatement_bodyBegin(node, condition);
  -    body.accept(this);
  +    node.body.accept(this);
       flowAnalysis.flow?.whileStatement_end();
       nullSafetyDeadCodeVerifier.flowEnd(node.body);
       // TODO(brianwilkerson) If the loop can only be exited because the condition
  
positive.code:     boolExpressionVerifier.checkForNonBoolCondition(condition,
          whyNotPromoted: whyNotPromoted);
  
      Expression thenExpression = node.thenExpression;
      InferenceContext.setTypeFromNode(thenExpression, node);
  
      if (flow != null) {
        flow.conditional_thenBegin(condition, node);
        checkUnreachableNode(thenExpression);
      }
      thenExpression.accept(this);
      nullSafetyDeadCodeVerifier.flowEnd(thenExpression);
  
      Expression elseExpression = node.elseExpression;
      InferenceContext.setTypeFromNode(elseExpression, node);
  
      if (flow != null) {
        flow.conditional_elseBegin(thenExpression);
        checkUnreachableNode(elseExpression);
        elseExpression.accept(this);
        flow.conditional_end(node, elseExpression);
  
negative.code:     var expression = node.expression;
      InferenceContext.setType(expression, fieldType);
      expression.accept(this);
      expression = node.expression;
      var whyNotPromoted = flowAnalysis.flow?.whyNotPromoted(expression);
      node.accept(elementResolver);
      node.accept(typeAnalyzer);
  