Add -Wall

[Cherry-picked 5727187][modified]

Author: WojciechMazur

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

@@ -165,46 +165,50 @@ private sealed trait WarningSettings:
 
   val Whelp: Setting[Boolean] = BooleanSetting("-W", "Print a synopsis of warning options.")
   val XfatalWarnings: Setting[Boolean] = BooleanSetting("-Werror", "Fail the compilation if there are any warnings.", aliases = List("-Xfatal-warnings"))
-  val WvalueDiscard: Setting[Boolean] = BooleanSetting("-Wvalue-discard", "Warn when non-Unit expression results are unused.")
-  val WNonUnitStatement = BooleanSetting("-Wnonunit-statement", "Warn when block statements are non-Unit expressions.")
-  val WenumCommentDiscard = BooleanSetting("-Wenum-comment-discard", "Warn when a comment ambiguously assigned to multiple enum cases is discarded.")
-  val Wunused: Setting[List[ChoiceWithHelp[String]]] = MultiChoiceHelpSetting(
+  val Wall: Setting[Boolean] = BooleanSetting("-Wall", "Enable all warning settings.")
+  private val WvalueDiscard: Setting[Boolean] = BooleanSetting("-Wvalue-discard", "Warn when non-Unit expression results are unused.")
+  private val WNonUnitStatement = BooleanSetting("-Wnonunit-statement", "Warn when block statements are non-Unit expressions.")
+  private val WenumCommentDiscard = BooleanSetting("-Wenum-comment-discard", "Warn when a comment ambiguously assigned to multiple enum cases is discarded.")
+  private val Wunused: Setting[List[ChoiceWithHelp[String]]] = MultiChoiceHelpSetting(
     name = "-Wunused",
     helpArg = "warning",
     descr = "Enable or disable specific `unused` warnings",
-    choices = List(
+    choices = List( 
       ChoiceWithHelp("nowarn", ""),
-      ChoiceWithHelp("all",""),
+      ChoiceWithHelp("all", ""),
       ChoiceWithHelp(
         name = "imports",
         description = "Warn if an import selector is not referenced.\n" +
         "NOTE : overrided by -Wunused:strict-no-implicit-warn"),
-        ChoiceWithHelp("privates","Warn if a private member is unused"),
-        ChoiceWithHelp("locals","Warn if a local definition is unused"),
-        ChoiceWithHelp("explicits","Warn if an explicit parameter is unused"),
-        ChoiceWithHelp("implicits","Warn if an implicit parameter is unused"),
-        ChoiceWithHelp("params","Enable -Wunused:explicits,implicits"),
-        ChoiceWithHelp("linted","Enable -Wunused:imports,privates,locals,implicits"),
-        ChoiceWithHelp(
-          name = "strict-no-implicit-warn",
-          description = "Same as -Wunused:import, only for imports of explicit named members.\n" +
-          "NOTE : This overrides -Wunused:imports and NOT set by -Wunused:all"
-        ),
-        // ChoiceWithHelp("patvars","Warn if a variable bound in a pattern is unused"),
-        ChoiceWithHelp(
-          name = "unsafe-warn-patvars",
-          description = "(UNSAFE) Warn if a variable bound in a pattern is unused.\n" +
-          "This warning can generate false positive, as warning cannot be\n" +
-          "suppressed yet."
-        )
+      ChoiceWithHelp("privates", "Warn if a private member is unused"),
+      ChoiceWithHelp("locals", "Warn if a local definition is unused"),
+      ChoiceWithHelp("explicits", "Warn if an explicit parameter is unused"),
+      ChoiceWithHelp("implicits", "Warn if an implicit parameter is unused"),
+      ChoiceWithHelp("params", "Enable -Wunused:explicits,implicits"),
+      ChoiceWithHelp("linted", "Enable -Wunused:imports,privates,locals,implicits"),
+      ChoiceWithHelp(
+        name = "strict-no-implicit-warn",
+        description = "Same as -Wunused:import, only for imports of explicit named members.\n" +
+        "NOTE : This overrides -Wunused:imports and NOT set by -Wunused:all"
+      ),
+      // ChoiceWithHelp("patvars","Warn if a variable bound in a pattern is unused"),
+      ChoiceWithHelp(
+        name = "unsafe-warn-patvars",
+        description = "(UNSAFE) Warn if a variable bound in a pattern is unused.\n" +
+        "This warning can generate false positive, as warning cannot be\n" +
+        "suppressed yet."
+      )
     ),
     default = Nil
   )
   object WunusedHas:
     def isChoiceSet(s: String)(using Context) = Wunused.value.pipe(us => us.contains(s))
-    def allOr(s: String)(using Context) = Wunused.value.pipe(us => us.contains("all") || us.contains(s))
+    def allOr(s: String)(using Context) = Wall.value || Wunused.value.pipe(us => us.contains("all") || us.contains(s))
     def nowarn(using Context) = allOr("nowarn")
 
+    // Is any choice set for -Wunused?
+    def any(using Context): Boolean = Wunused.value.nonEmpty
+
     // overrided by strict-no-implicit-warn
     def imports(using Context) =
       (allOr("imports") || allOr("linted")) && !(strictNoImplicitWarn)
@@ -278,6 +282,16 @@ private sealed trait WarningSettings:
          |to prevent the shell from expanding patterns.""".stripMargin,
   )
 
+  private val WcheckInit: Setting[Boolean] = BooleanSetting("-Wsafe-init", "Ensure safe initialization of objects.")
+
+  object Whas:
+    def allOr(s: Setting[Boolean])(using Context): Boolean =
+      Wall.value || s.value
+    def valueDiscard(using Context): Boolean = allOr(WvalueDiscard)
+    def nonUnitStatement(using Context): Boolean = allOr(WNonUnitStatement)
+    def enumCommentDiscard(using Context): Boolean = allOr(WenumCommentDiscard)
+    def checkInit(using Context): Boolean = allOr(WcheckInit)
+
 /** -X "Extended" or "Advanced" settings */
 private sealed trait XSettings:
   self: SettingGroup =>

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

@@ -80,7 +80,7 @@ object Symbols extends SymUtils {
       ctx.settings.YretainTrees.value ||
       denot.owner.isTerm ||                // no risk of leaking memory after a run for these
       denot.isOneOf(InlineOrProxy) ||      // need to keep inline info
-      ctx.settings.YcheckInit.value        // initialization check
+      ctx.settings.Whas.checkInit          // initialization check
 
     /** The last denotation of this symbol */
     private var lastDenot: SymDenotation = _

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3923,7 +3923,7 @@ object Parsers {
         if (in.token == COMMA) {
           in.nextToken()
           val ids = commaSeparated(() => termIdent())
-          if ctx.settings.WenumCommentDiscard.value then
+          if ctx.settings.Whas.enumCommentDiscard then
             in.getDocComment(start).foreach: comm =>
               warning(
                 em"""Ambiguous Scaladoc comment on multiple cases is ignored.

compiler/src/dotty/tools/dotc/transform/CheckUnused.scala

@@ -58,7 +58,7 @@ class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _ke
 
   override def isRunnable(using Context): Boolean =
     super.isRunnable &&
-    ctx.settings.Wunused.value.nonEmpty &&
+    ctx.settings.WunusedHas.any &&
     !ctx.isJava
 
   // ========== SETUP ============

compiler/src/dotty/tools/dotc/transform/init/Checker.scala

@@ -29,7 +29,7 @@ class Checker extends Phase:
   override val runsAfter = Set(Pickler.name)
 
   override def isEnabled(using Context): Boolean =
-    super.isEnabled && ctx.settings.YcheckInit.value
+    super.isEnabled && ctx.settings.Whas.checkInit
 
   def traverse(traverser: InitTreeTraverser)(using Context): Boolean = monitor(phaseName):
     val unit = ctx.compilationUnit
@@ -46,7 +46,8 @@ class Checker extends Phase:
     cancellable {
       val classes = traverser.getClasses()
 
-      Semantic.checkClasses(classes)(using checkCtx)
+      if ctx.settings.Whas.checkInit then
+        Semantic.checkClasses(classes)(using checkCtx)
     }
 
     units0

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -4196,7 +4196,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         // so will take the code path that decides on inlining
         val tree1 = adapt(tree, WildcardType, locked)
         checkStatementPurity(tree1)(tree, ctx.owner, isUnitExpr = true)
-        if (!ctx.isAfterTyper && !tree.isInstanceOf[Inlined] && ctx.settings.WvalueDiscard.value && !isThisTypeResult(tree)) {
+        if (!ctx.isAfterTyper && !tree.isInstanceOf[Inlined] && ctx.settings.Whas.valueDiscard && !isThisTypeResult(tree)) {
           report.warning(ValueDiscarding(tree.tpe), tree.srcPos)
         }
         return tpd.Block(tree1 :: Nil, unitLiteral)
@@ -4498,7 +4498,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       && !isJavaApplication(t)                  // Java methods are inherently side-effecting
       // && !treeInfo.hasExplicitUnit(t)           // suppressed by explicit expr: Unit // TODO Should explicit `: Unit` be added as warning suppression?
     )
-    if ctx.settings.WNonUnitStatement.value && !ctx.isAfterTyper && checkInterestingShapes(t) then
+    if ctx.settings.Whas.nonUnitStatement && !ctx.isAfterTyper && checkInterestingShapes(t) then
       val where = t match {
         case Block(_, res) => res
         case If(_, thenpart, Literal(Constant(()))) =>