Change -Yprint-user to -Yprint-decompile

Author: nicolasstucki

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

@@ -101,7 +101,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val YplainPrinter = BooleanSetting("-Yplain-printer", "Pretty-print using a plain printer.")
   val YprintSyms = BooleanSetting("-Yprint-syms", "when printing trees print info in symbols instead of corresponding info in trees.")
   val YprintDebug = BooleanSetting("-Yprint-debug", "when printing trees, print some extra information useful for debugging.")
-  val YprintUser = BooleanSetting("-Yprint-user", "Print the program using user friendly abstractions.")
+  val YprintDecompile = BooleanSetting("-Yprint-decompile", "Print the program using user friendly abstractions.")
   val YshowPrintErrors = BooleanSetting("-Yshow-print-errors", "don't suppress exceptions thrown during tree printing.")
   val YtestPickler = BooleanSetting("-Ytest-pickler", "self-test for pickling functionality; should be used with -Ystop-after:pickler")
   val YcheckReentrant = BooleanSetting("-Ycheck-reentrant", "check that compiled program does not contain vars that can be accessed from a global root.")

compiler/src/dotty/tools/dotc/decompiler/Main.scala

@@ -16,6 +16,6 @@ object Main extends dotc.Driver {
   override def setup(args0: Array[String], rootCtx: Context): (List[String], Context) = {
     var args = args0.filter(a => a != "-decompile")
     args = if (args.contains("-from-tasty")) args else "-from-tasty" +: args
-    super.setup("-Yprint-user" +: args, rootCtx)
+    super.setup("-Yprint-decompile" +: args, rootCtx)
   }
 }

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

@@ -28,8 +28,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   private[this] var myCtx: Context = _ctx
   private[this] var printPos = ctx.settings.YprintPos.value
   private[this] val printLines = ctx.settings.printLines.value
-  private[this] val YprintUser =
-   ctx.settings.YprintUser.value && !ctx.phases.dropWhile(!_.isInstanceOf[FirstTransform]).contains(ctx.phase)
+  private[this] val YprintDecompile =
+    ctx.settings.YprintDecompile.value && !ctx.phases.dropWhile(!_.isInstanceOf[FirstTransform]).contains(ctx.phase)
   override protected[this] implicit def ctx: Context = myCtx
 
   def withEnclosingDef(enclDef: Tree[_ >: Untyped])(op: => Text): Text = {
@@ -282,7 +282,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       val flags = mods.flags & flagMask
       val flagsText = if (flags.isEmpty) "" else keywordStr((mods.flags & flagMask).toString)
       val annotations =
-        if (YprintUser) mods.annotations.filter(_.tpe != defn.SourceFileAnnotType)
+        if (YprintDecompile) mods.annotations.filter(_.tpe != defn.SourceFileAnnotType)
         else mods.annotations
       Text(annotations.map(annotText), " ") ~~ flagsText ~~ (Str(kw) provided !suppressKw)
     }
@@ -428,7 +428,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         }
       case Closure(env, ref, target) =>
         ("closure(" ~ (toTextGlobal(env, ", ") ~ " | " provided env.nonEmpty) ~
-        toTextGlobal(ref) ~ (":" ~ toText(target) provided !target.isEmpty) ~ ")").provided(!YprintUser)
+        toTextGlobal(ref) ~ (":" ~ toText(target) provided !target.isEmpty) ~ ")").provided(!YprintDecompile)
       case Match(sel, cases) =>
         if (sel.isEmpty) blockText(cases)
         else changePrec(GlobalPrec) { toText(sel) ~ keywordStr(" match ") ~ blockText(cases) }
@@ -489,10 +489,10 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           modText(tree.mods, keywordStr(if (tree.mods is Mutable) "var" else "val")) ~~
           valDefText(nameIdText(tree)) ~ optAscription(tpt) ~
           withEnclosingDef(tree) { optText(tree.rhs)(" = " ~ _) }
-        }.provided(!YprintUser || !tree.symbol.is(Module))
+        }.provided(!YprintDecompile || !tree.symbol.is(Module))
       case tree @ DefDef(name, tparams, vparamss, tpt, _) =>
         dclTextOr {
-          val printLambda = tree.symbol.isAnonymousFunction && YprintUser
+          val printLambda = tree.symbol.isAnonymousFunction && YprintDecompile
           val prefix = modText(tree.mods, keywordStr("def")) ~~ valDefText(nameIdText(tree)) provided (!printLambda)
           withEnclosingDef(tree) {
             addVparamssText(prefix ~ tparamsText(tparams), vparamss) ~ optAscription(tpt).provided(!printLambda) ~
@@ -508,7 +508,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         def recur(rhs: Tree, tparamsTxt: => Text): Text = rhs match {
           case impl: Template =>
             val decl =
-              if (!YprintUser || !tree.mods.is(Module)) modText(tree.mods, keywordStr(if ((tree).mods is Trait) "trait" else "class"))
+              if (!YprintDecompile || !tree.mods.is(Module)) modText(tree.mods, keywordStr(if ((tree).mods is Trait) "trait" else "class"))
               else modText(tree.mods &~ (Final | Module), keywordStr("object"))
             decl ~~ typeText(nameIdText(tree)) ~ withEnclosingDef(tree) { toTextTemplate(impl) } ~
             (if (tree.hasType && ctx.settings.verbose.value) i"[decls = ${tree.symbol.info.decls}]" else "")