[silgen] Rename SILGenFunction::emitManagedRetain -> emitManagedCopy.

This is an old API that should have been renamed a long time ago. It just kept
its early name due to inertia.

Author: gottesmm

lib/SILGen/SILGenBridging.cpp

@@ -312,7 +312,7 @@ static ManagedValue emitManagedParameter(SILGenFunction &SGF, SILLocation loc,
 
   case ParameterConvention::Direct_Unowned:
     // We need to independently retain the value.
-    return SGF.emitManagedRetain(loc, value, valueTL);
+    return SGF.emitManagedCopy(loc, value, valueTL);
 
   case ParameterConvention::Indirect_Inout:
     return ManagedValue::forLValue(value);
@@ -2180,7 +2180,7 @@ void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
           break;
         case ParameterConvention::Direct_Guaranteed:
         case ParameterConvention::Direct_Unowned:
-          param = emitManagedRetain(fd, paramValue);
+          param = emitManagedCopy(fd, paramValue);
           break;
         case ParameterConvention::Indirect_Inout:
         case ParameterConvention::Indirect_InoutAliasable:

lib/SILGen/SILGenBuiltin.cpp

@@ -406,7 +406,7 @@ static ManagedValue emitBuiltinBridgeFromRawPointer(SILGenFunction &SGF,
   SILValue result = SGF.B.createRawPointerToRef(loc, args[0].getUnmanagedValue(),
                                                 destType);
   // The result has ownership semantics, so retain it with a cleanup.
-  return SGF.emitManagedRetain(loc, result, destLowering);
+  return SGF.emitManagedCopy(loc, result, destLowering);
 }
 
 static ManagedValue emitBuiltinAddressOfBuiltins(SILGenFunction &SGF,
@@ -924,7 +924,7 @@ static ManagedValue emitBuiltinValueToBridgeObject(SILGenFunction &SGF,
   }
 
   SILValue result = SGF.B.createValueToBridgeObject(loc, args[0].getValue());
-  return SGF.emitManagedRetain(loc, result);
+  return SGF.emitManagedCopy(loc, result);
 }
 
 // This should only accept as an operand type single-refcounted-pointer types,

lib/SILGen/SILGenExpr.cpp

@@ -60,15 +60,13 @@
 using namespace swift;
 using namespace Lowering;
 
-ManagedValue SILGenFunction::emitManagedRetain(SILLocation loc,
-                                               SILValue v) {
+ManagedValue SILGenFunction::emitManagedCopy(SILLocation loc, SILValue v) {
   auto &lowering = getTypeLowering(v->getType());
-  return emitManagedRetain(loc, v, lowering);
+  return emitManagedCopy(loc, v, lowering);
 }
 
-ManagedValue SILGenFunction::emitManagedRetain(SILLocation loc,
-                                               SILValue v,
-                                               const TypeLowering &lowering) {
+ManagedValue SILGenFunction::emitManagedCopy(SILLocation loc, SILValue v,
+                                             const TypeLowering &lowering) {
   assert(lowering.getLoweredType() == v->getType());
   if (lowering.isTrivial())
     return ManagedValue::forRValueWithoutOwnership(v);
@@ -5710,7 +5708,7 @@ class AutoreleasingWritebackComponent : public LogicalPathComponent {
     auto strongType = SILType::getPrimitiveObjectType(
               unowned->getType().castTo<UnmanagedStorageType>().getReferentType());
     auto owned = SGF.B.createUnmanagedToRef(loc, unowned, strongType);
-    auto ownedMV = SGF.emitManagedRetain(loc, owned);
+    auto ownedMV = SGF.emitManagedCopy(loc, owned);
 
     // Then create a mark dependence in between the base and the ownedMV. This
     // is important to ensure that the destroy of the assign is not hoisted

lib/SILGen/SILGenFunction.cpp

@@ -864,7 +864,7 @@ void SILGenFunction::emitCaptures(SILLocation loc,
           capturedArgs.push_back(
               ManagedValue::forUnmanaged(Entry.box).borrow(*this, loc));
         } else {
-          capturedArgs.push_back(emitManagedRetain(loc, Entry.box));
+          capturedArgs.push_back(emitManagedCopy(loc, Entry.box));
         }
         if (captureCanEscape)
           escapesToMark.push_back(val);

lib/SILGen/SILGenFunction.h

@@ -1697,9 +1697,9 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                      Type resultType,
                                      RValue &&operand);
 
-  ManagedValue emitManagedRetain(SILLocation loc, SILValue v);
-  ManagedValue emitManagedRetain(SILLocation loc, SILValue v,
-                                 const TypeLowering &lowering);
+  ManagedValue emitManagedCopy(SILLocation loc, SILValue v);
+  ManagedValue emitManagedCopy(SILLocation loc, SILValue v,
+                               const TypeLowering &lowering);
 
   ManagedValue emitManagedLoadCopy(SILLocation loc, SILValue v);
   ManagedValue emitManagedLoadCopy(SILLocation loc, SILValue v,

lib/SILGen/SILGenPoly.cpp

@@ -1756,7 +1756,7 @@ class TranslateArguments : public ExpanderBase<TranslateArguments> {
     // initially owned.
     if (inner.getOwnershipKind() == OwnershipKind::Unowned) {
       assert(!inner.hasCleanup());
-      inner = SGF.emitManagedRetain(Loc, inner.getValue());
+      inner = SGF.emitManagedCopy(Loc, inner.getValue());
     }
 
     // If the inner is unowned or owned, create a borrow.
@@ -4366,7 +4366,7 @@ void ResultPlanner::execute(SmallVectorImpl<SILValue> &innerDirectResultStack,
                        "reabstraction of returns_inner_pointer function");
       LLVM_FALLTHROUGH;
     case ResultConvention::Unowned:
-      return SGF.emitManagedRetain(Loc, resultValue, resultTL);
+      return SGF.emitManagedCopy(Loc, resultValue, resultTL);
     }
     llvm_unreachable("bad result convention!");
   };