Demangler: fix demangling and remangling of associated type paths.

fixes SR-6138

Author: eeckstein

docs/ABI/Mangling.rst

@@ -74,7 +74,7 @@ Globals
   global ::= protocol-conformance 'WP'   // protocol witness table
 
   global ::= protocol-conformance identifier 'Wt' // associated type metadata accessor
-  global ::= protocol-conformance identifier nominal-type 'WT' // associated type witness table accessor
+  global ::= protocol-conformance assoc_type_path nominal-type 'WT' // associated type witness table accessor
   global ::= type protocol-conformance 'Wl' // lazy protocol witness table accessor
   global ::= type 'WV'                   // value witness table
   global ::= entity 'Wv' DIRECTNESS      // field offset
@@ -84,6 +84,8 @@ Globals
   global ::= type 'Wr' // Outlined Retain Function Type
   global ::= type 'Ws' // Outlined Release Function Type
 
+  assoc_type_path ::= identifier '_' identifier*
+
   DIRECTNESS ::= 'd'                         // direct
   DIRECTNESS ::= 'i'                         // indirect
 

include/swift/Demangling/DemangleNodes.def

@@ -189,5 +189,6 @@ NODE(OutlinedConsume)
 NODE(OutlinedRetain)
 NODE(OutlinedRelease)
 NODE(OutlinedVariable)
+NODE(AssocTypePath)
 #undef CONTEXT_NODE
 #undef NODE

lib/Demangling/Demangler.cpp

@@ -1653,10 +1653,20 @@ NodePointer Demangler::demangleWitness() {
     }
     case 'T': {
       NodePointer ProtoTy = popNode(Node::Kind::Type);
-      NodePointer Name = popNode(isDeclName);
+      NodePointer AssocTypePath = createNode(Node::Kind::AssocTypePath);
+      bool firstElem = false;
+      do {
+        firstElem = (popNode(Node::Kind::FirstElementMarker) != nullptr);
+        NodePointer AssocTyName = popNode(isDeclName);
+        if (!AssocTyName)
+          return nullptr;
+        AssocTypePath->addChild(AssocTyName, *this);
+      } while (!firstElem);
+      AssocTypePath->reverseChildren();
+
       NodePointer Conf = popProtocolConformance();
       return createWithChildren(Node::Kind::AssociatedTypeWitnessTableAccessor,
-                                Conf, Name, ProtoTy);
+                                Conf, AssocTypePath, ProtoTy);
     }
     case 'y': {
       return createWithChild(Node::Kind::OutlinedCopy,

lib/Demangling/NodePrinter.cpp

@@ -416,6 +416,7 @@ class NodePrinter {
     case Node::Kind::OutlinedRetain:
     case Node::Kind::OutlinedRelease:
     case Node::Kind::OutlinedVariable:
+    case Node::Kind::AssocTypePath:
       return false;
     }
     printer_unreachable("bad node kind");
@@ -1779,6 +1780,9 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
            && Node->getChild(0)->getKind() == Node::Kind::Type);
     print(Node->getChild(0));
     return nullptr;
+  case Node::Kind::AssocTypePath:
+    printChildren(Node->begin(), Node->end(), ".");
+      return nullptr;
   }
   printer_unreachable("bad node kind!");
 }

lib/Demangling/OldRemangler.cpp

@@ -1797,6 +1797,10 @@ void Remangler::mangleSILBoxImmutableField(Node *node) {
   mangleType(node->getChild(0));
 }
 
+void Remangler::mangleAssocTypePath(Node *node) {
+  unreachable("unsupported");
+}
+
 /// The top-level interface to the remangler.
 std::string Demangle::mangleNodeOld(const NodePointer &node) {
   if (!node) return "";

lib/Demangling/Remangler.cpp

@@ -1799,6 +1799,14 @@ void Remangler::mangleSILBoxImmutableField(Node *node) {
   unreachable("should be part of SILBoxTypeWithLayout");
 }
 
+void Remangler::mangleAssocTypePath(Node *node) {
+  bool FirstElem = true;
+  for (NodePointer Child : *node) {
+    mangle(Child);
+    mangleListSeparator(FirstElem);
+  }
+}
+
 } // anonymous namespace
 
 /// The top-level interface to the remangler.

lib/IRGen/IRGenMangler.h

@@ -113,16 +113,18 @@ class IRGenMangler : public Mangle::ASTMangler {
                                       const ProtocolDecl *Proto) {
     beginMangling();
     appendProtocolConformance(Conformance);
-    appendAssociatedTypePath(AssociatedType);
+    bool isFirstAssociatedTypeIdentifier = true;
+    appendAssociatedTypePath(AssociatedType, isFirstAssociatedTypeIdentifier);
     appendAnyGenericType(Proto);
     appendOperator("WT");
     return finalize();
   }
 
