[Mangler] Handle mangling for Clang types not derivable from Swift types.

Author: varungandhi-apple

docs/ABI/Mangling.rst

@@ -523,15 +523,20 @@ Types
   FUNCTION-KIND ::= 'U'                      // uncurried function type (currently not used)
   FUNCTION-KIND ::= 'K'                      // @auto_closure function type (noescape)
   FUNCTION-KIND ::= 'B'                      // objc block function type
-  FUNCTION-KIND ::= 'L'                      // objc block function type (escaping) (DWARF only; otherwise use 'B')
+  FUNCTION-KIND ::= 'zB' C-TYPE              // objc block type with non-canonical C type
+  FUNCTION-KIND ::= 'L'                      // objc block function type with canonical C type (escaping) (DWARF only; otherwise use 'B' or 'zB' C-TYPE)
   FUNCTION-KIND ::= 'C'                      // C function pointer type
+  FUNCTION-KIND ::= 'zC' C-TYPE              // C function pointer type with with non-canonical C type
   FUNCTION-KIND ::= 'A'                      // @auto_closure function type (escaping)
   FUNCTION-KIND ::= 'E'                      // function type (noescape)
   FUNCTION-KIND ::= 'F'                      // @differentiable function type
   FUNCTION-KIND ::= 'G'                      // @differentiable function type (escaping)
   FUNCTION-KIND ::= 'H'                      // @differentiable(linear) function type
   FUNCTION-KIND ::= 'I'                      // @differentiable(linear) function type (escaping)
 
+  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? throws? // results and parameters
 
   params-type ::= type 'z'? 'h'?              // tuple in case of multiple parameters or a single parameter with a single tuple type
@@ -618,7 +623,9 @@ mangled in to disambiguate.
   CALLEE-CONVENTION ::= 't'                  // thin
 
   FUNC-REPRESENTATION ::= 'B'                // C block invocation function
+  FUNC-REPRESENTATION ::= 'zB' C-TYPE        // C block invocation function with non-canonical C type
   FUNC-REPRESENTATION ::= 'C'                // C global function
+  FUNC-REPRESENTATION ::= 'zC' C-TYPE        // C global function with non-canonical C type
   FUNC-REPRESENTATION ::= 'M'                // Swift method
   FUNC-REPRESENTATION ::= 'J'                // ObjC method
   FUNC-REPRESENTATION ::= 'K'                // closure

include/swift/AST/ASTMangler.h

@@ -318,6 +318,9 @@ class ASTMangler : public Mangler {
                       const ValueDecl *forDecl = nullptr);
   void appendFunctionType(AnyFunctionType *fn, bool isAutoClosure = false,
                           const ValueDecl *forDecl = nullptr);
+  void appendClangType(AnyFunctionType *fn);
+  template <typename FnType>
+  void appendClangType(FnType *fn, llvm::raw_svector_ostream &os);
 
   void appendFunctionSignature(AnyFunctionType *fn,
                                const ValueDecl *forDecl = nullptr);

include/swift/Demangling/DemangleNodes.def

@@ -44,6 +44,7 @@ NODE(BoundGenericTypeAlias)
 NODE(BoundGenericFunction)
 NODE(BuiltinTypeName)
 NODE(CFunctionPointer)
+NODE(ClangType)
 CONTEXT_NODE(Class)
 NODE(ClassMetadataBaseOffset)
 NODE(ConcreteProtocolConformance)
@@ -119,6 +120,8 @@ NODE(ImplEscaping)
 NODE(ImplConvention)
 NODE(ImplDifferentiability)
 NODE(ImplFunctionAttribute)
+NODE(ImplFunctionConvention)
+NODE(ImplFunctionConventionName)
 NODE(ImplFunctionType)
 NODE(ImplInvocationSubstitutions)
 CONTEXT_NODE(ImplicitClosure)

include/swift/Demangling/Demangler.h

