anchor.diff:    }
   
     /// Creates the necessary constraint(s) for an assignment from [sourceType] to
  -  /// [destinationType].  [expression] is the expression whose type is
  -  /// [sourceType]; it is the expression we will have to null-check in the case
  -  /// where a nullable source is assigned to a non-nullable destination.
  +  /// [destinationType].  [expressionChecks] tracks checks that might have to be
  +  /// done on the type of an expression.  [hard] indicates whether a hard edge
  +  /// should be created.
     void _checkAssignment(DecoratedType destinationType, DecoratedType sourceType,
  -      Expression expression,
  -      {bool hard}) {
  -    if (expression != null) {
  -      _variables.recordExpressionChecks(
  -          _source,
  -          expression,
  -          ExpressionChecks(
  -              expression.end, sourceType.node, destinationType.node, _guards));
  -    }
  +      ExpressionChecks expressionChecks,
  +      {@required bool hard}) {
       NullabilityNode.recordAssignment(
           sourceType.node, destinationType.node, _guards, _graph,
  -        hard: hard ??
  -            (_isVariableOrParameterReference(expression) &&
  -                !_inConditionalControlFlow));
  -    // TODO(paulberry): it's a cheat to pass in expression=null for the
  -    // recursive checks.  Really we want to unify all the checks in a single
  -    // ExpressionChecks object.
  -    expression = null;
  +        hard: hard);
       // TODO(paulberry): generalize this.
       if ((_isSimple(sourceType) || destinationType.type.isObject) &&
           _isSimple(destinationType)) {
  
positive.code:       throw StateError('No type computed for ${expression.runtimeType} '
            '(${expression.toSource()}) offset=${expression.offset}');
      }
      _checkAssignment(
          destinationType, sourceType, canInsertChecks ? expression : null);
      return sourceType;
    }
  
  
negative.code:   @override
    DecoratedType visitReturnStatement(ReturnStatement node) {
      if (node.expression == null) {
        _checkAssignment(_currentFunctionType.returnType, _nullType, null,
            hard: false);
      } else {
        _handleAssignment(_currentFunctionType.returnType, node.expression);
      }
  