anchor.diff:            inferrer.typeSchemaEnvironment.unfutureType(returnContext));
       }
       return new ClosureContext._(isAsync, isGenerator, returnContext,
  -        declaredReturnType, needToInferReturnType, needImplicitDowncasts);
  -  }
  -
  -  ClosureContext._(
  -      this.isAsync,
  -      this.isGenerator,
  -      this.returnOrYieldContext,
  -      this.declaredReturnType,
  -      this._needToInferReturnType,
  -      this._needImplicitDowncasts) {
  -    assert(returnOrYieldContext != null);
  -  }
  +        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].
  
positive.code:   /// wrapping this type in `Stream` or `Iterator`, as appropriate.
    DartType _inferredUnwrappedReturnOrYieldType;
  
    factory ClosureContext(
        TypeInferrerImpl inferrer,
        AsyncMarker asyncMarker,
        DartType returnContext,
        bool needToInferReturnType,
        bool needImplicitDowncasts) {
      DartType declaredReturnType = returnContext;
      bool isAsync = asyncMarker == AsyncMarker.Async ||
          asyncMarker == AsyncMarker.AsyncStar;
  
negative.code:     assert(_needToInferReturnType);
      DartType inferredType =
          inferrer.inferReturnType(_inferredUnwrappedReturnOrYieldType);
      if (!_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);
  