Mangler: Add support for same-shape requirements

Author: slavapestov

docs/ABI/Mangling.rst

@@ -887,6 +887,8 @@ now codified into the ABI; the index 0 is therefore reserved.
   requirement ::= type assoc-type-list 'RM' GENERIC-PARAM-INDEX LAYOUT-CONSTRAINT    // layout requirement on associated type at depth
   requirement ::= type substitution 'RM' LAYOUT-CONSTRAINT                           // layout requirement with substitution
 
+  requirement ::= type 'Rh' GENERIC-PARAM-INDEX                     // same-shape requirement (only supported on a generic parameter)
+
   GENERIC-PARAM-INDEX ::= 'z'                // depth = 0,   idx = 0
   GENERIC-PARAM-INDEX ::= INDEX              // depth = 0,   idx = N+1
   GENERIC-PARAM-INDEX ::= 'd' INDEX INDEX    // depth = M+1, idx = N

include/swift/Demangling/DemangleNodes.def

@@ -59,6 +59,7 @@ NODE(DependentGenericConformanceRequirement)
 NODE(DependentGenericParamCount)
 NODE(DependentGenericParamType)
 NODE(DependentGenericSameTypeRequirement)
+NODE(DependentGenericSameShapeRequirement)
 NODE(DependentGenericLayoutRequirement)
 NODE(DependentGenericSignature)
 NODE(DependentGenericType)

lib/AST/ASTMangler.cpp

