Cleanup Constraint printing

Author: dwijnand

compiler/src/dotty/tools/dotc/core/Constraint.scala

@@ -197,10 +197,11 @@ abstract class Constraint extends Showable {
    */
   def validBoundsFor(param: TypeParamRef, bounds: TypeBounds)(using Context): Type
 
-  /** A string that shows the reverse dependencies maintained by this constraint
-   *  (coDeps and contraDeps for OrderingConstraints).
-   */
-  def depsToString(using Context): String
+  /** The covariant reverse dependencies maintained by this constraint */
+  def covDeps: SimpleIdentityMap[TypeParamRef, SimpleIdentitySet[TypeParamRef]]
+
+  /** The contravariant reverse dependencies maintained by this constraint */
+  def conDeps: SimpleIdentityMap[TypeParamRef, SimpleIdentitySet[TypeParamRef]]
 
   /** Does the constraint restricted to variables outside `except` depend on `tv`
    *  in the given direction `co`?

compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala

@@ -439,12 +439,8 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     coDeps = coDeps.remove(param)
     contraDeps = contraDeps.remove(param)
 
-  /** A string representing the two dependency maps */
-  def depsToString(using Context): String =
-    def depsStr(deps: ReverseDeps): String =
-      def depStr(param: TypeParamRef) = i"$param --> ${deps.at(param).toList}%, %"
-      if deps.isEmpty then "" else i"\n     ${deps.toList.map((k, v) => depStr(k))}%\n     %"
-    i" co-deps:${depsStr(coDeps)}\n contra-deps:${depsStr(contraDeps)}\n"
+  def covDeps: ReverseDeps = coDeps
+  def conDeps: ReverseDeps = contraDeps
 
 // ---------- Adding TypeLambdas --------------------------------------------------
 

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -717,40 +717,27 @@ class PlainPrinter(_ctx: Context) extends Printer {
     try
       // The current TyperState constraint determines how type variables are printed
       ctx.typerState.constraint = c
-      def entryText(tp: Type) = tp match {
-        case tp: TypeBounds =>
-          toText(tp)
-        case _ =>
-          " := " ~ toText(tp)
-      }
-      val indent = 3
-      val uninstVarsText = " uninstantiated variables: " ~
-        Text(c.uninstVars.map(toText), ", ")
-      val constrainedText =
-        " constrained types: " ~ Text(c.domainLambdas.map(toText), ", ")
-      val boundsText =
-        " bounds: " ~ {
-          val assocs =
-            for (param <- c.domainParams)
-            yield (" " * indent) ~ toText(param) ~ entryText(c.entry(param))
-          Text(assocs, "\n")
-        }
-      val orderingText =
-        " ordering: " ~ {
-          val deps =
-            for {
-              param <- c.domainParams
-              ups = c.minUpper(param)
-              if ups.nonEmpty
-            }
-            yield
-              (" " * indent) ~ toText(param) ~ " <: " ~
-                Text(ups.map(toText), ", ")
-          Text(deps, "\n")
-        }
-      val depsText = if Config.showConstraintDeps then c.depsToString else ""
+
+      def depsText(k: TypeParamRef, vs: List[TypeParamRef]): Text =
+        (toText(k) ~ " --> ") ~: ("[" ~ toText(vs, ", ") ~ "]").provided(vs.nonEmpty && Config.showConstraintDeps).close
+
+      def orderText(p: TypeParamRef, op: String, doms: List[TypeParamRef], sep: String) =
+        (toText(p) ~ op) ~: Text(doms.map(toText), sep)
+
       //Printer.debugPrintUnique = false
-      Text.lines(List(uninstVarsText, constrainedText, boundsText, orderingText, depsText))
+      val parts = List(
+        "uninsts: " ~: Text(c.uninstVars.map(toText), ", "),
+        "lambdas: " ~: Text(c.domainLambdas.map(toText), ", "),
+        "bounds:  " ~: Text(c.domainParams.map(p => toText(p) ~: toText(TypeComparer.fullBounds(p))), ", "),
+        "uppers:  " ~: Text(c.domainParams.map(p => orderText(p, " <: ", c.minUpper(p), " & ")), ", "),
+        "lowers:  " ~: Text(c.domainParams.map(p => orderText(p, " >: ", c.minLower(p), " | ")), ", "),
+        "covdeps: " ~: Text(c.covDeps.map2((k, vs) => depsText(k, vs.toList)), ", "),
+        "condeps: " ~: Text(c.conDeps.map2((k, vs) => depsText(k, vs.toList)), ", "),
+      ).filter(!_.isEmpty).map(_.close)
+
+      if parts.sizeIs > 1
+      then "Constr:" ~ Text(parts, "\n")
+      else "Constr(" ~ Text(parts, ", ")  ~ ")"
     finally
       ctx.typerState.constraint = savedConstraint
 

compiler/src/dotty/tools/dotc/printing/Texts.scala

@@ -155,6 +155,8 @@ object Texts {
           case Fluid(relems2) if !that.isClosed => Fluid(relems2 :+ this)
           case _                                => Fluid(that :: this :: Nil)
 
+    def ~: (lhs: Text): Text = (lhs ~ this).provided(!isEmpty)
+
     def ~~ (that: Text): Text =
       if (this.isEmpty) that
       else if (that.isEmpty) this