Merge branch 'main' into isolated-any-silgen

Author: rjmccall

include/swift/ABI/MetadataValues.h

@@ -1187,6 +1187,9 @@ class TargetExtendedFunctionTypeFlags {
 
     // Values for the enumerated isolation kinds
     IsolatedAny            = 0x00000002U,
+
+    // Values if we have a transferring result.
+    HasTransferringResult  = 0x00000010U,
   };
   int_type Data;
 
@@ -1211,12 +1214,23 @@ class TargetExtendedFunctionTypeFlags {
               (Data & ~IsolationMask) | IsolatedAny);
   }
 
+  const TargetExtendedFunctionTypeFlags<int_type>
+  withTransferringResult(bool newValue = true) const {
+    return TargetExtendedFunctionTypeFlags<int_type>(
+        (Data & ~HasTransferringResult) |
+        (newValue ? HasTransferringResult : 0));
+  }
+
   bool isTypedThrows() const { return bool(Data & TypedThrowsMask); }
 
   bool isIsolatedAny() const {
     return (Data & IsolationMask) == IsolatedAny;
   }
 
+  bool hasTransferringResult() const {
+    return bool(Data & HasTransferringResult);
+  }
+
   int_type getIntValue() const {
     return Data;
   }
@@ -1242,6 +1256,7 @@ class TargetParameterTypeFlags {
     AutoClosureMask       = 0x100,
     NoDerivativeMask      = 0x200,
     IsolatedMask          = 0x400,
+    TransferringMask      = 0x800,
   };
   int_type Data;
 
@@ -1280,11 +1295,18 @@ class TargetParameterTypeFlags {
         (Data & ~IsolatedMask) | (isIsolated ? IsolatedMask : 0));
   }
 
+  constexpr TargetParameterTypeFlags<int_type>
+  withTransferring(bool isTransferring) const {
+    return TargetParameterTypeFlags<int_type>(
+        (Data & ~TransferringMask) | (isTransferring ? TransferringMask : 0));
+  }
+
   bool isNone() const { return Data == 0; }
   bool isVariadic() const { return Data & VariadicMask; }
   bool isAutoClosure() const { return Data & AutoClosureMask; }
   bool isNoDerivative() const { return Data & NoDerivativeMask; }
   bool isIsolated() const { return Data & IsolatedMask; }
+  bool isTransferring() const { return Data & TransferringMask; }
 
   ValueOwnership getValueOwnership() const {
     return (ValueOwnership)(Data & ValueOwnershipMask);

include/swift/AST/Types.h

@@ -1146,25 +1146,16 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// function with each archetype-to-substituted-type binding. The callback
   /// may return a new type to substitute into the result type, or return
   /// CanType() to error out of the operation. Each invocation of the callback
-  /// receives three arguments:
+  /// receives two arguments:
   /// - The `orig` archetype from a position in `this` type.
-  /// - The `subst` type in the same structural position of `ty` that is trying to be bound
-  ///  to `orig`.
-  /// - The `upperBound` archetype, which if set, indicates the minimum set of constraints
-  ///  that any type substituted in this structural position must conform to. May be null,
-  ///  indicating an unconstrained context.
-  /// - If `upperBound` is set, then the `substConformances` array will contain the
-  ///  protocol conformances for `subst` to each of the protocol requirements
-  ///  on `upperBound` in `getConformsTo` order.
+  /// - The `subst` type in the same structural position of `ty` that is trying
+  /// to be bound to `orig`.
   ///
   /// Returns the substituted type, or a null CanType() if this type
   /// is not bindable to the substituted type, or the callback returns
   /// CanType().
   CanType substituteBindingsTo(Type ty,
-         llvm::function_ref<CanType(ArchetypeType *orig,
-                CanType subst,
-                ArchetypeType *upperBound,
-                ArrayRef<ProtocolConformanceRef> substConformances)> substFn);
+         llvm::function_ref<CanType(ArchetypeType *orig, CanType subst)> substFn);
 
   /// Determines whether this type is similar to \p other as defined by
   /// \p matchOptions.

include/swift/Basic/Features.def

@@ -125,6 +125,7 @@ LANGUAGE_FEATURE(TypedThrows, 413, "Typed throws")
 LANGUAGE_FEATURE(OptionalIsolatedParameters, 420, "Optional isolated parameters")
 SUPPRESSIBLE_LANGUAGE_FEATURE(Extern, 0, "@_extern")
 LANGUAGE_FEATURE(ExpressionMacroDefaultArguments, 422, "Expression macro as caller-side default argument")
