Add mangling, metadata, and reflection support for "isolated" parameters.

Isolated parameters are part of function types. Encode them in function
type manglings and metadata, and ensure that they round-trip through
the various mangling and metadata facilities. This nails down the ABI
for isolated parameters.

Author: DougGregor

docs/ABI/Mangling.rst

@@ -611,7 +611,7 @@ Types
   type-list ::= empty-list
 
                                                   // FIXME: Consider replacing 'h' with a two-char code
-  list-type ::= type identifier? 'Yk'? 'z'? 'h'? 'n'? 'd'?  // type with optional label, '@noDerivative', inout convention, shared convention, owned convention, and variadic specifier
+  list-type ::= type identifier? 'Yk'? 'z'? 'h'? 'n'? 'Yi'? 'd'?  // type with optional label, '@noDerivative', inout convention, shared convention, owned convention, actor 'isolated', and variadic specifier
 
   METATYPE-REPR ::= 't'                      // Thin metatype representation
   METATYPE-REPR ::= 'T'                      // Thick metatype representation

include/swift/ABI/MetadataValues.h

@@ -950,7 +950,8 @@ class TargetParameterTypeFlags {
     ValueOwnershipMask    = 0x7F,
     VariadicMask          = 0x80,
     AutoClosureMask       = 0x100,
-    NoDerivativeMask      = 0x200
+    NoDerivativeMask      = 0x200,
+    IsolatedMask          = 0x400,
   };
   int_type Data;
 
@@ -983,10 +984,17 @@ class TargetParameterTypeFlags {
         (Data & ~NoDerivativeMask) | (isNoDerivative ? NoDerivativeMask : 0));
   }
 
