Switch InitializationPtr to use PossiblyUniquePtr so that we can just

rjmccall · rjmccall · commit bee053f1f0d5 · 2025-08-02T02:13:25.000-04:00
forward existing initializations around when necessary.
diff --git a/lib/SILGen/Condition.cpp b/lib/SILGen/Condition.cpp
@@ -100,7 +100,8 @@ void ConditionalValue::exitBranch(RValue &&condResult) {
     // already.
     assert(currentInitialization && "no current initialization?!");
     std::move(condResult).forwardInto(SGF, loc,
-                                      currentInitialization.release());
+                                      currentInitialization.get());
+    currentInitialization.reset();
     scope.reset();
     SGF.B.createBranch(loc, contBB);
   } else {
diff --git a/lib/SILGen/Condition.h b/lib/SILGen/Condition.h
@@ -109,7 +109,7 @@ class ConditionalValue {
   std::optional<Scope> scope;
 
   /// A place to hold conditional Initializations of our result.
-  std::unique_ptr<Initialization> currentInitialization;
+  InitializationPtr currentInitialization;
   
 public:
   /// Begins a conditional computation of the type represented by the given
diff --git a/lib/SILGen/Initialization.h b/lib/SILGen/Initialization.h
@@ -19,6 +19,7 @@
 #define SWIFT_LOWERING_INITIALIZATION_H
 
 #include "ManagedValue.h"
+#include "swift/Basic/PossiblyUniquePtr.h"
 #include "swift/SIL/AbstractionPattern.h"
 #include "llvm/ADT/TinyPtrVector.h"
 #include <memory>
@@ -28,9 +29,9 @@ namespace Lowering {
 
 class SILGenFunction;
 class Initialization;
-using InitializationPtr = std::unique_ptr<Initialization>;
+using InitializationPtr = PossiblyUniquePtr<Initialization>;
 class TemporaryInitialization;
-using TemporaryInitializationPtr = std::unique_ptr<TemporaryInitialization>;
+using TemporaryInitializationPtr = PossiblyUniquePtr<TemporaryInitialization>;
 class ConvertingInitialization;
 
 /// An abstract class for consuming a value.  This is used for initializing
diff --git a/lib/SILGen/ResultPlan.cpp b/lib/SILGen/ResultPlan.cpp
@@ -225,14 +225,14 @@ class IndirectOpenedSelfResultPlan final : public ResultPlan {
 /// reabstracting it.  The value can actually be a tuple if the
 /// abstraction is opaque.
 class ScalarResultPlan final : public ResultPlan {
-  std::unique_ptr<TemporaryInitialization> temporary;
+  TemporaryInitializationPtr temporary;
   AbstractionPattern origType;
   CanType substType;
   Initialization *init;
   SILFunctionTypeRepresentation rep;
 
 public:
-  ScalarResultPlan(std::unique_ptr<TemporaryInitialization> &&temporary,
+  ScalarResultPlan(TemporaryInitializationPtr &&temporary,
                    AbstractionPattern origType, CanType substType,
                    Initialization *init,
                    SILFunctionTypeRepresentation rep)
@@ -339,13 +339,13 @@ class InitValueFromTemporaryResultPlan final : public ResultPlan {
   Initialization *init;
   CanType substType;
   ResultPlanPtr subPlan;
-  std::unique_ptr<TemporaryInitialization> temporary;
+  TemporaryInitializationPtr temporary;
 
 public:
   InitValueFromTemporaryResultPlan(
       Initialization *init, CanType substType,
       ResultPlanPtr &&subPlan,
-      std::unique_ptr<TemporaryInitialization> &&temporary)
+      TemporaryInitializationPtr &&temporary)
       : init(init), substType(substType), subPlan(std::move(subPlan)),
         temporary(std::move(temporary)) {}
 
@@ -1249,7 +1249,7 @@ ResultPlanPtr ResultPlanBuilder::buildForScalar(Initialization *init,
   }
 
   // Create a temporary if the result is indirect.
-  std::unique_ptr<TemporaryInitialization> temporary;
+  TemporaryInitializationPtr temporary;
   if (SGF.silConv.isSILIndirect(result)) {
     auto &resultTL = SGF.getTypeLowering(result.getReturnValueType(
         SGF.SGM.M, calleeTy, SGF.getTypeExpansionContext()));
diff --git a/lib/SILGen/SILGenBuiltin.cpp b/lib/SILGen/SILGenBuiltin.cpp
@@ -2130,7 +2130,7 @@ static ManagedValue emitBuiltinEmplace(SILGenFunction &SGF,
   bool didEmitInto;
   Initialization *dest;
   TemporaryInitialization *destTemporary = nullptr;
-  std::unique_ptr<Initialization> destOwner;
+  InitializationPtr destOwner;
   
   // Use the context destination if available.
   if (C.getEmitInto()
diff --git a/lib/SILGen/SILGenConstructor.cpp b/lib/SILGen/SILGenConstructor.cpp
@@ -853,7 +853,7 @@ void SILGenFunction::emitEnumConstructor(EnumElementDecl *element) {
   Loc.markAutoGenerated();
 
   // Emit the indirect return slot.
-  std::unique_ptr<Initialization> dest;
+  InitializationPtr dest;
   if (enumTI.isAddressOnly() && silConv.useLoweredAddresses()) {
     auto &AC = getASTContext();
     auto VD = new (AC) ParamDecl(SourceLoc(), SourceLoc(),
@@ -865,8 +865,7 @@ void SILGenFunction::emitEnumConstructor(EnumElementDecl *element) {
     VD->setInterfaceType(enumIfaceTy);
     auto resultSlot =
         F.begin()->createFunctionArgument(enumTI.getLoweredType(), VD);
-    dest = std::unique_ptr<Initialization>(
-        new KnownAddressInitialization(resultSlot));
+    dest.reset(new KnownAddressInitialization(resultSlot));
   }
 
   Scope scope(Cleanups, CleanupLoc);
diff --git a/lib/SILGen/SILGenDecl.cpp b/lib/SILGen/SILGenDecl.cpp
@@ -312,7 +312,7 @@ splitSingleBufferIntoTupleElements(SILGenFunction &SGF, SILLocation loc,
     if (eltCleanup.isValid())
       splitCleanups.push_back(eltCleanup);
 
-    buf.emplace_back(eltInit.release());
+    buf.emplace_back(std::move(eltInit));
   }
 
   return buf;
@@ -1992,7 +1992,7 @@ InitializationPtr SILGenFunction::emitLocalVariableWithCleanup(
 }
 
 /// Create an Initialization for an uninitialized temporary.
-std::unique_ptr<TemporaryInitialization>
+TemporaryInitializationPtr
 SILGenFunction::emitTemporary(SILLocation loc, const TypeLowering &tempTL) {
   SILValue addr = emitTemporaryAllocation(loc, tempTL.getLoweredType());
   if (addr->getType().isMoveOnly())
@@ -2002,7 +2002,7 @@ SILGenFunction::emitTemporary(SILLocation loc, const TypeLowering &tempTL) {
   return useBufferAsTemporary(addr, tempTL);
 }
 
-std::unique_ptr<TemporaryInitialization>
+TemporaryInitializationPtr
 SILGenFunction::emitFormalAccessTemporary(SILLocation loc,
                                           const TypeLowering &tempTL) {
   SILValue addr = emitTemporaryAllocation(loc, tempTL.getLoweredType());
@@ -2012,16 +2012,16 @@ SILGenFunction::emitFormalAccessTemporary(SILLocation loc,
         MarkUnresolvedNonCopyableValueInst::CheckKind::ConsumableAndAssignable);
   CleanupHandle cleanup =
       enterDormantFormalAccessTemporaryCleanup(addr, loc, tempTL);
-  return std::unique_ptr<TemporaryInitialization>(
+  return TemporaryInitializationPtr(
       new TemporaryInitialization(addr, cleanup));
 }
 
 /// Create an Initialization for an uninitialized buffer.
-std::unique_ptr<TemporaryInitialization>
+TemporaryInitializationPtr
 SILGenFunction::useBufferAsTemporary(SILValue addr,
                                      const TypeLowering &tempTL) {
   CleanupHandle cleanup = enterDormantTemporaryCleanup(addr, tempTL);
-  return std::unique_ptr<TemporaryInitialization>(
+  return TemporaryInitializationPtr(
                                     new TemporaryInitialization(addr, cleanup));
 }
 
diff --git a/lib/SILGen/SILGenDynamicCast.cpp b/lib/SILGen/SILGenDynamicCast.cpp
@@ -59,7 +59,7 @@ namespace {
 
       SGFContext ctx;
 
-      std::unique_ptr<TemporaryInitialization> temporary;
+      TemporaryInitializationPtr temporary;
       if (isOperandIndirect()) {
         temporary = SGF.emitTemporary(Loc, origSourceTL);
         ctx = SGFContext(temporary.get());
@@ -417,7 +417,7 @@ adjustForConditionalCheckedCastOperand(SILLocation loc, ManagedValue src,
   if (!hasAbstraction && (!requiresAddress || src.getType().isAddress()))
     return src;
   
-  std::unique_ptr<TemporaryInitialization> init;
+  TemporaryInitializationPtr init;
   if (requiresAddress) {
     init = SGF.emitTemporary(loc, srcAbstractTL);
 
diff --git a/lib/SILGen/SILGenExpr.cpp b/lib/SILGen/SILGenExpr.cpp
@@ -1295,7 +1295,7 @@ RValue RValueEmitter::visitOptionalTryExpr(OptionalTryExpr *E, SGFContext C) {
   bool isByAddress = ((usingProvidedContext || optTL.isAddressOnly()) &&
       SGF.silConv.useLoweredAddresses());
 
-  std::unique_ptr<TemporaryInitialization> optTemp;
+  TemporaryInitializationPtr optTemp;
   if (!isByAddress) {
     // If the caller produced a context for us, but we're not going
     // to use it, make sure we don't.
@@ -6117,7 +6117,7 @@ void SILGenFunction::emitOptionalEvaluation(SILLocation loc, Type optType,
   bool isByAddress = ((usingProvidedContext || optTL.isAddressOnly()) &&
                       silConv.useLoweredAddresses());
 
-  std::unique_ptr<TemporaryInitialization> optTemp;
+  TemporaryInitializationPtr optTemp;
   if (!isByAddress) {
     // If the caller produced a context for us, but we're not going
     // to use it, make sure we don't.
@@ -6141,7 +6141,7 @@ void SILGenFunction::emitOptionalEvaluation(SILLocation loc, Type optType,
 
   // Inside of the cleanups scope, create a new initialization to
   // emit into optAddr.
-  std::unique_ptr<TemporaryInitialization> normalInit;
+  TemporaryInitializationPtr normalInit;
   if (isByAddress) {
     normalInit = useBufferAsTemporary(optAddr, optTL);
   }
@@ -7149,7 +7149,7 @@ RValue RValueEmitter::visitConsumeExpr(ConsumeExpr *E, SGFContext C) {
 
   // If we aren't loadable, then create a temporary initialization and
   // explicit_copy_addr into that.
-  std::unique_ptr<TemporaryInitialization> optTemp;
+  TemporaryInitializationPtr optTemp;
   optTemp = SGF.emitTemporary(E, SGF.getTypeLowering(subType));
   SILValue toAddr = optTemp->getAddressForInPlaceInitialization(SGF, E);
   assert(!isa<LValueType>(E->getType()->getCanonicalType()) &&
@@ -7256,7 +7256,7 @@ RValue RValueEmitter::visitCopyExpr(CopyExpr *E, SGFContext C) {
 
   // If we aren't loadable, then create a temporary initialization and
   // explicit_copy_addr into that.
-  std::unique_ptr<TemporaryInitialization> optTemp;
+  TemporaryInitializationPtr optTemp;
   optTemp = SGF.emitTemporary(E, SGF.getTypeLowering(subType));
   SILValue toAddr = optTemp->getAddressForInPlaceInitialization(SGF, E);
   assert(!isa<LValueType>(E->getType()->getCanonicalType()) &&
diff --git a/lib/SILGen/SILGenFunction.cpp b/lib/SILGen/SILGenFunction.cpp
@@ -1746,7 +1746,7 @@ void SILGenFunction::emitGeneratorFunction(
   mergeCleanupBlocks();
 }
 
-std::unique_ptr<Initialization> SILGenFunction::getSingleValueStmtInit(Expr *E) {
+InitializationPtr SILGenFunction::getSingleValueStmtInit(Expr *E) {
   if (SingleValueStmtInitStack.empty())
     return nullptr;
 
@@ -1756,7 +1756,7 @@ std::unique_ptr<Initialization> SILGenFunction::getSingleValueStmtInit(Expr *E)
     return nullptr;
   
   auto resultAddr = SingleValueStmtInitStack.back().InitializationBuffer;
-  return std::make_unique<KnownAddressInitialization>(resultAddr);
+  return make_possibly_unique<KnownAddressInitialization>(resultAddr);
 }
 
 void SILGenFunction::emitProfilerIncrement(ASTNode Node) {
diff --git a/lib/SILGen/SILGenFunction.h b/lib/SILGen/SILGenFunction.h
@@ -987,7 +987,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// Return to the previous debug scope.
   void leaveDebugScope();
 
-  std::unique_ptr<Initialization>
+  InitializationPtr
   prepareIndirectResultInit(SILLocation loc,
                             AbstractionPattern origResultType,
                             CanType formalResultType,
@@ -997,7 +997,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// Check to see if an initalization for a SingleValueStmtExpr is active, and
   /// if the provided expression is for one of its branches. If so, returns the
   /// initialization to use for the expression. Otherwise returns \c nullptr.
-  std::unique_ptr<Initialization> getSingleValueStmtInit(Expr *E);
+  InitializationPtr getSingleValueStmtInit(Expr *E);
 
   //===--------------------------------------------------------------------===//
   // Entry points for codegen
@@ -2854,7 +2854,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   void emitPatternBinding(PatternBindingDecl *D, unsigned entry,
                           bool generateDebugInfo);
 
-  std::unique_ptr<Initialization>
+  InitializationPtr
   emitPatternBindingInitialization(Pattern *P, JumpDest failureDest,
                                    bool generateDebugInfo = true);
 
@@ -2878,7 +2878,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   void visitMacroExpansionDecl(MacroExpansionDecl *D);
 
   /// Emit an Initialization for a 'var' or 'let' decl in a pattern.
-  std::unique_ptr<Initialization>
+  InitializationPtr
   emitInitializationForVarDecl(VarDecl *vd, bool immutable,
                                bool generateDebugInfo = true);
 
@@ -2887,7 +2887,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// scope.
   /// \param ArgNo optionally describes this function argument's
   /// position for debug info.
-  std::unique_ptr<Initialization> emitLocalVariableWithCleanup(
+  InitializationPtr emitLocalVariableWithCleanup(
       VarDecl *D, std::optional<MarkUninitializedInst::Kind> kind,
       unsigned ArgNo = 0, bool generateDebugInfo = true);
 
@@ -2896,22 +2896,22 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// cleanups in the active scope.
   ///
   /// The initialization is guaranteed to be a single buffer.
-  std::unique_ptr<TemporaryInitialization>
+  TemporaryInitializationPtr
   emitTemporary(SILLocation loc, const TypeLowering &tempTL);
 
   /// Emit the allocation for a local temporary, provides an
   /// Initialization that can be used to initialize it, and registers
   /// cleanups in the current active formal evaluation scope.
   ///
   /// The initialization is guaranteed to be a single buffer.
-  std::unique_ptr<TemporaryInitialization>
+  TemporaryInitializationPtr
   emitFormalAccessTemporary(SILLocation loc, const TypeLowering &tempTL);
 
   /// Provides an Initialization that can be used to initialize an already-
   /// allocated temporary, and registers cleanups in the active scope.
   ///
   /// The initialization is guaranteed to be a single buffer.
-  std::unique_ptr<TemporaryInitialization>
+  TemporaryInitializationPtr
   useBufferAsTemporary(SILValue addr, const TypeLowering &tempTL);
 
   /// Enter a currently-dormant cleanup to destroy the value in the
diff --git a/lib/SILGen/SILGenPack.cpp b/lib/SILGen/SILGenPack.cpp
@@ -1099,7 +1099,7 @@ SILGenFunction::emitPackTransform(SILLocation loc,
     // If this is not a simple projection, project the output tuple element
     // and encourage the transformation to initialize into it.
     SILValue outputEltAddr;
-    std::unique_ptr<TemporaryInitialization> outputEltInit;
+    TemporaryInitializationPtr outputEltInit;
     if (!isSimpleProjection) {
       outputEltAddr = B.createTuplePackElementAddr(loc, packExpansionIndex,
                                                    outputTupleAddr,
diff --git a/lib/SILGen/SILGenPattern.cpp b/lib/SILGen/SILGenPattern.cpp
@@ -1877,7 +1877,7 @@ emitCastOperand(SILGenFunction &SGF, SILLocation loc,
   assert(src.getFinalConsumption() != CastConsumptionKind::TakeOnSuccess &&
          "Loadable types can not have take_on_success?!");
 
-  std::unique_ptr<TemporaryInitialization> init;
+  TemporaryInitializationPtr init;
   SGFContext ctx;
   if (requiresAddress) {
     init = SGF.emitTemporary(loc, srcAbstractTL);
diff --git a/lib/SILGen/SILGenPoly.cpp b/lib/SILGen/SILGenPoly.cpp
@@ -1246,7 +1246,7 @@ class ParamInfo {
     return slot.allocate(SGF, loc);
   }
 
-  std::unique_ptr<AnyTemporaryInitialization>
+  PossiblyUniquePtr<AnyTemporaryInitialization>
   allocateForInitialization(SILGenFunction &SGF, SILLocation loc,
                             bool forceAllocation = false) {
     auto &lowering = getTypeLowering(SGF);
@@ -1262,7 +1262,7 @@ class ParamInfo {
           MarkUnresolvedNonCopyableValueInst::CheckKind::
               ConsumableAndAssignable);
     if (temporaryShouldBorrow(SGF, forceAllocation)) {
-      return std::make_unique<StoreBorrowInitialization>(address);
+      return make_possibly_unique<StoreBorrowInitialization>(address);
     }
     auto innerTemp = SGF.useBufferAsTemporary(address, lowering);
     return innerTemp;
diff --git a/lib/SILGen/SILGenStmt.cpp b/lib/SILGen/SILGenStmt.cpp
@@ -482,7 +482,7 @@ createIndirectResultInit(SILGenFunction &SGF, SILValue addr,
   if (cleanup.isValid())
     cleanups.push_back(cleanup);
 
-  return InitializationPtr(temporary.release());
+  return temporary;
 }
 
 static InitializationPtr
@@ -668,7 +668,7 @@ prepareIndirectResultInit(SILGenFunction &SGF, SILLocation loc,
 ///   components of the result
 /// \param cleanups - will be filled (after initialization completes)
 ///   with all the active cleanups managing the result values
-std::unique_ptr<Initialization>
+InitializationPtr
 SILGenFunction::prepareIndirectResultInit(
                                  SILLocation loc,
                                  AbstractionPattern origResultType,

Original file line number	Diff line number	Diff line change
`@@ -1746,7 +1746,7 @@ void SILGenFunction::emitGeneratorFunction(`
`1746`	`1746`	`mergeCleanupBlocks();`
`1747`	`1747`	`}`
`1748`	`1748`
`1749`		`-std::unique_ptr<Initialization> SILGenFunction::getSingleValueStmtInit(Expr *E) {`
	`1749`	`+InitializationPtr SILGenFunction::getSingleValueStmtInit(Expr *E) {`
`1750`	`1750`	`if (SingleValueStmtInitStack.empty())`
`1751`	`1751`	`return nullptr;`
`1752`	`1752`
`@@ -1756,7 +1756,7 @@ std::unique_ptr<Initialization> SILGenFunction::getSingleValueStmtInit(Expr *E)`
`1756`	`1756`	`return nullptr;`
`1757`	`1757`
`1758`	`1758`	`auto resultAddr = SingleValueStmtInitStack.back().InitializationBuffer;`
`1759`		`- return std::make_unique<KnownAddressInitialization>(resultAddr);`
	`1759`	`+ return make_possibly_unique<KnownAddressInitialization>(resultAddr);`
`1760`	`1760`	`}`
`1761`	`1761`
`1762`	`1762`	`void SILGenFunction::emitProfilerIncrement(ASTNode Node) {`