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;