ASTDemangler: Round-trip @isolated @sil_implicit_leading_param parameter attributes

slavapestov · slavapestov · commit 903319867471 · 2025-06-27T10:56:12.000-04:00
We sometimes mangle SILFunctionTypes when generating debug info
for reabstraction thunks, and these can have various exotic
parameter and result attributes. Two recent additions were
never plumbed through the mangler, causing assertion failures
when emitting debug info.

Fixes rdar://153730847.
diff --git a/docs/ABI/Mangling.rst b/docs/ABI/Mangling.rst
@@ -902,6 +902,15 @@ mangled in to disambiguate.
   PARAM-CONVENTION ::= 'p'                   // pack guaranteed
   PARAM-CONVENTION ::= 'm'                   // pack inout
 
+  #if SWIFT_RUNTIME_VERSION >= 6.0
+    SENDING-PARAM  ::= 'T'                   // sending parameter
+  #endif
+
+  #if SWIFT_RUNTIME_VERSION >= 6.2
+    ISOLATED-PARAM ::= 'I'                   // @isolated parameter
+    IMPLICIT-LEADING-PARAM ::= 'L'           // @implicit_leading parameter
+  #endif
+
   PARAM-DIFFERENTIABILITY ::= 'w'            // @noDerivative
 
   RESULT-CONVENTION ::= 'r'                  // indirect
