Add -print-lines setting

Author: nicolasstucki

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

@@ -43,7 +43,10 @@ class ScalaSettings extends Settings.SettingGroup {
   val rewrite = OptionSetting[Rewrites]("-rewrite", "When used in conjunction with -language:Scala2 rewrites sources to migrate to new syntax")
   val silentWarnings = BooleanSetting("-nowarn", "Silence all warnings.")
   val fromTasty = BooleanSetting("-from-tasty", "Compile classes from tasty in classpath. The arguments are used as class names.")
+
+  /** Decompiler settings */
   val printTasty = BooleanSetting("-print-tasty", "Prints the raw tasty when decompiling.")
+  val printLines = BooleanSetting("-print-lines", "Show source code line numbers.")
 
   /** -X "Advanced" settings
    */

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

@@ -16,13 +16,16 @@ import config.Config
 import transform.SymUtils._
 import scala.annotation.switch
 import language.implicitConversions
+import dotty.tools.dotc.util.SourcePosition
+
 
 class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
   /** A stack of enclosing DefDef, TypeDef, or ClassDef, or ModuleDefs nodes */
   private[this] var enclosingDef: untpd.Tree = untpd.EmptyTree
   private[this] var myCtx: Context = _ctx
   private[this] var printPos = ctx.settings.Yprintpos.value
+  private[this] val printLines = ctx.settings.printLines.value
   override protected[this] implicit def ctx: Context = myCtx
 
   def withEnclosingDef(enclDef: Tree[_ >: Untyped])(op: => Text): Text = {
@@ -287,9 +290,17 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       if (ctx.settings.uniqid.value && tree.hasType && tree.symbol.exists) s"#${tree.symbol.id}" else ""
     }
 
-    def nameIdText(tree: untpd.NameTree): Text =
-      if (tree.hasType && tree.symbol.exists) nameString(tree.symbol)
+    def nameIdText(tree: untpd.NameTree): Text = {
+      if (tree.hasType && tree.symbol.exists) {
+        val str: Text = nameString(tree.symbol)
+        tree match {
+          case tree: RefTree => withPos(str, tree.pos)
+          case tree: MemberDef => withPos(str, tree.namePos)
+          case _ => str
+        }
+      }
       else toText(tree.name) ~ idText(tree)
+    }
 
     def toTextTemplate(impl: Template, ofNew: Boolean = false): Text = {
       val Template(constr @ DefDef(_, tparams, vparamss, _, _), parents, self, _) = impl
@@ -343,7 +354,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         tree.typeOpt match {
           case tp: NamedType if name != nme.WILDCARD =>
             val pre = if (tp.symbol is JavaStatic) tp.prefix.widen else tp.prefix
-            toTextPrefix(pre) ~ selectionString(tp)
+            toTextPrefix(pre) ~ withPos(selectionString(tp), tree.pos)
           case _ =>
             toText(name)
         }
@@ -365,8 +376,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         toTextLocal(fun) ~ "[" ~ toTextGlobal(args, ", ") ~ "]"
       case Literal(c) =>
         tree.typeOpt match {
-          case ConstantType(tc) => toText(tc)
-          case _ => toText(c)
+          case ConstantType(tc) => withPos(toText(tc), tree.pos)
+          case _ => withPos(toText(c), tree.pos)
         }
       case New(tpt) =>
         "new " ~ {
@@ -517,7 +528,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case SymbolLit(str) =>
         "'" + str
       case InterpolatedString(id, segments) =>
-        def strText(str: Literal) = Str(escapedString(str.const.stringValue))
+        def strText(str: Literal) = withPos(escapedString(str.const.stringValue), tree.pos)
         def segmentText(segment: Tree) = segment match {
           case Thicket(List(str: Literal, expr)) => strText(str) ~ "{" ~ toTextGlobal(expr) ~ "}"
           case str: Literal => strText(str)
@@ -694,4 +705,12 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   }
 
   override def plain = new PlainPrinter(_ctx)
+
+  def withPos(txt: Text, pos: SourcePosition): Text = {
+    if (!printLines || !pos.exists) txt
+    else txt match {
+      case Str(s, _, _) => Str(s, pos.line, pos.endLine)
+      case _ => txt
+    }
+  }
 }

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

@@ -1,6 +1,5 @@
 package dotty.tools.dotc
 package printing
-import core.Contexts.Context
 import language.implicitConversions
 
 object Texts {
@@ -12,7 +11,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
     }
@@ -25,7 +24,7 @@ object Texts {
     def close = new Closed(relems)
 
     def remaining(width: Int): Int = this match {
-      case Str(s) =>
+      case Str(s, _, _) =>
         width - s.length
       case Fluid(Nil) =>
         width
@@ -37,15 +36,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) =>
+      case Str(s2, start1, end1) =>
         this match {
-          case Str(s1) => Str(s1 + s2)
-          case Fluid(Str(s1) :: prev) => Fluid(Str(s1 + s2) :: prev)
+          case Str(s1, start2, end2) => Str(s1 + s2, start1 min start2, end1 max end2)
+          case Fluid(Str(s1, start2, end2) :: prev) => Fluid(Str(s1 + s2, start1 min start2, end1 max end2) :: prev)
           case Fluid(relems) => Fluid(that :: relems)
         }
       case Fluid(relems) =>
@@ -66,7 +65,7 @@ object Texts {
     }
 
     def layout(width: Int): Text = this match {
-      case Str(_) =>
+      case Str(s, _, _) =>
         this
       case Fluid(relems) =>
         ((Str(""): Text) /: relems.reverse)(_.append(width)(_))
@@ -75,13 +74,13 @@ object Texts {
     }
 
     def map(f: String => String): Text = this match {
-      case Str(s) => Str(f(s))
+      case Str(s, start, end) => Str(f(s), start, end)
       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
@@ -94,14 +93,18 @@ object Texts {
     }
 
     private def indented: Text = this match {
-      case Str(s) => Str((" " * indentMargin) + s)
+      case Str(s, start, end) => Str((" " * indentMargin) + s, start, end)
       case Fluid(relems) => Fluid(relems map (_.indented))
       case Vertical(relems) => Vertical(relems map (_.indented))
     }
 
     def print(sb: StringBuilder): Unit = this match {
-      case Str(s) =>
+      case Str(s, start, end) =>
         sb.append(s)
+        if (start == end)
+          sb.append(s"   // @line ${start + 1}")
+        else if (start != Int.MaxValue)
+          sb.append(s"   // @lines ${start + 1} to ${end + 1}")
       case _ =>
         var follow = false
         for (elem <- relems.reverse) {
@@ -155,7 +158,7 @@ object Texts {
     def lines(xs: Traversable[Text]) = Vertical(xs.toList.reverse)
   }
 
-  case class Str(s: String) extends Text {
+  case class Str(s: String, startLine: Int = Int.MaxValue, endLine: Int = -1) extends Text {
     override def relems: List[Text] = List(this)
   }