anchor.diff:                    : inferrer.coreTypes.iterableClass) ??
             type;
       }
  -    _updateInferredReturnType(
  -        inferrer, type, unwrappedType, expression, fileOffset, isYieldStar);
  -  }
  -
  -  DartType inferReturnType(TypeInferrerImpl inferrer) {
  -    assert(_needToInferReturnType);
  -    DartType inferredReturnType = inferrer.inferReturnType(_inferredReturnType);
  -    if (returnContext != null &&
  -        !_analyzerSubtypeOf(inferrer, inferredReturnType, returnContext)) {
  -      // If the inferred return type isn't a subtype of the context, we use the
  -      // context.
  -      inferredReturnType = greatestClosure(inferrer.coreTypes, returnContext);
  -    }
  -
  -    return _wrapAsyncOrGenerator(inferrer, inferredReturnType);
  -  }
  -
  -  void _updateInferredReturnType(
  -      TypeInferrerImpl inferrer,
  -      DartType type,
  -      DartType unwrappedType,
  -      Expression expression,
  -      int fileOffset,
  -      bool isYieldStar) {
       if (_needToInferReturnType) {
         if (_inferredReturnType == null) {
           _inferredReturnType = unwrappedType;
         } else {
           _inferredReturnType = inferrer.typeSchemaEnvironment
               .getLeastUpperBound(_inferredReturnType, unwrappedType);
  -      }
  -    }
  -    if (_needImplicitDowncasts) {
  -      var expectedType = isYieldStar
  -          ? _wrapAsyncOrGenerator(inferrer, returnContext)
  -          : returnContext;
  -      if (expectedType != null) {
  -        inferrer.checkAssignability(
  -            greatestClosure(inferrer.coreTypes, expectedType),
  -            type,
  -            expression,
  -            fileOffset);
         }
       }
     }
  
positive.code:   void handleReturn(TypeInferrerImpl inferrer, DartType type,
        Expression expression, int fileOffset) {
      if (isGenerator) return;
      var unwrappedType = type;
      if (isAsync) {
        if (type is InterfaceType) {
          if (identical(type.classNode, inferrer.coreTypes.futureClass)) {
            unwrappedType = type.typeArguments[0];
  
negative.code:           unwrappedType = type.typeArguments[0];
          }
        }
      } else if (isYieldStar) {
        unwrappedType = inferrer.getDerivedTypeArgumentOf(
                type,
                isAsync
  