Mangling: add a new mangling for generic specialization

For performance annotations we need the generic specializer to trop non-generic metatype argumentrs
(which we don't do in general). For this we need a separate mangling.

Author: eeckstein

docs/ABI/Mangling.rst

@@ -1133,7 +1133,7 @@ Some kinds need arguments, which precede ``Tf``.
   spec-arg ::= identifier
   spec-arg ::= type
 
-  SPEC-INFO ::= FRAGILE? PASSID
+  SPEC-INFO ::= MT-REMOVED? FRAGILE? PASSID
 
   PASSID ::= '0'                             // AllocBoxToStack,
   PASSID ::= '1'                             // ClosureSpecializer,
@@ -1142,6 +1142,8 @@ Some kinds need arguments, which precede ``Tf``.
   PASSID ::= '4'                             // FunctionSignatureOpts,
   PASSID ::= '5'                             // GenericSpecializer,
 
+  MT-REMOVED ::= 'm'                         // non-generic metatype arguments are removed in the specialized function
+
   FRAGILE ::= 'q'
 
   ARG-SPEC-KIND ::= 'n'                      // Unmodified argument

include/swift/Demangling/DemangleNodes.def

@@ -344,5 +344,7 @@ NODE(UniqueExtendedExistentialTypeShapeSymbolicReference)
 NODE(NonUniqueExtendedExistentialTypeShapeSymbolicReference)
 NODE(SymbolicExtendedExistentialType)
 
+NODE(MetatypeParamsRemoved)
+
 #undef CONTEXT_NODE
 #undef NODE

include/swift/SIL/GenericSpecializationMangler.h

@@ -90,7 +90,19 @@ class GenericSpecializationMangler : public SpecializationMangler {
 
   std::string mangleNotReabstracted(SubstitutionMap subs);
 
-  std::string mangleReabstracted(SubstitutionMap subs, bool alternativeMangling);
+  /// Mangle a generic specialization with re-abstracted parameters.
+  ///
+  /// Re-abstracted means that indirect (generic) parameters/returns are
+  /// converted to direct parameters/returns.
+  ///
+  /// This is the default for generic specializations.
+  ///
+  /// \param alternativeMangling   true for specialized functions with a
+  ///                              differet resilience expansion.
+  /// \param metatyeParamsRemoved  true if non-generic metatype parameters are
+  ///                              removed in the specialized function.
+  std::string mangleReabstracted(SubstitutionMap subs, bool alternativeMangling,
+                                 bool metatyeParamsRemoved = false);
 
   std::string mangleForDebugInfo(GenericSignature sig, SubstitutionMap subs,
                                  bool forInlining);

lib/Demangling/Demangler.cpp

@@ -3040,13 +3040,18 @@ NodePointer Demangler::addFuncSpecParamNumber(NodePointer Param,
 }
 
 NodePointer Demangler::demangleSpecAttributes(Node::Kind SpecKind) {
+  bool metatypeParamsRemoved = nextIf('m');
   bool isSerialized = nextIf('q');
 
   int PassID = (int)nextChar() - '0';
   if (PassID < 0 || PassID > 9)
     return nullptr;
 
   NodePointer SpecNd = createNode(SpecKind);
+
+  if (metatypeParamsRemoved)
+    SpecNd->addChild(createNode(Node::Kind::MetatypeParamsRemoved), *this);
+
   if (isSerialized)
     SpecNd->addChild(createNode(Node::Kind::IsSerialized),
                      *this);

lib/Demangling/NodePrinter.cpp

@@ -496,6 +496,7 @@ class NodePrinter {
     case Node::Kind::SILBoxMutableField:
     case Node::Kind::SILBoxImmutableField:
     case Node::Kind::IsSerialized:
+    case Node::Kind::MetatypeParamsRemoved:
     case Node::Kind::SpecializationPassID:
     case Node::Kind::Static:
     case Node::Kind::Subscript:
@@ -1127,7 +1128,8 @@ void NodePrinter::printSpecializationPrefix(NodePointer node,
   for (NodePointer child : *node) {
     switch (child->getKind()) {
       case Node::Kind::SpecializationPassID:
-        // We skip the SpecializationPassID since it does not contain any
+      case Node::Kind::MetatypeParamsRemoved:
+        // We skip those nodes since it does not contain any
         // information that is useful to our users.
         break;
 
@@ -1549,6 +1551,9 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
   case Node::Kind::IsSerialized:
     Printer << "serialized";
     return nullptr;
+  case Node::Kind::MetatypeParamsRemoved:
+    Printer << "metatypes-removed";
+    return nullptr;
   case Node::Kind::GenericSpecializationParam:
     print(Node->getChild(0), depth + 1);
     for (unsigned i = 1, e = Node->getNumChildren(); i < e; ++i) {

lib/Demangling/OldRemangler.cpp

@@ -446,6 +446,11 @@ ManglingError Remangler::mangleIsSerialized(Node *node, unsigned depth) {
   return ManglingError::Success;
 }
 
+ManglingError Remangler::mangleMetatypeParamsRemoved(Node *node, unsigned depth) {
+  Buffer << "m";
+  return ManglingError::Success;
+}
+
 ManglingError
 Remangler::mangleFunctionSignatureSpecializationReturn(Node *node,
                                                        unsigned depth) {

lib/Demangling/Remangler.cpp

@@ -2801,6 +2801,11 @@ ManglingError Remangler::mangleIsSerialized(Node *node, unsigned depth) {
   return ManglingError::Success;
 }
 
+ManglingError Remangler::mangleMetatypeParamsRemoved(Node *node, unsigned depth) {
+  Buffer << 'm';
+  return ManglingError::Success;
+}
+
 ManglingError Remangler::mangleStatic(Node *node, unsigned depth) {
   RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << 'Z';

lib/SIL/Utils/GenericSpecializationMangler.cpp

@@ -105,13 +105,18 @@ mangleNotReabstracted(SubstitutionMap subs) {
 }
 
 std::string GenericSpecializationMangler::
-mangleReabstracted(SubstitutionMap subs, bool alternativeMangling) {
+mangleReabstracted(SubstitutionMap subs, bool alternativeMangling,
+                   bool metatyeParamsRemoved) {
   beginMangling();
   appendSubstitutions(getGenericSignature(), subs);
 
   // See ReabstractionInfo::hasConvertedResilientParams for why and when to use
   // the alternative mangling.
-  appendSpecializationOperator(alternativeMangling ? "TB" : "Tg");
+  if (metatyeParamsRemoved) {
+    appendSpecializationOperator(alternativeMangling ? "TBm" : "Tgm");
+  } else {
+    appendSpecializationOperator(alternativeMangling ? "TB" : "Tg");
+  }
   return finalize();
 }
 

test/Demangle/Inputs/manglings.txt

@@ -359,6 +359,7 @@ $S18resilient_protocol21ResilientBaseProtocolTL ---> protocol requirements base
 $S1t1PP10AssocType2_AA1QTn ---> associated conformance descriptor for t.P.AssocType2: t.Q
 $S1t1PP10AssocType2_AA1QTN ---> default associated conformance accessor for t.P.AssocType2: t.Q
 $s4Test6testityyxlFAA8MystructV_TB5 ---> generic specialization <Test.Mystruct> of Test.testit<A>(A) -> ()
+$sSUss17FixedWidthIntegerRzrlEyxqd__cSzRd__lufCSu_SiTgm5 ---> generic specialization <Swift.UInt, Swift.Int> of (extension in Swift):Swift.UnsignedInteger< where A: Swift.FixedWidthInteger>.init<A where A1: Swift.BinaryInteger>(A1) -> A
 $sSD5IndexVy__GD ---> $sSD5IndexVy__GD
 $s4test3StrCACycfC ---> {T:$s4test3StrCACycfc} test.Str.__allocating_init() -> test.Str
 $s18keypaths_inlinable13KeypathStructV8computedSSvpACTKq  ---> key path getter for keypaths_inlinable.KeypathStruct.computed : Swift.String : keypaths_inlinable.KeypathStruct, serialized