[silgen] Convert a few instances of ManagedValue::forUnmanaged(*).copy() -> ManagedValue::forCopyOwnedObjectRValue.

Just removing more ManagedValue::forUnmanaged.

Author: gottesmm

lib/SILGen/ManagedValue.h

@@ -92,6 +92,24 @@ class ManagedValue {
     return ManagedValue(value, false, CleanupHandle::invalid());
   }
 
+  enum class ScopeKind {
+    Lexical,
+    FormalAccess,
+  };
+
+  /// Given a value \p value, create a copy of it and return the relevant
+  /// ManagedValue.
+  static ManagedValue forCopyOwnedObjectRValue(SILGenFunction &SGF,
+                                               SILLocation loc, SILValue value,
+                                               ScopeKind kind) {
+    assert(value && "No value specified");
+    assert(value->getType().isObject());
+    auto mv = ManagedValue::forUnmanaged(value);
+    if (kind == ScopeKind::Lexical)
+      return mv.copy(SGF, loc);
+    return mv.formalAccessCopy(SGF, loc);
+  }
+
   /// Create a managed value for a SILValue whose ownership is
   /// forwarded. Creates a new cleanup for +1 values. Forwarded +0 values
   /// require no cleanup.

lib/SILGen/ResultPlan.cpp

@@ -899,8 +899,9 @@ class ForeignAsyncInitializationPlan final : public ResultPlan {
             SILValue(wrappedContinuation));
         SGF.emitApplyOfLibraryIntrinsic(
             loc, errorIntrinsic, subs,
-            {continuationMV,
-             ManagedValue::forUnmanaged(bridgedForeignError).copy(SGF, loc)},
+            {continuationMV, ManagedValue::forCopyOwnedObjectRValue(
+                                 SGF, loc, bridgedForeignError,
+                                 ManagedValue::ScopeKind::Lexical)},
             SGFContext());
 
         // Second, emit a branch from the end of the foreign error block to the

lib/SILGen/SILGenBuilder.cpp

@@ -525,7 +525,8 @@ static ManagedValue createInputFunctionArgument(
     //
     // NOTE: If we have a trivial value, the copy will do nothing, so this is
     // just a convenient way to avoid writing conditional code.
-    return ManagedValue::forUnmanaged(arg).copy(SGF, loc);
+    return ManagedValue::forCopyOwnedObjectRValue(
+        SGF, loc, arg, ManagedValue::ScopeKind::Lexical);
 
   case SILArgumentConvention::Direct_Owned:
     return SGF.emitManagedRValueWithCleanup(arg);
@@ -712,7 +713,8 @@ ManagedValue SILGenBuilder::createUncheckedBitCast(SILLocation loc,
   // identity implying that we need a copy of the casted value to be returned so
   // that the inputs/outputs of the case have separate ownership.
   if (isa<UncheckedBitwiseCastInst>(cast)) {
-    return ManagedValue::forUnmanaged(cast).copy(SGF, loc);
+    return ManagedValue::forCopyOwnedObjectRValue(
+        SGF, loc, cast, ManagedValue::ScopeKind::Lexical);
   }
 
   // Otherwise, we forward the cleanup of the input value and place the cleanup