-Ystatistics accepts a list of phases, cleanups in MultiChoiceSetting

MultiChoiceSetting and Xlint with its deprecated aliases is now a bit
simpler, but there's still room for improvement, as noted in comments.

1 files changed, 71 insertions, 123 deletions

diff --git a/src/compiler/scala/tools/nsc/settings/Warnings.scala b/src/compiler/scala/tools/nsc/settings/Warnings.scala
index 4c37633301..771543ec77 100644
--- a/src/compiler/scala/tools/nsc/settings/Warnings.scala
+++ b/src/compiler/scala/tools/nsc/settings/Warnings.scala
@@ -17,145 +17,93 @@ trait Warnings {
   // Warning semantics.
   val fatalWarnings = BooleanSetting("-Xfatal-warnings", "Fail the compilation if there are any warnings.")
 
-  // These additional warnings are all so noisy as to be useless in their
-  // present form, but have the potential to offer useful info.
-  protected def allWarnings = lintWarnings ++ List(
-    warnDeadCode,
-    warnValueDiscard,
-    warnNumericWiden,
-    warnUnused,           // SI-7712, SI-7707 warnUnused not quite ready for prime-time
-    warnUnusedImport,     // currently considered too noisy for general use
-    warnValueOverrides    // currently turned off as experimental
-  )
-  // These warnings should be pretty quiet unless you're doing
-  // something inadvisable.
-  protected def lintWarnings = List(
-    warnInaccessible,
-    warnNullaryOverride,
-    warnNullaryUnit,
-    warnAdaptedArgs,
-    warnInferAny,
-    warnMissingInterpolator,
-    warnDocDetached,
-    warnPrivateShadow,
-    warnTypeParameterShadow,
-    warnPolyImplicitOverload,
-    warnOptionImplicit,
-    warnDelayedInit,
-    warnByNameRightAssociative,
-    warnPackageObjectClasses,
-    warnUnsoundMatch
-  )
-
-  // Individual warnings. They can be set with -Ywarn.
-  private def nonlintflag(name: String, text: String): BooleanSetting = BooleanSetting(name, text)
-
-  val warnDeadCode         = nonlintflag("-Ywarn-dead-code",
-                             "Warn when dead code is identified.")
-  val warnValueDiscard     = nonlintflag("-Ywarn-value-discard",
-                             "Warn when non-Unit expression results are unused.")
-  val warnNumericWiden     = nonlintflag("-Ywarn-numeric-widen",
-                             "Warn when numerics are widened.")
-  val warnUnused           = nonlintflag("-Ywarn-unused",
-                             "Warn when local and private vals, vars, defs, and types are are unused")
-  val warnUnusedImport     = nonlintflag("-Ywarn-unused-import",
-                             "Warn when imports are unused")
-
-  // Lint warnings that have no -Y avatar, created with new instead of the autoregistering factory method.
-  // They evaluate true if set to true or else are unset but -Xlint is true
-  private def lintflag(name: String, text: String): BooleanSetting =
-    new BooleanSetting(name, text) {
-      override def value = if (isSetByUser) super.value else xlint
-    }
+  // Non-lint warnings
 
-  val warnAdaptedArgs          = lintflag("adapted-args",
-                                 "Warn if an argument list is modified to match the receiver.")
-  val warnNullaryUnit          = lintflag("nullary-unit",
-                                 "Warn when nullary methods return Unit.")
-  val warnInaccessible         = lintflag("inaccessible",
-                                "Warn about inaccessible types in method signatures.")
-  val warnNullaryOverride      = lintflag("nullary-override",
-                                "Warn when non-nullary `def f()' overrides nullary `def f'.")
-  val warnInferAny             = lintflag("infer-any",
-                                "Warn when a type argument is inferred to be `Any`.")
-  val warnMissingInterpolator  = lintflag("missing-interpolator",
-                                "A string literal appears to be missing an interpolator id.")
-  val warnDocDetached          = lintflag("doc-detached",
-                                "A ScalaDoc comment appears to be detached from its element.")
-  val warnPrivateShadow        = lintflag("private-shadow",
-                                "A private field (or class parameter) shadows a superclass field.")
-  val warnTypeParameterShadow  = lintflag("type-parameter-shadow",
-                                "A local type parameter shadows a type already in scope.")
-  val warnPolyImplicitOverload = lintflag("poly-implicit-overload",
-                                "Parameterized overloaded implicit methods are not visible as view bounds")
-  val warnOptionImplicit       = lintflag("option-implicit",
-                                "Option.apply used implicit view.")
-  val warnDelayedInit          = lintflag("delayedinit-select",
-                                "Selecting member of DelayedInit")
-  val warnByNameRightAssociative = lintflag("by-name-right-associative",
-                                "By-name parameter of right associative operator")
-  val warnPackageObjectClasses = lintflag("package-object-classes",
-                                "Class or object defined in package object")
-  val warnUnsoundMatch         = lintflag("unsound-match",
-                                "Pattern match may not be typesafe")
+  val warnDeadCode         = BooleanSetting("-Ywarn-dead-code", "Warn when dead code is identified.")
+  val warnValueDiscard     = BooleanSetting("-Ywarn-value-discard", "Warn when non-Unit expression results are unused.")
+  val warnNumericWiden     = BooleanSetting("-Ywarn-numeric-widen", "Warn when numerics are widened.")
+  // SI-7712, SI-7707 warnUnused not quite ready for prime-time
+  val warnUnused           = BooleanSetting("-Ywarn-unused", "Warn when local and private vals, vars, defs, and types are are unused.")
+  // currently considered too noisy for general use
+  val warnUnusedImport     = BooleanSetting("-Ywarn-unused-import", "Warn when imports are unused.")
 
   // Experimental lint warnings that are turned off, but which could be turned on programmatically.
   // These warnings are said to blind those who dare enable them.
   // They are not activated by -Xlint and can't be enabled on the command line.
-  val warnValueOverrides = {
-    val flag = lintflag("value-overrides", "Generated value class method overrides an implementation")
+  val warnValueOverrides = { // currently turned off as experimental. creaded using constructor (new BS), so not available on the command line.
+  val flag = new BooleanSetting("value-overrides", "Generated value class method overrides an implementation")
     flag.value = false
     flag
   }
 
-  // The Xlint warning group.
-  private val xlint = new BooleanSetting("-Zunused", "True if -Xlint or -Xlint:_")
-  // On -Xlint or -Xlint:_, set xlint, otherwise set the lint warning unless already set true
-  val lint = {
-    val description = "Enable or disable specific warnings"
-    val choices     = (lintWarnings map (_.name)).sorted
-    MultiChoiceSetting(
-      name    = "-Xlint",
-      helpArg = "warning",
-      descr   = description,
-      choices = choices,
-      default = Some(() => xlint.value = true)
-    ) { s =>
-      def helpline(n: String) = lintWarnings.find(_.name == n).map(w => f"  ${w.name}%-25s ${w.helpDescription}%n")
-      choices flatMap (helpline(_)) mkString (f"$description:%n", "", f"%n")
-    } withPostSetHook { x =>
-      val Neg = "-"
-      def setPolitely(b: BooleanSetting, v: Boolean) = if (!b.isSetByUser || !b) b.value = v
-      def set(w: String, v: Boolean) = lintWarnings find (_.name == w) foreach (setPolitely(_, v))
-      def propagate(ss: List[String]): Unit = ss match {
-        case w :: rest => if (w startsWith Neg) set(w stripPrefix Neg, false) else set(w, true) ; propagate(rest)
-        case Nil       => ()
-      }
-      propagate(x.value)
-    }
-  }
+  // Lint warnings
+
+  def warnAdaptedArgs            = lint contains "adapted-args"
+  def warnNullaryUnit            = lint contains "nullary-unit"
+  def warnInaccessible           = lint contains "inaccessible"
+  def warnNullaryOverride        = lint contains "nullary-override"
+  def warnInferAny               = lint contains "infer-any"
+  def warnMissingInterpolator    = lint contains "missing-interpolator"
+  def warnDocDetached            = lint contains "doc-detached"
+  def warnPrivateShadow          = lint contains "private-shadow"
+  def warnTypeParameterShadow    = lint contains "type-parameter-shadow"
+  def warnPolyImplicitOverload   = lint contains "poly-implicit-overload"
+  def warnOptionImplicit         = lint contains "option-implicit"
+  def warnDelayedInit            = lint contains "delayedinit-select"
+  def warnByNameRightAssociative = lint contains "by-name-right-associative"
+  def warnPackageObjectClasses   = lint contains "package-object-classes"
+  def warnUnsoundMatch           = lint contains "unsound-match"
 
   // Lint warnings that are currently -Y, but deprecated in that usage
   @deprecated("Use warnAdaptedArgs", since="2.11.2")
-  val YwarnAdaptedArgs      = BooleanSetting("-Ywarn-adapted-args",
-                             "Warn if an argument list is modified to match the receiver.") enabling List(warnAdaptedArgs)
-                             //withDeprecationMessage "Enable -Xlint:adapted-args"
+  def YwarnAdaptedArgs = warnAdaptedArgs
   @deprecated("Use warnNullaryUnit", since="2.11.2")
-  val YwarnNullaryUnit      = BooleanSetting("-Ywarn-nullary-unit",
-                             "Warn when nullary methods return Unit.") enabling List(warnNullaryUnit)
-                             //withDeprecationMessage "Enable -Xlint:nullary-unit"
+  def YwarnNullaryUnit = warnNullaryUnit
   @deprecated("Use warnInaccessible", since="2.11.2")
-  val YwarnInaccessible     = BooleanSetting("-Ywarn-inaccessible",
-                             "Warn about inaccessible types in method signatures.") enabling List(warnInaccessible)
-                             //withDeprecationMessage "Enable -Xlint:inaccessible"
+  def YwarnInaccessible = warnInaccessible
   @deprecated("Use warnNullaryOverride", since="2.11.2")
-  val YwarnNullaryOverride  = BooleanSetting("-Ywarn-nullary-override",
-                             "Warn when non-nullary `def f()' overrides nullary `def f'.") enabling List(warnNullaryOverride)
-                             //withDeprecationMessage "Enable -Xlint:nullary-override"
+  def YwarnNullaryOverride = warnNullaryOverride
   @deprecated("Use warnInferAny", since="2.11.2")
-  val YwarnInferAny         = BooleanSetting("-Ywarn-infer-any",
-                             "Warn when a type argument is inferred to be `Any`.") enabling List(warnInferAny)
-                             //withDeprecationMessage "Enable -Xlint:infer-any"
+  def YwarnInferAny = warnInferAny
+
+  // The Xlint warning group.
+  val lint: MultiChoiceSetting = {
+    val description = "Enable or disable specific warnings"
+
+    val choices = List(
+      ("adapted-args",              "Warn if an argument list is modified to match the receiver.",               true),
+      ("nullary-unit",              "Warn when nullary methods return Unit.",                                    true),
+      ("inaccessible",              "Warn about inaccessible types in method signatures.",                       true),
+      ("nullary-override",          "Warn when non-nullary `def f()' overrides nullary `def f'.",                true),
+      ("infer-any",                 "Warn when a type argument is inferred to be `Any`.",                        true),
+      ("missing-interpolator",      "A string literal appears to be missing an interpolator id.",                false),
+      ("doc-detached",              "A ScalaDoc comment appears to be detached from its element.",               false),
+      ("private-shadow",            "A private field (or class parameter) shadows a superclass field.",          false),
+      ("type-parameter-shadow",     "A local type parameter shadows a type already in scope.",                   false),
+      ("poly-implicit-overload",    "Parameterized overloaded implicit methods are not visible as view bounds.", false),
+      ("option-implicit",           "Option.apply used implicit view.",                                          false),
+      ("delayedinit-select",        "Selecting member of DelayedInit",                                           false),
+      ("by-name-right-associative", "By-name parameter of right associative operator.",                          false),
+      ("package-object-classes",    "Class or object defined in package object.",                                false),
+      ("unsound-match",             "Pattern match may not be typesafe.",                                        false)
+    ).sorted
+
+    for (c <- choices.filter(_._3)) {
+      BooleanSetting("-Ywarn-"+ c._1, c._2) withPostSetHook { s =>
+        if (s) lint.add(c._1)
+        else lint.add("-" + c._1)
+      } // withDeprecationMessage s"Enable -Xlint:${c._1}"
+    }
+
+    MultiChoiceSetting(
+      name         = "-Xlint",
+      helpArg      = "warning",
+      descr        = description,
+      choices      = choices map (_._1),
+      descriptions = choices map (_._2),
+      default      = Some(List("_"))
+    )
+  }
 
   private lazy val warnSelectNullable = BooleanSetting("-Xcheck-null", "This option is obsolete and does nothing.")