+LANGUAGE_FEATURE(BuiltinStoreRaw, 0, "Builtin.storeRaw")
 
 UPCOMING_FEATURE(ConciseMagicFile, 274, 6)
 UPCOMING_FEATURE(ForwardTrailingClosures, 286, 6)

include/swift/Demangling/Demangle.h

@@ -278,7 +278,7 @@ class Node {
   /// Prints the whole node tree in readable form to stderr.
   ///
   /// Useful to be called from the debugger.
-  void dump();
+  void dump() LLVM_ATTRIBUTE_USED;
 };
 
 /// Returns the length of the swift mangling prefix of the \p SymbolName.
@@ -555,6 +555,7 @@ struct [[nodiscard]] ManglingError {
     InvalidImplDifferentiability,
     InvalidImplFunctionAttribute,
     InvalidImplParameterConvention,
+    InvalidImplParameterTransferring,
     InvalidMetatypeRepresentation,
     MultiByteRelatedEntity,
     BadValueWitnessKind,

include/swift/Demangling/DemangleNodes.def

@@ -133,6 +133,7 @@ NODE(ImplConvention)
 NODE(ImplDifferentiabilityKind)
 NODE(ImplErasedIsolation)
 NODE(ImplParameterResultDifferentiability)
+NODE(ImplParameterTransferring)
 NODE(ImplFunctionAttribute)
 NODE(ImplFunctionConvention)
 NODE(ImplFunctionConventionName)
@@ -149,7 +150,9 @@ NODE(InfixOperator)
 CONTEXT_NODE(Initializer)
 CONTEXT_NODE(InitAccessor)
 NODE(Isolated)
+NODE(Transferring)
 NODE(IsolatedAnyFunctionType)
+NODE(TransferringResultFunctionType)
 NODE(KeyPathGetterThunkHelper)
 NODE(KeyPathSetterThunkHelper)
 NODE(KeyPathEqualsThunkHelper)

include/swift/Demangling/Demangler.h

@@ -566,6 +566,7 @@ class Demangler : public NodeFactory {
   NodePointer demangleInitializer();
   NodePointer demangleImplParamConvention(Node::Kind ConvKind);
   NodePointer demangleImplResultConvention(Node::Kind ConvKind);
+  NodePointer demangleImplParameterTransferring();
   NodePointer demangleImplParameterResultDifferentiability();
   NodePointer demangleImplFunctionType();
   NodePointer demangleClangType();

include/swift/Demangling/TypeDecoder.h

@@ -78,6 +78,7 @@ class FunctionParam {
   }
   void setNoDerivative() { Flags = Flags.withNoDerivative(true); }
   void setIsolated() { Flags = Flags.withIsolated(true); }
+  void setTransferring() { Flags = Flags.withTransferring(true); }
   void setFlags(ParameterFlags flags) { Flags = flags; };
 
   FunctionParam withLabel(StringRef label) const {
@@ -109,6 +110,7 @@ enum class ImplParameterConvention {
 
 enum class ImplParameterInfoFlags : uint8_t {
   NotDifferentiable = 0x1,
+  Transferring = 0x2,
 };
 
 using ImplParameterInfoOptions = OptionSet<ImplParameterInfoFlags>;
@@ -282,72 +284,88 @@ class ImplFunctionTypeFlags {
   unsigned Async : 1;
   unsigned ErasedIsolation : 1;
   unsigned DifferentiabilityKind : 3;
+  unsigned HasTransferringResult : 1;
 
 public:
   ImplFunctionTypeFlags()
       : Rep(0), Pseudogeneric(0), Escaping(0), Concurrent(0), Async(0),
-        ErasedIsolation(0), DifferentiabilityKind(0) {}
+        ErasedIsolation(0), DifferentiabilityKind(0), HasTransferringResult(0) {
+  }
 
   ImplFunctionTypeFlags(ImplFunctionRepresentation rep, bool pseudogeneric,
                         bool noescape, bool concurrent, bool async,
                         bool erasedIsolation,
-                        ImplFunctionDifferentiabilityKind diffKind)
+                        ImplFunctionDifferentiabilityKind diffKind,
+                        bool hasTransferringResult)
       : Rep(unsigned(rep)), Pseudogeneric(pseudogeneric), Escaping(noescape),
         Concurrent(concurrent), Async(async), ErasedIsolation(erasedIsolation),
-        DifferentiabilityKind(unsigned(diffKind)) {}
+        DifferentiabilityKind(unsigned(diffKind)),
+        HasTransferringResult(hasTransferringResult) {}
 
   ImplFunctionTypeFlags
   withRepresentation(ImplFunctionRepresentation rep) const {
     return ImplFunctionTypeFlags(
         rep, Pseudogeneric, Escaping, Concurrent, Async, ErasedIsolation,
-        ImplFunctionDifferentiabilityKind(DifferentiabilityKind));
+        ImplFunctionDifferentiabilityKind(DifferentiabilityKind),
+        HasTransferringResult);
   }
 
   ImplFunctionTypeFlags
   withConcurrent() const {
     return ImplFunctionTypeFlags(
-        ImplFunctionRepresentation(Rep), Pseudogeneric, Escaping, true,
-        Async, ErasedIsolation,
-        ImplFunctionDifferentiabilityKind(DifferentiabilityKind));
+        ImplFunctionRepresentation(Rep), Pseudogeneric, Escaping, true, Async,
+        ErasedIsolation,
+        ImplFunctionDifferentiabilityKind(DifferentiabilityKind),
+        HasTransferringResult);
   }
 
   ImplFunctionTypeFlags
   withAsync() const {
     return ImplFunctionTypeFlags(
         ImplFunctionRepresentation(Rep), Pseudogeneric, Escaping, Concurrent,
         true, ErasedIsolation,
-        ImplFunctionDifferentiabilityKind(DifferentiabilityKind));
+        ImplFunctionDifferentiabilityKind(DifferentiabilityKind),
+        HasTransferringResult);
   }
 
   ImplFunctionTypeFlags
   withEscaping() const {
     return ImplFunctionTypeFlags(
         ImplFunctionRepresentation(Rep), Pseudogeneric, true, Concurrent, Async,
         ErasedIsolation,
-        ImplFunctionDifferentiabilityKind(DifferentiabilityKind));
+        ImplFunctionDifferentiabilityKind(DifferentiabilityKind),
+        HasTransferringResult);
   }
 
   ImplFunctionTypeFlags
   withErasedIsolation() const {
     return ImplFunctionTypeFlags(
         ImplFunctionRepresentation(Rep), Pseudogeneric, Escaping, Concurrent,
-        Async, true,
-        ImplFunctionDifferentiabilityKind(DifferentiabilityKind));
+        Async, true, ImplFunctionDifferentiabilityKind(DifferentiabilityKind),
+        HasTransferringResult);
   }
 
   ImplFunctionTypeFlags
   withPseudogeneric() const {
     return ImplFunctionTypeFlags(
         ImplFunctionRepresentation(Rep), true, Escaping, Concurrent, Async,
         ErasedIsolation,
-        ImplFunctionDifferentiabilityKind(DifferentiabilityKind));
+        ImplFunctionDifferentiabilityKind(DifferentiabilityKind),
+        HasTransferringResult);
   }
 
   ImplFunctionTypeFlags
   withDifferentiabilityKind(ImplFunctionDifferentiabilityKind diffKind) const {
     return ImplFunctionTypeFlags(ImplFunctionRepresentation(Rep), Pseudogeneric,
                                  Escaping, Concurrent, Async, ErasedIsolation,
-                                 diffKind);
+                                 diffKind, HasTransferringResult);
+  }
+
+  ImplFunctionTypeFlags withTransferringResult() const {
+    return ImplFunctionTypeFlags(
+        ImplFunctionRepresentation(Rep), Pseudogeneric, Escaping, Concurrent,
+        Async, ErasedIsolation,
+        ImplFunctionDifferentiabilityKind(DifferentiabilityKind), true);
   }
 
   ImplFunctionRepresentation getRepresentation() const {
@@ -364,6 +382,8 @@ class ImplFunctionTypeFlags {
 
   bool hasErasedIsolation() const { return ErasedIsolation; }
 
+  bool hasTransferringResult() const { return HasTransferringResult; }
+
   bool isDifferentiable() const {
     return getDifferentiabilityKind() !=
         ImplFunctionDifferentiabilityKind::NonDifferentiable;
@@ -868,6 +888,12 @@ class TypeDecoder {
         extFlags = extFlags.withIsolatedAny();
         ++firstChildIdx;
       }
+      
+      if (Node->getChild(firstChildIdx)->getKind() ==
+                 NodeKind::TransferringResultFunctionType) {
+        extFlags = extFlags.withTransferringResult();
+        ++firstChildIdx;
+      }
 
       FunctionMetadataDifferentiabilityKind diffKind;
       if (Node->getChild(firstChildIdx)->getKind() ==
@@ -1707,6 +1733,12 @@ class TypeDecoder {
           hasParamFlags = true;
           break;
 
+        case NodeKind::Transferring:
+          param.setTransferring();
+          node = node->getFirstChild();
+          hasParamFlags = true;
+          break;
+
         case NodeKind::AutoClosureType:
         case NodeKind::EscapingAutoClosureType:
           param.setAutoClosure();

include/swift/RemoteInspection/TypeRefBuilder.h

@@ -1163,6 +1163,8 @@ class TypeRefBuilder {
     funcFlags = funcFlags.withConcurrent(flags.isSendable());
     funcFlags = funcFlags.withAsync(flags.isAsync());
     funcFlags = funcFlags.withDifferentiable(flags.isDifferentiable());
+    extFuncFlags =
+        extFuncFlags.withTransferringResult(flags.hasTransferringResult());
 
     FunctionMetadataDifferentiabilityKind diffKind;
     switch (flags.getDifferentiabilityKind()) {

lib/AST/ASTDemangler.cpp

@@ -414,7 +414,8 @@ Type ASTBuilder::createFunctionType(
                               .withVariadic(flags.isVariadic())
                               .withAutoClosure(flags.isAutoClosure())
                               .withNoDerivative(flags.isNoDerivative())
-                              .withIsolated(flags.isIsolated());
+                              .withIsolated(flags.isIsolated())
+                              .withTransferring(flags.isTransferring());
 
     hasIsolatedParameter |= flags.isIsolated();
     funcParams.push_back(AnyFunctionType::Param(type, label, parameterFlags));
@@ -472,7 +473,7 @@ Type ASTBuilder::createFunctionType(
   auto einfo = FunctionType::ExtInfoBuilder(
                    representation, noescape, flags.isThrowing(), thrownError,
                    resultDiffKind, clangFunctionType, isolation,
-                   LifetimeDependenceInfo(), false /*is transferring*/)
+                   LifetimeDependenceInfo(), extFlags.hasTransferringResult())
                    .withAsync(flags.isAsync())
                    .withConcurrent(flags.isSendable())
                    .build();
@@ -517,6 +518,11 @@ getParameterOptions(ImplParameterInfoOptions implOptions) {
     result |= SILParameterInfo::NotDifferentiable;
   }
 
+  if (implOptions.contains(ImplParameterInfoFlags::Transferring)) {
+    implOptions -= ImplParameterInfoFlags::Transferring;
+    result |= SILParameterInfo::Transferring;
+  }
+
   // If we did not handle all flags in implOptions, this code was not updated
   // appropriately. Return None to signal error.
   if (bool(implOptions))
@@ -659,7 +665,7 @@ Type ASTBuilder::createImplFunctionType(
                    representation, flags.isPseudogeneric(), !flags.isEscaping(),
                    flags.isSendable(), flags.isAsync(), unimplementable,
                    isolation, diffKind, clangFnType, LifetimeDependenceInfo(),
-                   false /*has transferring result*/)
+                   flags.hasTransferringResult())
                    .build();
 
   return SILFunctionType::get(genericSig, einfo, funcCoroutineKind,

lib/AST/ASTMangler.cpp

@@ -1989,6 +1989,9 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn,
   if (!fn->isNoEscape())
     OpArgs.push_back('e');
 
+  if (fn->hasTransferringResult())
+    OpArgs.push_back('T');
+
   switch (fn->getIsolation()) {
   case SILFunctionTypeIsolation::Unknown:
     break;
@@ -2089,6 +2092,8 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn,
   // Mangle the parameters.
   for (auto param : fn->getParameters()) {
     OpArgs.push_back(getParamConvention(param.getConvention()));
+    if (param.hasOption(SILParameterInfo::Transferring))
+      OpArgs.push_back('T');
     if (auto diffKind = getParamDifferentiability(param.getOptions()))
       OpArgs.push_back(*diffKind);
     appendType(param.getInterfaceType(), sig, forDecl);
@@ -2858,6 +2863,10 @@ void ASTMangler::appendFunctionSignature(AnyFunctionType *fn,
     break;
   }
 
+  if (fn->hasTransferringResult()) {
+    appendOperator("YT");
+  }
+
   if (auto *afd = dyn_cast_or_null<AbstractFunctionDecl>(forDecl)) {
     if (afd->hasImplicitSelfDecl()) {
       auto lifetimeDependenceKind =
@@ -3034,7 +3043,8 @@ void ASTMangler::appendParameterTypeListElement(
   }
   if (flags.isIsolated())
     appendOperator("Yi");
-
+  if (flags.isTransferring())
+    appendOperator("Yu");
   if (flags.isCompileTimeConst())
     appendOperator("Yt");