@@ -505,7 +505,7 @@ class Demangler : public NodeFactory {
   NodePointer demangleAnyGenericType(Node::Kind kind);
   NodePointer demangleExtensionContext();
   NodePointer demanglePlainFunction();
-  NodePointer popFunctionType(Node::Kind kind);
+  NodePointer popFunctionType(Node::Kind kind, bool hasClangType = false);
   NodePointer popFunctionParams(Node::Kind kind);
   NodePointer popFunctionParamLabels(NodePointer FuncType);
   NodePointer popTuple();
@@ -522,6 +522,7 @@ class Demangler : public NodeFactory {
   NodePointer demangleImplResultConvention(Node::Kind ConvKind);
   NodePointer demangleImplDifferentiability();
   NodePointer demangleImplFunctionType();
+  NodePointer demangleClangType();
   NodePointer demangleMetatype();
   NodePointer demanglePrivateContextDescriptor();
   NodePointer createArchetypeRef(int depth, int i);

include/swift/Demangling/TypeDecoder.h

@@ -631,6 +631,12 @@ class TypeDecoder {
       }
 
       unsigned firstChildIdx = 0;
+      if (Node->getChild(firstChildIdx)->getKind() == NodeKind::ClangType) {
+        // [TODO: synthesize-Clang-type-from-mangled-name] Use the first child
+        // to create a ClangTypeInfo.
+        ++firstChildIdx;
+      }
+
       bool isThrow = false;
       if (Node->getChild(firstChildIdx)->getKind()
             == NodeKind::ThrowsAnnotation) {
@@ -695,18 +701,28 @@ class TypeDecoder {
           } else if (child->getText() == "@callee_guaranteed") {
             calleeConvention = ImplParameterConvention::Direct_Guaranteed;
           }
-        } else if (child->getKind() == NodeKind::ImplFunctionAttribute) {
-          if (!child->hasText())
-            return MAKE_NODE_TYPE_ERROR0(child, "expected text");
-
-          StringRef text = child->getText();
-          if (text == "@convention(c)") {
+        } else if (child->getKind() == NodeKind::ImplFunctionConvention) {
+          if (child->getNumChildren() == 0)
+            return MAKE_NODE_TYPE_ERROR0(child, "expected grandchildren");
+          if ((child->getFirstChild()->getKind() !=
+               NodeKind::ImplFunctionConventionName) ||
+              !child->getFirstChild()->hasText())
+            return MAKE_NODE_TYPE_ERROR0(child, "expected convention name");
+
+          // [TODO: synthesize-Clang-type-from-mangled-name] If there are two
+          // grand-children, the second is going to be the mangled Clang type.
+          StringRef text = child->getFirstChild()->getText();
+          if (text == "c") {
             flags =
               flags.withRepresentation(ImplFunctionRepresentation::CFunctionPointer);
-          } else if (text == "@convention(block)") {
+          } else if (text == "block") {
             flags =
               flags.withRepresentation(ImplFunctionRepresentation::Block);
-          } else if (text == "@async") {
+          }
+        } else if (child->getKind() == NodeKind::ImplFunctionAttribute) {
+          if (!child->hasText())
+            return MAKE_NODE_TYPE_ERROR0(child, "expected text");
+          if (child->getText() == "@async") {
             flags = flags.withAsync();
           }
         } else if (child->getKind() == NodeKind::ImplDifferentiable) {

lib/AST/ASTMangler.cpp

@@ -30,24 +30,27 @@
 #include "swift/AST/ProtocolConformanceRef.h"
 #include "swift/AST/SILLayout.h"
 #include "swift/Basic/Defer.h"
+#include "swift/ClangImporter/ClangImporter.h"
+#include "swift/Demangling/Demangler.h"
 #include "swift/Demangling/ManglingMacros.h"
 #include "swift/Demangling/ManglingUtils.h"
-#include "swift/Demangling/Demangler.h"
 #include "swift/Strings.h"
 #include "clang/AST/ASTContext.h"
-#include "clang/Basic/CharInfo.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Mangle.h"
+#include "clang/Basic/CharInfo.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Support/CommandLine.h"
+
+#include <memory>
 
 using namespace swift;
 using namespace swift::Mangle;
@@ -1653,15 +1656,35 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn) {
     OpArgs.push_back('t');
   }
 
+  bool mangleClangType = fn->getASTContext().LangOpts.UseClangFunctionTypes &&
+                         fn->hasNonDerivableClangType();
+
+  auto appendClangTypeToVec = [this, fn](auto &Vec) {
+    llvm::raw_svector_ostream OpArgsOS(Vec);
+    appendClangType(fn, OpArgsOS);
+  };
+
   switch (fn->getRepresentation()) {
     case SILFunctionTypeRepresentation::Thick:
     case SILFunctionTypeRepresentation::Thin:
       break;
     case SILFunctionTypeRepresentation::Block:
+      if (!mangleClangType) {
+        OpArgs.push_back('B');
+        break;
+      }
+      OpArgs.push_back('z');
       OpArgs.push_back('B');
+      appendClangTypeToVec(OpArgs);
       break;
     case SILFunctionTypeRepresentation::CFunctionPointer:
+      if (!mangleClangType) {
+        OpArgs.push_back('C');
+        break;
+      }
+      OpArgs.push_back('z');
       OpArgs.push_back('C');
+      appendClangTypeToVec(OpArgs);
       break;
     case SILFunctionTypeRepresentation::ObjCMethod:
       OpArgs.push_back('O');
@@ -2244,6 +2267,9 @@ void ASTMangler::appendFunctionType(AnyFunctionType *fn, bool isAutoClosure,
 
   appendFunctionSignature(fn, forDecl);
 
+  bool mangleClangType = fn->getASTContext().LangOpts.UseClangFunctionTypes &&
+                         fn->hasNonDerivableClangType();
+
   // Note that we do not currently use thin representations in the AST
   // for the types of function decls.  This may need to change at some
   // point, in which case the uncurry logic can probably migrate to that
@@ -2256,6 +2282,10 @@ void ASTMangler::appendFunctionType(AnyFunctionType *fn, bool isAutoClosure,
   // changes to better support thin functions.
   switch (fn->getRepresentation()) {
   case AnyFunctionType::Representation::Block:
+    if (mangleClangType) {
+      appendOperator("XzB");
+      return appendClangType(fn);
+    }
     // We distinguish escaping and non-escaping blocks, but only in the DWARF
     // mangling, because the ABI is already set.
     if (!fn->isNoEscape() && DWARFMangling)
@@ -2287,10 +2317,31 @@ void ASTMangler::appendFunctionType(AnyFunctionType *fn, bool isAutoClosure,
     return appendOperator("c");
 
   case AnyFunctionType::Representation::CFunctionPointer:
+    if (mangleClangType) {
+      appendOperator("XzC");
+      return appendClangType(fn);
+    }
     return appendOperator("XC");
   }
 }
 
+template <typename FnType>
+void ASTMangler::appendClangType(FnType *fn, llvm::raw_svector_ostream &out) {
+  auto clangType = fn->getClangTypeInfo().getType();
+  SmallString<64> scratch;
+  llvm::raw_svector_ostream scratchOS(scratch);
+  clang::ASTContext &clangCtx =
+      fn->getASTContext().getClangModuleLoader()->getClangASTContext();
+  std::unique_ptr<clang::ItaniumMangleContext> mangler{
+      clang::ItaniumMangleContext::create(clangCtx, clangCtx.getDiagnostics())};
+  mangler->mangleTypeName(clang::QualType(clangType, 0), scratchOS);
+  out << scratchOS.str().size() << scratchOS.str();
+}
+
+void ASTMangler::appendClangType(AnyFunctionType *fn) {
+  appendClangType(fn, Buffer);
+}
+
 void ASTMangler::appendFunctionSignature(AnyFunctionType *fn,
                                          const ValueDecl *forDecl) {
   appendFunctionResultType(fn->getResult(), forDecl);

lib/Demangling/Demangler.cpp

@@ -1228,8 +1228,13 @@ NodePointer Demangler::demanglePlainFunction() {
   return createWithChildren(Node::Kind::Function, Ctx, Name, Type);
 }
 
-NodePointer Demangler::popFunctionType(Node::Kind kind) {
+NodePointer Demangler::popFunctionType(Node::Kind kind, bool hasClangType) {
   NodePointer FuncType = createNode(kind);
+  NodePointer ClangType = nullptr;
+  if (hasClangType) {
+    ClangType = demangleClangType();
+  }
+  addChild(FuncType, ClangType);
   addChild(FuncType, popNode(Node::Kind::ThrowsAnnotation));
   addChild(FuncType, popNode(Node::Kind::AsyncAnnotation));
 
@@ -1748,6 +1753,16 @@ NodePointer Demangler::demangleImplDifferentiability() {
   return createNode(Node::Kind::ImplDifferentiability, attr);
 }
 
+NodePointer Demangler::demangleClangType() {
+  int numChars = demangleNatural();
+  if (numChars <= 0 || Pos + numChars > Text.size())
+    return nullptr;
+  CharVector mangledClangType;
+  mangledClangType.append(StringRef(Text.data() + Pos, numChars), *this);
+  Pos = Pos + numChars;
+  return createNode(Node::Kind::ClangType, mangledClangType);
+}
+
 NodePointer Demangler::demangleImplFunctionType() {
   NodePointer type = createNode(Node::Kind::ImplFunctionType);
 
@@ -1806,20 +1821,33 @@ NodePointer Demangler::demangleImplFunctionType() {
   }
   type->addChild(createNode(Node::Kind::ImplConvention, CAttr), *this);
 
-  const char *FAttr = nullptr;
+  const char *FConv = nullptr;
+  bool hasClangType = false;
   switch (nextChar()) {
-    case 'B': FAttr = "@convention(block)"; break;
-    case 'C': FAttr = "@convention(c)"; break;
-    case 'M': FAttr = "@convention(method)"; break;
-    case 'O': FAttr = "@convention(objc_method)"; break;
-    case 'K': FAttr = "@convention(closure)"; break;
-    case 'W': FAttr = "@convention(witness_method)"; break;
-    default:
-      pushBack();
-      break;
+  case 'B': FConv = "block"; break;
+  case 'C': FConv = "c"; break;
+  case 'z': {
+    switch (nextChar()) {
+    case 'B': hasClangType = true; FConv = "block"; break;
+    case 'C': hasClangType = true; FConv = "c"; break;
+    default: pushBack(); pushBack(); break;
+    }
+    break;
+  }
+  case 'M': FConv = "method"; break;
+  case 'O': FConv = "objc_method"; break;
+  case 'K': FConv = "closure"; break;
+  case 'W': FConv = "witness_method"; break;
+  default: pushBack(); break;
+  }
+  if (FConv) {
+    auto FAttrNode = createNode(Node::Kind::ImplFunctionConvention);
+    FAttrNode->addChild(
+        createNode(Node::Kind::ImplFunctionConventionName, FConv), *this);
+    if (hasClangType)
+      FAttrNode->addChild(demangleClangType(), *this);
+    type->addChild(FAttrNode, *this);
   }
-  if (FAttr)
-    type->addChild(createNode(Node::Kind::ImplFunctionAttribute, FAttr), *this);
 
   const char *CoroAttr = nullptr;
   if (nextIf('A'))
@@ -2863,6 +2891,15 @@ NodePointer Demangler::demangleSpecialType() {
       return popFunctionType(Node::Kind::ObjCBlock);
     case 'C':
       return popFunctionType(Node::Kind::CFunctionPointer);
+    case 'z':
+      switch (auto cchar = nextChar()) {
+      case 'B':
+        return popFunctionType(Node::Kind::ObjCBlock, true);
+      case 'C':
+        return popFunctionType(Node::Kind::CFunctionPointer, true);
+      default:
+        return nullptr;
+      }
     case 'F':
       return popFunctionType(Node::Kind::DifferentiableFunctionType);
     case 'G':