-Vphases takes names to mark, -Vprint is typer

Distinguish whether a setting was "set" by the user.

Author: som-snytt

compiler/src/dotty/tools/dotc/Run.scala

@@ -342,7 +342,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
             profiler.onPhase(phase):
               try units = phase.runOn(units)
               catch case _: InterruptedException => cancelInterrupted()
-            if (ctx.settings.Xprint.value.containsPhase(phase))
+            for (printAt <- ctx.settings.Xprint.userValue if printAt.containsPhase(phase))
               for (unit <- units)
                 def printCtx(unit: CompilationUnit) = phase.printingContext(
                   ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))

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

@@ -158,12 +158,15 @@ trait CliCommand:
     private def columnate(sb: StringBuilder, texts: List[List[(String, String)]])(using Context): Unit =
       import Highlighting.*
       val colors = Seq(Green(_), Yellow(_), Magenta(_), Cyan(_), Red(_))
+      val bolds = Seq(GreenB(_), YellowB(_), MagentaB(_), CyanB(_), RedB(_))
       val nocolor = texts.length == 1
       def color(index: Int): String => Highlight = if nocolor then NoColor(_) else colors(index % colors.length)
+      def colorB(index: Int): String => Highlight = if nocolor then NoColor(_) else bolds(index % colors.length)
       val maxCol = ctx.settings.pageWidth.value
       val field1 = maxField.min(texts.flatten.map(_._1.length).filter(_ < maxField).max) // widest field under maxField
       val field2 = if field1 + separation + maxField < maxCol then maxCol - field1 - separation else 0 // skinny window -> terminal wrap
-      val separator = " " * separation
+      val toMark = ctx.settings.XshowPhases.value.toSet
+      def separator(name: String) = if toMark(name) then "->" + " " * (separation - 2) else " " * separation
       val EOL = "\n"
       def formatField1(text: String): String = if text.length <= field1 then text.padLeft(field1) else text + EOL + "".padLeft(field1)
       def formatField2(text: String): String =
@@ -172,15 +175,15 @@ trait CliCommand:
           else
             fld.lastIndexOf(" ", field2) match
               case -1 => List(fld)
-              case i  => val (prefix, rest) = fld.splitAt(i) ; prefix :: loopOverField2(rest.trim)
-        text.split("\n").toList.flatMap(loopOverField2).filter(_.nonEmpty).mkString(EOL + "".padLeft(field1) + separator)
+              case i  => val (prefix, rest) = fld.splitAt(i); prefix :: loopOverField2(rest.trim)
+        text.split("\n").toList.flatMap(loopOverField2).filter(_.nonEmpty).mkString(EOL + "".padLeft(field1) + separator("no-phase"))
       end formatField2
       def format(first: String, second: String, index: Int, colorPicker: Int => String => Highlight) =
         sb.append(colorPicker(index)(formatField1(first)).show)
-          .append(separator)
+          .append(colorPicker(index)(separator(first)).show)
           .append(formatField2(second))
           .append(EOL): Unit
-      def fancy(first: String, second: String, index: Int) = format(first, second, index, color)
+      def fancy(first: String, second: String, index: Int) = format(first, second, index, if toMark(first) then colorB else color)
       def plain(first: String, second: String) = format(first, second, 0, _ => NoColor(_))
 
       if heading1.nonEmpty then

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

@@ -18,10 +18,10 @@ abstract class CompilerCommand extends CliCommand:
         else if (settings.Xhelp.value) xusageMessage
         else if (settings.Yhelp.value) yusageMessage
         else if (settings.showPlugins.value) ctx.base.pluginDescriptions
-        else if (settings.XshowPhases.value) phasesMessage
+        else if settings.XshowPhases.isPresentIn(summon[SettingsState]) then phasesMessage
         else ""
 
   final def isHelpFlag(using settings: ConcreteSettings)(using SettingsState): Boolean =
     import settings.*
-    val flags = Set(help, Vhelp,  Whelp, Xhelp, Yhelp, showPlugins, XshowPhases)
-    flags.exists(_.value) || allSettings.exists(isHelping)
+    val flags = Set(help, Vhelp,  Whelp, Xhelp, Yhelp, showPlugins)
+    flags.exists(_.value) || XshowPhases.isPresentIn(summon[SettingsState]) || allSettings.exists(isHelping)

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

@@ -142,8 +142,8 @@ private sealed trait PluginSettings:
 private sealed trait VerboseSettings:
   self: SettingGroup =>
   val Vhelp: Setting[Boolean] = BooleanSetting(VerboseSetting, "V", "Print a synopsis of verbose options.")
