Merge pull request #60443 from amritpan/improve-solver-step-printing

[ConstraintSystem] Improve solver step printing in the type inference algorithm debug output

Author: xedin

Diff for: include/swift/Sema/ConstraintSystem.h

@@ -626,7 +626,7 @@ class TypeVariableType::Implementation {
 
   /// Print the type variable to the given output stream.
   void print(llvm::raw_ostream &OS);
-  
+
 private:
   StringRef getTypeVariableOptions(TypeVariableOptions TVO) const {
   #define ENTRY(Kind, String) case TypeVariableOptions::Kind: return String

Diff for: lib/Sema/CSBindings.cpp

@@ -1657,9 +1657,11 @@ void BindingSet::dump(llvm::raw_ostream &out, unsigned indent) const {
 
   out.indent(indent);
   out << "(";
-  if (auto typeVar = getTypeVariable())
-    out << "$T" << typeVar->getImpl().getID() << " ";
-  
+  if (auto typeVar = getTypeVariable()) {
+    typeVar->print(out, PO);
+    out << " ";
+  }
+
   std::vector<std::string> attributes;
   if (isDirectHole())
     attributes.push_back("hole");
@@ -1722,56 +1724,96 @@ void BindingSet::dump(llvm::raw_ostream &out, unsigned indent) const {
 
   auto numDefaultable = getNumViableDefaultableBindings();
   if (numDefaultable > 0)
-    out << "#defaultable_bindings: " << numDefaultable << " ";
+    out << "[#defaultable_bindings: " << numDefaultable << "] ";
 
-  auto printBinding = [&](const PotentialBinding &binding) {
-    auto type = binding.BindingType;
-    switch (binding.Kind) {
-    case AllowedBindingKind::Exact:
-      break;
+  struct PrintableBinding {
+  private:
+    enum class BindingKind { Exact, Subtypes, Supertypes, Literal };
+    BindingKind Kind;
+    Type BindingType;
+    PrintableBinding(BindingKind kind, Type bindingType)
+        : Kind(kind), BindingType(bindingType) {}
 
-    case AllowedBindingKind::Subtypes:
-      out << "(subtypes of) ";
-      break;
+  public:
+    static PrintableBinding supertypesOf(Type binding) {
+      return PrintableBinding{BindingKind::Supertypes, binding};
+    }
+    
+    static PrintableBinding subtypesOf(Type binding) {
+      return PrintableBinding{BindingKind::Subtypes, binding};
+    }
+    
+    static PrintableBinding exact(Type binding) {
+      return PrintableBinding{BindingKind::Exact, binding};
+    }
+    
+    static PrintableBinding literalDefaultType(Type binding) {
+      return PrintableBinding{BindingKind::Literal, binding};
+    }
 
-    case AllowedBindingKind::Supertypes:
-      out << "(supertypes of) ";
-      break;
+    void print(llvm::raw_ostream &out, const PrintOptions &PO,
+               unsigned indent = 0) const {
+      switch (Kind) {
+      case BindingKind::Exact:
+        break;
+      case BindingKind::Subtypes:
+        out << "(subtypes of) ";
+        break;
+      case BindingKind::Supertypes:
+        out << "(supertypes of) ";
+        break;
+      case BindingKind::Literal:
+        out << "(default type of literal) ";
+        break;
+      }
+      BindingType.print(out);
     }
-    if (auto *literal = binding.getDefaultedLiteralProtocol())
-      out << "(default from " << literal->getName() << ") ";
-    out << type.getString(PO);
   };
 
   out << "[with possible bindings: ";
-  interleave(Bindings, printBinding, [&]() { out << "; "; });
-  if (!Literals.empty()) {
-    std::vector<std::string> defaultLiterals;
-    for (const auto &literal : Literals) {
-      if (literal.second.viableAsBinding()) {
-        auto defaultWithType = "(default type of literal) " +
-                               literal.second.getDefaultType().getString(PO);
-        defaultLiterals.push_back(defaultWithType);
-      }
+  SmallVector<PrintableBinding, 2> potentialBindings;
+  for (const auto &binding : Bindings) {
+    switch (binding.Kind) {
+    case AllowedBindingKind::Exact:
+      potentialBindings.push_back(PrintableBinding::exact(binding.BindingType));
+      break;
+    case AllowedBindingKind::Supertypes:
+      potentialBindings.push_back(
+          PrintableBinding::supertypesOf(binding.BindingType));
+      break;
+    case AllowedBindingKind::Subtypes:
+      potentialBindings.push_back(
+          PrintableBinding::subtypesOf(binding.BindingType));
+      break;
     }
-    interleave(defaultLiterals, out, ", ");
   }
-  if (Bindings.empty() && Literals.empty()) {
+  for (const auto &literal : Literals) {
+    if (literal.second.viableAsBinding()) {
+      potentialBindings.push_back(PrintableBinding::literalDefaultType(
+          literal.second.getDefaultType()));
+    }
+  }
+  if (potentialBindings.empty()) {
     out << "<empty>";
+  } else {
+    interleave(
+        potentialBindings,
+        [&](const PrintableBinding &binding) { binding.print(out, PO); },
+        [&] { out << ", "; });
   }
   out << "]";
 
   if (!Defaults.empty()) {
-    out << "[defaults: ";
+    out << " [defaults: ";
     for (const auto &entry : Defaults) {
       auto *constraint = entry.second;
-      PotentialBinding binding{constraint->getSecondType(),
-                               AllowedBindingKind::Exact, constraint};
-      printBinding(binding);
+      auto defaultBinding =
+          PrintableBinding::exact(constraint->getSecondType());
+      defaultBinding.print(out, PO);
     }
-    out << "] ";
+    out << "]";
   }
-  out << ")\n";
+  out << ")";
 }
 
 // Given a possibly-Optional type, return the direct superclass of the

Diff for: lib/Sema/CSGen.cpp

@@ -4207,6 +4207,7 @@ bool ConstraintSystem::generateConstraints(
       print(log, expr);
       log << "\n";
       print(log);
+      log << "\n";
     }
 
     return false;

Diff for: lib/Sema/CSStep.cpp

@@ -352,6 +352,7 @@ StepResult ComponentStep::take(bool prevFailed) {
   auto bestBindings = CS.determineBestBindings([&](const BindingSet &bindings) {
     if (CS.isDebugMode() && bindings.hasViableBindings()) {
       bindings.dump(bos, CS.solverState->getCurrentIndent() + 2);
+      bos << "\n";
     }
   });
 
@@ -875,6 +876,10 @@ StepResult ConjunctionStep::resume(bool prevFailed) {
   // attempted to apply information gained from the
   // isolated constraint to the outer context.
   if (Snapshot && Snapshot->isScoped()) {
+    Snapshot.reset();
+    if (CS.isDebugMode())
+      getDebugLogger() << ")\n";
+    
     return done(/*isSuccess=*/!prevFailed);
   }
 

Diff for: lib/Sema/CSStep.h

@@ -999,9 +999,6 @@ class ConjunctionStep : public BindingStep<ConjunctionElementProducer> {
       auto remainingTime = OuterTimeRemaining->second;
       CS.Timer.emplace(anchor, CS, remainingTime);
     }
-    
-    if (CS.isDebugMode())
-      getDebugLogger() << ")\n";
   }
 
   StepResult resume(bool prevFailed) override;

Diff for: lib/Sema/ConstraintSystem.cpp

@@ -3547,10 +3547,28 @@ void ConstraintSystem::resolveOverload(ConstraintLocator *locator,
   if (isDebugMode()) {
     PrintOptions PO;
     PO.PrintTypesForDebugging = true;
-    llvm::errs().indent(solverState ? solverState->getCurrentIndent() : 2)
-      << "(overload set choice binding "
-      << boundType->getString(PO) << " := "
-      << adjustedRefType->getString(PO) << ")\n";
+
+    auto &log = llvm::errs();
+    log.indent(solverState ? solverState->getCurrentIndent() : 2);
+    log << "(overload set choice binding ";
+    boundType->print(log, PO);
+    log << " := ";
+    adjustedRefType->print(log, PO);
+
+    auto openedAtLoc = getOpenedTypes(locator);
+    if (!openedAtLoc.empty()) {
+      log << " [";
+      llvm::interleave(
+          openedAtLoc.begin(), openedAtLoc.end(),
+          [&](OpenedType opened) {
+            opened.second->getImpl().getGenericParameter()->print(log, PO);
+            log << " := ";
+            Type(opened.second).print(log, PO);
+          },
+          [&]() { log << ", "; });
+      log << "]";
+    }
+    log << ")\n";
   }
 
   if (auto *decl = choice.getDeclOrNull()) {

Diff for: lib/Sema/TypeCheckConstraints.cpp

@@ -1299,9 +1299,9 @@ void Solution::dump(raw_ostream &out) const {
   if (!overloadChoices.empty()) {
     out << "\nOverload choices:";
     for (auto ovl : overloadChoices) {
-      out.indent(2);
       if (ovl.first) {
         out << "\n";
+        out.indent(2);
         ovl.first->dump(sm, out);
       }
 
@@ -1466,16 +1466,17 @@ void ConstraintSystem::print(raw_ostream &out) const {
              });
   for (auto tv : typeVariables) {
     out.indent(2);
-    tv->getImpl().print(out);
     auto rep = getRepresentative(tv);
     if (rep == tv) {
       if (auto fixed = getFixedType(tv)) {
+        tv->getImpl().print(out);
         out << " as ";
         Type(fixed).print(out, PO);
       } else {
         const_cast<ConstraintSystem *>(this)->getBindingsFor(tv).dump(out, 1);
       }
     } else {
+      tv->getImpl().print(out);
       out << " equivalent to ";
       Type(rep).print(out, PO);
     }