silgen: eliminate ManagedValue::copyUnmanaged

There's no material difference between it and
`ManagedValue::copy`, i.e., it doesn't actually
produce something without a clean-up. SILGen
grew a `ManagedValue::unmanagedCopy` for that
purpose.

Author: kavon

lib/SILGen/ManagedValue.cpp

@@ -123,18 +123,6 @@ void ManagedValue::copyInto(SILGenFunction &SGF, SILLocation loc,
   dest->finishInitialization(SGF);
 }
 
-/// This is the same operation as 'copy', but works on +0 values that don't
-/// have cleanups.  It returns a +1 value with one.
-ManagedValue ManagedValue::copyUnmanaged(SILGenFunction &SGF, SILLocation loc) {
-  if (getType().isObject()) {
-    return SGF.B.createCopyValue(loc, *this);
-  }
-
-  SILValue result = SGF.emitTemporaryAllocation(loc, getType());
-  SGF.B.createCopyAddr(loc, getValue(), result, IsNotTake, IsInitialization);
-  return SGF.emitManagedRValueWithCleanup(result);
-}
-
 /// This is the same operation as 'copy', but works on +0 values that don't
 /// have cleanups.  It returns a +1 value with one.
 ManagedValue ManagedValue::formalAccessCopyUnmanaged(SILGenFunction &SGF,

lib/SILGen/ManagedValue.h

@@ -365,10 +365,6 @@ class ManagedValue {
   /// formal evaluation scope.
   ManagedValue formalAccessCopy(SILGenFunction &SGF, SILLocation loc);
 
-  /// This is the same operation as 'copy', but works on +0 values that don't
-  /// have cleanups.  It returns a +1 value with one.
-  ManagedValue copyUnmanaged(SILGenFunction &SGF, SILLocation loc);
-
   /// This is the same operation as 'formalAccessCopy', but works on +0 values
   /// that don't have cleanups.  It returns a +1 value with one.
   ManagedValue formalAccessCopyUnmanaged(SILGenFunction &SGF, SILLocation loc);

lib/SILGen/SILGenApply.cpp

@@ -272,14 +272,14 @@ static ManagedValue convertOwnershipConventionGivenParamInfo(
   if (isOwned && valueType.isMoveOnlyWrapped() &&
       valueType.removingMoveOnlyWrapper().isTrivial(SGF.F)) {
     if (value.getOwnershipKind() == OwnershipKind::Guaranteed) {
-      value = value.copyUnmanaged(SGF, loc);
+      value = value.copy(SGF, loc);
       return SGF.B.createOwnedMoveOnlyWrapperToCopyableValue(loc, value);
     }
   }
 
   if (param.isConsumedInCaller() &&
       value.getOwnershipKind() == OwnershipKind::Guaranteed) {
-    return value.copyUnmanaged(SGF, loc);
+    return value.copy(SGF, loc);
   }
 
   // If we are emitting arguments for a coroutine, we need to borrow owned
@@ -5982,18 +5982,13 @@ RValue SILGenFunction::emitApply(
     case ParameterConvention::Direct_Owned:
       // If the callee will consume the 'self' parameter, let's retain it so we
       // can keep it alive.
-      lifetimeExtendedSelf =
-          B.emitCopyValueOperation(loc, lifetimeExtendedSelf);
+      lifetimeExtendedSelf = selfMV.copy(*this, loc).forward(*this);
       break;
     case ParameterConvention::Direct_Guaranteed:
     case ParameterConvention::Direct_Unowned:
       // We'll manually manage the argument's lifetime after the
       // call. Disable its cleanup, forcing a copy if it was emitted +0.
-      if (selfMV.hasCleanup()) {
-        selfMV.forwardCleanup(*this);
-      } else {
-        lifetimeExtendedSelf = selfMV.copyUnmanaged(*this, loc).forward(*this);
-      }
+      lifetimeExtendedSelf = selfMV.ensurePlusOne(*this, loc).forward(*this);
       break;
 
     case ParameterConvention::Indirect_In_Guaranteed:
@@ -7361,7 +7356,7 @@ ArgumentSource AccessorBaseArgPreparer::prepareAccessorObjectBaseArg() {
 
   // We need to produce the value at +1 if it's going to be consumed.
   if (selfParam.isConsumedInCaller() && !base.hasCleanup()) {
-    base = base.copyUnmanaged(SGF, loc);
+    base = base.copy(SGF, loc);
   }
   // If the parameter is indirect, we'll need to drop the value into
   // temporary memory. Make a copy scoped to the current formal access that

lib/SILGen/SILGenConvert.cpp

@@ -1049,7 +1049,7 @@ ManagedValue SILGenFunction::manageOpaqueValue(ManagedValue value,
   }
 
   // Otherwise, copy the value into a temporary.
-  return value.copyUnmanaged(*this, loc);
+  return value.copy(*this, loc);
 }
 
 ManagedValue SILGenFunction::emitAsOrig(SILLocation loc,

lib/SILGen/SILGenDecl.cpp

@@ -991,7 +991,7 @@ class LetValueInitialization : public Initialization {
       // Disable the expression cleanup of the copy, since the let value
       // initialization has a cleanup that lives for the entire scope of the
       // let declaration.
-      bindValue(value.copyUnmanaged(SGF, loc).forward(SGF), SGF, true, loc);
+      bindValue(value.copy(SGF, loc).forward(SGF), SGF, true, loc);
     }
   }
 
@@ -1298,13 +1298,13 @@ void EnumElementPatternInitialization::emitEnumMatch(
               ManagedValue borrowedVal =
                   SGF.B.createLoadBorrow(loc, mvAccessAddress);
               mv = loadScope.popPreservingValue(
-                  borrowedVal.copyUnmanaged(SGF, loc));
+                  borrowedVal.copy(SGF, loc));
             }
             access.endAccess(SGF);
           } else {
             // If we do not have a loadable value, just do a copy of the
             // boxedValue.
-            mv = boxedValue.copyUnmanaged(SGF, loc);
+            mv = boxedValue.copy(SGF, loc);
           }
         }
 

lib/SILGen/SILGenLValue.cpp

@@ -5581,7 +5581,7 @@ RValue SILGenFunction::emitRValueForStorageLoad(
 
     // Otherwise, bring the component up to +1 so we can reabstract it.
     result = std::move(loaded).getAsSingleValue(*this, loc)
-                              .copyUnmanaged(*this, loc);
+                              .copy(*this, loc);
   } else if (!base.getType().isAddress()) {
     // For non-address-only structs, we emit a struct_extract sequence.
     result = B.createStructExtract(loc, base, field);
@@ -5600,7 +5600,7 @@ RValue SILGenFunction::emitRValueForStorageLoad(
       // guaranteed consumer. Otherwise, since we do not have enough information
       // to know if the base's lifetime last's as long as our use of the access,
       // we can only emit at +0 for immediate clients.
-      result = result.copyUnmanaged(*this, loc);
+      result = result.copy(*this, loc);
     }
   } else {
     // Create a tiny unenforced access scope around a load from local memory. No

lib/SILGen/SILGenPoly.cpp

@@ -2109,7 +2109,7 @@ class TranslateArguments : public ExpanderBase<TranslateArguments, ParamInfo> {
 
     // If our inner is guaranteed or unowned, we need to create a copy here.
     if (inner.getOwnershipKind() != OwnershipKind::Owned)
-      inner = inner.copyUnmanaged(SGF, Loc);
+      inner = inner.copy(SGF, Loc);
 
     return inner;
   }
@@ -2190,7 +2190,7 @@ class TranslateArguments : public ExpanderBase<TranslateArguments, ParamInfo> {
     if (outer.getType() == innerParam.getType()) {
       if (isConsumedParameterInCaller(innerParam.getConvention()) &&
           !outer.isPlusOne(SGF)) {
-        outer = outer.copyUnmanaged(SGF, Loc);
+        outer = outer.copy(SGF, Loc);
       }
 
       return outer;

lib/SILGen/SILGenProlog.cpp

@@ -498,9 +498,7 @@ class EmitBBArguments : public CanTypeVisitor<EmitBBArguments,
       } else {
         // Otherwise, we need to move or copy values into a +1 tuple.
         for (auto element : elements) {
-          SILValue value = element.hasCleanup()
-            ? element.forward(SGF)
-            : element.copyUnmanaged(SGF, loc).forward(SGF);
+          SILValue value = element.ensurePlusOne(SGF, loc).forward(SGF);
           elementValues.push_back(value);
         }
       }