Convert test classes (2)

Author: odersky

compiler/test/dotty/tools/DottyTest.scala

@@ -54,7 +54,7 @@ trait DottyTest extends ContextEscapeDetection {
       val lastGroup = allPhases.find(x => x.contains(targetPhase)).get.takeWhile(x => !(x eq targetPhase))
       val checker = new Phase {
         def phaseName = "assertionChecker"
-        override def run(implicit ctx: Context): Unit = assertion(ctx.compilationUnit.tpdTree, ctx)
+        override def run(using ctx: Context): Unit = assertion(ctx.compilationUnit.tpdTree, ctx)
       }
       val lastGroupAppended = List(lastGroup ::: targetPhase :: Nil)
 

compiler/test/dotty/tools/dotc/EntryPointsTest.scala.disabled

@@ -50,7 +50,7 @@ class EntryPointsTest {
   private class CustomReporter extends Reporter
       with UniqueMessagePositions
       with HideNonSensicalMessages {
-    def doReport(m: Diagnostic)(implicit ctx: Context): Unit = {
+    def doReport(m: Diagnostic)(using Context): Unit = {
     }
   }
 

compiler/test/dotty/tools/dotc/ast/DesugarTests.scala

@@ -11,7 +11,7 @@ import org.junit.Assert._
 class DesugarTests extends DottyTest {
   import tpd._
 
-  private def validSym(sym: Symbol)(implicit ctx: Context): Unit = {
+  private def validSym(sym: Symbol)(using Context): Unit = {
       assert(
         // remaining symbols must be either synthetic:
         sym.is(Synthetic) ||

compiler/test/dotty/tools/dotc/ast/UntypedTreeMapTest.scala

@@ -22,7 +22,7 @@ class UntpdTreeMapTest extends DottyTest {
   def testMapInterpolatedString = {
     val tree = parse(""" q"hello ${2017}!" """)
     val identity = new UntypedTreeMap {
-      override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
+      override def transform(tree: Tree)(using Context): Tree = tree match {
         case _ =>  super.transform(tree)
       }
     }

compiler/test/dotty/tools/dotc/parsing/DeSugarTest.scala

@@ -31,10 +31,10 @@ class DeSugarTest extends ParserTest {
       finally curMode = saved
     }
 
-    def transform(tree: Tree, mode: Mode)(implicit ctx: Context): Tree = withMode(mode) { transform(tree) }
-    def transform(trees: List[Tree], mode: Mode)(implicit ctx: Context): List[Tree] = withMode(mode) { transform(trees) }
+    def transform(tree: Tree, mode: Mode)(using Context): Tree = withMode(mode) { transform(tree) }
+    def transform(trees: List[Tree], mode: Mode)(using Context): List[Tree] = withMode(mode) { transform(trees) }
 
-    override def transform(tree: Tree)(implicit ctx: Context): Tree = {
+    override def transform(tree: Tree)(using Context): Tree = {
       val tree1 = desugar(tree)(using ctx.withModeBits(curMode))
       tree1 match {
         case TypedSplice(t) =>

compiler/test/dotty/tools/dotc/parsing/parsePackage.scala

@@ -14,7 +14,7 @@ object parsePackage extends ParserTest {
   var nodes = 0
 
   val transformer = new UntypedTreeMap {
-    override def transform(tree: Tree)(implicit ctx: Context): Tree = {
+    override def transform(tree: Tree)(using Context): Tree = {
       nodes += 1
       tree match {
         case Ident(name) =>

compiler/test/dotty/tools/dotc/reporting/TestMessageLaziness.scala

@@ -9,11 +9,11 @@ import core.Contexts._
 class TestMessageLaziness extends DottyTest {
   ctx = ctx.fresh.setReporter(new NonchalantReporter)
 
-  class NonchalantReporter(implicit ctx: Context) extends Reporter
+  class NonchalantReporter(using Context) extends Reporter
   with UniqueMessagePositions with HideNonSensicalMessages {
-    def doReport(dia: Diagnostic)(implicit ctx: Context) = ???
+    def doReport(dia: Diagnostic)(using Context) = ???
 
-    override def report(dia: Diagnostic)(implicit ctx: Context) = ()
+    override def report(dia: Diagnostic)(using Context) = ()
   }
 
   case class LazyError() extends Message(ErrorMessageID.LazyErrorId) {

compiler/test/dotty/tools/dotc/reporting/TestReporter.scala

@@ -33,7 +33,7 @@ extends Reporter with UniqueMessagePositions with HideNonSensicalMessages with M
   private var _didCrash = false
   final def compilerCrashed: Boolean = _didCrash
 
-  protected final def inlineInfo(pos: SourcePosition)(implicit ctx: Context): String =
+  protected final def inlineInfo(pos: SourcePosition)(using Context): String =
     if (pos.exists) {
       if (pos.outer.exists)
         i"\ninlined at ${pos.outer}:\n" + inlineInfo(pos.outer)
@@ -53,7 +53,7 @@ extends Reporter with UniqueMessagePositions with HideNonSensicalMessages with M
   }
 
   /** Prints the message with the given position indication. */
-  def printMessageAndPos(dia: Diagnostic, extra: String)(implicit ctx: Context): Unit = {
+  def printMessageAndPos(dia: Diagnostic, extra: String)(using Context): Unit = {
     val msg = messageAndPos(dia.msg, dia.pos, diagnosticLevel(dia))
     val extraInfo = inlineInfo(dia.pos)
 
@@ -66,7 +66,7 @@ extends Reporter with UniqueMessagePositions with HideNonSensicalMessages with M
     if (extraInfo.nonEmpty) _messageBuf.append(extraInfo)
   }
 
-  override def doReport(dia: Diagnostic)(implicit ctx: Context): Unit = {
+  override def doReport(dia: Diagnostic)(using Context): Unit = {
 
     // Here we add extra information that we should know about the error message
     val extra = dia.msg match {
@@ -125,7 +125,7 @@ object TestReporter {
   def simplifiedReporter(writer: PrintWriter): TestReporter = {
     val rep = new TestReporter(writer, logPrintln, WARNING) {
       /** Prints the message with the given position indication in a simplified manner */
-      override def printMessageAndPos(dia: Diagnostic, extra: String)(implicit ctx: Context): Unit = {
+      override def printMessageAndPos(dia: Diagnostic, extra: String)(using Context): Unit = {
         def report() = {
           val msg = s"${dia.pos.line + 1}: " + dia.msg.kind + extra
           val extraInfo = inlineInfo(dia.pos)

compiler/test/dotty/tools/dotc/transform/TreeTransformerTest.scala

@@ -32,7 +32,7 @@ class TreeTransformerTest extends DottyTest {
       given Context = context
       class ConstantTransform extends MiniPhase {
 
-        override def transformLiteral(tree: tpd.Literal)(implicit ctx: Context): tpd.Tree = tpd.Literal(Constant(2))
+        override def transformLiteral(tree: tpd.Literal)(using Context): tpd.Tree = tpd.Literal(Constant(2))
         override def phaseName: String = "canReplaceConstant"
         init(ctx.base, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
       }
@@ -50,10 +50,10 @@ class TreeTransformerTest extends DottyTest {
       given Context = context
       class Transformation extends MiniPhase {
 
-        override def transformLiteral(tree: tpd.Literal)(implicit ctx: Context): tpd.Tree = tpd.Literal(Constant(-1))
+        override def transformLiteral(tree: tpd.Literal)(using Context): tpd.Tree = tpd.Literal(Constant(-1))
         override def phaseName: String = "canOverwrite"
 
-        override def transformValDef(tree: tpd.ValDef)(implicit ctx: Context): tpd.ValDef = {
+        override def transformValDef(tree: tpd.ValDef)(using Context): tpd.ValDef = {
           Assert.assertTrue("transformation of children succeeded",
             tree.rhs.toString == "Literal(Constant(-1))"
           )
@@ -77,14 +77,14 @@ class TreeTransformerTest extends DottyTest {
       class Transformation1 extends MiniPhase {
         override def phaseName: String = "transformationOrder1"
 
-        override def transformLiteral(tree: tpd.Literal)(implicit ctx: Context): tpd.Tree = {
+        override def transformLiteral(tree: tpd.Literal)(using Context): tpd.Tree = {
           Assert.assertTrue("correct constant",
             tree.const.toString == "Constant(1)"
           )
           tpd.cpy.Literal(tree)(Constant(-1))
         }
 
-        override def transformValDef(tree: tpd.ValDef)(implicit ctx: Context): tpd.ValDef = {
+        override def transformValDef(tree: tpd.ValDef)(using Context): tpd.ValDef = {
           Assert.assertTrue("transformation of children succeeded",
             tree.rhs.toString == "Literal(Constant(-1))"
           )
@@ -95,7 +95,7 @@ class TreeTransformerTest extends DottyTest {
       }
       class Transformation2 extends MiniPhase {
         override def phaseName: String = "transformationOrder2"
-        override def transformValDef(tree: tpd.ValDef)(implicit ctx: Context): tpd.ValDef = {
+        override def transformValDef(tree: tpd.ValDef)(using Context): tpd.ValDef = {
           Assert.assertTrue("transformation of children succeeded",
             tree.rhs.toString == "Literal(Constant(2))"
           )
@@ -119,15 +119,15 @@ class TreeTransformerTest extends DottyTest {
       var transformed1 = 0
       class Transformation1 extends MiniPhase {
         override def phaseName: String = "invocationCount1"
-        override def transformLiteral(tree: tpd.Literal)(implicit ctx: Context): tpd.Tree = {
+        override def transformLiteral(tree: tpd.Literal)(using Context): tpd.Tree = {
           transformed1 += 1
           Assert.assertTrue("correct constant",
             tree.const.toString == "Constant(1)"
           )
           tpd.cpy.Literal(tree)(Constant(-1))
         }
 
-        override def transformValDef(tree: tpd.ValDef)(implicit ctx: Context) = {
+        override def transformValDef(tree: tpd.ValDef)(using Context) = {
           transformed1 += 1
           Assert.assertTrue("transformation of children succeeded",
             tree.rhs.toString == "Literal(Constant(-3))"
@@ -141,7 +141,7 @@ class TreeTransformerTest extends DottyTest {
       class Transformation2 extends MiniPhase {
         var constantsSeen = 0
         override def phaseName: String = "invocationCount2"
-        override def transformLiteral(tree: tpd.Literal)(implicit ctx: Context): tpd.Tree = {
+        override def transformLiteral(tree: tpd.Literal)(using Context): tpd.Tree = {
           transformed2 += 1
           constantsSeen match {
             case 0 =>
@@ -158,7 +158,7 @@ class TreeTransformerTest extends DottyTest {
           tpd.cpy.Literal(tree)(Constant(-3))
         }
 
-        override def transformValDef(tree: tpd.ValDef)(implicit ctx: Context) = {
+        override def transformValDef(tree: tpd.ValDef)(using Context) = {
           transformed2 += 1
           Assert.assertTrue("transformation of children succeeded",
             tree.rhs.toString == "Literal(Constant(-3))"

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

@@ -467,7 +467,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
           private def ntimes(n: Int)(op: Int => Reporter): Reporter =
             (1 to n).foldLeft(emptyReporter) ((_, i) => op(i))
 
-          override def doCompile(comp: Compiler, files: List[String])(implicit ctx: Context) =
+          override def doCompile(comp: Compiler, files: List[String])(using Context) =
             ntimes(times) { run =>
               val start = System.nanoTime()
               val rep = super.doCompile(comp, files)