Remove warnings in Test infrastructure

odersky · odersky · commit b5d20c85e3b7 · 2025-09-23T14:51:46.000+02:00
diff --git a/compiler/test/dotc/comptest.scala b/compiler/test/dotc/comptest.scala
@@ -27,5 +27,5 @@ object comptest extends ParallelTesting {
         dotcDir + "tools/dotc/ast/Trees.scala"
       ),
       TestFlags("", Array("-Ylog:typer", "-Xprompt"))
-  )(TestGroup("comptest"))
+  )(using TestGroup("comptest"))
 }
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -210,8 +210,8 @@ class CompilationTests {
     implicit val testGroup: TestGroup = TestGroup("explicitNullsNeg")
     aggregateTests(
       compileFilesInDir("tests/explicit-nulls/neg", explicitNullsOptions, FileFilter.exclude(TestSources.negExplicitNullsScala2LibraryTastyExcludelisted)),
-      compileFilesInDir("tests/explicit-nulls/flexible-types-common", explicitNullsOptions and "-Yno-flexible-types"),
-      compileFilesInDir("tests/explicit-nulls/unsafe-common", explicitNullsOptions and "-Yno-flexible-types", FileFilter.exclude(TestSources.negExplicitNullsScala2LibraryTastyExcludelisted)),
+      compileFilesInDir("tests/explicit-nulls/flexible-types-common", explicitNullsOptions `and` "-Yno-flexible-types"),
+      compileFilesInDir("tests/explicit-nulls/unsafe-common", explicitNullsOptions `and` "-Yno-flexible-types", FileFilter.exclude(TestSources.negExplicitNullsScala2LibraryTastyExcludelisted)),
     ).checkExpectedErrors()
 
     locally {
@@ -231,12 +231,12 @@ class CompilationTests {
     aggregateTests(
       compileFilesInDir("tests/explicit-nulls/pos", explicitNullsOptions),
       compileFilesInDir("tests/explicit-nulls/flexible-types-common", explicitNullsOptions),
-      compileFilesInDir("tests/explicit-nulls/unsafe-common", explicitNullsOptions and "-language:unsafeNulls" and "-Yno-flexible-types"),
+      compileFilesInDir("tests/explicit-nulls/unsafe-common", explicitNullsOptions `and` "-language:unsafeNulls" `and` "-Yno-flexible-types"),
     ).checkCompile()
 
     locally {
       val tests = List(
-        compileFile("tests/explicit-nulls/flexible-unpickle/pos/Unsafe_1.scala", explicitNullsOptions without "-Yexplicit-nulls"),
+        compileFile("tests/explicit-nulls/flexible-unpickle/pos/Unsafe_1.scala", explicitNullsOptions `without` "-Yexplicit-nulls"),
         compileFile("tests/explicit-nulls/flexible-unpickle/pos/Flexible_2.scala",
         explicitNullsOptions.and("-Yflexify-tasty").withClasspath(defaultOutputDir + testGroup + "/Unsafe_1/pos/Unsafe_1")),
       ).map(_.keepOutput.checkCompile())
@@ -289,9 +289,9 @@ class CompilationTests {
       val outDir2 = defaultOutputDir + i12128Group + "/Macro_2/i12128/Macro_2"
 
       val tests = List(
-        compileFile("tests/init/special/i12128/Reflect_1.scala", i12128Options)(i12128Group),
-        compileFile("tests/init/special/i12128/Macro_2.scala", i12128Options.withClasspath(outDir1))(i12128Group),
-        compileFile("tests/init/special/i12128/Test_3.scala", options.withClasspath(outDir2))(i12128Group)
+        compileFile("tests/init/special/i12128/Reflect_1.scala", i12128Options)(using i12128Group),
+        compileFile("tests/init/special/i12128/Macro_2.scala", i12128Options.withClasspath(outDir1))(using i12128Group),
+        compileFile("tests/init/special/i12128/Test_3.scala", options.withClasspath(outDir2))(using i12128Group)
       ).map(_.keepOutput.checkCompile())
 
       tests.foreach(_.delete())
@@ -310,12 +310,12 @@ class CompilationTests {
       val classB1 = defaultOutputDir + tastyErrorGroup + "/B/v1/B"
 
       val tests = List(
-        compileFile("tests/init/tasty-error/val-or-defdef/v1/A.scala", tastyErrorOptions)(tastyErrorGroup),
-        compileFile("tests/init/tasty-error/val-or-defdef/v1/B.scala", tastyErrorOptions.withClasspath(classA1))(tastyErrorGroup),
-        compileFile("tests/init/tasty-error/val-or-defdef/v0/A.scala", tastyErrorOptions)(tastyErrorGroup),
+        compileFile("tests/init/tasty-error/val-or-defdef/v1/A.scala", tastyErrorOptions)(using tastyErrorGroup),
+        compileFile("tests/init/tasty-error/val-or-defdef/v1/B.scala", tastyErrorOptions.withClasspath(classA1))(using tastyErrorGroup),
+        compileFile("tests/init/tasty-error/val-or-defdef/v0/A.scala", tastyErrorOptions)(using tastyErrorGroup),
       ).map(_.keepOutput.checkCompile())
 
-      compileFile("tests/init/tasty-error/val-or-defdef/Main.scala", tastyErrorOptions.withClasspath(classA0).withClasspath(classB1))(tastyErrorGroup).checkExpectedErrors()
+      compileFile("tests/init/tasty-error/val-or-defdef/Main.scala", tastyErrorOptions.withClasspath(classA0).withClasspath(classB1))(using tastyErrorGroup).checkExpectedErrors()
 
       tests.foreach(_.delete())
     }
@@ -334,13 +334,13 @@ class CompilationTests {
       val classB1 = defaultOutputDir + tastyErrorGroup + "/B/v1/B"
 
       val tests = List(
-        compileFile("tests/init/tasty-error/typedef/C.scala", tastyErrorOptions)(tastyErrorGroup),
-        compileFile("tests/init/tasty-error/typedef/v1/A.scala", tastyErrorOptions.withClasspath(classC))(tastyErrorGroup),
-        compileFile("tests/init/tasty-error/typedef/v1/B.scala", tastyErrorOptions.withClasspath(classC).withClasspath(classA1))(tastyErrorGroup),
-        compileFile("tests/init/tasty-error/typedef/v0/A.scala", tastyErrorOptions.withClasspath(classC))(tastyErrorGroup),
+        compileFile("tests/init/tasty-error/typedef/C.scala", tastyErrorOptions)(using tastyErrorGroup),
+        compileFile("tests/init/tasty-error/typedef/v1/A.scala", tastyErrorOptions.withClasspath(classC))(using tastyErrorGroup),
+        compileFile("tests/init/tasty-error/typedef/v1/B.scala", tastyErrorOptions.withClasspath(classC).withClasspath(classA1))(using tastyErrorGroup),
+        compileFile("tests/init/tasty-error/typedef/v0/A.scala", tastyErrorOptions.withClasspath(classC))(using tastyErrorGroup),
       ).map(_.keepOutput.checkCompile())
 
-      compileFile("tests/init/tasty-error/typedef/Main.scala", tastyErrorOptions.withClasspath(classC).withClasspath(classA0).withClasspath(classB1))(tastyErrorGroup).checkExpectedErrors()
+      compileFile("tests/init/tasty-error/typedef/Main.scala", tastyErrorOptions.withClasspath(classC).withClasspath(classA0).withClasspath(classB1))(using tastyErrorGroup).checkExpectedErrors()
 
       tests.foreach(_.delete())
     }
diff --git a/compiler/test/dotty/tools/dotc/IdempotencyTests.scala b/compiler/test/dotty/tools/dotc/IdempotencyTests.scala
@@ -30,8 +30,8 @@ class IdempotencyTests {
     val opt = defaultOptions
 
     val posIdempotency = aggregateTests(
-      compileFilesInDir("tests/pos", opt, filter)(TestGroup("idempotency/posIdempotency1")),
-      compileFilesInDir("tests/pos", opt, filter)(TestGroup("idempotency/posIdempotency2")),
+      compileFilesInDir("tests/pos", opt, filter)(using TestGroup("idempotency/posIdempotency1")),
+      compileFilesInDir("tests/pos", opt, filter)(using TestGroup("idempotency/posIdempotency2")),
     )
 
     val orderIdempotency = {
@@ -41,16 +41,16 @@ class IdempotencyTests {
         } yield {
           val sources = TestSources.sources(testDir.toPath)
           aggregateTests(
-            compileList(testDir.getName, sources, opt)(TestGroup("idempotency/orderIdempotency1")),
-            compileList(testDir.getName, sources.reverse, opt)(TestGroup("idempotency/orderIdempotency2"))
+            compileList(testDir.getName, sources, opt)(using TestGroup("idempotency/orderIdempotency1")),
+            compileList(testDir.getName, sources.reverse, opt)(using TestGroup("idempotency/orderIdempotency2"))
           )
         }
       aggregateTests(tests*)
     }
 
     def check(name: String) = {
       val files = List(s"tests/idempotency/$name.scala", "tests/idempotency/IdempotencyCheck.scala")
-      compileList(name, files, defaultOptions)(TestGroup("idempotency/check"))
+      compileList(name, files, defaultOptions)(using TestGroup("idempotency/check"))
     }
     val allChecks = aggregateTests(
       check("CheckOrderIdempotency"),
diff --git a/compiler/test/dotty/tools/dotc/SettingsTests.scala b/compiler/test/dotty/tools/dotc/SettingsTests.scala
@@ -218,7 +218,7 @@ class SettingsTests {
 
       assertNotEquals(fileStateBefore, String(Files.readAllBytes(file)), "Jar should have been overriden")
 
-    }(Files.deleteIfExists(_))
+    }(using Files.deleteIfExists(_))
 
   @Test def `Output setting is respecting previous setting`: Unit =
     val result = Using.resources(
@@ -263,7 +263,7 @@ class SettingsTests {
 
       assertEquals(fileStateBefore, String(Files.readAllBytes(file)))
 
-    }(Files.deleteIfExists(_))
+    }(using Files.deleteIfExists(_))
 
   @Test def `Arguments of flags are correctly parsed with both ":" and " " separating`: Unit =
     object Settings extends SettingGroup:
@@ -319,7 +319,7 @@ class SettingsTests {
       testValues(summary = summaryColon)
       testValues(summary = summaryWhitespace)
 
-    }(Files.deleteIfExists(_))
+    }(using Files.deleteIfExists(_))
 
   private def withProcessedArgs(summary: ArgsSummary)(f: SettingsState ?=> Unit) = f(using summary.sstate)
 
diff --git a/compiler/test/dotty/tools/dotc/TastyBootstrapTests.scala b/compiler/test/dotty/tools/dotc/TastyBootstrapTests.scala
@@ -61,18 +61,18 @@ class TastyBootstrapTests {
       compileList("lib", librarySources,
         defaultOptions.and("-Ycheck-reentrant",
           //  "-source", "future",  // TODO: re-enable once library uses updated syntax for vararg splices, wildcard imports, and import renaming
-          ))(libGroup)
+          ))(using libGroup)
 
     val tastyCoreSources = sources(Paths.get("tasty/src"))
-    val tastyCore = compileList("tastyCore", tastyCoreSources, opt)(tastyCoreGroup)
+    val tastyCore = compileList("tastyCore", tastyCoreSources, opt)(using tastyCoreGroup)
 
     val compilerSources = sources(Paths.get("compiler/src")) ++ sources(Paths.get("compiler/src-bootstrapped"))
     val compilerManagedSources = Properties.dottyCompilerManagedSources match
       case p if Files.isDirectory(p) => sources(p)
       case _                         => Nil
 
-    val dotty1 = compileList("dotty1", compilerSources ++ compilerManagedSources, opt)(dotty1Group)
-    val dotty2 = compileList("dotty2", compilerSources ++ compilerManagedSources, opt)(dotty2Group)
+    val dotty1 = compileList("dotty1", compilerSources ++ compilerManagedSources, opt)(using dotty1Group)
+    val dotty2 = compileList("dotty2", compilerSources ++ compilerManagedSources, opt)(using dotty2Group)
 
     val tests = {
       lib.keepOutput :: tastyCore.keepOutput :: dotty1.keepOutput :: aggregateTests(
diff --git a/compiler/test/dotty/tools/dotc/config/ScalaSettingsTests.scala b/compiler/test/dotty/tools/dotc/config/ScalaSettingsTests.scala
@@ -92,7 +92,7 @@ class ScalaSettingsTests:
 
   @nowarn("cat=deprecation")
   @Test def `Deprecated options are correctly mapped to their replacements`: Unit =
-    def createTestCase(oldSetting: Setting[_], newSetting: Setting[_], value: String = "") =
+    def createTestCase(oldSetting: Setting[?], newSetting: Setting[?], value: String = "") =
       s"${oldSetting.name}$value" -> newSetting
 
     val settings = ScalaSettings
@@ -121,7 +121,7 @@ class ScalaSettingsTests:
 
   @nowarn("cat=deprecation")
   @Test def `Deprecated options should not be set if old option was incorrect`: Unit =
-    def createTestCase(oldSetting: Setting[_], newSetting: Setting[_], value: String = ":illegal") =
+    def createTestCase(oldSetting: Setting[?], newSetting: Setting[?], value: String = ":illegal") =
       s"${oldSetting.name}:$value" -> newSetting
 
     val settings = ScalaSettings
@@ -161,7 +161,7 @@ class ScalaSettingsTests:
 
   @nowarn("cat=deprecation")
   @Test def `Deprecated options aliases are correctly mapped to their replacements`: Unit =
-    def createTestCase(oldSetting: Setting[_], newSetting: Setting[_], value: String = "") =
+    def createTestCase(oldSetting: Setting[?], newSetting: Setting[?], value: String = "") =
       oldSetting.aliases.map: alias =>
         s"$alias$value" -> newSetting
 
@@ -250,7 +250,7 @@ class ScalaSettingsTests:
           )
         )
       )
-    }(Files.deleteIfExists(_))
+    }(using Files.deleteIfExists(_))
     assertEquals(result, Right(reporting.Action.Silent))
 
   @Test def `WConf src filter doesn't silence warnings from a non-matching path for real file`: Unit =
@@ -265,7 +265,7 @@ class ScalaSettingsTests:
           )
         )
       )
