Got most of tests to work

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

@@ -211,6 +211,7 @@ class CompilationTests {
     implicit val testGroup: TestGroup = TestGroup("checkInitGlobal")
     val options = defaultOptions.and("-Ysafe-init-global", "-Xfatal-warnings")
     compileFilesInDir("tests/init-global/neg", options).checkExpectedErrors()
+    compileFilesInDir("tests/init-global/warn", options).checkWarnings()
     compileFilesInDir("tests/init-global/pos", options).checkCompile()
   }
 
@@ -219,6 +220,7 @@ class CompilationTests {
     implicit val testGroup: TestGroup = TestGroup("checkInit")
     val options = defaultOptions.and("-Ysafe-init", "-Xfatal-warnings")
     compileFilesInDir("tests/init/neg", options).checkExpectedErrors()
+    compileFilesInDir("tests/init/warn", options).checkWarnings()
     compileFilesInDir("tests/init/pos", options).checkCompile()
     compileFilesInDir("tests/init/crash", options.without("-Xfatal-warnings")).checkCompile()
     // The regression test for i12128 has some atypical classpath requirements.

compiler/test/dotty/tools/vulpix/ParallelTesting.scala

@@ -755,7 +755,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
     end maybeFailureMessage
 
     def getWarnMapAndExpectedCount(files: Seq[JFile]): (HashMap[String, Integer], Int) =
-      val comment = raw"//( *)warn".r
+      val comment = raw"//( *)(nopos-)?warn".r
       val map = new HashMap[String, Integer]()
       var count = 0
       def bump(key: String): Unit =
@@ -766,8 +766,11 @@ trait ParallelTesting extends RunnerOrchestration { self =>
       files.filter(isSourceFile).foreach { file =>
         Using(Source.fromFile(file, StandardCharsets.UTF_8.name)) { source =>
           source.getLines.zipWithIndex.foreach { case (line, lineNbr) =>
-            comment.findAllMatchIn(line).foreach { _ =>
-              bump(s"${file.getPath}:${lineNbr+1}")
+            comment.findAllMatchIn(line).foreach { m =>
+              m.group(2) match
+                case "nopos-" =>
+                  bump("nopos")
+                case _ => bump(s"${file.getPath}:${lineNbr+1}")
             }
           }
         }.get
@@ -788,7 +791,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
           val key = s"${relativize(srcpos.source.file.toString())}:${srcpos.line + 1}"
           if !seenAt(key) then unexpected += key
         else
-          unpositioned += relativize(srcpos.source.file.toString())
+          if(!seenAt("nopos")) unpositioned += relativize(srcpos.source.file.toString())
 
       reporterWarnings.foreach(sawDiagnostic)
 

tests/init-global/neg/context-sensitivity.check

@@ -0,0 +1,11 @@
+-- Warning: tests/init-global/neg/context-sensitivity.scala:9:21 -------------------------------------------------------
+9 |  def foo(): Int = A.m  
+  |                   ^^^
+  |                   Access uninitialized field value m. Call trace: 
+  |                   -> object A:	[ context-sensitivity.scala:14 ]
+  |                      ^
+  |                   -> val m: Int = box1.value.foo()	[ context-sensitivity.scala:17 ]
+  |                                   ^^^^^^^^^^^^^^^^
+  |                   -> def foo(): Int = A.m	[ context-sensitivity.scala:9 ]
+  |                                       ^^^
+No warnings can be incurred under -Werror.

tests/init-global/neg/context-sensitivity.scala

@@ -6,7 +6,7 @@ class C(var x: Int) extends Foo {
 }
 
 class D(var y: Int) extends Foo {
-  def foo(): Int = A.m  // error
+  def foo(): Int = A.m  
 }
 
 class Box(var value: Foo)

tests/init-global/neg/global-cycle1.check

@@ -0,0 +1,21 @@
+-- Warning: tests/init-global/neg/global-cycle1.scala:1:7 --------------------------------------------------------------
+1 |object A {             
+  |       ^
+  |       Cyclic initialization: object A -> object B -> object A. Calling trace:
+  |       -> object A {	[ global-cycle1.scala:1 ]
+  |          ^
+  |       -> val a: Int = B.b	[ global-cycle1.scala:2 ]
+  |                       ^
+  |       -> object B {	[ global-cycle1.scala:5 ]
+  |          ^
+  |       -> val b: Int = A.a	[ global-cycle1.scala:6 ]
+  |                       ^
+-- Warning: tests/init-global/neg/global-cycle1.scala:6:17 -------------------------------------------------------------
+6 |  val b: Int = A.a     
+  |               ^^^
+  |               Access uninitialized field value a. Call trace: 
+  |               -> object B {	[ global-cycle1.scala:5 ]
+  |                  ^
+  |               -> val b: Int = A.a	[ global-cycle1.scala:6 ]
+  |                               ^^^
+No warnings can be incurred under -Werror.

tests/init-global/neg/global-cycle1.scala

@@ -1,9 +1,9 @@
-object A {             // error
+object A {             
   val a: Int = B.b
 }
 
 object B {
-  val b: Int = A.a     // error
+  val b: Int = A.a     
 }
 
 @main

tests/init-global/neg/global-cycle14.check

@@ -0,0 +1,21 @@
+-- Warning: tests/init-global/neg/global-cycle14.scala:8:7 -------------------------------------------------------------
+8 |object A {              
+  |       ^
+  |       Cyclic initialization: object A -> object B -> object A. Calling trace:
+  |       -> object A {	[ global-cycle14.scala:8 ]
+  |          ^
+  |       -> val n: Int = B.m	[ global-cycle14.scala:9 ]
+  |                       ^
+  |       -> object B {	[ global-cycle14.scala:12 ]
+  |          ^
+  |       -> val m: Int = A.n	[ global-cycle14.scala:13 ]
+  |                       ^
+-- Warning: tests/init-global/neg/global-cycle14.scala:13:17 -----------------------------------------------------------
+13 |  val m: Int = A.n      
+   |               ^^^
+   |               Access uninitialized field value n. Call trace: 
+   |               -> object B {	[ global-cycle14.scala:12 ]
+   |                  ^
+   |               -> val m: Int = A.n	[ global-cycle14.scala:13 ]
+   |                               ^^^
+No warnings can be incurred under -Werror.

tests/init-global/neg/global-cycle14.scala

@@ -5,12 +5,12 @@ object O {
   val d = Data(3)
 }
 
-object A {              // error
+object A {              
   val n: Int = B.m
 }
 
 object B {
-  val m: Int = A.n      // error
+  val m: Int = A.n      
 }
 
 // nopos-error: No warnings can be incurred under -Werror.

tests/init-global/neg/global-cycle2.check

@@ -0,0 +1,11 @@
+-- Warning: tests/init-global/neg/global-cycle2.scala:6:21 -------------------------------------------------------------
+6 |  def foo(): Int = A.a * 2  
+  |                   ^^^
+  |                   Access uninitialized field value a. Call trace: 
+  |                   -> object A {	[ global-cycle2.scala:1 ]
+  |                      ^
+  |                   -> val a: Int = B.foo()	[ global-cycle2.scala:2 ]
+  |                                   ^^^^^^^
+  |                   -> def foo(): Int = A.a * 2	[ global-cycle2.scala:6 ]
+  |                                       ^^^
+No warnings can be incurred under -Werror.

tests/init-global/neg/global-cycle2.scala

@@ -3,7 +3,7 @@ object A {
 }
 
 object B {
-  def foo(): Int = A.a * 2  // error
+  def foo(): Int = A.a * 2  
 }
 
 // nopos-error: No warnings can be incurred under -Werror.

tests/init-global/neg/global-cycle3.check

@@ -0,0 +1,11 @@
+-- Warning: tests/init-global/neg/global-cycle3.scala:2:21 -------------------------------------------------------------
+2 |  def foo(): Int = B.a + 10  
+  |                   ^^^
+  |                   Access uninitialized field value a. Call trace: 
+  |                   -> object B {	[ global-cycle3.scala:5 ]
+  |                      ^
+  |                   -> val a: Int = A(4).foo()	[ global-cycle3.scala:6 ]
+  |                                   ^^^^^^^^^^
+  |                   -> def foo(): Int = B.a + 10	[ global-cycle3.scala:2 ]
+  |                                       ^^^
+No warnings can be incurred under -Werror.

tests/init-global/neg/global-cycle3.scala

@@ -1,5 +1,5 @@
 class A(x: Int) {
-  def foo(): Int = B.a + 10  // error
+  def foo(): Int = B.a + 10  
 }
 
 object B {

tests/init-global/neg/global-cycle4.check

@@ -0,0 +1,11 @@
+-- Warning: tests/init-global/neg/global-cycle4.scala:10:21 ------------------------------------------------------------
+10 |  def foo(): Int = O.a + 10       
+   |                   ^^^
+   |                   Access uninitialized field value a. Call trace: 
+   |                   -> object O {	[ global-cycle4.scala:17 ]
+   |                      ^
+   |                   -> val a: Int = D(5).bar().foo()	[ global-cycle4.scala:18 ]
+   |                                   ^^^^^^^^^^^^^^^^
+   |                   -> def foo(): Int = O.a + 10	[ global-cycle4.scala:10 ]
+   |                                       ^^^
+No warnings can be incurred under -Werror.

tests/init-global/neg/global-cycle4.scala

@@ -7,7 +7,7 @@ class B extends A {
 }
 
 class C extends A {
-  def foo(): Int = O.a + 10       // error
+  def foo(): Int = O.a + 10       
 }
 
 class D(x: Int) {

tests/init-global/neg/global-cycle5.check

@@ -0,0 +1,10 @@
+-- Warning: tests/init-global/neg/global-cycle5.scala:10:17 ------------------------------------------------------------
+10 |  val b: Int = A.a.foo()  
+   |               ^^^
+   |Reading mutable state of object A during initialization of object B.
+   |Reading mutable state of other static objects is forbidden as it breaks initialization-time irrelevance. Calling trace: 
+   |-> object B {	[ global-cycle5.scala:9 ]
+   |   ^
+   |-> val b: Int = A.a.foo()	[ global-cycle5.scala:10 ]
+   |                ^^^
+No warnings can be incurred under -Werror.

tests/init-global/neg/global-cycle5.scala

@@ -7,7 +7,7 @@ object A {
 }
 
 object B {
-  val b: Int = A.a.foo()  // error
+  val b: Int = A.a.foo()  
 }
 
 class Y extends X {

tests/init-global/neg/global-cycle6.check

@@ -0,0 +1,29 @@
+-- Warning: tests/init-global/neg/global-cycle6.scala:1:7 --------------------------------------------------------------
+1 |object A {             
+  |       ^
+  |       Cyclic initialization: object A -> object B -> object A. Calling trace:
+  |       -> object A {	[ global-cycle6.scala:1 ]
+  |          ^
+  |       -> val n: Int = B.m	[ global-cycle6.scala:2 ]
+  |                       ^
+  |       -> object B {	[ global-cycle6.scala:8 ]
+  |          ^
+  |       -> val a = new A.Inner	[ global-cycle6.scala:9 ]
+  |                  ^^^^^^^^^^^
+  |       -> class Inner {	[ global-cycle6.scala:3 ]
+  |          ^
+  |       -> println(n)	[ global-cycle6.scala:4 ]
+  |                  ^
+-- Warning: tests/init-global/neg/global-cycle6.scala:4:12 -------------------------------------------------------------
+4 |    println(n)         
+  |            ^
+  |            Access uninitialized field value n. Call trace: 
+  |            -> object B {	[ global-cycle6.scala:8 ]
+  |               ^
+  |            -> val a = new A.Inner	[ global-cycle6.scala:9 ]
+  |                       ^^^^^^^^^^^
+  |            -> class Inner {	[ global-cycle6.scala:3 ]
+  |               ^
+  |            -> println(n)	[ global-cycle6.scala:4 ]
+  |                       ^
+No warnings can be incurred under -Werror.

tests/init-global/neg/global-cycle6.scala

@@ -1,7 +1,7 @@
-object A {             // error
+object A {             
   val n: Int = B.m
   class Inner {
-    println(n)         // error
+    println(n)         
   }
 }
 

tests/init-global/neg/global-cycle7.check

@@ -0,0 +1,21 @@
+-- Warning: tests/init-global/neg/global-cycle7.scala:1:7 --------------------------------------------------------------
+1 |object A {              
+  |       ^
+  |       Cyclic initialization: object A -> object B -> object A. Calling trace:
+  |       -> object A {	[ global-cycle7.scala:1 ]
+  |          ^
+  |       -> val n: Int = B.m	[ global-cycle7.scala:2 ]
+  |                       ^
+  |       -> object B {	[ global-cycle7.scala:5 ]
+  |          ^
+  |       -> val m: Int = A.n	[ global-cycle7.scala:6 ]
+  |                       ^
+-- Warning: tests/init-global/neg/global-cycle7.scala:6:17 -------------------------------------------------------------
+6 |  val m: Int = A.n      
+  |               ^^^
+  |               Access uninitialized field value n. Call trace: 
+  |               -> object B {	[ global-cycle7.scala:5 ]
+  |                  ^
+  |               -> val m: Int = A.n	[ global-cycle7.scala:6 ]
+  |                               ^^^
+No warnings can be incurred under -Werror.

tests/init-global/neg/global-cycle7.scala

@@ -1,9 +1,9 @@
-object A {              // error
+object A {              
   val n: Int = B.m
 }
 
 object B {
-  val m: Int = A.n      // error
+  val m: Int = A.n      
 }
 
 abstract class TokensCommon {

tests/init-global/neg/global-cycle8.check

@@ -0,0 +1,17 @@
+-- Warning: tests/init-global/neg/global-cycle8.scala:9:7 --------------------------------------------------------------
+9 |object O {           
+  |       ^
+  |       Cyclic initialization: object O -> object P -> object O. Calling trace:
+  |       -> object O {	[ global-cycle8.scala:9 ]
+  |          ^
+  |       -> println(P.m)	[ global-cycle8.scala:11 ]
+  |                  ^
+  |       -> object P {	[ global-cycle8.scala:14 ]
+  |          ^
+  |       -> val m = Q.bar(new B)	[ global-cycle8.scala:15 ]
+  |                  ^^^^^^^^^^^^
+  |       -> def bar(b: B) = b.a.foo()	[ global-cycle8.scala:19 ]
+  |                          ^^^^^^^^^
+  |       -> def foo() = println(O.n)	[ global-cycle8.scala:2 ]
+  |                              ^
+No warnings can be incurred under -Werror.

tests/init-global/neg/global-cycle8.scala

@@ -6,7 +6,7 @@ class B {
   val a = new A
 }
 
-object O {           // error
+object O {           
   val n: Int = 10
   println(P.m)
 }

tests/init-global/neg/global-irrelevance1.check

@@ -0,0 +1,10 @@
+-- Warning: tests/init-global/neg/global-irrelevance1.scala:5:12 -------------------------------------------------------
+5 |  var y = A.x * 2 
+  |          ^^^
+  |Reading mutable state of object A during initialization of object B.
+  |Reading mutable state of other static objects is forbidden as it breaks initialization-time irrelevance. Calling trace: 
+  |-> object B:	[ global-irrelevance1.scala:4 ]
+  |   ^
+  |-> var y = A.x * 2	[ global-irrelevance1.scala:5 ]
+  |           ^^^
+No warnings can be incurred under -Werror.

tests/init-global/neg/global-irrelevance1.scala

@@ -2,5 +2,5 @@ object A:
   var x = 6
 
 object B:
-  var y = A.x * 2 // error
+  var y = A.x * 2 
 // nopos-error: No warnings can be incurred under -Werror.

tests/init-global/neg/global-irrelevance2.check

@@ -0,0 +1,15 @@
+-- Warning: tests/init-global/neg/global-irrelevance2.scala:5:6 --------------------------------------------------------
+5 |  A.x =  b * 2 
+  |  ^^^^^^^^^^^^
+  |  Mutating object A during initialization of object B.
+  |  Mutating other static objects during the initialization of one static object is forbidden. Calling trace:
+  |
+  |  -> object B:	[ global-irrelevance2.scala:7 ]
+  |     ^
+  |  -> new B(10)	[ global-irrelevance2.scala:8 ]
+  |     ^^^^^^^^^
+  |  -> class B(b: Int):	[ global-irrelevance2.scala:4 ]
+  |     ^
+  |  -> A.x =  b * 2	[ global-irrelevance2.scala:5 ]
+  |     ^^^^^^^^^^^^
+No warnings can be incurred under -Werror.

tests/init-global/neg/global-irrelevance2.scala

@@ -2,7 +2,7 @@ object A:
   var x = 6
 
 class B(b: Int):
-  A.x =  b * 2 // error
+  A.x =  b * 2 
 
 object B:
   new B(10)

tests/init-global/neg/global-irrelevance3.check

@@ -0,0 +1,12 @@
+-- Warning: tests/init-global/neg/global-irrelevance3.scala:9:13 -------------------------------------------------------
+9 |      (() => x)   
+  |             ^
+  |Reading mutable state of object A during initialization of object B.
+  |Reading mutable state of other static objects is forbidden as it breaks initialization-time irrelevance. Calling trace: 
+  |-> object B:	[ global-irrelevance3.scala:13 ]
+  |   ^
+  |-> var y = A.p.g()	[ global-irrelevance3.scala:14 ]
+  |           ^^^^^^^
+  |-> (() => x)	[ global-irrelevance3.scala:9 ]
+  |          ^
+No warnings can be incurred under -Werror.

tests/init-global/neg/global-irrelevance3.scala

@@ -6,7 +6,7 @@ object A:
     var x = 6
     new Pair(
       y => x = y,
-      (() => x)   // error
+      (() => x)   
     )