Do Text construction via extension methods

Do Text construction via extension methods in class Printer. This
refactoring is a necssary first step to be able to implement output
throttling to avoid error messages that become too large.

Author: odersky

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

@@ -631,6 +631,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
 // ---------- toText -----------------------------------------------------
 
   override def toText(printer: Printer): Text = {
+    import printer.{~, concat, lines}
     def entryText(tp: Type) = tp match {
       case tp: TypeBounds =>
         tp.toText(printer)
@@ -640,15 +641,15 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     val indent = 3
     val header: Text = "Constraint("
     val uninstVarsText = " uninstVars = " ~
-      Text(uninstVars map (_.toText(printer)), ", ") ~ ";"
+      concat(uninstVars map (_.toText(printer)), ", ") ~ ";"
     val constrainedText =
-      " constrained types = " ~ Text(domainLambdas map (_.toText(printer)), ", ")
+      " constrained types = " ~ concat(domainLambdas map (_.toText(printer)), ", ")
     val boundsText =
       " bounds = " ~ {
         val assocs =
           for (param <- domainParams)
           yield (" " * indent) ~ param.toText(printer) ~ entryText(entry(param))
-        Text(assocs, "\n")
+        concat(assocs, "\n")
       }
     val orderingText =
       " ordering = " ~ {
@@ -660,10 +661,10 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
           }
           yield
             (" " * indent) ~ param.toText(printer) ~ " <: " ~
-              Text(ups.map(_.toText(printer)), ", ")
-        Text(deps, "\n")
+              concat(ups.map(_.toText(printer)), ", ")
+        concat(deps, "\n")
       }
-    Text.lines(List(header, uninstVarsText, constrainedText, boundsText, orderingText, ")"))
+    lines(List(header, uninstVarsText, constrainedText, boundsText, orderingText, ")"))
   }
 
   override def toString: String = {

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

@@ -5233,6 +5233,7 @@ object Types {
     assert(!hi.isInstanceOf[Range])
 
     override def toText(printer: Printer): Text =
+      import printer.~
       lo.toText(printer) ~ ".." ~ hi.toText(printer)
   }
 

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -26,6 +26,7 @@ object TreePickler {
     override def isTerm: Boolean = isTermHole
     override def isType: Boolean = !isTermHole
     override def fallbackToText(printer: Printer): Text =
+      import printer.~~
       s"[[$idx|" ~~ printer.toTextGlobal(args, ", ") ~~ "]]"
   }
 }

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -37,6 +37,7 @@ object Scala2Unpickler {
 
   case class TempPolyType(tparams: List[TypeSymbol], tpe: Type) extends UncachedGroundType {
     override def fallbackToText(printer: Printer): Text =
+      import printer.~
       "[" ~ printer.dclsText(tparams, ", ") ~ "]" ~ printer.toText(tpe)
   }
 

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

@@ -66,7 +66,7 @@ class DecompilerPrinter(_ctx: Context) extends RefinedPrinter(_ctx) {
     // We don't print self type and constructor for objects
     val isObject = impl.constr.symbol.owner.is(Module)
     if (isObject) {
-      val parentsText = keywordText(" extends") ~~ Text(parents.map(constrText), keywordStr(" with "))
+      val parentsText = keywordText(" extends") ~~ concat(parents.map(constrText), keywordStr(" with "))
       val bodyText = " {" ~~ toTextGlobal(impl.body, "\n") ~ "}"
       parentsText.provided(parents.nonEmpty) ~ bodyText
     }

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

@@ -31,7 +31,9 @@ object Formatting {
           case NonFatal(ex)
           if !ctx.mode.is(Mode.PrintShowExceptions) &&
              !ctx.settings.YshowPrintErrors.value =>
-            val msg = ex match { case te: TypeError => te.toMessage case _ => ex.getMessage }
+            val msg = ex match
+              case te: TypeError => te.toMessage
+              case _ => ex.getMessage
             s"[cannot display due to $msg, raw string = ${arg.toString}]"
         }
       case _ => arg.toString

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

@@ -23,6 +23,27 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   protected def maxToTextRecursions: Int = 100
 
+  def (x: Text) ~ (y: Text): Text =
+    if (x.isEmpty) y
+    else if (y.isEmpty) x
+    else Fluid(y :: x :: Nil)
+
+  def (x: Text) ~~ (y: Text): Text =
+    if (x.isEmpty) y
+    else if (y.isEmpty) x
+    else Fluid(y :: Str(" ") :: x :: Nil)
+
+  def concat(xs: Traversable[Text], sep: String = " "): Text =
+    if (sep == "\n") lines(xs)
+    else {
+      val ys = xs filterNot (_.isEmpty)
+      if (ys.isEmpty) Str("")
+      else ys reduce (_ ~ sep ~ _)
+    }
+
+  /** The given texts `xs`, each on a separate line */
+  def lines(xs: Traversable[Text]): Vertical = Vertical(xs.toList.reverse)
+
   protected final def controlled(op: => Text): Text =
     if (ctx.base.toTextRecursions < maxToTextRecursions && ctx.base.toTextRecursions < maxSummarized)
       try {
@@ -112,7 +133,8 @@ class PlainPrinter(_ctx: Context) extends Printer {
   /** Pretty-print comma-separated type arguments for a constructor to be inserted among parentheses or brackets
     * (hence with `GlobalPrec` precedence).
     */
-  protected def argsText(args: List[Type]): Text = atPrec(GlobalPrec) { Text(args.map(arg => argText(arg) ), ", ") }
+  protected def argsText(args: List[Type]): Text =
+    atPrec(GlobalPrec) { concat(args.map(arg => argText(arg) ), ", ") }
 
   /** The longest sequence of refinement types, starting at given type
    *  and following parents.
@@ -156,7 +178,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
       case tp: RefinedType =>
         val parent :: (refined: List[RefinedType @unchecked]) =
           refinementChain(tp).reverse
-        toTextLocal(parent) ~ "{" ~ Text(refined map toTextRefinement, "; ").close ~ "}"
+        toTextLocal(parent) ~ "{" ~ concat(refined map toTextRefinement, "; ").close ~ "}"
       case tp: RecType =>
         try {
           openRecs = tp :: openRecs
@@ -173,7 +195,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
             case defn.MatchCase(pat, body) => "case " ~ toText(pat) ~ " => " ~ toText(body)
             case _ => "case " ~ toText(tp)
           }
-          def casesText = Text(cases.map(caseText), "\n")
+          def casesText = concat(cases.map(caseText), "\n")
             atPrec(InfixPrec) { toText(scrutinee) } ~
             keywordStr(" match ") ~ "{" ~ casesText ~ "}" ~
             (" <: " ~ toText(bound) provided !bound.isAny)
@@ -240,7 +262,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
   protected def paramsText(lam: LambdaType): Text = {
     def paramText(name: Name, tp: Type) =
       toText(name) ~ lambdaHash(lam) ~ toTextRHS(tp)
-    Text(lam.paramNames.lazyZip(lam.paramInfos).map(paramText), ", ")
+    concat(lam.paramNames.lazyZip(lam.paramInfos).map(paramText), ", ")
   }
 
   protected def ParamRefNameString(name: Name): String = name.toString
@@ -363,22 +385,22 @@ class PlainPrinter(_ctx: Context) extends Printer {
           case tp: AliasingBounds =>
             " = " ~ toText(tp.alias)
           case TypeBounds(lo, hi) =>
-            (if (lo isRef defn.NothingClass) Text() else " >: " ~ toText(lo))
-            ~ (if hi.isAny then Text() else " <: " ~ toText(hi))
+            (if (lo isRef defn.NothingClass) Text.empty else " >: " ~ toText(lo))
+            ~ (if hi.isAny then Text.empty else " <: " ~ toText(hi))
         tparamStr ~ binder
       case tp @ ClassInfo(pre, cls, cparents, decls, selfInfo) =>
         val preText = toTextLocal(pre)
         val (tparams, otherDecls) = decls.toList partition treatAsTypeParam
         val tparamsText =
-          if (tparams.isEmpty) Text() else ("[" ~ dclsText(tparams) ~ "]").close
+          if (tparams.isEmpty) Text.empty else ("[" ~ dclsText(tparams) ~ "]").close
         val selfText: Text = selfInfo match {
-          case NoType => Text()
+          case NoType => Text.empty
           case sym: Symbol if !sym.isCompleted => "this: ? =>"
           case _ => "this: " ~ atPrec(InfixPrec) { toText(tp.selfType) } ~ " =>"
         }
         val trueDecls = otherDecls.filterNot(treatAsTypeArg)
         val declsText =
-          if (trueDecls.isEmpty || !ctx.settings.Ydebug.value) Text()
+          if (trueDecls.isEmpty || !ctx.settings.Ydebug.value) Text.empty
           else dclsText(trueDecls)
         tparamsText ~ " extends " ~ toTextParents(tp.parents) ~~ "{" ~ selfText ~ declsText ~
           "} at " ~ preText
@@ -391,7 +413,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
     }
   }
 
-  protected def toTextParents(parents: List[Type]): Text = Text(parents.map(toTextLocal), " with ")
+  protected def toTextParents(parents: List[Type]): Text = concat(parents.map(toTextLocal), " with ")
 
   protected def treatAsTypeParam(sym: Symbol): Boolean = false
   protected def treatAsTypeArg(sym: Symbol): Boolean = false
@@ -445,9 +467,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
   protected def toTextFlags(sym: Symbol): Text = toTextFlags(sym, sym.flagsUNSAFE)
 
   protected def toTextFlags(sym: Symbol, flags: FlagSet): Text =
-    Text(flags.flagStrings(privateWithinString(sym)).map(flag => stringToText(keywordStr(flag))), " ")
+    concat(flags.flagStrings(privateWithinString(sym)).map(flag => stringToText(keywordStr(flag))), " ")
 
-  def annotsText(sym: Symbol): Text = Text(sym.annotations.map(toText))
+  def annotsText(sym: Symbol): Text = concat(sym.annotations.map(toText))
 
   def dclText(sym: Symbol): Text = dclTextWithInfo(sym, sym.unforcedInfo)
 
@@ -469,7 +491,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
     if (!sym.exists) ""
     else {
       val ownr = sym.effectiveOwner
-      if (ownr.isClass && !isEmptyPrefix(ownr)) " in " ~ toText(ownr) else Text()
+      if (ownr.isClass && !isEmptyPrefix(ownr)) " in " ~ toText(ownr) else Text.empty
     }
 
   def locatedText(sym: Symbol): Text =
@@ -522,25 +544,25 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   protected def escapedString(str: String): String = str flatMap escapedChar
 
-  def dclsText(syms: List[Symbol], sep: String): Text = Text(syms map dclText, sep)
+  def dclsText(syms: List[Symbol], sep: String): Text = concat(syms map dclText, sep)
 
   def toText(sc: Scope): Text =
     ("Scope{" ~ dclsText(sc.toList) ~ "}").close
 
   def toText[T >: Untyped](tree: Tree[T]): Text = {
     def toTextElem(elem: Any): Text = elem match {
       case elem: Showable => elem.toText(this)
-      case elem: List[?] => "List(" ~ Text(elem map toTextElem, ",") ~ ")"
+      case elem: List[?] => "List(" ~ concat(elem map toTextElem, ",") ~ ")"
       case elem => elem.toString
     }
     val nodeName = tree.productPrefix
     val elems =
-      Text(tree.productIterator.map(toTextElem).toList, ", ")
+      concat(tree.productIterator.map(toTextElem).toList, ", ")
     val tpSuffix =
       if (ctx.settings.XprintTypes.value && tree.hasType)
         " | " ~ toText(tree.typeOpt)
       else
-        Text()
+        Text.empty
 
     nodeName ~ "(" ~ elems ~ tpSuffix ~ ")" ~ (Str(tree.sourcePos.toString) provided printDebug)
   }.close // todo: override in refined printer

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

@@ -157,7 +157,7 @@ abstract class Printer {
 
   /** Render elements alternating with `sep` string */
   def toText(elems: Traversable[Showable], sep: String): Text =
-    Text(elems map (_ toText this), sep)
+    concat(elems map (_ toText this), sep)
 
   /** Render elements within highest precedence */
   def toTextLocal(elems: Traversable[Showable], sep: String): Text =
@@ -172,6 +172,18 @@ abstract class Printer {
    */
   def summarized[T](depth: Int)(op: => T): T
 
+  /** A text that concatenates `x` and `y` */
+  def (x: Text) ~ (y: Text): Text
+
+  /** A text that concatenates `x` and `y` with ` ` between them if both are nonempty */
+  def (x: Text) ~~ (y: Text): Text
+
+  /** A text that concatenates all elements of `xs` with `sep` between them */
+  def concat(xs: Traversable[Text], sep: String = " "): Text
+
+  /** A text that concatenates all elements of `xs` as individual lines */
+  def lines(xs: Traversable[Text]): Text
+
   /** A plain printer without any embellishments */
   def plain: Printer
 }

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

@@ -120,7 +120,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   }
 
   override protected def toTextParents(parents: List[Type]): Text =
-    Text(parents.map(toTextLocal).map(typeText), keywordStr(" with "))
+    concat(parents.map(toTextLocal).map(typeText), keywordStr(" with "))
 
   override protected def refinementNameString(tp: RefinedType): String =
     if (tp.parent.isInstanceOf[WildcardType] || tp.refinedName == nme.WILDCARD)
@@ -303,7 +303,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     }
 
     def forText(enums: List[untpd.Tree], expr: untpd.Tree, sep: String): Text = // DD
-      changePrec(GlobalPrec) { keywordStr("for ") ~ Text(enums map enumText, "; ") ~ sep ~ toText(expr) }
+      changePrec(GlobalPrec) { keywordStr("for ") ~ concat(enums map enumText, "; ") ~ sep ~ toText(expr) }
 
     def cxBoundToText(bound: untpd.Tree): Text = bound match { // DD
       case AppliedTypeTree(tpt, _) => " : " ~ toText(tpt)
@@ -347,7 +347,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         case (sel @ untpd.ImportSelector(name, EmptyTree, EmptyTree)) :: Nil =>
           selectorText(sel)
         case _ =>
-          "{" ~ Text(selectors.map(selectorText), ", ") ~ "}"
+          "{" ~ concat(selectors.map(selectorText), ", ") ~ "}"
 
       toTextLocal(expr) ~ "." ~ selectorsText
 
@@ -480,7 +480,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         else if (tpt.symbol == defn.andType && args.length == 2)
           changePrec(AndTypePrec) { toText(args(0)) ~ " & " ~ atPrec(AndTypePrec + 1) { toText(args(1)) } }
         else
-          toTextLocal(tpt) ~ "[" ~ Text(args map argText, ", ") ~ "]"
+          toTextLocal(tpt) ~ "[" ~ concat(args map argText, ", ") ~ "]"
       case LambdaTypeTree(tparams, body) =>
         changePrec(GlobalPrec) {
           tparamsText(tparams) ~ " =>> " ~ toText(body)
@@ -560,7 +560,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           case Thicket(List(str: Literal, expr)) => strText(str) ~ "{" ~ toTextGlobal(expr) ~ "}"
           case str: Literal => strText(str)
         }
-        toText(id) ~ "\"" ~ Text(segments map segmentText, "") ~ "\""
+        toText(id) ~ "\"" ~ concat(segments map segmentText, "") ~ "\""
       case Function(args, body) =>
         var implicitSeen: Boolean = false
         var isGiven: Boolean = false
@@ -581,12 +581,12 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           case _ =>
             "("
             ~ keywordText("erased ").provided(isErased)
-            ~ Text(args.map(argToText), ", ")
+            ~ concat(args.map(argToText), ", ")
             ~ ")"
         }
         argsText ~ " " ~ arrow(isGiven) ~ " " ~ toText(body)
       case PolyFunction(targs, body) =>
-        val targsText = "[" ~ Text(targs.map((arg: Tree) => toText(arg)), ", ") ~ "]"
+        val targsText = "[" ~ concat(targs.map((arg: Tree) => toText(arg)), ", ") ~ "]"
         changePrec(GlobalPrec) {
           targsText ~ " => " ~ toText(body)
         }
@@ -805,8 +805,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         if (constr.mods.hasAnnotations && !constr.mods.hasFlags) modsText = modsText ~~ " this"
         withEnclosingDef(constr) { addVparamssText(tparamsTxt ~~ modsText, vparamss) }
       }
-    val parentsText = Text(impl.parents.map(constrText), if (ofNew) keywordStr(" with ") else ", ")
-    val derivedText = Text(impl.derived.map(toText(_)), ", ")
+    val parentsText = concat(impl.parents.map(constrText), if (ofNew) keywordStr(" with ") else ", ")
+    val derivedText = concat(impl.derived.map(toText(_)), ", ")
     val selfText = {
       val selfName = if (self.name == nme.WILDCARD) keywordStr("this") else self.name.toString
       (selfName ~ optText(self.tpt)(": " ~ _) ~ " =>").close
@@ -870,7 +870,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     val annotations =
       if (sym.exists) sym.annotations.filterNot(ann => dropAnnotForModText(ann.symbol)).map(_.tree)
       else mods.annotations.filterNot(tree => dropAnnotForModText(tree.symbol))
-    Text(annotations.map(annotText), " ") ~~ flagsText ~~ (Str(kw) provided !suppressKw)
+    concat(annotations.map(annotText), " ") ~~ flagsText ~~ (Str(kw) provided !suppressKw)
   }
 
   def optText(name: Name)(encl: Text => Text): Text =
@@ -949,7 +949,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     }
 
   override def toText(denot: Denotation): Text = denot match {
-    case denot: MultiDenotation => Text(denot.alternatives.map(dclText), " <and> ")
+    case denot: MultiDenotation => concat(denot.alternatives.map(dclText), " <and> ")
     case NoDenotation => "NoDenotation"
     case _ =>
       if (denot.symbol.exists) toText(denot.symbol)

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

@@ -134,16 +134,6 @@ object Texts {
       sb.toString
     }
 
-    def ~ (that: Text): Text =
-      if (this.isEmpty) that
-      else if (that.isEmpty) this
-      else Fluid(that :: this :: Nil)
-
-    def ~~ (that: Text): Text =
-      if (this.isEmpty) that
-      else if (that.isEmpty) this
-      else Fluid(that :: Str(" ") :: this :: Nil)
-
     def over (that: Text): Vertical =
       if (this.isVertical) Vertical(that :: this.relems)
       else Vertical(that :: this :: Nil)
@@ -152,21 +142,7 @@ object Texts {
   object Text {
 
     /** The empty text */
-    def apply(): Text = Str("")
-
-    /** A concatenation of elements in `xs` and interspersed with
-     *  separator strings `sep`.
-     */
-    def apply(xs: Traversable[Text], sep: String = " "): Text =
-      if (sep == "\n") lines(xs)
-      else {
-        val ys = xs filterNot (_.isEmpty)
-        if (ys.isEmpty) Str("")
-        else ys reduce (_ ~ sep ~ _)
-      }
-
-    /** The given texts `xs`, each on a separate line */
-    def lines(xs: Traversable[Text]): Vertical = Vertical(xs.toList.reverse)
+    def empty: Text = Str("")
 
     implicit class textDeco(text: => Text) {
       def provided(cond: Boolean): Text = if (cond) text else Str("")