anchor.diff:      // to `xi` in `B` having type `Pi`.  This produces `B’`.
       bool needToSetReturnType = hasImplicitReturnType && strongMode;
       ClosureContext oldClosureContext = this.closureContext;
  -    bool needImplicitDowncasts = returnContext != null;
       ClosureContext closureContext = new ClosureContext(
  -        this,
  -        function.asyncMarker,
  -        returnContext,
  -        needToSetReturnType,
  -        needImplicitDowncasts);
  +        this, function.asyncMarker, returnContext, needToSetReturnType);
       this.closureContext = closureContext;
       inferStatement(function.body);
   
  
positive.code:       bool isReturn,
        bool isYieldStar,
        bool isArrow) {
      if (_needImplicitDowncasts) {
        var expectedType = isYieldStar
            ? _wrapAsyncOrGenerator(inferrer, returnOrYieldContext)
            : returnOrYieldContext;
        if (expectedType != null) {
          expectedType = greatestClosure(inferrer.coreTypes, expectedType);
          if (inferrer.ensureAssignable(
                  expectedType, type, expression, fileOffset,
                  isReturnFromAsync: isAsync,
                  isReturn: isReturn,
                  declaredReturnType: declaredReturnType,
                  isArrow: isArrow) !=
              null) {
            type = expectedType;
          }
        }
      }
      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 (_needToInferReturnType) {
        if (_inferredUnwrappedReturnOrYieldType == null) {
          _inferredUnwrappedReturnOrYieldType = unwrappedType;
        } else {
  
negative.code:           inferrer.typeSchemaEnvironment.unfutureType(returnContext));
      }
      return new ClosureContext._(isAsync, isGenerator, returnContext,
          declaredReturnType, needToInferReturnType);
    }
  
    ClosureContext._(this.isAsync, this.isGenerator, this.returnOrYieldContext,
        this.declaredReturnType, this._needToInferReturnType) {}
  
    /// Updates the inferred return type based on the presence of a return
    /// statement returning the given [type].
  