Merge pull request #37789 from DougGregor/global-actor-function-types-abi-5.5

Concurrency ABI for global-actor-qualified function types

Author: DougGregor

docs/ABI/Mangling.rst

@@ -466,6 +466,7 @@ Types
   KNOWN-TYPE-KIND ::= 'a'                    // Swift.Array
   KNOWN-TYPE-KIND ::= 'B'                    // Swift.BinaryFloatingPoint
   KNOWN-TYPE-KIND ::= 'b'                    // Swift.Bool
+  KNOWN-TYPE-KIND ::= 'c' KNOWN-TYPE-KIND-2  // Second set of standard types
   KNOWN-TYPE-KIND ::= 'D'                    // Swift.Dictionary
   KNOWN-TYPE-KIND ::= 'd'                    // Swift.Float64
   KNOWN-TYPE-KIND ::= 'E'                    // Swift.Encodable
@@ -511,6 +512,25 @@ Types
   KNOWN-TYPE-KIND ::= 'Z'                    // Swift.SignedInteger
   KNOWN-TYPE-KIND ::= 'z'                    // Swift.BinaryInteger
 
+  KNOWN-TYPE-KIND-2 ::= 'A'        // Swift.Actor
+  KNOWN-TYPE-KIND-2 ::= 'C'        // Swift.CheckedContinuation
+  KNOWN-TYPE-KIND-2 ::= 'c'        // Swift.UnsafeContinuation
+  KNOWN-TYPE-KIND-2 ::= 'E'        // Swift.CancellationError
+  KNOWN-TYPE-KIND-2 ::= 'e'        // Swift.UnownedSerialExecutor
+  KNOWN-TYPE-KIND-2 ::= 'F'        // Swift.Executor
+  KNOWN-TYPE-KIND-2 ::= 'f'        // Swift.SerialExecutor
+  KNOWN-TYPE-KIND-2 ::= 'G'        // Swift.TaskGroup
+  KNOWN-TYPE-KIND-2 ::= 'g'        // Swift.ThrowingTaskGroup
+  KNOWN-TYPE-KIND-2 ::= 'I'        // Swift.AsyncIteratorProtocol
+  KNOWN-TYPE-KIND-2 ::= 'i'        // Swift.AsyncSequence
+  KNOWN-TYPE-KIND-2 ::= 'J'        // Swift.UnownedJob
+  KNOWN-TYPE-KIND-2 ::= 'M'        // Swift.MainActor
+  KNOWN-TYPE-KIND-2 ::= 'P'        // Swift.TaskPriority
+  KNOWN-TYPE-KIND-2 ::= 'S'        // Swift.AsyncStream
+  KNOWN-TYPE-KIND-2 ::= 's'        // Swift.AsyncThrowingStream
+  KNOWN-TYPE-KIND-2 ::= 'T'        // Swift.Task
+  KNOWN-TYPE-KIND-2 ::= 't'        // Swift.UnsafeCurrentTask
+
   protocol ::= context decl-name
   protocol ::= standard-substitutions
 
@@ -569,7 +589,7 @@ Types
   C-TYPE is mangled according to the Itanium ABI, and prefixed with the length.
   Non-ASCII identifiers are preserved as-is; we do not use Punycode.
 
-  function-signature ::= params-type params-type async? sendable? throws? differentiable? // results and parameters
+  function-signature ::= params-type params-type async? sendable? throws? differentiable? global-actor? // results and parameters
 
   params-type ::= type 'z'? 'h'?             // tuple in case of multiple parameters or a single parameter with a single tuple type
                                              // with optional inout convention, shared convention. parameters don't have labels,
@@ -579,6 +599,7 @@ Types
   #if SWIFT_RUNTIME_VERSION >= 5.5
     async ::= 'Ya'                             // 'async' annotation on function types
     sendable ::= 'Yb'                          // @Sendable on function types
+    global-actor :: = type 'Yc'                // Global actor on function type
   #endif
   throws ::= 'K'                             // 'throws' annotation on function types
   differentiable ::= 'Yjf'                   // @differentiable(_forward) on function type

include/swift/ABI/Metadata.h

