anchor.diff:            destinationType.typeArguments.length);
         for (int i = 0; i < sourceType.typeArguments.length; i++) {
           _checkAssignment(destinationType.typeArguments[i],
  -            sourceType.typeArguments[i], expression);
  +            sourceType.typeArguments[i], expressionChecks,
  +            hard: false);
         }
       } else if (destinationType.type.isDynamic || sourceType.type.isDynamic) {
         // ok; nothing further to do.
  
positive.code:   }
  
    /// 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.
    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));
      }
      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;
      // TODO(paulberry): generalize this.
      if ((_isSimple(sourceType) || destinationType.type.isObject) &&
          _isSimple(destinationType)) {
  
negative.code:   @override
    DecoratedType visitReturnStatement(ReturnStatement node) {
      if (node.expression == null) {
        _checkAssignment(_currentFunctionType.returnType, _nullType, null,
            hard: false);
      } else {
        _handleAssignment(_currentFunctionType.returnType, node.expression);
      }
  