-    }(Files.deleteIfExists(_))
+    }(using Files.deleteIfExists(_))
     assertEquals(result, Right(reporting.Action.Warning))
 
   @Test def `WConf src filter reports an error on an invalid regex`: Unit =
diff --git a/compiler/test/dotty/tools/dotc/core/tasty/CommentPicklingTest.scala b/compiler/test/dotty/tools/dotc/core/tasty/CommentPicklingTest.scala
@@ -22,7 +22,7 @@ import dotty.tools.io.AbstractFile
 
 class CommentPicklingTest {
 
-  val compileOptions = TestConfiguration.defaultOptions and "-Ykeep-comments" and "-Yemit-tasty"
+  val compileOptions = TestConfiguration.defaultOptions `and` "-Ykeep-comments" `and` "-Yemit-tasty"
   val unpickleOptions = TestConfiguration.defaultOptions
 
   @Test def commentOnDef: Unit = {
diff --git a/compiler/test/dotty/tools/dotc/parsing/ScannerTest.scala b/compiler/test/dotty/tools/dotc/parsing/ScannerTest.scala
@@ -33,12 +33,12 @@ class ScannerTest extends DottyTest {
   def scanDir(path: String): Unit = scanDir(Directory(path))
 
   def scanDir(dir: Directory): Unit = {
-    if (excluded exists (dir.jpath.toString endsWith _))
+    if excluded.exists(dir.jpath.toString.endsWith(_)) then
       println(s"excluded package: ${dir.toAbsolute.jpath}")
     else
       for (f <- dir.files)
         if (f.name.endsWith(".scala"))
-          if (excluded exists (f.jpath.toString endsWith _))
+          if excluded.exists(f.jpath.toString.endsWith(_)) then
             println(s"excluded file: ${f.toAbsolute.jpath}")
           else
             scan(new PlainFile(f))
diff --git a/compiler/test/dotty/tools/dotc/sbt/ProgressCallbackTest.scala b/compiler/test/dotty/tools/dotc/sbt/ProgressCallbackTest.scala
@@ -149,7 +149,7 @@ final class ProgressCallbackTest extends DottyTest:
       assertEquals(s"Phase $recordedCurr was not expected", expectedCurr, recordedCurr)
 
     val (seenCurrPhases, seenNextPhases) =
-      val (currs0, nexts0) = progressCallback.progressPhasesFinal.unzip(Tuple.fromProductTyped)
+      val (currs0, nexts0) = progressCallback.progressPhasesFinal.unzip(using Tuple.fromProductTyped)
       (currs0.toSet, nexts0.toSet)
 
     val missingCurrPhases = expectedCurrPhases.diff(seenCurrPhases)
diff --git a/compiler/test/dotty/tools/repl/AbstractFileClassLoaderTest.scala b/compiler/test/dotty/tools/repl/AbstractFileClassLoaderTest.scala
@@ -18,7 +18,7 @@ class AbstractFileClassLoaderTest:
   def closing[T <: Closeable, U](stream: T)(f: T => U): U = try f(stream) finally stream.close()
 
   extension (f: AbstractFile) def writeContent(s: String): Unit = closing(f.bufferedOutput)(_.write(s.getBytes(UTF8.charSet)))
-  def slurp(inputStream: => InputStream)(implicit codec: Codec): String = closing(Source.fromInputStream(inputStream)(codec))(_.mkString)
+  def slurp(inputStream: => InputStream)(implicit codec: Codec): String = closing(Source.fromInputStream(inputStream)(using codec))(_.mkString)
   def slurp(url: URL)(implicit codec: Codec): String = slurp(url.openStream())
 
   extension (input: InputStream) def bytes: Array[Byte] =
diff --git a/compiler/test/dotty/tools/vulpix/ParallelTesting.scala b/compiler/test/dotty/tools/vulpix/ParallelTesting.scala
@@ -684,7 +684,7 @@ trait ParallelTesting extends RunnerOrchestration:
 
     protected def compileFromBestEffortTasty(flags0: TestFlags, targetDir: JFile): TestReporter = {
       val classes = flattenFiles(targetDir).filter(isBestEffortTastyFile).map(_.toString)
-      val flags = flags0 and "-from-tasty" and "-Ywith-best-effort-tasty"
+      val flags = flags0 `and` "-from-tasty" `and` "-Ywith-best-effort-tasty"
       val reporter = mkReporter
       val driver = new Driver
 
@@ -710,7 +710,7 @@ trait ParallelTesting extends RunnerOrchestration:
     protected def compileFromTasty(flags0: TestFlags, targetDir: JFile): TestReporter = {
       val tastyOutput = new JFile(targetDir.getPath + "_from-tasty")
       tastyOutput.mkdir()
-      val flags = flags0 and ("-d", tastyOutput.getPath) and "-from-tasty"
+      val flags = flags0 `and` ("-d", tastyOutput.getPath) `and` "-from-tasty"
 
       val classes = flattenFiles(targetDir).filter(isTastyFile).map(_.toString)
 
@@ -1566,7 +1566,7 @@ trait ParallelTesting extends RunnerOrchestration:
   def compileTastyInDir(f: String, flags0: TestFlags, fromTastyFilter: FileFilter)(
       implicit testGroup: TestGroup): TastyCompilationTest = {
     val outDir = defaultOutputDir + testGroup + JFile.separator
-    val flags = flags0 and "-Yretain-trees"
+    val flags = flags0 `and` "-Yretain-trees"
     val sourceDir = new JFile(f)
     checkRequirements(f, sourceDir, outDir)
 
diff --git a/compiler/test/dotty/tools/vulpix/TestConfiguration.scala b/compiler/test/dotty/tools/vulpix/TestConfiguration.scala
@@ -62,7 +62,7 @@ object TestConfiguration {
 
   val commonOptions = Array("-indent") ++ checkOptions ++ noCheckOptions ++ yCheckOptions
   val noYcheckCommonOptions = Array("-indent") ++ checkOptions ++ noCheckOptions
-  val defaultOptions = TestFlags(basicClasspath, commonOptions) and "-Yno-stdlib-patches"
+  val defaultOptions = TestFlags(basicClasspath, commonOptions) `and` "-Yno-stdlib-patches"
   val noYcheckOptions = TestFlags(basicClasspath, noYcheckCommonOptions)
   val bestEffortBaselineOptions = TestFlags(basicClasspath, noCheckOptions)
   val unindentOptions = TestFlags(basicClasspath, Array("-no-indent") ++ checkOptions ++ noCheckOptions ++ yCheckOptions)
@@ -74,9 +74,9 @@ object TestConfiguration {
     defaultOptions.withClasspath(withTastyInspectorClasspath).withRunClasspath(withTastyInspectorClasspath)
   lazy val scalaJSOptions =
     defaultOptions.and("-scalajs").withClasspath(scalaJSClasspath).withRunClasspath(scalaJSClasspath)
-  val allowDeepSubtypes = defaultOptions without "-Yno-deep-subtypes"
-  val allowDoubleBindings = defaultOptions without "-Yno-double-bindings"
-  val picklingOptions = defaultOptions and (
+  val allowDeepSubtypes = defaultOptions `without` "-Yno-deep-subtypes"
+  val allowDoubleBindings = defaultOptions `without` "-Yno-double-bindings"
+  val picklingOptions = defaultOptions `and` (
     "-Xprint-types",
     "-Ytest-pickler",
     "-Yprint-pos",
@@ -85,7 +85,7 @@ object TestConfiguration {
   val picklingWithCompilerOptions =
     picklingOptions.withClasspath(withCompilerClasspath).withRunClasspath(withCompilerClasspath)
 
-  val explicitNullsOptions = defaultOptions and "-Yexplicit-nulls"
+  val explicitNullsOptions = defaultOptions `and` "-Yexplicit-nulls"
 
   /** Default target of the generated class files */
   private def defaultTarget: String = {
diff --git a/tasty/test/dotty/tools/tasty/TastyVersionFormatTest.scala b/tasty/test/dotty/tools/tasty/TastyVersionFormatTest.scala
@@ -31,34 +31,34 @@ class TastyVersionFormatTest {
 
   /** these cases are unrelated because a final compiler can only read final tasty of <= minor version */
   @Test def reject_FinalReadFinal_GTMinor: Unit = {
-    assert(file(28,2,Final) unrelatedTo compiler(28,1,Final)) // succeeding minor
+    assert(file(28,2,Final) `unrelatedTo` compiler(28,1,Final)) // succeeding minor
   }
 
   /** these cases are unrelated because a final compiler can not read experimental tasty */
   @Test def reject_FinalReadExperimental: Unit = {
-    assert(file(28,0,Exp(1)) unrelatedTo compiler(28,1,Final)) // preceding  minor
-    assert(file(28,1,Exp(1)) unrelatedTo compiler(28,1,Final)) // same       minor
-    assert(file(28,2,Exp(1)) unrelatedTo compiler(28,1,Final)) // succeeding minor
+    assert(file(28,0,Exp(1)) `unrelatedTo` compiler(28,1,Final)) // preceding  minor
+    assert(file(28,1,Exp(1)) `unrelatedTo` compiler(28,1,Final)) // same       minor
+    assert(file(28,2,Exp(1)) `unrelatedTo` compiler(28,1,Final)) // succeeding minor
   }
 
   /** These cases are unrelated because an experimental compiler can only read final tasty of < minor version */
   @Test def reject_ExperimentalReadFinal_GTEqualMinor: Unit = {
-    assert(file(28,2,Final) unrelatedTo compiler(28,1,Exp(1))) // succeeding minor
-    assert(file(28,1,Final) unrelatedTo compiler(28,1,Exp(1))) // equal      minor
+    assert(file(28,2,Final) `unrelatedTo` compiler(28,1,Exp(1))) // succeeding minor
+    assert(file(28,1,Final) `unrelatedTo` compiler(28,1,Exp(1))) // equal      minor
   }
 
   /**These cases are unrelated because both compiler and file are experimental,
    * and with unequal experimental part.
    */
   @Test def reject_ExperimentalReadNEExperimental: Unit = {
-    assert(file(28,1,Exp(2)) unrelatedTo compiler(28,1,Exp(1))) // same minor version, succeeding experimental
-    assert(file(28,1,Exp(1)) unrelatedTo compiler(28,1,Exp(2))) // same minor version, preceding  experimental
+    assert(file(28,1,Exp(2)) `unrelatedTo` compiler(28,1,Exp(1))) // same minor version, succeeding experimental
+    assert(file(28,1,Exp(1)) `unrelatedTo` compiler(28,1,Exp(2))) // same minor version, preceding  experimental
   }
 
   /** these cases are unrelated because the major version must be identical */
   @Test def reject_NEMajor: Unit = {
-    assert(file(27,0,Final) unrelatedTo compiler(28,0,Final)) // less    than
-    assert(file(29,0,Final) unrelatedTo compiler(28,0,Final)) // greater than
+    assert(file(27,0,Final) `unrelatedTo` compiler(28,0,Final)) // less    than
+    assert(file(29,0,Final) `unrelatedTo` compiler(28,0,Final)) // greater than
   }
 
 }

Original file line number	Diff line number	Diff line change
`@@ -27,5 +27,5 @@ object comptest extends ParallelTesting {`
`27`	`27`	`dotcDir + "tools/dotc/ast/Trees.scala"`
`28`	`28`	`),`
`29`	`29`	`TestFlags("", Array("-Ylog:typer", "-Xprompt"))`
`30`		`- )(TestGroup("comptest"))`
	`30`	`+ )(using TestGroup("comptest"))`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,8 +30,8 @@ class IdempotencyTests {`
`30`	`30`	`val opt = defaultOptions`
`31`	`31`
`32`	`32`	`val posIdempotency = aggregateTests(`
`33`		`- compileFilesInDir("tests/pos", opt, filter)(TestGroup("idempotency/posIdempotency1")),`
`34`		`- compileFilesInDir("tests/pos", opt, filter)(TestGroup("idempotency/posIdempotency2")),`
	`33`	`+ compileFilesInDir("tests/pos", opt, filter)(using TestGroup("idempotency/posIdempotency1")),`
	`34`	`+ compileFilesInDir("tests/pos", opt, filter)(using TestGroup("idempotency/posIdempotency2")),`
`35`	`35`	`)`
`36`	`36`
`37`	`37`	`val orderIdempotency = {`
`@@ -41,16 +41,16 @@ class IdempotencyTests {`
`41`	`41`	`} yield {`
`42`	`42`	`val sources = TestSources.sources(testDir.toPath)`
`43`	`43`	`aggregateTests(`
`44`		`- compileList(testDir.getName, sources, opt)(TestGroup("idempotency/orderIdempotency1")),`
`45`		`- compileList(testDir.getName, sources.reverse, opt)(TestGroup("idempotency/orderIdempotency2"))`
	`44`	`+ compileList(testDir.getName, sources, opt)(using TestGroup("idempotency/orderIdempotency1")),`
	`45`	`+ compileList(testDir.getName, sources.reverse, opt)(using TestGroup("idempotency/orderIdempotency2"))`
`46`	`46`	`)`
`47`	`47`	`}`
`48`	`48`	`aggregateTests(tests*)`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`def check(name: String) = {`
`52`	`52`	`val files = List(s"tests/idempotency/$name.scala", "tests/idempotency/IdempotencyCheck.scala")`
`53`		`- compileList(name, files, defaultOptions)(TestGroup("idempotency/check"))`
	`53`	`+ compileList(name, files, defaultOptions)(using TestGroup("idempotency/check"))`
`54`	`54`	`}`
`55`	`55`	`val allChecks = aggregateTests(`
`56`	`56`	`check("CheckOrderIdempotency"),`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ class ScalaSettingsTests:`
`92`	`92`
`93`	`93`	`@nowarn("cat=deprecation")`
`94`	`94`	@Test def `Deprecated options are correctly mapped to their replacements`: Unit =
`95`		`- def createTestCase(oldSetting: Setting[_], newSetting: Setting[_], value: String = "") =`
	`95`	`+ def createTestCase(oldSetting: Setting[?], newSetting: Setting[?], value: String = "") =`
`96`	`96`	`s"${oldSetting.name}$value" -> newSetting`
`97`	`97`
`98`	`98`	`val settings = ScalaSettings`
`@@ -121,7 +121,7 @@ class ScalaSettingsTests:`
`121`	`121`
`122`	`122`	`@nowarn("cat=deprecation")`
`123`	`123`	@Test def `Deprecated options should not be set if old option was incorrect`: Unit =
`124`		`- def createTestCase(oldSetting: Setting[_], newSetting: Setting[_], value: String = ":illegal") =`
	`124`	`+ def createTestCase(oldSetting: Setting[?], newSetting: Setting[?], value: String = ":illegal") =`
`125`	`125`	`s"${oldSetting.name}:$value" -> newSetting`
`126`	`126`
`127`	`127`	`val settings = ScalaSettings`
`@@ -161,7 +161,7 @@ class ScalaSettingsTests:`
`161`	`161`
`162`	`162`	`@nowarn("cat=deprecation")`
`163`	`163`	@Test def `Deprecated options aliases are correctly mapped to their replacements`: Unit =
`164`		`- def createTestCase(oldSetting: Setting[_], newSetting: Setting[_], value: String = "") =`
	`164`	`+ def createTestCase(oldSetting: Setting[?], newSetting: Setting[?], value: String = "") =`
`165`	`165`	`oldSetting.aliases.map: alias =>`
`166`	`166`	`s"$alias$value" -> newSetting`
`167`	`167`
`@@ -250,7 +250,7 @@ class ScalaSettingsTests:`
`250`	`250`	`)`
`251`	`251`	`)`
`252`	`252`	`)`
`253`		`- }(Files.deleteIfExists(_))`
	`253`	`+ }(using Files.deleteIfExists(_))`
`254`	`254`	`assertEquals(result, Right(reporting.Action.Silent))`
`255`	`255`
`256`	`256`	@Test def `WConf src filter doesn't silence warnings from a non-matching path for real file`: Unit =
`@@ -265,7 +265,7 @@ class ScalaSettingsTests:`
`265`	`265`	`)`
`266`	`266`	`)`
`267`	`267`	`)`
`268`		`- }(Files.deleteIfExists(_))`
	`268`	`+ }(using Files.deleteIfExists(_))`
`269`	`269`	`assertEquals(result, Right(reporting.Action.Warning))`
`270`	`270`
`271`	`271`	@Test def `WConf src filter reports an error on an invalid regex`: Unit =