[+0-normal-args] Change getNextUncurryLevelRef and emitCurryThunk to traffic in ManagedValues instead of SILValues.

This is a refactor that we want in general and allows me to use
ensurePlusOne(...) to ensure we retain all values we put into the partial
apply.

rdar://34222540

Author: gottesmm

lib/SILGen/SILGenBuilder.h

@@ -92,6 +92,13 @@ class SILGenBuilder : public SILBuilder {
                                   SILType substFnTy, SubstitutionList subs,
                                   ArrayRef<ManagedValue> args,
                                   SILType closureTy);
+  ManagedValue createPartialApply(SILLocation loc, ManagedValue fn,
+                                  SILType substFnTy, SubstitutionList subs,
+                                  ArrayRef<ManagedValue> args,
+                                  SILType closureTy) {
+    return createPartialApply(loc, fn.getValue(), substFnTy, subs, args,
+                              closureTy);
+  }
 
   BuiltinInst *createBuiltin(SILLocation loc, Identifier name, SILType resultTy,
                              SubstitutionList subs, ArrayRef<SILValue> args);

lib/SILGen/SILGenThunk.cpp

@@ -82,11 +82,10 @@ SILValue SILGenFunction::emitDynamicMethodRef(SILLocation loc,
   return B.createFunctionRef(loc, F);
 }
 
-static SILValue getNextUncurryLevelRef(SILGenFunction &SGF,
-                                       SILLocation loc,
-                                       SILDeclRef thunk,
-                                       SILValue selfArg,
-                                       SubstitutionList curriedSubs) {
+static ManagedValue getNextUncurryLevelRef(SILGenFunction &SGF, SILLocation loc,
+                                           SILDeclRef thunk,
+                                           ManagedValue selfArg,
+                                           SubstitutionList curriedSubs) {
   auto *vd = thunk.getDecl();
 
   // Reference the next uncurrying level of the function.
@@ -95,23 +94,26 @@ static SILValue getNextUncurryLevelRef(SILGenFunction &SGF,
 
   // If the function is natively foreign, reference its foreign entry point.
   if (requiresForeignToNativeThunk(vd))
-    return SGF.emitGlobalFunctionRef(loc, next);
+    return ManagedValue::forUnmanaged(SGF.emitGlobalFunctionRef(loc, next));
 
   // If the thunk is a curry thunk for a direct method reference, we are
   // doing a direct dispatch (eg, a fragile 'super.foo()' call).
   if (thunk.isDirectReference)
-    return SGF.emitGlobalFunctionRef(loc, next);
+    return ManagedValue::forUnmanaged(SGF.emitGlobalFunctionRef(loc, next));
 
   auto constantInfo = SGF.SGM.Types.getConstantInfo(next);
 
   if (auto *func = dyn_cast<AbstractFunctionDecl>(vd)) {
     if (getMethodDispatch(func) == MethodDispatch::Class) {
       // Use the dynamic thunk if dynamic.
       if (vd->isDynamic())
-        return SGF.emitDynamicMethodRef(loc, next, constantInfo.SILFnType);
+        return ManagedValue::forUnmanaged(
+                 SGF.emitDynamicMethodRef(loc, next, constantInfo.SILFnType));
 
       auto methodTy = SGF.SGM.Types.getConstantOverrideType(next);
-      return SGF.emitClassMethodRef(loc, selfArg, next, methodTy);
+      SILValue result =
+          SGF.emitClassMethodRef(loc, selfArg.getValue(), next, methodTy);
+      return ManagedValue::forUnmanaged(result);
     }
 
     // If the fully-uncurried reference is to a generic method, look up the
@@ -125,13 +127,14 @@ static SILValue getNextUncurryLevelRef(SILGenFunction &SGF,
       auto origSelfType = protocol->getSelfInterfaceType()->getCanonicalType();
       auto substSelfType = origSelfType.subst(subMap)->getCanonicalType();
       auto conformance = subMap.lookupConformance(origSelfType, protocol);
-      return SGF.B.createWitnessMethod(loc, substSelfType, *conformance, next,
-                                      constantInfo.getSILType());
+      auto result = SGF.B.createWitnessMethod(loc, substSelfType, *conformance,
+                                              next, constantInfo.getSILType());
+      return ManagedValue::forUnmanaged(result);
     }
   }
 
   // Otherwise, emit a direct call.
-  return SGF.emitGlobalFunctionRef(loc, next);
+  return ManagedValue::forUnmanaged(SGF.emitGlobalFunctionRef(loc, next));
 }
 
 void SILGenFunction::emitCurryThunk(SILDeclRef thunk) {
@@ -148,13 +151,13 @@ void SILGenFunction::emitCurryThunk(SILDeclRef thunk) {
   auto selfTy = vd->getInterfaceType()->castTo<AnyFunctionType>()
     ->getInput();
   selfTy = vd->getInnermostDeclContext()->mapTypeIntoContext(selfTy);
-  auto selfArg = F.begin()->createFunctionArgument(getLoweredType(selfTy));
+  ManagedValue selfArg =
+      B.createFunctionArgument(getLoweredType(selfTy), nullptr);
 
   // Forward substitutions.
   auto subs = F.getForwardingSubstitutions();
 
-  SILValue toFn = getNextUncurryLevelRef(*this, vd, thunk,
-                                         selfArg, subs);
+  ManagedValue toFn = getNextUncurryLevelRef(*this, vd, thunk, selfArg, subs);
 
   // FIXME: Using the type from the ConstantInfo instead of looking at
   // getConstantOverrideInfo() for methods looks suspect in the presence
@@ -163,25 +166,23 @@ void SILGenFunction::emitCurryThunk(SILDeclRef thunk) {
       SGM.Types.getConstantInfo(thunk).SILFnType, SGM.M);
   SILType resultTy = fromConv.getSingleSILResultType();
   resultTy = F.mapTypeIntoContext(resultTy);
-  auto substTy = toFn->getType().substGenericArgs(SGM.M,  subs);
+  auto substTy = toFn.getType().substGenericArgs(SGM.M, subs);
 
   auto calleeConvention = ParameterConvention::Direct_Guaranteed;
 
   // Partially apply the next uncurry level and return the result closure.
   auto closureTy = SILGenBuilder::getPartialApplyResultType(
-      toFn->getType(), /*appliedParams=*/1, SGM.M, subs, calleeConvention);
-  SILValue toClosure =
-    B.createPartialApply(vd, toFn, substTy, subs, {selfArg}, closureTy);
+      toFn.getType(), /*appliedParams=*/1, SGM.M, subs, calleeConvention);
+  ManagedValue toClosure =
+      B.createPartialApply(vd, toFn, substTy, subs, {selfArg}, closureTy);
   if (resultTy != closureTy) {
     CanSILFunctionType resultFnTy = resultTy.castTo<SILFunctionType>();
     CanSILFunctionType closureFnTy = closureTy.castTo<SILFunctionType>();
     if (resultFnTy->isABICompatibleWith(closureFnTy).isCompatible()) {
       toClosure = B.createConvertFunction(vd, toClosure, resultTy);
     } else {
       toClosure =
-          emitCanonicalFunctionThunk(vd, ManagedValue::forUnmanaged(toClosure),
-                                     closureFnTy, resultFnTy)
-              .forward(*this);
+          emitCanonicalFunctionThunk(vd, toClosure, closureFnTy, resultFnTy);
     }
   }
   B.createReturn(ImplicitReturnLocation::getImplicitReturnLoc(vd), toClosure);