-  void appendAssociatedTypePath(CanType associatedType) {
+  void appendAssociatedTypePath(CanType associatedType, bool &isFirst) {
     if (auto memberType = dyn_cast<DependentMemberType>(associatedType)) {
-      appendAssociatedTypePath(memberType.getBase());
+      appendAssociatedTypePath(memberType.getBase(), isFirst);
       appendIdentifier(memberType->getName().str());
+      appendListSeparator(isFirst);
     } else {
       assert(isa<GenericTypeParamType>(associatedType));
     }

test/Demangle/Inputs/manglings.txt

@@ -271,3 +271,4 @@ _T0So11UITextFieldC4textSSSgvgToTepb_ ---> outlined bridged method (pb) of @objc
 _T0So11UITextFieldC4textSSSgvgToTeab_ ---> outlined bridged method (ab) of @objc __ObjC.UITextField.text.getter : Swift.String?
 _T0So5GizmoC11doSomethingSQyypGSQySaySSGGFToTembnn_ ---> outlined bridged method (mbnn) of @objc __ObjC.Gizmo.doSomething([Swift.String]!) -> Any!
 _T0So5GizmoC12modifyStringSQySSGAD_Si10withNumberSQyypG0D6FoobartFToTembnnnb_ ---> outlined bridged method (mbnnnb) of @objc __ObjC.Gizmo.modifyString(Swift.String!, withNumber: Swift.Int, withFoobar: Any!) -> Swift.String!
+_T04test1SVyxGAA1RA2A1ZRzAA1Y2ZZRpzl1A_AhaGPWT ---> {C} associated type witness table accessor for A.ZZ : test.Y in <A where A: test.Z, A.ZZ: test.Y> test.S<A> : test.R in test

test/IRGen/associated_type_witness.swift

@@ -41,8 +41,8 @@ struct GenericWithUniversal<T> : Assocked {
 //   Witness table for Fulfilled : Assocked.
 // GLOBAL-LABEL: @_T023associated_type_witness9FulfilledVyxGAA8AssockedAAWP = hidden constant [3 x i8*] [
 // GLOBAL-SAME:    i8* bitcast (%swift.type* (%swift.type*, i8**)* @_T023associated_type_witness9FulfilledVyxGAA8AssockedAA5AssocWt to i8*)
-// GLOBAL-SAME:    i8* bitcast (i8** (%swift.type*, %swift.type*, i8**)* @_T023associated_type_witness9FulfilledVyxGAA8AssockedAA5AssocAA1PPWT to i8*)
-// GLOBAL-SAME:    i8* bitcast (i8** (%swift.type*, %swift.type*, i8**)* @_T023associated_type_witness9FulfilledVyxGAA8AssockedAA5AssocAA1QPWT to i8*)
+// GLOBAL-SAME:    i8* bitcast (i8** (%swift.type*, %swift.type*, i8**)* @_T023associated_type_witness9FulfilledVyxGAA8AssockedAA5Assoc_AA1PPWT to i8*)
+// GLOBAL-SAME:    i8* bitcast (i8** (%swift.type*, %swift.type*, i8**)* @_T023associated_type_witness9FulfilledVyxGAA8AssockedAA5Assoc_AA1QPWT to i8*)
 // GLOBAL-SAME:  ]
 struct Fulfilled<T : P & Q> : Assocked {
   typealias Assoc = T
@@ -56,14 +56,14 @@ struct Fulfilled<T : P & Q> : Assocked {
 // CHECK-NEXT:    ret %swift.type* [[T2]]
 
 //   Associated type witness table access function for Fulfilled.Assoc : P.
-// CHECK-LABEL:  define internal i8** @_T023associated_type_witness9FulfilledVyxGAA8AssockedAA5AssocAA1PPWT(%swift.type* %"Fulfilled<T>.Assoc", %swift.type* %"Fulfilled<T>", i8** %"Fulfilled<T>.Assocked")
+// CHECK-LABEL:  define internal i8** @_T023associated_type_witness9FulfilledVyxGAA8AssockedAA5Assoc_AA1PPWT(%swift.type* %"Fulfilled<T>.Assoc", %swift.type* %"Fulfilled<T>", i8** %"Fulfilled<T>.Assocked")
 // CHECK:         [[T0:%.*]] = bitcast %swift.type* %"Fulfilled<T>" to i8***
 // CHECK-NEXT:    [[T1:%.*]] = getelementptr inbounds i8**, i8*** [[T0]], i64 3
 // CHECK-NEXT:    [[T2:%.*]] = load i8**, i8*** [[T1]], align 8, !invariant.load
 // CHECK-NEXT:    ret i8** [[T2]]
 
 //   Associated type witness table access function for Fulfilled.Assoc : Q.
-// CHECK-LABEL:  define internal i8** @_T023associated_type_witness9FulfilledVyxGAA8AssockedAA5AssocAA1QPWT(%swift.type* %"Fulfilled<T>.Assoc", %swift.type* %"Fulfilled<T>", i8** %"Fulfilled<T>.Assocked")
+// CHECK-LABEL:  define internal i8** @_T023associated_type_witness9FulfilledVyxGAA8AssockedAA5Assoc_AA1QPWT(%swift.type* %"Fulfilled<T>.Assoc", %swift.type* %"Fulfilled<T>", i8** %"Fulfilled<T>.Assocked")
 // CHECK:         [[T0:%.*]] = bitcast %swift.type* %"Fulfilled<T>" to i8***
 // CHECK-NEXT:    [[T1:%.*]] = getelementptr inbounds i8**, i8*** [[T0]], i64 4
 // CHECK-NEXT:    [[T2:%.*]] = load i8**, i8*** [[T1]], align 8, !invariant.load
@@ -74,8 +74,8 @@ struct Pair<T, U> : P, Q {}
 //   Generic witness table pattern for Computed : Assocked.
 // GLOBAL-LABEL: @_T023associated_type_witness8ComputedVyxq_GAA8AssockedAAWP = hidden constant [3 x i8*] [
 // GLOBAL-SAME:    i8* bitcast (%swift.type* (%swift.type*, i8**)* @_T023associated_type_witness8ComputedVyxq_GAA8AssockedAA5AssocWt to i8*)
-// GLOBAL-SAME:    i8* bitcast (i8** (%swift.type*, %swift.type*, i8**)* @_T023associated_type_witness8ComputedVyxq_GAA8AssockedAA5AssocAA1PPWT to i8*)
-// GLOBAL-SAME:    i8* bitcast (i8** (%swift.type*, %swift.type*, i8**)* @_T023associated_type_witness8ComputedVyxq_GAA8AssockedAA5AssocAA1QPWT to i8*)
+// GLOBAL-SAME:    i8* bitcast (i8** (%swift.type*, %swift.type*, i8**)* @_T023associated_type_witness8ComputedVyxq_GAA8AssockedAA5Assoc_AA1PPWT to i8*)
+// GLOBAL-SAME:    i8* bitcast (i8** (%swift.type*, %swift.type*, i8**)* @_T023associated_type_witness8ComputedVyxq_GAA8AssockedAA5Assoc_AA1QPWT to i8*)
 // GLOBAL-SAME:  ]
 //   Generic witness table cache for Computed : Assocked.
 // GLOBAL-LABEL: @_T023associated_type_witness8ComputedVyxq_GAA8AssockedAAWG = internal constant %swift.generic_witness_table_cache {

test/IRGen/assoctypepath.swift

@@ -0,0 +1,24 @@
+// RUN: %target-swift-frontend -primary-file %s -emit-ir | %FileCheck %s
+
+// Check that we can mangle+demangle the associated type witness table accessor
+// and do not crash
+
+protocol V {}
+protocol W: V {}
+protocol X: W {}
+protocol Y: X {}
+protocol Z: W {
+	associatedtype ZZ: X
+}
+
+protocol P {
+	associatedtype A: W
+}
+protocol Q: P where A: Z {}
+protocol R: Q where A.ZZ: Y {}
+
+// CHECK: define {{.*}} @_T013assoctypepath1SVyxGAA1RAA1A_2ZZAA1YPWT
+
+struct S<T>: R where T: Z, T.ZZ: Y {
+	typealias A = T
+}

test/IRGen/same_type_constraints.swift

@@ -60,5 +60,5 @@ where Self : CodingType,
   print(Self.ValueType.self)
 }
 
-// OSIZE: define internal i8** @_T021same_type_constraints12GenericKlazzCyxq_GAA1EAA4DataAA0F4TypePWT(%swift.type* %"GenericKlazz<T, R>.Data", %swift.type* nocapture readonly %"GenericKlazz<T, R>", i8** nocapture readnone %"GenericKlazz<T, R>.E") [[ATTRS:#[0-9]+]] {
+// OSIZE: define internal i8** @_T021same_type_constraints12GenericKlazzCyxq_GAA1EAA4Data_AA0F4TypePWT(%swift.type* %"GenericKlazz<T, R>.Data", %swift.type* nocapture readonly %"GenericKlazz<T, R>", i8** nocapture readnone %"GenericKlazz<T, R>.E") [[ATTRS:#[0-9]+]] {
 // OSIZE: [[ATTRS]] = {{{.*}}noinline