Add option to ignore using unknown value warning

Author: EnzeXing

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

@@ -171,7 +171,7 @@ class Compiler {
     val rctx =
       if ctx.settings.Xsemanticdb.value then
         ctx.addMode(Mode.ReadPositions)
-      else if ctx.settings.YcheckInitGlobal.value then
+      else if !ctx.settings.YcheckInitGlobal.isDefault then
         ctx.addMode(Mode.ReadPositions)
       else
         ctx

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

@@ -446,7 +446,7 @@ private sealed trait YSettings:
   val YnoKindPolymorphism: Setting[Boolean] = BooleanSetting(ForkSetting, "Yno-kind-polymorphism", "Disable kind polymorphism.")
   val YexplicitNulls: Setting[Boolean] = BooleanSetting(ForkSetting, "Yexplicit-nulls", "Make reference types non-nullable. Nullable types can be expressed with unions: e.g. String|Null.")
   val YnoFlexibleTypes: Setting[Boolean] = BooleanSetting(ForkSetting, "Yno-flexible-types", "Disable turning nullable Java return types and parameter types into flexible types, which behave like abstract types with a nullable lower bound and non-nullable upper bound.")
-  val YcheckInitGlobal: Setting[Boolean] = BooleanSetting(ForkSetting, "Ysafe-init-global", "Check safe initialization of global objects.")
+  val YcheckInitGlobal: Setting[String] = ChoiceSetting(ForkSetting, "Ysafe-init-global", "[report-unknown, ignore-unknown]", "Check safe initialization of global objects.", List("report-unknown", "ignore-unknown", "off"), "off")
   val YrequireTargetName: Setting[Boolean] = BooleanSetting(ForkSetting, "Yrequire-targetName", "Warn if an operator is defined without a @targetName annotation.")
   val YrecheckTest: Setting[Boolean] = BooleanSetting(ForkSetting, "Yrecheck-test", "Run basic rechecking (internal test only).")
   val YccDebug: Setting[Boolean] = BooleanSetting(ForkSetting, "Ycc-debug", "Used in conjunction with captureChecking language import, debug info for captured references.")

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

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

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.Whas.checkInit || ctx.settings.YcheckInitGlobal.value)
+    super.isEnabled && (ctx.settings.Whas.checkInit || !ctx.settings.YcheckInitGlobal.isDefault)
 
   def traverse(traverser: InitTreeTraverser)(using Context): Boolean = monitor(phaseName):
     val unit = ctx.compilationUnit
@@ -53,7 +53,7 @@ class Checker extends Phase:
       if ctx.settings.Whas.checkInit then
         Semantic.checkClasses(classes)(using checkCtx)
 
-      if ctx.settings.YcheckInitGlobal.value then
+      if !ctx.settings.YcheckInitGlobal.isDefault then
         val obj = new Objects
         obj.checkClasses(classes)(using checkCtx)
     }

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

@@ -718,6 +718,11 @@ class Objects(using Context @constructorOnly):
 
     def widen(height: Int): Contextual[List[Value]] = values.map(_.widen(height)).toList
 
+  /** Check if the checker option reports warnings about unknown code
+   */
+  def reportUnknown(using context: Context): Boolean =
+    context.settings.YcheckInitGlobal.value == "report-unknown"
+
   /** Handle method calls `e.m(args)`.
    *
    * @param value        The value for the receiver.
@@ -727,18 +732,21 @@ class Objects(using Context @constructorOnly):
    * @param superType    The type of the super in a super call. NoType for non-super calls.
    * @param needResolve  Whether the target of the call needs resolution?
    */
-  def call(value: Value, meth: Symbol, args: List[ArgInfo], receiver: Type, superType: Type, needResolve: Boolean = true): Contextual[Value] = log("call " + meth.show + ", this = " + value.show + ", args = " + args.map(_.value.show), printer, (_: Value).show) {
+  def call(value: Value, meth: Symbol, args: List[ArgInfo], receiver: Type, superType: Type, needResolve: Boolean = true): Contextual[Value] = log("call " + meth.show + ", this = " + value.show + ", args = " + args.map(_.tree.show), printer, (_: Value).show) {
     value.filterClass(meth.owner) match
-    case UnknownValue => // TODO: This ensures soundness but emits extra warnings. Add an option to turn off warnings here
-      report.warning("Using unknown value. " + Trace.show, Trace.position)
-      Bottom
+    case UnknownValue =>
+      if reportUnknown then
+        report.warning("Using unknown value. " + Trace.show, Trace.position)
+        Bottom
+      else
+        UnknownValue
 
     case Package(packageSym) =>
       report.warning("[Internal error] Unexpected call on package = " + value.show + ", meth = " + meth.show + Trace.show, Trace.position)
       Bottom
 
-    case BaseValue => // TODO: This ensures soundness but emits extra warnings. Add an option to return BaseValue here
-      UnknownValue
+    case BaseValue =>
+      if reportUnknown then UnknownValue else BaseValue
 
     case Bottom =>
       Bottom
@@ -786,7 +794,10 @@ class Objects(using Context @constructorOnly):
           arr
         else if target.equals(defn.Predef_classOf) then
           // Predef.classOf is a stub method in tasty and is replaced in backend
-          UnknownValue
+          BaseValue
+        else if target.equals(defn.ClassTagModule_apply) then
+          // ClassTag and other reflection related values are considered safe
+          BaseValue
         else if target.hasSource then
           val cls = target.owner.enclosingClass.asClass
           val ddef = target.defTree.asInstanceOf[DefDef]
@@ -894,11 +905,14 @@ class Objects(using Context @constructorOnly):
   def select(value: Value, field: Symbol, receiver: Type, needResolve: Boolean = true): Contextual[Value] = log("select " + field.show + ", this = " + value.show, printer, (_: Value).show) {
     value.filterClass(field.owner) match
     case UnknownValue =>
-      report.warning("Using unknown value", Trace.position)
-      Bottom
+      if reportUnknown then
+        report.warning("Using unknown value. " + Trace.show, Trace.position)
+        Bottom
+      else
+        UnknownValue
 
     case BaseValue =>
-      UnknownValue
+      if reportUnknown then UnknownValue else BaseValue
 
     case Package(packageSym) =>
       if field.isStaticObject then

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -231,8 +231,8 @@ class CompilationTests {
   // initialization tests
   @Test def checkInitGlobal: Unit = {
     implicit val testGroup: TestGroup = TestGroup("checkInitGlobal")
-    compileFilesInDir("tests/init-global/warn", defaultOptions.and("-Ysafe-init-global"), FileFilter.exclude(TestSources.negInitGlobalScala2LibraryTastyExcludelisted)).checkWarnings()
-    compileFilesInDir("tests/init-global/pos", defaultOptions.and("-Ysafe-init-global", "-Xfatal-warnings"), FileFilter.exclude(TestSources.posInitGlobalScala2LibraryTastyExcludelisted)).checkCompile()
+    compileFilesInDir("tests/init-global/warn", defaultOptions.and("-Ysafe-init-global:ignore-unknown"), FileFilter.exclude(TestSources.negInitGlobalScala2LibraryTastyExcludelisted)).checkWarnings()
+    compileFilesInDir("tests/init-global/pos", defaultOptions.and("-Ysafe-init-global:ignore-unknown", "-Xfatal-warnings"), FileFilter.exclude(TestSources.posInitGlobalScala2LibraryTastyExcludelisted)).checkCompile()
   }
 
   // initialization tests