@@ -2912,8 +2912,6 @@ void ASTMangler::appendRequirement(const Requirement &reqt,
   Type FirstTy = reqt.getFirstType()->getCanonicalType();
 
   switch (reqt.getKind()) {
-  case RequirementKind::SameShape:
-    llvm_unreachable("Same-shape requirement not supported here");
   case RequirementKind::Layout:
     break;
   case RequirementKind::Conformance: {
@@ -2925,7 +2923,8 @@ void ASTMangler::appendRequirement(const Requirement &reqt,
     appendProtocolName(reqt.getProtocolDecl());
   } break;
   case RequirementKind::Superclass:
-  case RequirementKind::SameType: {
+  case RequirementKind::SameType:
+  case RequirementKind::SameShape: {
     Type SecondTy = reqt.getSecondType();
     appendType(SecondTy->getCanonicalType(), sig);
     break;
@@ -2957,7 +2956,7 @@ void ASTMangler::appendRequirement(const Requirement &reqt,
     assert(gpBase);
     switch (reqt.getKind()) {
       case RequirementKind::SameShape:
-        llvm_unreachable("Same-shape requirement not supported here");
+        llvm_unreachable("Same-shape requirement with a dependent member type?");
       case RequirementKind::Conformance:
         return appendOpWithGenericParamIndex(isAssocTypeAtDepth ? "RP" : "Rp",
                                              gpBase, lhsBaseIsProtocolSelf);
@@ -2977,8 +2976,6 @@ void ASTMangler::appendRequirement(const Requirement &reqt,
   }
   GenericTypeParamType *gpBase = FirstTy->castTo<GenericTypeParamType>();
   switch (reqt.getKind()) {
-    case RequirementKind::SameShape:
-      llvm_unreachable("Same-shape requirement not supported here");
     case RequirementKind::Conformance:
       return appendOpWithGenericParamIndex("R", gpBase);
     case RequirementKind::Layout:
@@ -2989,6 +2986,8 @@ void ASTMangler::appendRequirement(const Requirement &reqt,
       return appendOpWithGenericParamIndex("Rb", gpBase);
     case RequirementKind::SameType:
       return appendOpWithGenericParamIndex("Rs", gpBase);
+    case RequirementKind::SameShape:
+      return appendOpWithGenericParamIndex("Rh", gpBase);
   }
   llvm_unreachable("bad requirement type");
 }

lib/Demangling/Demangler.cpp

@@ -77,6 +77,7 @@ static bool isEntity(Node::Kind kind) {
 static bool isRequirement(Node::Kind kind) {
   switch (kind) {
     case Node::Kind::DependentGenericSameTypeRequirement:
+    case Node::Kind::DependentGenericSameShapeRequirement:
     case Node::Kind::DependentGenericLayoutRequirement:
     case Node::Kind::DependentGenericConformanceRequirement:
       return true;
@@ -3691,7 +3692,7 @@ NodePointer Demangler::demangleGenericSignature(bool hasParamCounts) {
 NodePointer Demangler::demangleGenericRequirement() {
 
   enum { Generic, Assoc, CompoundAssoc, Substitution } TypeKind;
-  enum { Protocol, BaseClass, SameType, Layout } ConstraintKind;
+  enum { Protocol, BaseClass, SameType, SameShape, Layout } ConstraintKind;
 
   switch (nextChar()) {
     case 'c': ConstraintKind = BaseClass; TypeKind = Assoc; break;
@@ -3709,6 +3710,7 @@ NodePointer Demangler::demangleGenericRequirement() {
     case 'p': ConstraintKind = Protocol; TypeKind = Assoc; break;
     case 'P': ConstraintKind = Protocol; TypeKind = CompoundAssoc; break;
     case 'Q': ConstraintKind = Protocol; TypeKind = Substitution; break;
+    case 'h': ConstraintKind = SameShape; TypeKind = Generic; break;
     default:  ConstraintKind = Protocol; TypeKind = Generic; pushBack(); break;
   }
 
@@ -3743,6 +3745,9 @@ NodePointer Demangler::demangleGenericRequirement() {
   case SameType:
     return createWithChildren(Node::Kind::DependentGenericSameTypeRequirement,
                               ConstrTy, popNode(Node::Kind::Type));
+  case SameShape:
+    return createWithChildren(Node::Kind::DependentGenericSameShapeRequirement,
+                              ConstrTy, popNode(Node::Kind::Type));
   case Layout: {
     auto c = nextChar();
     NodePointer size = nullptr;

lib/Demangling/NodePrinter.cpp

@@ -368,6 +368,7 @@ class NodePrinter {
     case Node::Kind::DependentGenericConformanceRequirement:
     case Node::Kind::DependentGenericLayoutRequirement:
     case Node::Kind::DependentGenericSameTypeRequirement:
+    case Node::Kind::DependentGenericSameShapeRequirement:
     case Node::Kind::DependentPseudogenericSignature:
     case Node::Kind::Destructor:
     case Node::Kind::DidSet:
@@ -2674,6 +2675,16 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
     print(snd, depth + 1);
     return nullptr;
   }
+  case Node::Kind::DependentGenericSameShapeRequirement: {
+    NodePointer fst = Node->getChild(0);
+    NodePointer snd = Node->getChild(1);
+
+    print(fst, depth + 1);
+    Printer << ".shape == ";
+    print(snd, depth + 1);
+    Printer << ".shape";
+    return nullptr;
+  }
   case Node::Kind::DependentGenericParamType: {
     unsigned index = Node->getChild(1)->getIndex();
     unsigned depth = Node->getChild(0)->getIndex();

lib/Demangling/OldRemangler.cpp

@@ -1946,6 +1946,12 @@ Remangler::mangleDependentGenericSameTypeRequirement(Node *node,
   return mangle(node->getChild(1), depth + 1);
 }
 
+ManglingError
+Remangler::mangleDependentGenericSameShapeRequirement(Node *node,
+                                                      unsigned depth) {
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
+}
+
 ManglingError
 Remangler::mangleDependentGenericLayoutRequirement(Node *node, unsigned depth) {
   RETURN_IF_ERROR(mangleConstrainedType(node->getChild(0), depth + 1));

lib/Demangling/Remangler.cpp

@@ -1076,6 +1076,28 @@ Remangler::mangleDependentGenericSameTypeRequirement(Node *node,
   return ManglingError::Success;
 }
 
+ManglingError
+Remangler::mangleDependentGenericSameShapeRequirement(Node *node,
+                                                      unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
+  auto Mangling = mangleConstrainedType(node->getChild(0), depth + 1);
+  if (!Mangling.isSuccess())
+    return Mangling.error();
+  auto NumMembersAndParamIdx = Mangling.result();
+  DEMANGLER_ASSERT(
+      NumMembersAndParamIdx.first < 0 || NumMembersAndParamIdx.second, node);
+  switch (NumMembersAndParamIdx.first) {
+  case 0:
+    Buffer << "Rh";
+    break;
+  default:
+    assert(false && "Invalid same-shape requirement");
+    return ManglingError::AssertionFailed;
+  }
+  mangleDependentGenericParamIndex(NumMembersAndParamIdx.second);
+  return ManglingError::Success;
+}
+
 ManglingError
 Remangler::mangleDependentGenericLayoutRequirement(Node *node, unsigned depth) {
   auto Mangling = mangleConstrainedType(node->getChild(0), depth + 1);