Drop -print-lines option

It does not seem to be used anywhere and it complicates text formatting considerably.

Author: odersky

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -62,7 +62,6 @@ trait AllScalaSettings extends CommonScalaSettings, PluginSettings, VerboseSetti
 
   /* Decompiler settings */
   val printTasty: Setting[Boolean] = BooleanSetting(RootSetting, "print-tasty", "Prints the raw tasty.", aliases = List("--print-tasty"))
-  val printLines: Setting[Boolean] = BooleanSetting(RootSetting, "print-lines", "Show source code line numbers.", aliases = List("--print-lines"))
 
   /* Scala.js-related settings */
   val scalajsGenStaticForwardersForNonTopLevelObjects: Setting[Boolean] = BooleanSetting(RootSetting, "scalajs-genStaticForwardersForNonTopLevelObjects", "Generate static forwarders even for non-top-level objects (Scala.js only).")

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

@@ -245,7 +245,7 @@ object Decorators {
   end extension
 
   extension (text: Text)
-    def show(using Context): String = text.mkString(ctx.settings.pageWidth.value, ctx.settings.printLines.value)
+    def show(using Context): String = text.mkString(ctx.settings.pageWidth.value)
 
   /** Test whether a list of strings representing phases contains
    *  a given phase. See [[config.CompilerCommand#explainAdvanced]] for the

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

@@ -49,9 +49,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   protected def controlled(op: => Text): Text = limiter.controlled(op)
 
-  def Str(str: String, lineRange: LineRange = EmptyLineRange): Str =
+  def Str(str: String): Str =
     limiter.register(str)
-    Texts.Str(str, lineRange)
+    Texts.Str(str)
 
   given stringToText: Conversion[String, Text] = Str(_)
 

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

@@ -41,7 +41,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   private var enclosingDef: untpd.Tree = untpd.EmptyTree
   private var myCtx: Context = super.printerContext
   private var printPos = ctx.settings.YprintPos.value
-  private val printLines = ctx.settings.printLines.value
 
   override def printerContext: Context = myCtx
 
@@ -481,7 +480,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case id @ Ident(name) =>
         val txt = tree.typeOpt match {
           case tp: NamedType if name != nme.WILDCARD =>
-            toTextPrefixOf(tp) ~ withPos(selectionString(tp), tree.sourcePos)
+            toTextPrefixOf(tp) ~ selectionString(tp)
           case _ =>
             toText(name)
         }
@@ -517,8 +516,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         typeApplyText(tree)
       case Literal(c) =>
         tree.typeOpt match {
-          case ConstantType(tc) => withPos(toText(tc), tree.sourcePos)
-          case _ => withPos(toText(c), tree.sourcePos)
+          case ConstantType(tc) => toText(tc)
+          case _ => toText(c)
         }
       case New(tpt) =>
         keywordStr("new ") ~ {
@@ -729,8 +728,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case SymbolLit(str) =>
         "'" + str
       case InterpolatedString(id, segments) =>
-        def strText(str: Literal) = withPos(escapedString(str.const.stringValue), tree.sourcePos)
-        def segmentText(segment: Tree) = segment match {
+        def strText(str: Literal) = escapedString(str.const.stringValue)
+        def segmentText(segment: Tree): Text = segment match {
           case Thicket(List(str: Literal, expr)) => strText(str) ~ "{" ~ toTextGlobal(expr) ~ "}"
           case str: Literal => strText(str)
         }
@@ -968,14 +967,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     tree.hasType && tree.symbol.exists && ctx.settings.YprintSyms.value
 
   protected def nameIdText[T <: Untyped](tree: NameTree[T]): Text =
-    if (tree.hasType && tree.symbol.exists && tree.symbol.isType == tree.name.isTypeName) {
-      val str = nameString(tree.symbol)
-      tree match {
-        case tree: RefTree => withPos(str, tree.sourcePos)
-        case tree: MemberDef => withPos(str, tree.sourcePos.withSpan(tree.nameSpan))
-        case _ => str
-      }
-    }
+    if tree.hasType && tree.symbol.exists && tree.symbol.isType == tree.name.isTypeName
+    then nameString(tree.symbol)
     else toText(tree.name) ~ idText(tree)
 
   private def toTextOwner(tree: Tree[?]) =
@@ -1280,11 +1273,4 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   }
 
   override def plain: PlainPrinter = new PlainPrinter(_ctx)
-
-  private def withPos(txt: Text, pos: SourcePosition): Text =
-    if (!printLines || !pos.exists) txt
-    else txt match {
-      case Str(s, _) => Str(s, LineRange(pos.line, pos.endLine))
-      case _ => txt
-    }
 }

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

@@ -14,7 +14,7 @@ object Texts {
     def relems: List[Text]
 
     def isEmpty: Boolean = this match {
-      case Str(s, _) => s.isEmpty
+      case Str(s) => s.isEmpty
       case Fluid(relems) => relems forall (_.isEmpty)
       case Vertical(relems) => relems.isEmpty
     }
@@ -32,7 +32,7 @@ object Texts {
     def close: Text = if isSplittable then Closed(relems) else this
 
     def remaining(width: Int): Int = this match {
-      case Str(s, _) =>
+      case Str(s) =>
         width - lengthWithoutAnsi(s)
       case Fluid(Nil) =>
         width
@@ -44,15 +44,15 @@ object Texts {
     }
 
     def lastLine: String = this match {
-      case Str(s, _) => s
+      case Str(s) => s
       case _ => relems.head.lastLine
     }
 
     def appendToLastLine(that: Text): Text = that match {
-      case Str(s2, lines1) =>
+      case Str(s2) =>
         this match {
-          case Str(s1, lines2) => Str(s1 + s2, lines1 `union` lines2)
-          case Fluid(Str(s1, lines2) :: prev) => Fluid(Str(s1 + s2, lines1 `union` lines2) :: prev)
+          case Str(s1) => Str(s1 + s2)
+          case Fluid(Str(s1) :: prev) => Fluid(Str(s1 + s2) :: prev)
           case Fluid(relems) => Fluid(that :: relems)
           case Vertical(_) => throw new IllegalArgumentException("Unexpected Vertical.appendToLastLine")
         }
@@ -77,7 +77,7 @@ object Texts {
       ansi.matcher(str).replaceAll("").length
 
     def layout(width: Int): Text = this match {
-      case Str(s, _) =>
+      case Str(s) =>
         this
       case Fluid(relems) =>
         relems.reverse.foldLeft(Str(""): Text)(_.append(width)(_))
@@ -86,13 +86,13 @@ object Texts {
     }
 
     def map(f: String => String): Text = this match {
-      case Str(s, lines) => Str(f(s), lines)
+      case Str(s) => Str(f(s))
       case Fluid(relems) => Fluid(relems.map(_.map(f)))
       case Vertical(relems) => Vertical(relems.map(_.map(f)))
     }
 
     def stripPrefix(pre: String): Text = this match {
-      case Str(s, _) =>
+      case Str(s) =>
         if (s.startsWith(pre)) s.drop(pre.length) else s
       case Fluid(relems) =>
         val elems = relems.reverse
@@ -105,43 +105,27 @@ object Texts {
     }
 
     private def indented: Text = this match {
-      case Str(s, lines) => Str((" " * indentMargin) + s, lines)
+      case Str(s) => Str((" " * indentMargin) + s)
       case Fluid(relems) => Fluid(relems map (_.indented))
       case Vertical(relems) => Vertical(relems map (_.indented))
     }
 
-    def print(sb: StringBuilder, numberWidth: Int): Unit = this match {
-      case Str(s, lines) =>
-        if (numberWidth != 0) {
-          val ln = lines.show
-          if (ln.nonEmpty) {
-            val pad = (numberWidth - ln.length - 1)
-            assert(pad >= 0)
-            sb.append(" " * pad)
-            sb.append(ln)
-            sb.append("|")
-          }
-        }
+    def print(sb: StringBuilder): Unit = this match {
+      case Str(s) =>
         sb.append(s.replaceAll("[ ]+$", ""))
       case _ =>
         var follow = false
         for (elem <- relems.reverse) {
           if (follow) sb.append(System.lineSeparator)
-          elem.print(sb, numberWidth)
+          elem.print(sb)
           follow = true
         }
     }
 
-    def maxLine: Int = this match {
-      case Str(_, lines) => lines.end
-      case _ => relems.foldLeft(-1)((acc, relem) => acc max relem.maxLine)
-    }
-
-    def mkString(width: Int = Int.MaxValue, withLineNumbers: Boolean = false): String = {
+    def mkString(width: Int = Int.MaxValue): String = {
       val sb = new StringBuilder
       // width display can be upto a range "n-n" where 1 <= n <= maxLine+1
-      val numberWidth = if (withLineNumbers) (2 * (maxLine + 1).toString.length) + 2 else 0
-      layout(width - numberWidth).print(sb, numberWidth)
+      layout(width).print(sb)
       sb.toString
     }
 
@@ -190,12 +174,9 @@ object Texts {
 
   }
 
-  case class Str(s: String, lineRange: LineRange = EmptyLineRange) extends Text {
+  case class Str(s: String) extends Text:
     override def relems: List[Text] = List(this)
-    override def toString = this match
-      case Str(s, EmptyLineRange) => s"Str($s)"
-      case Str(s, lineRange)      => s"Str($s, $lineRange)"
-  }
+    override def toString = s"Str($s)"
 
   case class Vertical(relems: List[Text]) extends Text
   case class Fluid(relems: List[Text]) extends Text

compiler/test/dotty/tools/dotc/TupleShowTests.scala

@@ -52,7 +52,7 @@ class TupleShowTests extends DottyTest:
     ))
     chkEq(exp, obt)
 
-  @Test def tup3_show10 = chkEq("(Int,\n  Long,\n  Short)".normEOL, tup3.toText(ctx.printer).mkString(10, false))
+  @Test def tup3_show10 = chkEq("(Int,\n  Long,\n  Short)".normEOL, tup3.toText(ctx.printer).mkString(10))
 
   val res21: String =
     """|(Int, Int, Int, Int, Int, Long, Long, Long, Long, Long, Int, Int, Int, Int,

docs/_docs/contributing/debugging/other-debugging.md

@@ -121,7 +121,6 @@ So, the error happened in the Namer's `checkNoConflict` method (after which all
 Printing from the `show` and `-Xprint` is done from the Printers framework (discussed in more details below). The following settings influence the output of the printers:
 
 ```scala
-val printLines        = BooleanSetting("-print-lines"        , "Show source code line numbers.") withAbbreviation "--print-lines"
 val uniqid            = BooleanSetting("-uniqid"             , "Uniquely tag all identifiers in debugging output.") withAbbreviation "--unique-id"
 val XprintInline      = BooleanSetting("-Xprint-inline"      , "Show  where inlined code comes from")
 val XprintTypes       = BooleanSetting("-Xprint-types"       , "Print tree types (debugging option).")

presentation-compiler/src/main/dotty/tools/pc/RawScalaPresentationCompiler.scala

@@ -65,7 +65,7 @@ case class RawScalaPresentationCompiler(
 
   override val scalaVersion = BuildInfo.scalaVersion
 
-  private val forbiddenOptions = Set("-print-lines", "-print-tasty")
+  private val forbiddenOptions = Set("-print-tasty")
   private val forbiddenDoubleOptions = Set.empty[String]
 
   val driverSettings =

presentation-compiler/src/main/dotty/tools/pc/ScalaPresentationCompiler.scala

@@ -72,7 +72,7 @@ case class ScalaPresentationCompiler(
 
   val scalaVersion = BuildInfo.scalaVersion
 
-  private val forbiddenOptions = Set("-print-lines", "-print-tasty")
+  private val forbiddenOptions = Set("-print-tasty")
   private val forbiddenDoubleOptions = Set.empty[String]
 
 

tests/neg/i13026.scala

@@ -1,5 +1,3 @@
-//> using options -print-lines
-
 val x: Int = "not an int" // error
 val y: Int = "not an int" // error
 def foo(x: Any) = x.foo // error