@@ -1665,6 +1665,7 @@ struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime> {
   bool isDifferentiable() const { return Flags.isDifferentiable(); }
   bool hasParameterFlags() const { return Flags.hasParameterFlags(); }
   bool isEscaping() const { return Flags.isEscaping(); }
+  bool hasGlobalActor() const { return Flags.hasGlobalActor(); }
 
   static constexpr StoredSize OffsetToFlags = sizeof(TargetMetadata<Runtime>);
 
@@ -1702,6 +1703,31 @@ struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime> {
     return TargetFunctionMetadataDifferentiabilityKind<StoredSize>
         ::NonDifferentiable;
   }
+
+  ConstTargetMetadataPointer<Runtime, swift::TargetMetadata> *
+  getGlobalActorAddr() {
+    assert(hasGlobalActor());
+    
+    void *endAddr =
+        isDifferentiable()
+          ? reinterpret_cast<void *>(getDifferentiabilityKindAddress() + 1) :
+        hasParameterFlags()
+          ? reinterpret_cast<void *>(getParameterFlags() + getNumParameters()) :
+        reinterpret_cast<void *>(getParameters() + getNumParameters());
+    return reinterpret_cast<
+        ConstTargetMetadataPointer<Runtime, swift::TargetMetadata> *>(
+          llvm::alignAddr(
+              endAddr, llvm::Align(alignof(typename Runtime::StoredPointer))));
+  }
+
+  ConstTargetMetadataPointer<Runtime, swift::TargetMetadata>
+  getGlobalActor() const {
+    if (!hasGlobalActor())
+      return ConstTargetMetadataPointer<Runtime, swift::TargetMetadata>();
+
+    return *const_cast<TargetFunctionTypeMetadata<Runtime> *>(this)
+      ->getGlobalActorAddr();
+  }
 };
 using FunctionTypeMetadata = TargetFunctionTypeMetadata<InProcess>;
 

include/swift/ABI/MetadataValues.h

@@ -834,8 +834,10 @@ class TargetFunctionTypeFlags {
     ParamFlagsMask         = 0x02000000U,
     EscapingMask           = 0x04000000U,
     DifferentiableMask     = 0x08000000U,
+    GlobalActorMask        = 0x10000000U,
     AsyncMask              = 0x20000000U,
     SendableMask           = 0x40000000U,
+    // NOTE: The next bit will need to introduce a separate flags word.
   };
   int_type Data;
 
@@ -891,6 +893,12 @@ class TargetFunctionTypeFlags {
         (isSendable ? SendableMask : 0));
   }
 
