Move WConf cache to ContextBase

Author: lrytz

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

@@ -947,6 +947,8 @@ object Contexts {
 
     private[core] val reusableDataReader = ReusableInstance(new ReusableDataReader())
 
+    private[dotc] var wConfCache: (List[String], WConf) = _
+
     def sharedCharArray(len: Int): Array[Char] =
       while len > charArray.length do
         charArray = new Array[Char](charArray.length * 2)

compiler/src/dotty/tools/dotc/reporting/WConf.scala

@@ -6,7 +6,6 @@ import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.util.SourcePosition
 
 import java.util.regex.PatternSyntaxException
-import scala.annotation.internal.sharable
 import scala.collection.mutable.ListBuffer
 import scala.util.matching.Regex
 
@@ -31,7 +30,7 @@ final case class WConf(confs: List[(List[MessageFilter], Action)]):
     case (filters, action) if filters.forall(_.matches(message)) => action
   }.getOrElse(Action.Warning)
 
-@sharable object WConf:
+object WConf:
   import Action._
   import MessageFilter._
 
@@ -49,38 +48,34 @@ final case class WConf(confs: List[(List[MessageFilter], Action)]):
     try Right(s.r)
     catch { case e: PatternSyntaxException => Left(s"invalid pattern `$s`: ${e.getMessage}") }
 
-  val splitter = raw"([^=]+)=(.+)".r
-
-  def parseFilter(s: String): Either[String, MessageFilter] = s match {
-    case "any" => Right(Any)
-    case splitter(filter, conf) => filter match {
-      case "msg" => regex(conf).map(MessagePattern.apply)
-      case "cat" =>
-        conf match {
+  def parseFilter(s: String): Either[String, MessageFilter] =
+    val splitter = raw"([^=]+)=(.+)".r
+    s match
+      case "any" => Right(Any)
+      case splitter(filter, conf) => filter match
+        case "msg" => regex(conf).map(MessagePattern.apply)
+        case "cat" => conf match
           case "deprecation" => Right(Deprecated)
           case "feature"     => Right(Feature)
           case _             => Left(s"unknown category: $conf")
-        }
-      case _ => Left(s"unknown filter: $filter")
-    }
-    case _ => Left(s"unknown filter: $s")
-  }
+        case _ => Left(s"unknown filter: $filter")
+      case _ => Left(s"unknown filter: $s")
 
-  private var parsedCache: (List[String], WConf) = null
   def parsed(using Context): WConf =
     val setting = ctx.settings.Wconf.value
-    if parsedCache == null || parsedCache._1 != setting then
+    def cached = ctx.base.wConfCache
+    if cached == null || cached._1 != setting then
       val conf = fromSettings(setting)
-      parsedCache = (setting, conf.getOrElse(WConf(Nil)))
+      ctx.base.wConfCache = (setting, conf.getOrElse(WConf(Nil)))
       conf.swap.foreach(msgs =>
         val multiHelp =
-          if (setting.sizeIs > 1)
+          if setting.sizeIs > 1 then
             """
               |Note: for multiple filters, use `-Wconf:filter1:action1,filter2:action2`
               |      or alternatively          `-Wconf:filter1:action1 -Wconf:filter2:action2`""".stripMargin
           else ""
         report.warning(s"Failed to parse `-Wconf` configuration: ${ctx.settings.Wconf.value.mkString(",")}\n${msgs.mkString("\n")}$multiHelp"))
-    parsedCache._2
+    cached._2
 
   def fromSettings(settings: List[String]): Either[List[String], WConf] =
     if (settings.isEmpty) Right(WConf(Nil))

compiler/test/dotty/tools/dotc/config/ScalaSettingsTests.scala

@@ -67,15 +67,19 @@ class ScalaSettingsTests:
   @Test def `WConf setting is parsed`: Unit =
     import reporting.{Action, Diagnostic, NoExplanation}
     val sets = new ScalaSettings
-    val args = tokenize("-Wconf:cat=deprecation:w,cat=feature:w -Wconf:msg=message\\.pattern:s")
+    val args = List("-Wconf:cat=deprecation:s,cat=feature:e", "-Wconf:msg=a problem\\.:s")
     val sumy = ArgsSummary(sets.defaultState, args, errors = Nil, warnings = Nil)
     val proc = sets.processArguments(sumy, processAll = true, skipped = Nil)
     val conf = sets.Wconf.valueIn(proc.sstate)
     val sut  = reporting.WConf.fromSettings(conf).getOrElse(???)
     val msg  = NoExplanation("There was a problem!")
-    val diag = new Diagnostic.DeprecationWarning(msg, util.NoSourcePosition)
-    assertEquals("Warns deprecation", Action.Warning, sut.action(diag))
+    val depr = new Diagnostic.DeprecationWarning(msg, util.NoSourcePosition)
+    assertEquals(Action.Silent, sut.action(depr))
     val feat = new Diagnostic.FeatureWarning(msg, util.NoSourcePosition)
-    assertEquals("Warns feature", Action.Warning, sut.action(feat))
+    assertEquals(Action.Error, sut.action(feat))
+    val warn = new Diagnostic.Warning(msg, util.NoSourcePosition)
+    assertEquals(Action.Warning, sut.action(warn))
+    val nowr = new Diagnostic.Warning(NoExplanation("This is a problem."), util.NoSourcePosition)
+    assertEquals(Action.Silent, sut.action(nowr))
 
 end ScalaSettingsTests