Merge pull request #83501 from rjmccall/pack-tuple-projection-silgen

Fix projecting a tuple element out of a tuple with packs.

Author: rjmccall

include/swift/Basic/Compiler.h

@@ -190,4 +190,10 @@ inline const char *operator""_swift_u8(const char8_t *p, size_t) {
 #endif // defined(__cpp_char8_t)
 #endif // defined(__cplusplus)
 
+#if __has_attribute(trivial_abi)
+#define SWIFT_TRIVIAL_ABI __attribute__((trivial_abi))
+#else
+#define SWIFT_TRIVIAL_ABI
+#endif
+
 #endif // SWIFT_BASIC_COMPILER_H

include/swift/Basic/PossiblyUniquePtr.h

@@ -0,0 +1,173 @@
+//===--- PossiblyUniquePtr.h - A dynamic smart pointer ----------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+///
+///  \file
+///
+///  This file defines PossiblyUniquePtr, a smart pointer template that
+///  typically owns its pointee but can dynamically just contain an unowned
+///  pointer.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_BASIC_POSSIBLY_UNIQUE_PTR_H
+#define SWIFT_BASIC_POSSIBLY_UNIQUE_PTR_H
+
+#include "llvm/ADT/PointerIntPair.h"
+#include "swift/Basic/Compiler.h"
+
+namespace swift {
+
+enum PointerIsOwned_t: bool {
+  PointerIsNotOwned = false,
+  PointerIsOwned = true
+};
+
+/// Essentially std::unique_ptr except it dynamically tracks whether the
+/// pointer is actually owned.
+///
+/// The operations which possibly transfer ownership into a PossiblyUniquePtr
+/// (the constructor and `reset`) privilege the owning case. This allows
+/// PossiblyUniquePtr<T> to serve as a drop-in replacement for
+/// std::unique_ptr<T>.
+template <class T, class PtrTraits = llvm::PointerLikeTypeTraits<T*>>
+class SWIFT_TRIVIAL_ABI PossiblyUniquePtr {
+  llvm::PointerIntPair<T*, 1, bool, PtrTraits> Value;
+
+  // Befriend all other specializations of this class, for the use of the
+  // converting constructor and assignment operator.
+  template <class, class>
+  friend class PossiblyUniquePtr;
+
+public:
+  PossiblyUniquePtr() {}
+
+  // Allow implicit conversion from a null pointer.
+  PossiblyUniquePtr(std::nullptr_t) {}
+
+  // Require conversion from any other pointer to be explicit.
+  explicit PossiblyUniquePtr(T *pointer,
+                             PointerIsOwned_t owned = PointerIsOwned)
+      : Value(pointer, owned) {
+    assert((pointer != nullptr || !owned) && "claiming ownership of null pointer");
+  }
+
+  PossiblyUniquePtr(PossiblyUniquePtr &&other)
+      : Value(other.Value) {
+    other.dropValue();
+  }
+
+  PossiblyUniquePtr &operator=(PossiblyUniquePtr &&other) {
+    destroyValue();
+    Value = other.Value;
+    other.dropValue();
+    return *this;
+  }
+
+  ~PossiblyUniquePtr() {
+    destroyValue();
+  }
+
+  // Converting constructor.
+  template <class U, class UTraits>
+  PossiblyUniquePtr(PossiblyUniquePtr<U,UTraits> &&other)
+      : Value(other.Value.getPointer(), other.Value.getInt()) {
+    other.dropValue();
+  }
+
+  // Converting assignment operator.
+  template <class U, class UTraits>
+  PossiblyUniquePtr &operator=(PossiblyUniquePtr<U,UTraits> &&other) {
+    destroyValue();
+    Value.setPointerAndInt(other.Value.getPointer(),
+                           other.Value.getInt());
+    other.dropValue();
+    return *this;
+  }
+
+  template <class ObjectType, class... Args>
+  static PossiblyUniquePtr make(Args &&...args) {
+    return PossiblyUniquePtr(new ObjectType(std::forward<Args>(args)...));
+  }
+
+  /// As a unique pointer, PossiblyUniquePtr is non-copyable.
+  PossiblyUniquePtr(const PossiblyUniquePtr &other) = delete;
+  PossiblyUniquePtr &operator=(const PossiblyUniquePtr &other) = delete;
+
+  explicit operator bool() const {
+    return Value.getPointer() != nullptr;
+  }
+
+  T &operator*() const {
+    return *get_nonnull();
+  }
+  T *operator->() const {
+    return get_nonnull();
+  }
+
+  /// Reset the value of this object to the given pointer.
+  ///
+  /// Destroys the current value, if any.
+  void reset(T *pointer = nullptr, PointerIsOwned_t owned = PointerIsOwned) & {
+    destroyValue();
+    Value.setPointerAndInt(pointer, owned);
+  }
+
+  /// Borrow the current pointer value, leaving ownership (if any) with this object.
+  T *get() const {
+    return Value.getPointer();
+  }
+
+  /// Borrow the current pointer value, leaving ownership (if any) with this object.
+  /// Asserts that the pointer is non-null.
+  T *get_nonnull() const {
+    auto value = get();
+    assert(value);
+    return value;
+  }
+
+  /// Determines whether this object owns its pointer value.
+  PointerIsOwned_t isOwned() const {
+    return PointerIsOwned_t(Value.getInt());
+  }
+
+  /// Release ownership of the pointer, making the caller responsible for it.
+  /// This can only be called on an owned pointer.
+  T *releaseOwned() {
+    assert(isOwned());
+    auto value = get();
+    dropValue();
+    return value;
+  }
+
+private:
+  /// Destroy the value, if we own it.
+  void destroyValue() {
+    if (Value.getInt()) {
+      delete Value.getPointer();
+    }
+  }
+
+  /// Clear the stored value without asserting ownership.
+  void dropValue() & {
+    Value.setPointerAndInt(nullptr, 0);
+  }
+};
+
+template <class ObjectType, class... As>
+PossiblyUniquePtr<ObjectType> make_possibly_unique(As &&...args) {
+  return PossiblyUniquePtr<ObjectType>::
+      template make<ObjectType>(std::forward<As>(args)...);
+}
+
+} // end namespace swift
+
+#endif

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 {

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

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

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()));

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()

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);

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));
 }
 

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);