-  val Xprint: Setting[List[String]] = PhasesSetting(VerboseSetting, "Vprint", "Print out program after", aliases = List("-Xprint"))
-  val XshowPhases: Setting[Boolean] = BooleanSetting(VerboseSetting, "Vphases", "List compiler phases.", aliases = List("-Xshow-phases"))
+  val Xprint: Setting[List[String]] = PhasesSetting(VerboseSetting, "Vprint", "Print out program after", default = "typer", aliases = List("-Xprint"))
+  val XshowPhases: Setting[List[String]] = PhasesSetting(VerboseSetting, "Vphases", "List compiler phases.", default = "none", aliases = List("-Xshow-phases"))
 
   val Vprofile: Setting[Boolean] = BooleanSetting(VerboseSetting, "Vprofile", "Show metrics about sources and internal representations to estimate compile-time complexity.")
   val VprofileSortedBy = ChoiceSetting(VerboseSetting, "Vprofile-sorted-by", "key", "Show metrics about sources and internal representations sorted by given column name", List("name", "path", "lines", "tokens", "tasty", "complexity"), "")

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

@@ -17,6 +17,8 @@ import dotty.tools.dotc.config.Settings.Setting.ChoiceWithHelp
 
 object Settings:
 
+  private inline def classTag[T](using ctag: ClassTag[T]): ClassTag[T] = ctag
+
   val BooleanTag: ClassTag[Boolean]      = ClassTag.Boolean
   val IntTag: ClassTag[Int]              = ClassTag.Int
   val StringTag: ClassTag[String]        = ClassTag(classOf[String])
@@ -104,21 +106,25 @@ object Settings:
     assert(legacyArgs || !choices.exists(_.contains("")), s"Empty string is not supported as a choice for setting $name")
     // Without the following assertion, it would be easy to mistakenly try to pass a file to a setting that ignores invalid args.
     // Example: -opt Main.scala would be interpreted as -opt:Main.scala, and the source file would be ignored.
-    assert(!(summon[ClassTag[T]] == ListTag && ignoreInvalidArgs), s"Ignoring invalid args is not supported for multivalue settings: $name")
+    assert(!(classTag[T] == ListTag && ignoreInvalidArgs), s"Ignoring invalid args is not supported for multivalue settings: $name")
 
     val allFullNames: List[String] = s"$name" :: s"-$name" :: aliases
 
+    def isPresentIn(state: SettingsState): Boolean = state.wasChanged(idx)
+
     def valueIn(state: SettingsState): T = state.value(idx).asInstanceOf[T]
 
+    def userValueIn(state: SettingsState): Option[T] = if isPresentIn(state) then Some(valueIn(state)) else None
+
     def updateIn(state: SettingsState, x: Any): SettingsState = x match
       case _: T => state.update(idx, x)
-      case _ => throw IllegalArgumentException(s"found: $x of type ${x.getClass.getName}, required: ${summon[ClassTag[T]]}")
+      case _ => throw IllegalArgumentException(s"found: $x of type ${x.getClass.getName}, required: ${classTag[T]}")
 
     def isDefaultIn(state: SettingsState): Boolean = valueIn(state) == default
 
-    def isMultivalue: Boolean = summon[ClassTag[T]] == ListTag
+    def isMultivalue: Boolean = classTag[T] == ListTag
 
-    def acceptsNoArg: Boolean = summon[ClassTag[T]] == BooleanTag || summon[ClassTag[T]] == OptionTag || choices.exists(_.contains(""))
+    def acceptsNoArg: Boolean = classTag[T] == BooleanTag || classTag[T] == OptionTag || choices.exists(_.contains(""))
 
     def legalChoices: String =
       choices match
@@ -134,7 +140,7 @@ object Settings:
         * Updates the value in state
         *
         * @param getValue it is crucial that this argument is passed by name, as [setOutput] have side effects.
-        * @param argStringValue string value of currently proccessed argument that will be used to set deprecation replacement
+        * @param argStringValue string value of currently processed argument that will be used to set deprecation replacement
         * @param args remaining arguments to process
         * @return new argumment state
         */
@@ -170,11 +176,17 @@ object Settings:
 
       def missingArg =
         val msg = s"missing argument for option $name"
-        if ignoreInvalidArgs then state.warn(msg + ", the tag was ignored") else state.fail(msg)
+        if ignoreInvalidArgs then state.warn(s"$msg, the tag was ignored") else state.fail(msg)
 
       def invalidChoices(invalid: List[String]) =
         val msg = s"invalid choice(s) for $name: ${invalid.mkString(",")}"