diff --git a/include/swift/Demangling/Demangle.h b/include/swift/Demangling/Demangle.h
@@ -649,7 +649,7 @@ struct [[nodiscard]] ManglingError {
     InvalidImplCoroutineKind,
     InvalidImplFunctionAttribute,
     InvalidImplParameterConvention,
-    InvalidImplParameterSending,
+    InvalidImplParameterAttr,
     InvalidMetatypeRepresentation,
     MultiByteRelatedEntity,
     BadValueWitnessKind,
diff --git a/include/swift/Demangling/DemangleNodes.def b/include/swift/Demangling/DemangleNodes.def
@@ -138,6 +138,8 @@ NODE(ImplErasedIsolation)
 NODE(ImplSendingResult)
 NODE(ImplParameterResultDifferentiability)
 NODE(ImplParameterSending)
+NODE(ImplParameterIsolated)
+NODE(ImplParameterImplicitLeading)
 NODE(ImplFunctionAttribute)
 NODE(ImplFunctionConvention)
 NODE(ImplFunctionConventionName)
diff --git a/include/swift/Demangling/Demangler.h b/include/swift/Demangling/Demangler.h
@@ -570,6 +570,8 @@ class Demangler : public NodeFactory {
   NodePointer demangleImplParamConvention(Node::Kind ConvKind);
   NodePointer demangleImplResultConvention(Node::Kind ConvKind);
   NodePointer demangleImplParameterSending();
+  NodePointer demangleImplParameterIsolated();
+  NodePointer demangleImplParameterImplicitLeading();
   NodePointer demangleImplParameterResultDifferentiability();
   NodePointer demangleImplFunctionType();
   NodePointer demangleClangType();
diff --git a/include/swift/Demangling/TypeDecoder.h b/include/swift/Demangling/TypeDecoder.h
@@ -118,6 +118,8 @@ enum class ImplParameterConvention {
 enum class ImplParameterInfoFlags : uint8_t {
   NotDifferentiable = 0x1,
   Sending = 0x2,
+  Isolated = 0x4,
+  ImplicitLeading = 0x8
 };
 
 using ImplParameterInfoOptions = OptionSet<ImplParameterInfoFlags>;
@@ -192,6 +194,22 @@ class ImplFunctionParam {
     return result;
   }
 
+  static OptionsType getIsolated() {
+    OptionsType result;
+
+    result |= ImplParameterInfoFlags::Isolated;
+
+    return result;
+  }
+
+  static OptionsType getImplicitLeading() {
+    OptionsType result;
+
+    result |= ImplParameterInfoFlags::ImplicitLeading;
+
+    return result;
+  }
+
   ImplFunctionParam(BuiltType type, ImplParameterConvention convention,
                     OptionsType options)
       : Type(type), Convention(convention), Options(options) {}
@@ -1143,11 +1161,11 @@ class TypeDecoder {
             return MAKE_NODE_TYPE_ERROR0(child,
                                          "failed to decode function yields");
         } else if (child->getKind() == NodeKind::ImplResult) {
-          if (decodeImplFunctionParam(child, depth + 1, results))
+          if (decodeImplFunctionResult(child, depth + 1, results))
             return MAKE_NODE_TYPE_ERROR0(child,
                                          "failed to decode function results");
         } else if (child->getKind() == NodeKind::ImplErrorResult) {
-          if (decodeImplFunctionPart(child, depth + 1, errorResults))
+          if (decodeImplFunctionResult(child, depth + 1, errorResults))
             return MAKE_NODE_TYPE_ERROR0(child,
                                          "failed to decode function part");
         } else {
@@ -1638,40 +1656,70 @@ class TypeDecoder {
   }
 
   template <typename T>
-  bool decodeImplFunctionPart(Demangle::NodePointer node, unsigned depth,
-                              llvm::SmallVectorImpl<T> &results) {
+  bool decodeImplFunctionParam(Demangle::NodePointer node, unsigned depth,
+                               llvm::SmallVectorImpl<T> &results) {
     if (depth > TypeDecoder::MaxDepth)
       return true;
 
-    if (node->getNumChildren() != 2)
+    // Children: `convention, attrs, type`
+    // attrs: `differentiability?, sending?, isolated?, implicit_leading?`
+    if (node->getNumChildren() < 2)
       return true;
-    
-    if (node->getChild(0)->getKind() != Node::Kind::ImplConvention ||
-        node->getChild(1)->getKind() != Node::Kind::Type)
+
+    auto *conventionNode = node->getChild(0);
+    auto *typeNode = node->getLastChild();
+    if (conventionNode->getKind() != Node::Kind::ImplConvention ||
+        typeNode->getKind() != Node::Kind::Type)
       return true;
 
-    StringRef conventionString = node->getChild(0)->getText();
-    std::optional<typename T::ConventionType> convention =
-        T::getConventionFromString(conventionString);
+    StringRef conventionString = conventionNode->getText();
+    auto convention = T::getConventionFromString(conventionString);
     if (!convention)
       return true;
-    auto type = decodeMangledType(node->getChild(1), depth + 1);
-    if (type.isError())
+    auto result = decodeMangledType(typeNode, depth + 1);
+    if (result.isError())
       return true;
 
-    results.emplace_back(type.getType(), *convention);
+    typename T::OptionsType options;
+    for (unsigned i = 1; i < node->getNumChildren() - 1; ++i) {
+      auto child = node->getChild(i);
+      switch (child->getKind()) {
+      case Node::Kind::ImplParameterResultDifferentiability: {
+        auto optDiffOptions =
+            T::getDifferentiabilityFromString(child->getText());
+        if (!optDiffOptions)
+          return true;
+        options |= *optDiffOptions;
+        break;
+      }
+      case Node::Kind::ImplParameterSending:
+        options |= T::getSending();
+        break;
+      case Node::Kind::ImplParameterIsolated:
+        options |= T::getIsolated();
+        break;
+      case Node::Kind::ImplParameterImplicitLeading:
+        options |= T::getImplicitLeading();
+        break;
+      default:
+        return true;
+      }
+    }
+
+    results.emplace_back(result.getType(), *convention, options);
+
     return false;
   }
 
   template <typename T>
-  bool decodeImplFunctionParam(Demangle::NodePointer node, unsigned depth,
-                               llvm::SmallVectorImpl<T> &results) {
+  bool decodeImplFunctionResult(Demangle::NodePointer node, unsigned depth,
+                                llvm::SmallVectorImpl<T> &results) {
     if (depth > TypeDecoder::MaxDepth)
       return true;
 
-    // Children: `convention, differentiability?, sending?, type`
-    if (node->getNumChildren() != 2 && node->getNumChildren() != 3 &&
-        node->getNumChildren() != 4)
+    // Children: `convention, attrs, type`
+    // attrs: `differentiability?, sending?, isolated?, implicit_leading?`
+    if (node->getNumChildren() < 2)
       return true;
 
     auto *conventionNode = node->getChild(0);
@@ -1689,23 +1737,23 @@ class TypeDecoder {
       return true;
 
     typename T::OptionsType options;
-    if (node->getNumChildren() == 3 || node->getNumChildren() == 4) {
-      auto diffKindNode = node->getChild(1);
-      if (diffKindNode->getKind() !=
-          Node::Kind::ImplParameterResultDifferentiability)
-        return true;
-      auto optDiffOptions =
-          T::getDifferentiabilityFromString(diffKindNode->getText());
-      if (!optDiffOptions)
-        return true;
-      options |= *optDiffOptions;
-    }
-
-    if (node->getNumChildren() == 4) {
-      auto sendingKindNode = node->getChild(2);
-      if (sendingKindNode->getKind() != Node::Kind::ImplParameterSending)
+    for (unsigned i = 1; i < node->getNumChildren() - 1; ++i) {
+      auto child = node->getChild(i);
+      switch (child->getKind()) {
+      case Node::Kind::ImplParameterResultDifferentiability: {
+        auto optDiffOptions =
+            T::getDifferentiabilityFromString(child->getText());
+        if (!optDiffOptions)
+          return true;
+        options |= *optDiffOptions;
+        break;
+      }
+      case Node::Kind::ImplParameterSending:
+        options |= T::getSending();
+        break;
+      default:
         return true;
-      options |= T::getSending();
+      }
     }
 
     results.emplace_back(result.getType(), *convention, options);
diff --git a/lib/AST/ASTDemangler.cpp b/lib/AST/ASTDemangler.cpp
@@ -528,6 +528,16 @@ getParameterOptions(ImplParameterInfoOptions implOptions) {
     result |= SILParameterInfo::Sending;
   }
 
+  if (implOptions.contains(ImplParameterInfoFlags::Isolated)) {
+    implOptions -= ImplParameterInfoFlags::Isolated;
+    result |= SILParameterInfo::Isolated;
+  }
+
+  if (implOptions.contains(ImplParameterInfoFlags::ImplicitLeading)) {
+    implOptions -= ImplParameterInfoFlags::ImplicitLeading;
+    result |= SILParameterInfo::ImplicitLeading;
+  }
+
   // If we did not handle all flags in implOptions, this code was not updated
   // appropriately. Return None to signal error.
   if (bool(implOptions))
diff --git a/lib/AST/ASTMangler.cpp b/lib/AST/ASTMangler.cpp
@@ -2412,6 +2412,10 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn,
     OpArgs.push_back(getParamConvention(param.getConvention()));
     if (param.hasOption(SILParameterInfo::Sending))
       OpArgs.push_back('T');
+    if (param.hasOption(SILParameterInfo::Isolated))
+      OpArgs.push_back('I');
+    if (param.hasOption(SILParameterInfo::ImplicitLeading))
+      OpArgs.push_back('L');
     if (auto diffKind = getParamDifferentiability(param.getOptions()))
       OpArgs.push_back(*diffKind);
     appendType(param.getInterfaceType(), sig, forDecl);
diff --git a/lib/Demangling/Demangler.cpp b/lib/Demangling/Demangler.cpp
@@ -2301,6 +2301,22 @@ NodePointer Demangler::demangleImplParameterSending() {
   return createNode(Node::Kind::ImplParameterSending, attr);
 }
 
+NodePointer Demangler::demangleImplParameterIsolated() {
+  // Empty string represents default differentiability.
+  if (!nextIf('I'))
+    return nullptr;
+  const char *attr = "isolated";
+  return createNode(Node::Kind::ImplParameterIsolated, attr);
+}
+
+NodePointer Demangler::demangleImplParameterImplicitLeading() {
+  // Empty string represents default differentiability.
+  if (!nextIf('L'))
+    return nullptr;
+  const char *attr = "sil_implicit_leading_param";
+  return createNode(Node::Kind::ImplParameterImplicitLeading, attr);
+}
+
 NodePointer Demangler::demangleImplParameterResultDifferentiability() {
   // Empty string represents default differentiability.
   const char *attr = "";
@@ -2452,6 +2468,10 @@ NodePointer Demangler::demangleImplFunctionType() {
       Param = addChild(Param, Diff);
     if (auto Sending = demangleImplParameterSending())
       Param = addChild(Param, Sending);
+    if (auto Sending = demangleImplParameterIsolated())
+      Param = addChild(Param, Sending);
+    if (auto Sending = demangleImplParameterImplicitLeading())
+      Param = addChild(Param, Sending);
     ++NumTypesToAdd;
   }
 
diff --git a/lib/Demangling/NodePrinter.cpp b/lib/Demangling/NodePrinter.cpp
@@ -390,6 +390,8 @@ bool NodePrinter::isSimpleType(NodePointer Node) {
   case Node::Kind::ImplConvention:
   case Node::Kind::ImplParameterResultDifferentiability:
   case Node::Kind::ImplParameterSending:
+  case Node::Kind::ImplParameterIsolated:
+  case Node::Kind::ImplParameterImplicitLeading:
   case Node::Kind::ImplFunctionAttribute:
   case Node::Kind::ImplFunctionConvention:
   case Node::Kind::ImplFunctionConventionName:
@@ -2803,6 +2805,8 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
     Printer << Node->getText() << ' ';
     return nullptr;
   case Node::Kind::ImplParameterSending:
+  case Node::Kind::ImplParameterIsolated:
+  case Node::Kind::ImplParameterImplicitLeading:
     // Skip if text is empty.
     if (Node->getText().empty())
       return nullptr;
diff --git a/lib/Demangling/OldRemangler.cpp b/lib/Demangling/OldRemangler.cpp
@@ -1868,7 +1868,17 @@ ManglingError Remangler::mangleImplParameterSending(Node *node,
     Buffer << 'T';
     return ManglingError::Success;
   }
-  return MANGLING_ERROR(ManglingError::InvalidImplParameterSending, node);
+  return MANGLING_ERROR(ManglingError::InvalidImplParameterAttr, node);
+}
+
+ManglingError Remangler::mangleImplParameterIsolated(Node *node,
+                                                    unsigned depth) {
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleImplParameterImplicitLeading(Node *node,
+                                                            unsigned depth) {
+  return ManglingError::Success;
 }
 
 ManglingError Remangler::mangleDynamicSelf(Node *node, unsigned depth) {
diff --git a/lib/Demangling/Remangler.cpp b/lib/Demangling/Remangler.cpp
diff --git a/test/Concurrency/attr_execution/conversions_silgen.swift b/test/Concurrency/attr_execution/conversions_silgen.swift
diff --git a/test/DebugInfo/nonisolated_nonsending.swift b/test/DebugInfo/nonisolated_nonsending.swift
diff --git a/test/SILGen/objc_async_from_swift.swift b/test/SILGen/objc_async_from_swift.swift
