anchor.diff:        Statement body) {
       assert(closureContext == null);
       this.helper = helper;
  -    closureContext =
  -        new ClosureContext(this, asyncMarker, returnType, false, true);
  +    closureContext = new ClosureContext(this, asyncMarker, returnType, false);
       inferStatement(body);
       closureContext = null;
       this.helper = null;
  
positive.code:     assert(_needToInferReturnType);
      DartType inferredType =
          inferrer.inferReturnType(_inferredUnwrappedReturnOrYieldType);
      if (returnOrYieldContext != null &&
          !_analyzerSubtypeOf(inferrer, inferredType, returnOrYieldContext)) {
        // If the inferred return type isn't a subtype of the context, we use the
        // context.
        inferredType = greatestClosure(inferrer.coreTypes, returnOrYieldContext);
  
negative.code:       bool isReturn,
        bool isYieldStar,
        bool isArrow) {
      var expectedType = isYieldStar
          ? _wrapAsyncOrGenerator(inferrer, returnOrYieldContext)
          : returnOrYieldContext;
      if (inferrer.ensureAssignable(expectedType, type, expression, fileOffset,
              isReturnFromAsync: isAsync,
              isReturn: isReturn,
              declaredReturnType: declaredReturnType,
              isArrow: isArrow) !=
          null) {
        type = greatestClosure(inferrer.coreTypes, expectedType);
      }
      if (_needToInferReturnType) {
        var unwrappedType = type;
        if (isAsync && isReturn) {
          unwrappedType = inferrer.typeSchemaEnvironment.unfutureType(type);
        } else if (isYieldStar) {
          unwrappedType = inferrer.getDerivedTypeArgumentOf(
                  type,
                  isAsync
                      ? inferrer.coreTypes.streamClass
                      : inferrer.coreTypes.iterableClass) ??
              type;
        }
        if (_inferredUnwrappedReturnOrYieldType == null) {
          _inferredUnwrappedReturnOrYieldType = unwrappedType;
        } else {
  