Prefer context functions for ReplTests

Author: som-snytt

compiler/test/dotty/tools/repl/DocTests.scala

@@ -7,109 +7,109 @@ import org.junit.Assert.assertEquals
 class DocTests extends ReplTest {
 
   @Test def docOfDef =
-    eval("/** doc */ def foo = 0").andThen { implicit s =>
+    eval("/** doc */ def foo = 0").andThen {
       assertEquals("doc", doc("foo"))
     }
 
   @Test def docOfVal =
-    eval("/** doc */ val foo = 0").andThen { implicit s =>
+    eval("/** doc */ val foo = 0").andThen {
       assertEquals("doc", doc("foo"))
     }
 
   @Test def docOfObject =
-    eval("/** doc */ object Foo").andThen { implicit s =>
+    eval("/** doc */ object Foo").andThen {
       assertEquals("doc", doc("Foo"))
     }
 
   @Test def docOfClass =
-    eval("/** doc */ class Foo").andThen { implicit s =>
+    eval("/** doc */ class Foo").andThen {
       assertEquals("doc", doc("new Foo"))
     }
 
   @Test def docOfTrait =
-    eval("/** doc */ trait Foo").andThen { implicit s =>
+    eval("/** doc */ trait Foo").andThen {
       assertEquals("doc", doc("new Foo"))
     }
 /*
   @Test def docOfExtension1 =
-    eval("/** doc */ extension (x: Int) def foo = 0").andThen { implicit s =>
+    eval("/** doc */ extension (x: Int) def foo = 0").andThen {
       assertEquals("doc", doc("extension_foo"))
     }
 
   @Test def docOfExtension2 =
-    eval("extension (x: Int) /** doc */ def foo = 0").andThen { implicit s =>
+    eval("extension (x: Int) /** doc */ def foo = 0").andThen {
       assertEquals("doc", doc("extension_foo"))
     }
 
   @Test def docOfExtension3 =
-    eval("/** doc0 */ extension (x: Int) { /** doc1 */ def foo = 0; /** doc2 */ def bar = 0; def baz = 0 }").andThen { implicit s =>
+    eval("/** doc0 */ extension (x: Int) { /** doc1 */ def foo = 0; /** doc2 */ def bar = 0; def baz = 0 }").andThen {
       assertEquals("doc1", doc("extension_foo"))
       assertEquals("doc2", doc("extension_bar"))
       assertEquals("doc0", doc("extension_baz"))
     }
 */
   @Test def docOfDefInObject =
-    eval("object O { /** doc */ def foo = 0 }").andThen { implicit s =>
+    eval("object O { /** doc */ def foo = 0 }").andThen {
       assertEquals("doc", doc("O.foo"))
     }
 
   @Test def docOfValInObject =
-    eval("object O { /** doc */ val foo = 0 }").andThen { implicit s =>
+    eval("object O { /** doc */ val foo = 0 }").andThen {
       assertEquals("doc", doc("O.foo"))
     }
 
   @Test def docOfObjectInObject =
-    eval("object O { /** doc */ object Foo }").andThen { implicit s =>
+    eval("object O { /** doc */ object Foo }").andThen {
       assertEquals("doc", doc("O.Foo"))
     }
 
   @Test def docOfClassInObject =
-    eval("object O { /** doc */ class Foo }").andThen { implicit s =>
+    eval("object O { /** doc */ class Foo }").andThen {
       assertEquals("doc", doc("new O.Foo"))
     }
 
   @Test def docOfTraitInObject =
-    eval("object O { /** doc */ trait Foo }").andThen { implicit s =>
+    eval("object O { /** doc */ trait Foo }").andThen {
       assertEquals("doc", doc("new O.Foo"))
     }
 
   @Test def docOfDefInClass =
     eval(
       """class C { /** doc */ def foo = 0 }
         |val c = new C
-      """.stripMargin).andThen { implicit s =>
+      """.stripMargin).andThen {
       assertEquals("doc", doc("c.foo"))
     }
 
   @Test def docOfValInClass =
     eval(
       """class C { /** doc */ val foo = 0 }
         |val c = new C
-      """.stripMargin).andThen { implicit s =>
+      """.stripMargin).andThen {
       assertEquals("doc", doc("c.foo"))
     }
 
   @Test def docOfObjectInClass =
     eval(
       """class C { /** doc */ object Foo }
         |val c = new C
-      """.stripMargin).andThen { implicit s =>
+      """.stripMargin).andThen {
       assertEquals("doc", doc("c.Foo"))
     }
 
   @Test def docOfClassInClass =
     eval(
       """class C { /** doc */ class Foo }
         |val c = new C
-      """.stripMargin).andThen { implicit s =>
+      """.stripMargin).andThen {
       assertEquals("doc", doc("new c.Foo"))
     }
 
   @Test def docOfTraitInClass =
     eval(
       """class C { /** doc */ trait Foo }
         |val c = new C
-      """.stripMargin).andThen { implicit s =>
+      """.stripMargin).andThen {
       assertEquals("doc", doc("new c.Foo"))
     }
 
@@ -119,7 +119,7 @@ class DocTests extends ReplTest {
         |  /** doc0 */ def foo(x: Int) = x
         |  /** doc1 */ def foo(x: String) = x
         |}
-      """.stripMargin).andThen { implicit s =>
+      """.stripMargin).andThen {
       assertEquals("doc0", doc("O.foo(_: Int)"))
       assertEquals("doc1", doc("O.foo(_: String)"))
     }
@@ -128,7 +128,7 @@ class DocTests extends ReplTest {
     eval(
       """class C { /** doc */ def foo = 0 }
         |object O extends C
-      """.stripMargin).andThen { implicit s =>
+      """.stripMargin).andThen {
       assertEquals("doc", doc("O.foo"))
     }
 
@@ -142,7 +142,7 @@ class DocTests extends ReplTest {
         |  override def foo(x: Int): Int = x
         |  /** overridden doc */ override def foo(x: String): String = x
         |}
-      """.stripMargin).andThen { implicit s =>
+      """.stripMargin).andThen {
       assertEquals("doc0", doc("O.foo(_: Int)"))
       assertEquals("overridden doc", doc("O.foo(_: String)"))
     }
@@ -158,7 +158,7 @@ class DocTests extends ReplTest {
         |    override def bar: Int = 0
         |  }
         |}
-      """.stripMargin).andThen { implicit s =>
+      """.stripMargin).andThen {
       assertEquals("companion", doc("O.foo"))
       assertEquals("doc0", doc("O.foo.bar"))
     }
@@ -173,18 +173,16 @@ class DocTests extends ReplTest {
         |  /** Expansion: $Variable */
         |  def hello = "world"
         |}
-      """.stripMargin).andThen { implicit s =>
+      """.stripMargin).andThen {
       assertEquals("Expansion: some-value", doc("Foo.hello"))
     }
 
-  @Test def docOfEmpty =
-    fromInitialState { implicit s =>
+  @Test def docOfEmpty = initially {
     run(":doc")
     assertEquals(":doc <expression>", storedOutput().trim)
   }
 
-  private def eval(code: String): State =
-    fromInitialState { implicit s => run(code) }
+  private def eval(code: String): State = initially(run(code))
 
   private def doc(expr: String)(implicit s: State): String = {
     storedOutput()

compiler/test/dotty/tools/repl/JavaDefinedTests.scala

@@ -4,12 +4,12 @@ import org.junit.Assert._
 import org.junit.Test
 
 class JavaDefinedTests extends ReplTest {
-  @Test def typeOfJavaDefinedString = fromInitialState { implicit s =>
+  @Test def typeOfJavaDefinedString = initially {
     run("String")
     assertTrue(storedOutput().contains("Java defined class String is not a value"))
   }
 
-  @Test def typeOfJavaDefinedClass = fromInitialState { implicit s =>
+  @Test def typeOfJavaDefinedClass = initially {
     run("Class")
     assertTrue(storedOutput().contains("Java defined class Class is not a value"))
   }

compiler/test/dotty/tools/repl/LoadTests.scala

@@ -46,15 +46,13 @@ class LoadTests extends ReplTest {
   )
 
   def loadTest(file: String, defs: String, runCode: String, output: String) =
-    eval(s":load ${writeFile(file)}").andThen { implicit s =>
+    eval(s":load ${writeFile(file)}").andThen {
       assertMultiLineEquals(defs, storedOutput())
       run(runCode)
       assertMultiLineEquals(output, storedOutput())
     }
 
-  private def eval(code: String): State =
-    fromInitialState { implicit s => run(code) }
-
+  private def eval(code: String): State = initially(run(code))
 }
 
 object LoadTests {