+  constexpr TargetParameterTypeFlags<int_type>
+  withIsolated(bool isIsolated) const {
+    return TargetParameterTypeFlags<int_type>(
+        (Data & ~IsolatedMask) | (isIsolated ? IsolatedMask : 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; }
 
   ValueOwnership getValueOwnership() const {
     return (ValueOwnership)(Data & ValueOwnershipMask);

include/swift/Demangling/DemangleNodes.def

@@ -133,6 +133,7 @@ NODE(ImplErrorResult)
 NODE(InOut)
 NODE(InfixOperator)
 CONTEXT_NODE(Initializer)
+NODE(Isolated)
 NODE(KeyPathGetterThunkHelper)
 NODE(KeyPathSetterThunkHelper)
 NODE(KeyPathEqualsThunkHelper)

include/swift/Demangling/TypeDecoder.h

@@ -73,6 +73,7 @@ class FunctionParam {
     Flags = Flags.withValueOwnership(ownership);
   }
   void setNoDerivative() { Flags = Flags.withNoDerivative(true); }
+  void setIsolated() { Flags = Flags.withIsolated(true); }
   void setFlags(ParameterFlags flags) { Flags = flags; };
 
   FunctionParam withLabel(StringRef label) const {
@@ -1415,6 +1416,12 @@ class TypeDecoder {
           hasParamFlags = true;
           break;
 
+        case NodeKind::Isolated:
+          param.setIsolated();
+          node = node->getFirstChild();
+          hasParamFlags = true;
+          break;
+
         case NodeKind::AutoClosureType:
         case NodeKind::EscapingAutoClosureType:
           param.setAutoClosure();

lib/AST/ASTMangler.cpp

@@ -2571,6 +2571,9 @@ void ASTMangler::appendTypeListElement(Identifier name, Type elementType,
     appendOperator("n");
     break;
   }
+  if (flags.isIsolated())
+    appendOperator("Yi");
+
   if (!name.empty())
     appendIdentifier(name.str());
   if (flags.isVariadic())

lib/Demangling/Demangler.cpp

@@ -739,6 +739,9 @@ NodePointer Demangler::demangleTypeAnnotation() {
   case 'c':
     return createWithChild(
         Node::Kind::GlobalActorFunctionType, popTypeAndGetChild());
+  case 'i':
+    return createType(
+        createWithChild(Node::Kind::Isolated, popTypeAndGetChild()));
   case 'j':
     return demangleDifferentiableFunctionType();
   case 'k':

lib/Demangling/NodePrinter.cpp

@@ -416,6 +416,7 @@ class NodePrinter {
     case Node::Kind::InOut:
     case Node::Kind::InfixOperator:
     case Node::Kind::Initializer:
+    case Node::Kind::Isolated:
     case Node::Kind::PropertyWrapperBackingInitializer:
     case Node::Kind::PropertyWrapperInitFromProjectedValue:
     case Node::Kind::KeyPathGetterThunkHelper:
@@ -1423,6 +1424,10 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     Printer << "inout ";
     print(Node->getChild(0));
     return nullptr;
+  case Node::Kind::Isolated:
+    Printer << "isolated ";
+    print(Node->getChild(0));
+    return nullptr;
   case Node::Kind::Shared:
     Printer << "__shared ";
     print(Node->getChild(0));

lib/Demangling/OldRemangler.cpp

@@ -1494,6 +1494,11 @@ void Remangler::mangleInOut(Node *node) {
   mangleSingleChildNode(node); // type
 }
 
+void Remangler::mangleIsolated(Node *node) {
+  Buffer << "Yi";
+  mangleSingleChildNode(node); // type
+}
+
 void Remangler::mangleNoDerivative(Node *node) {
   Buffer << 'k';
   mangleSingleChildNode(node); // type

lib/Demangling/Remangler.cpp

@@ -1670,6 +1670,11 @@ void Remangler::mangleInOut(Node *node) {
   Buffer << 'z';
 }
 
+void Remangler::mangleIsolated(Node *node) {
+  mangleSingleChildNode(node);
+  Buffer << "Yi";
+}
+
 void Remangler::mangleShared(Node *node) {
   mangleSingleChildNode(node);
   Buffer << 'h';

lib/IRGen/MetadataRequest.cpp

@@ -1383,7 +1383,8 @@ namespace {
             .withValueOwnership(flags.getValueOwnership())
             .withVariadic(flags.isVariadic())
             .withAutoClosure(flags.isAutoClosure())
-            .withNoDerivative(flags.isNoDerivative());
+            .withNoDerivative(flags.isNoDerivative())
+            .withIsolated(flags.isIsolated());
       };
 
       bool hasParameterFlags = false;

stdlib/public/Reflection/TypeRef.cpp

@@ -199,6 +199,9 @@ class PrintTypeRef : public TypeRefVisitor<PrintTypeRef, void> {
         break;
       }
 
+      if (flags.isIsolated())
+        printHeader("isolated");
+
       if (flags.isVariadic())
         printHeader("variadic");
 
@@ -633,6 +636,9 @@ class DemanglingForTypeRef
         wrapInput(Node::Kind::Owned);
         break;
       }
+      if (flags.isIsolated()) {
+        wrapInput(Node::Kind::Isolated);
+      }
 
       inputs.push_back({input, flags.isVariadic()});
     }

stdlib/public/runtime/Demangle.cpp

@@ -499,6 +499,9 @@ swift::_swift_buildDemanglingForMetadata(const Metadata *type,
         wrapInput(Node::Kind::Owned);
         break;
       }
+      if (flags.isIsolated()) {
+        wrapInput(Node::Kind::Isolated);
+      }
 
       inputs.push_back({input, flags.isVariadic()});
     }

test/Demangle/Inputs/manglings.txt

@@ -407,3 +407,5 @@ $sScA ---> Swift.Actor
 $sScGySiG ---> Swift.TaskGroup<Swift.Int>
 $s4test10returnsOptyxycSgxyScMYccSglF ---> test.returnsOpt<A>((@Swift.MainActor () -> A)?) -> (() -> A)?
 $sSvSgA3ASbIetCyyd_SgSbIetCyyyd_SgD ---> (@escaping @convention(thin) @convention(c) (@unowned Swift.UnsafeMutableRawPointer?, @unowned Swift.UnsafeMutableRawPointer?, @unowned (@escaping @convention(thin) @convention(c) (@unowned Swift.UnsafeMutableRawPointer?, @unowned Swift.UnsafeMutableRawPointer?) -> (@unowned Swift.Bool))?) -> (@unowned Swift.Bool))?
+$s4test10returnsOptyxycSgxyScMYccSglF ---> test.returnsOpt<A>(@Swift.MainActor () -> A?) -> () -> A?
+$s1t10globalFuncyyAA7MyActorCYiF ---> t.globalFunc(isolated t.MyActor) -> ()

test/Reflection/Inputs/ConcurrencyTypes.swift

@@ -1,3 +1,9 @@
+@available(SwiftStdlib 5.5, *)
+public actor SomeActor {
+}
+
+@available(SwiftStdlib 5.5, *)
 public struct UsesConcurrency {
   public var mainActorFunction: @MainActor () -> Void
+  public var actorIsolatedFunction: (isolated SomeActor) -> Void
 }

test/Reflection/typeref_decoding_concurrency.swift

@@ -23,3 +23,9 @@
 // CHECK: (function
 // CHECK:   (global-actor
 // CHECK:     (class Swift.MainActor))
+
+// CHECK: actorIsolatedFunction: (isolated TypesToReflect.SomeActor) -> ()
+// CHECK: (function
+// CHECK:   (parameters
+// CHECK:     isolated
+// CHECK:     (class TypesToReflect.SomeActor))

test/Runtime/demangleToMetadata.swift

@@ -60,6 +60,9 @@ func globalActorMetatypeFn<T>(_: T.Type) -> Any.Type {
   return Fn.self
 }
 
+@available(SwiftStdlib 5.5, *)
+func f1_actor(_: (isolated Actor) -> Void) { }
+
 DemangleToMetadataTests.test("function types") {
   // Conventions
   expectEqual(type(of: f0), _typeByName("yyc")!)
@@ -114,6 +117,13 @@ DemangleToMetadataTests.test("function types") {
   typealias MainActorFn = @MainActor () -> Float
   expectEqual(MainActorFn.self, _typeByName("SfyScMYcc")!)
   expectEqual(MainActorFn.self, globalActorMetatypeFn(Float.self))
+
+  // isolated parameters
+  if #available(SwiftStdlib 5.5, *) {
+    expectEqual(type(of: f1_actor), _typeByName("yyScA_pYiXEc")!)
+    typealias IsolatedFn = ((isolated Actor) -> Void) -> Void
+    expectEqual(IsolatedFn.self, type(of: f1_actor))
+  }
 }
 
 DemangleToMetadataTests.test("metatype types") {

test/SILGen/isolated_parameters.swift

@@ -0,0 +1,12 @@
+// RUN: %target-swift-frontend -emit-silgen %s -module-name test -swift-version 5 | %FileCheck %s
+// REQUIRES: concurrency
+
+@available(SwiftStdlib 5.5, *)
+public actor A {
+  // CHECK: sil {{.*}} [ossa] @$s4test1AC6methodyyF
+  public func method() { }
+}
+
+// CHECK: sil {{.*}} [ossa] @$s4test13takesIsolatedyyAA1ACYiF
+@available(SwiftStdlib 5.5, *)
+public func takesIsolated(_: isolated A) { }