[AST] Make dumping for SubstitutionMap lisp-formatted and indent-aware.

This is much easier to read when part of a larger dump, where it now occurs in
expressions and specialized conformances.

Part of rdar://problem/40074968.

Author: huonw

include/swift/AST/SubstitutionMap.h

@@ -219,7 +219,7 @@ class SubstitutionMap {
   void verify() const;
 
   /// Dump the contents of this substitution map for debugging purposes.
-  void dump(llvm::raw_ostream &out) const;
+  void dump(llvm::raw_ostream &out, unsigned indent = 0) const;
 
   LLVM_ATTRIBUTE_DEPRECATED(void dump() const, "only for use in the debugger");
 

lib/AST/ASTDumper.cpp

@@ -2905,7 +2905,8 @@ static void dumpProtocolConformanceRec(
       break;
 
     out << '\n';
-    conf->getSubstitutionMap().dump(out);
+    conf->getSubstitutionMap().dump(out, indent + 2);
+    out << '\n';
     for (auto subReq : conf->getConditionalRequirements()) {
       out.indent(indent + 2);
       subReq.dump(out);
@@ -2938,6 +2939,64 @@ void ProtocolConformance::dump(llvm::raw_ostream &out, unsigned indent) const {
   dumpProtocolConformanceRec(this, out, indent, visited);
 }
 
+void SubstitutionMap::dump(llvm::raw_ostream &out, unsigned indent) const {
+  auto *genericSig = getGenericSignature();
+  out.indent(indent);
+
+  auto printParen = [&](char p) {
+    PrintWithColorRAII(out, ParenthesisColor) << p;
+  };
+  printParen('(');
+  out << "substitution_map generic_signature=";
+  if (genericSig == nullptr) {
+    out << "<nullptr>";
+    printParen(')');
+    return;
+  }
+
+  genericSig->print(out);
+  auto genericParams = genericSig->getGenericParams();
+  auto replacementTypes = getReplacementTypesBuffer();
+  for (unsigned i : indices(genericParams)) {
+    out << "\n";
+    out.indent(indent + 2);
+    printParen('(');
+    out << "substitution ";
+    genericParams[i]->print(out);
+    out << " -> ";
+    if (replacementTypes[i])
+      replacementTypes[i]->print(out);
+    else
+      out << "<<unresolved concrete type>>";
+    printParen(')');
+  }
+
+  // We only really need to print a conformance once across this whole map.
+  llvm::SmallPtrSet<const ProtocolConformance *, 8> visited;
+  auto conformances = getConformances();
+  for (const auto &req : genericSig->getRequirements()) {
+    if (req.getKind() != RequirementKind::Conformance)
+      continue;
+
+    out << "\n";
+    out.indent(indent + 2);
+    printParen('(');
+    out << "conformance type=";
+    req.getFirstType()->print(out);
+    out << "\n";
+    dumpProtocolConformanceRefRec(conformances.front(), out, indent + 4,
+                                  visited);
+
+    printParen(')');
+    conformances = conformances.slice(1);
+  }
+}
+
+void SubstitutionMap::dump() const {
+  dump(llvm::errs());
+  llvm::errs() << "\n";
+}
+
 //===----------------------------------------------------------------------===//
 // Dumping for Types.
 //===----------------------------------------------------------------------===//

lib/AST/SubstitutionMap.cpp

@@ -609,48 +609,6 @@ void SubstitutionMap::verify() const {
 #endif
 }
 
-void SubstitutionMap::dump(llvm::raw_ostream &out) const {
-  auto *genericSig = getGenericSignature();
-  if (genericSig == nullptr) {
-    out << "Empty substitution map\n";
-    return;
-  }
-  out << "Generic signature: ";
-  genericSig->print(out);
-  out << "\n";
-  out << "Substitutions:\n";
-  auto genericParams = genericSig->getGenericParams();
-  auto replacementTypes = getReplacementTypesBuffer();
-  for (unsigned i : indices(genericParams)) {
-    out.indent(2);
-    genericParams[i]->print(out);
-    out << " -> ";
-    if (replacementTypes[i])
-      replacementTypes[i]->print(out);
-    else
-      out << "<<unresolved concrete type>>";
-    out << "\n";
-  }
-
-  out << "\nConformance map:\n";
-  auto conformances = getConformances();
-  for (const auto &req : genericSig->getRequirements()) {
-    if (req.getKind() != RequirementKind::Conformance) continue;
-
-    out.indent(2);
-    req.getFirstType()->print(out);
-    out << " -> ";
-    conformances.front().dump(out);
-    out << "\n";
-
-    conformances = conformances.slice(1);
-  }
-}
-
-void SubstitutionMap::dump() const {
-  return dump(llvm::errs());
-}
-
 void SubstitutionMap::profile(llvm::FoldingSetNodeID &id) const {
   id.AddPointer(storage);
 }

test/Driver/debug-generic-signatures.swift

@@ -75,37 +75,46 @@ extension Generic: P1 where T: P1 {
 
 
 // Satisfying associated types with requirements with generic params
-class Super<T> {}
-// CHECK-LABEL: ExtensionDecl line={{.*}} base=Super<T>
-// CHECK-NEXT: (normal_conformance type=Super<T> protocol=P2
-// CHECK-NEXT:   (assoc_type req=A type=Super<T>.A)
-// CHECK-NEXT:   (assoc_type req=B type=Super<T>.B)
+class Super<T, U> {}
+// CHECK-LABEL: ExtensionDecl line={{.*}} base=Super<T, U>
+// CHECK-NEXT: (normal_conformance type=Super<T, U> protocol=P2
+// CHECK-NEXT:   (assoc_type req=A type=Super<T, U>.A)
+// CHECK-NEXT:   (assoc_type req=B type=Super<T, U>.B)
 // CHECK-NEXT:   (abstract_conformance protocol=P2)
 // CHECK:        (abstract_conformance protocol=P2)
-// CHECK:        conforms_to: T P2)
-extension Super: P2 where T: P2 {
+// CHECK:        conforms_to: T P2
+// CHECK:        conforms_to: U P2)
+extension Super: P2 where T: P2, U: P2 {
     typealias A = T
     typealias B = T
 }
 
 // Inherited/specialized conformances.
 // CHECK-LABEL: ClassDecl name=Sub
 // CHECK-NEXT: (inherited_conformance type=Sub protocol=P2
-// CHECK-NEXT:   (specialized_conformance type=Super<Recur> protocol=P2
-// CHECK-NEXT: Generic signature: <T where T : P2>
-// CHECK-NEXT: Substitutions:
-// CHECK-NEXT:   T -> Recur
-// CHECK:      Conformance map:
-// CHECK-NEXT:   T -> (normal_conformance type=Recur protocol=P2
-// CHECK-NEXT:   (assoc_type req=A type=Recur.A)
-// CHECK-NEXT:   (assoc_type req=B type=Recur.B)
-// CHECK-NEXT:   (normal_conformance type=Recur protocol=P2 (details printed above))
-// CHECK-NEXT:   (normal_conformance type=Recur protocol=P2 (details printed above)))
+// CHECK-NEXT:   (specialized_conformance type=Super<NonRecur, Recur> protocol=P2
+// CHECK-NEXT:      (substitution_map generic_signature=<T, U where T : P2, U : P2>
+// CHECK-NEXT:         (substitution T -> NonRecur)
+// CHECK-NEXT:         (substitution U -> Recur)
+// CHECK-NEXT:         (conformance type=T
+// CHECK-NEXT:            (normal_conformance type=NonRecur protocol=P2
+// CHECK-NEXT:              (assoc_type req=A type=NonRecur.A)
+// CHECK-NEXT:              (assoc_type req=B type=NonRecur.B)
+// CHECK-NEXT:              (normal_conformance type=Recur protocol=P2
+// CHECK-NEXT:                (assoc_type req=A type=Recur.A)
+// CHECK-NEXT:                (assoc_type req=B type=Recur.B)
+// CHECK-NEXT:                (normal_conformance type=Recur protocol=P2 (details printed above))
+// CHECK-NEXT:                (normal_conformance type=Recur protocol=P2 (details printed above)))
+// CHECK-NEXT:              (normal_conformance type=Recur protocol=P2 (details printed above))))
+// CHECK-NEXT:         (conformance type=U
+// CHECK-NEXT:            (normal_conformance type=Recur protocol=P2 (details printed above))))
+// CHECK-NEXT:     conforms_to: NonRecur P2
 // CHECK-NEXT:     conforms_to: Recur P2
-// CHECK-NEXT:     (normal_conformance type=Super<T> protocol=P2
-// CHECK-NEXT:       (assoc_type req=A type=Super<T>.A)
-// CHECK-NEXT:       (assoc_type req=B type=Super<T>.B)
+// CHECK-NEXT:     (normal_conformance type=Super<T, U> protocol=P2
+// CHECK-NEXT:       (assoc_type req=A type=Super<T, U>.A)
+// CHECK-NEXT:       (assoc_type req=B type=Super<T, U>.B)
 // CHECK-NEXT:       (abstract_conformance protocol=P2)
 // CHECK:            (abstract_conformance protocol=P2)
-// CHECK:            conforms_to: T P2)))
-class Sub: Super<Recur> {}
+// CHECK:            conforms_to: T P2
+// CHECK:            conforms_to: U P2)))
+class Sub: Super<NonRecur, Recur> {}