+  constexpr TargetFunctionTypeFlags<int_type>
+  withGlobalActor(bool globalActor) const {
+    return TargetFunctionTypeFlags<int_type>(
+        (Data & ~GlobalActorMask) | (globalActor ? GlobalActorMask : 0));
+  }
+
   unsigned getNumParameters() const { return Data & NumParametersMask; }
 
   FunctionMetadataConvention getConvention() const {
@@ -915,6 +923,10 @@ class TargetFunctionTypeFlags {
     return bool (Data & DifferentiableMask);
   }
 
+  bool hasGlobalActor() const {
+    return bool (Data & GlobalActorMask);
+  }
+
   int_type getIntValue() const {
     return Data;
   }

include/swift/AST/ASTDemangler.h

@@ -98,7 +98,7 @@ class ASTBuilder {
   Type createFunctionType(
       ArrayRef<Demangle::FunctionParam<Type>> params,
       Type output, FunctionTypeFlags flags,
-      FunctionMetadataDifferentiabilityKind diffKind);
+      FunctionMetadataDifferentiabilityKind diffKind, Type globalActor);
 
   Type createImplFunctionType(
     Demangle::ImplParameterConvention calleeConvention,

include/swift/AST/Module.h

@@ -713,6 +713,9 @@ class ModuleDecl : public DeclContext, public TypeDecl {
   /// \returns true if this module is the "swift" standard library module.
   bool isStdlibModule() const;
 
+  /// \returns true if this module has standard substitutions for mangling.
+  bool hasStandardSubstitutions() const;
+
   /// \returns true if this module is the "SwiftShims" module;
   bool isSwiftShimsModule() const;
 

include/swift/Demangling/DemangleNodes.def

@@ -82,6 +82,7 @@ NODE(ErrorType)
 NODE(EscapingAutoClosureType)
 NODE(NoEscapeFunctionType)
 NODE(ConcurrentFunctionType)
+NODE(GlobalActorFunctionType)
 NODE(DifferentiableFunctionType)
 NODE(ExistentialMetatype)
 CONTEXT_NODE(ExplicitClosure)

include/swift/Demangling/Demangler.h

@@ -494,7 +494,7 @@ class Demangler : public NodeFactory {
   NodePointer pushMultiSubstitutions(int RepeatCount, size_t SubstIdx);
   NodePointer createSwiftType(Node::Kind typeKind, const char *name);
   NodePointer demangleStandardSubstitution();
-  NodePointer createStandardSubstitution(char Subst);
+  NodePointer createStandardSubstitution(char Subst, bool SecondLevel);
   NodePointer demangleLocalIdentifier();
 
   NodePointer popModule();

include/swift/Demangling/ManglingUtils.h

@@ -99,7 +99,7 @@ char translateOperatorChar(char op);
 std::string translateOperator(StringRef Op);
 
 /// Returns the standard type kind for an 'S' substitution, e.g. 'i' for "Int".
-char getStandardTypeSubst(StringRef TypeName);
+llvm::Optional<StringRef> getStandardTypeSubst(StringRef TypeName);
 
 /// Mangles an identifier using a generic Mangler class.
 ///
@@ -274,8 +274,9 @@ class SubstitutionMerging {
   /// *) getBufferStr(): Returns a StringRef of the current content of Buffer.
   /// *) resetBuffer(size_t): Resets the buffer to an old position.
   template <typename Mangler>
-  bool tryMergeSubst(Mangler &M, char Subst, bool isStandardSubst) {
-    assert(isUpperLetter(Subst) || (isStandardSubst && isLowerLetter(Subst)));
+  bool tryMergeSubst(Mangler &M, StringRef Subst, bool isStandardSubst) {
+    assert(isUpperLetter(Subst.back()) ||
+           (isStandardSubst && isLowerLetter(Subst.back())));
     StringRef BufferStr = M.getBufferStr();
     if (lastNumSubsts > 0 && lastNumSubsts < MaxRepeatCount
         && BufferStr.size() == lastSubstPosition + lastSubstSize
@@ -284,17 +285,20 @@ class SubstitutionMerging {
       // The last mangled thing is a substitution.
       assert(lastSubstPosition > 0 && lastSubstPosition < BufferStr.size());
       assert(lastSubstSize > 0);
-      char lastSubst = BufferStr.back();
-      assert(isUpperLetter(lastSubst)
-             || (isStandardSubst && isLowerLetter(lastSubst)));
+      StringRef lastSubst = BufferStr.take_back(lastSubstSize)
+            .drop_while([](char c) {
+        return isDigit(c);
+      });
+      assert(isUpperLetter(lastSubst.back())
+             || (isStandardSubst && isLowerLetter(lastSubst.back())));
       if (lastSubst != Subst && !isStandardSubst) {
         // We can merge with a different 'A' substitution,
         // e.g. 'AB' -> 'AbC'.
         lastSubstPosition = BufferStr.size();
         lastNumSubsts = 1;
         M.resetBuffer(BufferStr.size() - 1);
-        assert(isUpperLetter(lastSubst));
-        M.Buffer << (char)(lastSubst - 'A' + 'a') << Subst;
+        assert(isUpperLetter(lastSubst.back()));
+        M.Buffer << (char)(lastSubst.back() - 'A' + 'a') << Subst;
         lastSubstSize = 1;
         return true;
       }
@@ -312,7 +316,7 @@ class SubstitutionMerging {
     // We can't merge with the previous substitution, but let's remember this
     // substitution which will be mangled by the caller.
     lastSubstPosition = BufferStr.size() + 1;
-    lastSubstSize = 1;
+    lastSubstSize = Subst.size();
     lastNumSubsts = 1;
     lastSubstIsStandardSubst = isStandardSubst;
     return false;

include/swift/Demangling/StandardTypesMangling.def

@@ -12,7 +12,12 @@
 
 /// STANDARD_TYPE(KIND, MANGLING, TYPENAME)
 ///   The 1-character MANGLING for a known TYPENAME of KIND.
-
+///
+/// STANDARD_TYPE_2(KIND, MANGLING, TYPENAME)
+///   The 1-character MANGLING for a known TYPENAME of KIND that is in the
+///   second level of standard types, all of which are mangled with the form
+///   Sc<MANGLING>.
+///
 /// OBJC_INTEROP_STANDARD_TYPE(KIND, MANGLING, TYPENAME)
 ///   The 1-character MANGLING for a known TYPENAME of KIND, for a type that's
 ///   only available with ObjC interop enabled.
@@ -22,6 +27,7 @@
   STANDARD_TYPE(KIND, MANGLING, TYPENAME)
 #endif
 
+
 OBJC_INTEROP_STANDARD_TYPE(Structure, A, AutoreleasingUnsafeMutablePointer)
 STANDARD_TYPE(Structure, a, Array)
 STANDARD_TYPE(Structure, b, Bool)
@@ -73,5 +79,25 @@ STANDARD_TYPE(Protocol, y, StringProtocol)
 STANDARD_TYPE(Protocol, Z, SignedInteger)
 STANDARD_TYPE(Protocol, z, BinaryInteger)
 
+STANDARD_TYPE_2(Protocol, A, Actor)
+STANDARD_TYPE_2(Structure, C, CheckedContinuation)
+STANDARD_TYPE_2(Structure, c, UnsafeContinuation)
+STANDARD_TYPE_2(Structure, E, CancellationError)
+STANDARD_TYPE_2(Structure, e, UnownedSerialExecutor)
+STANDARD_TYPE_2(Protocol, F, Executor)
+STANDARD_TYPE_2(Protocol, f, SerialExecutor)
+STANDARD_TYPE_2(Structure, G, TaskGroup)
+STANDARD_TYPE_2(Structure, g, ThrowingTaskGroup)
+STANDARD_TYPE_2(Protocol, I, AsyncIteratorProtocol)
+STANDARD_TYPE_2(Protocol, i, AsyncSequence)
+STANDARD_TYPE_2(Structure, J, UnownedJob)
+STANDARD_TYPE_2(Class, M, MainActor)
+STANDARD_TYPE_2(Structure, P, TaskPriority)
+STANDARD_TYPE_2(Structure, S, AsyncStream)
+STANDARD_TYPE_2(Structure, s, AsyncThrowingStream)
+STANDARD_TYPE_2(Structure, T, Task)
+STANDARD_TYPE_2(Structure, t, UnsafeCurrentTask)
+
 #undef STANDARD_TYPE
 #undef OBJC_INTEROP_STANDARD_TYPE
+#undef STANDARD_TYPE_2

include/swift/Demangling/TypeDecoder.h

@@ -738,6 +738,23 @@ class TypeDecoder {
         ++firstChildIdx;
       }
 
+      BuiltType globalActorType = BuiltType();
+      if (Node->getChild(firstChildIdx)->getKind() ==
+          NodeKind::GlobalActorFunctionType) {
+        auto child = Node->getChild(firstChildIdx);
+        if (child->getNumChildren() < 1) {
+          return MAKE_NODE_TYPE_ERROR0(child,
+                                       "Global actor node is missing child");
+        }
+
+        auto globalActorResult = decodeMangledType(child->getChild(0));
+        if (globalActorResult.isError())
+          return globalActorResult;
+
+        globalActorType = globalActorResult.getType();
+        ++firstChildIdx;
+      }
+
       FunctionMetadataDifferentiabilityKind diffKind;
       if (Node->getChild(firstChildIdx)->getKind() ==
             NodeKind::DifferentiableFunctionType) {
@@ -811,7 +828,7 @@ class TypeDecoder {
       if (result.isError())
         return result;
       return Builder.createFunctionType(
-          parameters, result.getType(), flags, diffKind);
+          parameters, result.getType(), flags, diffKind, globalActorType);
     }
     case NodeKind::ImplFunctionType: {
       auto calleeConvention = ImplParameterConvention::Direct_Unowned;