-        if ignoreInvalidArgs then state.warn(msg + ", the tag was ignored") else state.fail(msg)
+        if ignoreInvalidArgs then state.warn(s"$msg, the tag was ignored") else state.fail(msg)
+
+      def isEmptyDefault = default == null.asInstanceOf[T] || classTag[T].match
+        case ListTag => default.asInstanceOf[List[?]].isEmpty
+        case StringTag => default.asInstanceOf[String].isEmpty
+        case OptionTag => default.asInstanceOf[Option[?]].isEmpty
+        case _ => false
 
       def setBoolean(argValue: String, args: List[String]) =
         if argValue.equalsIgnoreCase("true") || argValue.isEmpty then update(true, argValue, args)
@@ -203,11 +215,11 @@ object Settings:
       def setOutput(argValue: String, args: List[String]) =
         val path = Directory(argValue)
         val isJar = path.ext.isJar
-        if (!isJar && !path.isDirectory) then
+        if !isJar && !path.isDirectory then
           state.fail(s"'$argValue' does not exist or is not a directory or .jar file")
         else
           /* Side effect, do not change this method to evaluate eagerly */
-          def output = if (isJar) JarArchive.create(path) else new PlainDirectory(path)
+          def output = if isJar then JarArchive.create(path) else new PlainDirectory(path)
           update(output, argValue, args)
 
       def setVersion(argValue: String, args: List[String]) =
@@ -228,22 +240,28 @@ object Settings:
           case _ => update(strings, argValue, args)
 
       def doSet(argRest: String) =
-        ((summon[ClassTag[T]], args): @unchecked) match
-          case (BooleanTag, _) =>
+        classTag[T] match
+          case BooleanTag =>
             if sstate.wasChanged(idx) && preferPrevious then ignoreValue(args)
             else setBoolean(argRest, args)
-          case (OptionTag, _) =>
+          case OptionTag =>
             update(Some(propertyClass.get.getConstructor().newInstance()), "", args)
-          case (ct, args) =>
+          case ct =>
             val argInArgRest = !argRest.isEmpty || legacyArgs
-            val argAfterParam = !argInArgRest && args.nonEmpty && (ct == IntTag || !args.head.startsWith("-"))
+            inline def argAfterParam = !argInArgRest && args.nonEmpty && (ct == IntTag || !args.head.startsWith("-"))
             if argInArgRest then
               doSetArg(argRest, args)
             else if argAfterParam then
               doSetArg(args.head, args.tail)
-            else missingArg
+            else if isEmptyDefault then
+              missingArg
+            else
+              doSetArg(arg = null, args)
 
-      def doSetArg(arg: String, argsLeft: List[String]) = summon[ClassTag[T]] match
+      def doSetArg(arg: String, argsLeft: List[String]) =
+        classTag[T] match
+          case ListTag if arg == null =>
+            update(default, arg, argsLeft)
           case ListTag =>
             val strings = arg.split(",").toList
             appendList(strings, arg, argsLeft)
@@ -299,6 +317,7 @@ object Settings:
   object Setting:
     extension [T](setting: Setting[T])
       def value(using Context): T = setting.valueIn(ctx.settingsState)
+      def userValue(using Context): Option[T] = setting.userValueIn(ctx.settingsState)
       def update(x: T)(using Context): SettingsState = setting.updateIn(ctx.settingsState, x)
       def isDefault(using Context): Boolean = setting.isDefaultIn(ctx.settingsState)
 
@@ -429,7 +448,7 @@ object Settings:
       publish(Setting(category, prependName(name), descr, default, legacyArgs = legacyArgs, deprecation = deprecation))
 
     def OptionSetting[T: ClassTag](category: SettingCategory, name: String, descr: String, aliases: List[String] = Nil, deprecation: Option[Deprecation] = None): Setting[Option[T]] =
-      publish(Setting(category, prependName(name), descr, None, propertyClass = Some(summon[ClassTag[T]].runtimeClass), aliases = aliases, deprecation = deprecation))
+      publish(Setting(category, prependName(name), descr, None, propertyClass = Some(classTag[T].runtimeClass), aliases = aliases, deprecation = deprecation))
 
   end SettingGroup
 end Settings

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

@@ -251,13 +251,13 @@ object Decorators {
    *  a given phase. See [[config.CompilerCommand#explainAdvanced]] for the
    *  exact meaning of "contains" here.
    */
-   extension (names: List[String])
+  extension (names: List[String])
     def containsPhase(phase: Phase): Boolean =
       names.nonEmpty && {
         phase match {
-          case phase: MegaPhase => phase.miniPhases.exists(x => names.containsPhase(x))
+          case phase: MegaPhase => phase.miniPhases.exists(names.containsPhase)
           case _ =>
-            names exists { name =>
+            names.exists { name =>
               name == "all" || {
                 val strippedName = name.stripSuffix("+")
                 val logNextPhase = name != strippedName