Mangler: Support substituted SIL function types in thunk manglings

Author: jckarter

include/swift/AST/ASTMangler.h

@@ -245,6 +245,9 @@ class ASTMangler : public Mangler {
   unsigned appendBoundGenericArgs(DeclContext *dc,
                                   SubstitutionMap subs,
                                   bool &isFirstArgList);
+  
+  /// Append the bound generic arguments as a flat list, disregarding depth.
+  void appendFlatGenericArgs(SubstitutionMap subs);
 
   /// Append any retroactive conformances.
   void appendRetroactiveConformances(Type type);

include/swift/Demangling/DemangleNodes.def

@@ -113,6 +113,8 @@ NODE(ImplEscaping)
 NODE(ImplConvention)
 NODE(ImplFunctionAttribute)
 NODE(ImplFunctionType)
+NODE(ImplImpliedSubstitutions)
+NODE(ImplSubstitutions)
 CONTEXT_NODE(ImplicitClosure)
 NODE(ImplParameter)
 NODE(ImplResult)

lib/AST/ASTMangler.cpp

@@ -1201,6 +1201,16 @@ void ASTMangler::bindGenericParameters(const DeclContext *DC) {
     bindGenericParameters(sig->getCanonicalSignature());
 }
 
+void ASTMangler::appendFlatGenericArgs(SubstitutionMap subs) {
+  appendOperator("y");
+
+  for (auto replacement : subs.getReplacementTypes()) {
+    if (replacement->hasArchetype())
+      replacement = replacement->mapTypeOutOfContext();
+    appendType(replacement);
+  }
+}
+
 unsigned ASTMangler::appendBoundGenericArgs(DeclContext *dc,
                                             SubstitutionMap subs,
                                             bool &isFirstArgList) {
@@ -1429,6 +1439,13 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn) {
 
   llvm::SmallVector<char, 32> OpArgs;
 
+  if (fn->getSubstitutions()) {
+    OpArgs.push_back('s');
+    if (!fn->isGenericSignatureImplied()) {
+      OpArgs.push_back('i');
+    }
+  }
+  
   if (fn->isPolymorphic() && fn->isPseudogeneric())
     OpArgs.push_back('P');
 
@@ -1465,7 +1482,7 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn) {
       OpArgs.push_back('W');
       break;
   }
-
+  
   // Mangle the parameters.
   for (auto param : fn->getParameters()) {
     OpArgs.push_back(getParamConvention(param.getConvention()));
@@ -1485,8 +1502,13 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn) {
     OpArgs.push_back(getResultConvention(error.getConvention()));
     appendType(error.getInterfaceType());
   }
-  if (fn->isPolymorphic())
-    appendGenericSignature(fn->getSubstGenericSignature());
+  if (auto sig = fn->getSubstGenericSignature()) {
+    appendGenericSignature(sig);
+  }
+  if (auto subs = fn->getSubstitutions()) {
+    appendFlatGenericArgs(subs);
+    appendRetroactiveConformances(subs, Mod);
+  }
 
   OpArgs.push_back('_');
 

lib/Demangling/Demangler.cpp

@@ -1733,6 +1733,24 @@ NodePointer Demangler::demangleImplResultConvention(Node::Kind ConvKind) {
 NodePointer Demangler::demangleImplFunctionType() {
   NodePointer type = createNode(Node::Kind::ImplFunctionType);
 
+  if (nextIf('s')) {
+    Vector<NodePointer> Substitutions;
+    NodePointer SubstitutionRetroConformances;
+    if (!demangleBoundGenerics(Substitutions, SubstitutionRetroConformances))
+      return nullptr;
+    
+    bool isImplied = !nextIf('i');
+    
+    auto subsNode = createNode(isImplied
+                               ? Node::Kind::ImplImpliedSubstitutions
+                               : Node::Kind::ImplSubstitutions);
+    assert(Substitutions.size() == 1);
+    subsNode->addChild(Substitutions[0], *this);
+    if (SubstitutionRetroConformances)
+      subsNode->addChild(SubstitutionRetroConformances, *this);
+    type->addChild(subsNode, *this);
+  }
+  
   NodePointer GenSig = popNode(Node::Kind::DependentGenericSignature);
   if (GenSig && nextIf('P'))
     GenSig = changeKind(GenSig, Node::Kind::DependentPseudogenericSignature);
@@ -1794,6 +1812,7 @@ NodePointer Demangler::demangleImplFunctionType() {
       return nullptr;
     type->getChild(type->getNumChildren() - Idx - 1)->addChild(ConvTy, *this);
   }
+  
   return createType(type);
 }
 

lib/Demangling/NodePrinter.cpp

@@ -390,6 +390,8 @@ class NodePrinter {
     case Node::Kind::ImplConvention:
     case Node::Kind::ImplFunctionAttribute:
     case Node::Kind::ImplFunctionType:
+    case Node::Kind::ImplImpliedSubstitutions:
+    case Node::Kind::ImplSubstitutions:
     case Node::Kind::ImplicitClosure:
     case Node::Kind::ImplParameter:
     case Node::Kind::ImplResult:
@@ -979,7 +981,7 @@ static bool needSpaceBeforeType(NodePointer Type) {
 }
 
 NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
-  switch (Node->getKind()) {
+  switch (auto kind = Node->getKind()) {
   case Node::Kind::Static:
     Printer << "static ";
     print(Node->getChild(0));
@@ -2016,6 +2018,14 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
   case Node::Kind::ImplFunctionType:
     printImplFunctionType(Node);
     return nullptr;
+  case Node::Kind::ImplSubstitutions:
+  case Node::Kind::ImplImpliedSubstitutions:
+    Printer << "for <";
+    printChildren(Node->getChild(0), ", ");
+    Printer << '>';
+    if (kind == Node::Kind::ImplImpliedSubstitutions)
+      Printer << " in";
+    return nullptr;
   case Node::Kind::ErrorType:
     Printer << "<ERROR TYPE>";
     return nullptr;

lib/Demangling/OldRemangler.cpp

@@ -1252,6 +1252,14 @@ void Remangler::mangleImplEscaping(Node *node) {
   // The old mangler does not encode escaping.
 }
 
+void Remangler::mangleImplSubstitutions(Node *node) {
+  // The old mangler does not encode substituted function types.
+}
+
+void Remangler::mangleImplImpliedSubstitutions(Node *node) {
+  // The old mangler does not encode substituted function types.
+}
+
 void Remangler::mangleImplConvention(Node *node) {
   assert(node->getKind() == Node::Kind::ImplConvention);
   StringRef text = node->getText();

lib/Demangling/Remangler.cpp

@@ -1396,30 +1396,61 @@ void Remangler::mangleImplFunctionAttribute(Node *node) {
   unreachable("handled inline");
 }
 
+void Remangler::mangleImplSubstitutions(Node *node) {
+  unreachable("handled inline");
+}
+
+void Remangler::mangleImplImpliedSubstitutions(Node *node) {
+  unreachable("handled inline");
+}
+
 void Remangler::mangleImplFunctionType(Node *node) {
   const char *PseudoGeneric = "";
   Node *GenSig = nullptr;
+  Node *GenSubs = nullptr;
+  bool isImplied;
   for (NodePointer Child : *node) {
-    switch (Child->getKind()) {
-      case Node::Kind::ImplParameter:
-      case Node::Kind::ImplResult:
-      case Node::Kind::ImplErrorResult:
-        mangleChildNode(Child, 1);
-        break;
-      case Node::Kind::DependentPseudogenericSignature:
-        PseudoGeneric = "P";
-        LLVM_FALLTHROUGH;
-      case Node::Kind::DependentGenericSignature:
-        GenSig = Child;
-        break;
-      default:
-        break;
+    switch (auto kind = Child->getKind()) {
+    case Node::Kind::ImplParameter:
+    case Node::Kind::ImplResult:
+    case Node::Kind::ImplErrorResult:
+      mangleChildNode(Child, 1);
+      break;
+    case Node::Kind::DependentPseudogenericSignature:
+      PseudoGeneric = "P";
+      LLVM_FALLTHROUGH;
+    case Node::Kind::DependentGenericSignature:
+      GenSig = Child;
+      break;
+    case Node::Kind::ImplSubstitutions:
+    case Node::Kind::ImplImpliedSubstitutions:
+      GenSubs = Child;
+      isImplied = kind == Node::Kind::ImplImpliedSubstitutions;
+      break;
+    default:
+      break;
     }
   }
   if (GenSig)
     mangle(GenSig);
+  if (GenSubs) {
+    GenSubs->dump();
+
+    Buffer << 'y';
+    mangleChildNodes(GenSubs->getChild(0));
+    if (GenSubs->getNumChildren() >= 2)
+      mangleRetroactiveConformance(GenSubs->getChild(1));
+  }
+
+  Buffer << 'I';
+
+  if (GenSubs) {
+    Buffer << 's';
+    if (!isImplied)
+      Buffer << 'i';
+  }
 
-  Buffer << 'I' << PseudoGeneric;
+  Buffer << PseudoGeneric;
   for (NodePointer Child : *node) {
     switch (Child->getKind()) {
       case Node::Kind::ImplEscaping:

lib/SIL/SILType.cpp

@@ -421,7 +421,6 @@ ValueOwnershipKind
 SILResultInfo::getOwnershipKind(SILFunction &F) const {
   auto &M = F.getModule();
   auto FTy = F.getLoweredFunctionType();
-  auto sig = FTy->getInvocationGenericSignature();
 
   bool IsTrivial = getSILStorageType(M, FTy).isTrivial(F);
   switch (getConvention()) {