Explicit ModifiersParsingTest.parse

Author: OlivierBlanvillain

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

@@ -16,7 +16,7 @@ import core.Flags
 object ModifiersParsingTest {
   implicit val ctx: Context = (new ContextBase).initialCtx
 
-  implicit def parse(code: String): Tree = {
+  def parse(code: String): Tree = {
     val (_, stats) = new Parser(new SourceFile("<meta>", code)).templateStatSeq()
     stats match { case List(stat) => stat; case stats => Thicket(stats) }
   }
@@ -78,42 +78,42 @@ class ModifiersParsingTest {
 
 
   @Test def valDef = {
-    var source: Tree = "class A(var a: Int)"
+    var source = parse("class A(var a: Int)")
     assert(source.firstConstrValDef.modifiers == List(Mod.Var()))
 
-    source = "class A(val a: Int)"
+    source = parse("class A(val a: Int)")
     assert(source.firstConstrValDef.modifiers == List())
 
-    source = "class A(private val a: Int)"
+    source = parse("class A(private val a: Int)")
     assert(source.firstConstrValDef.modifiers == List(Mod.Private()))
 
-    source = "class A(protected var a: Int)"
+    source = parse("class A(protected var a: Int)")
     assert(source.firstConstrValDef.modifiers == List(Mod.Protected(), Mod.Var()))
 
-    source = "class A(protected implicit val a: Int)"
+    source = parse("class A(protected implicit val a: Int)")
     assert(source.firstConstrValDef.modifiers == List(Mod.Protected(), Mod.Implicit()))
 
-    source = "class A[T]"
+    source = parse("class A[T]")
     assert(source.firstTypeParam.modifiers == List())
   }
 
   @Test def typeDef = {
-    var source: Tree = "class A"
+    var source = parse("class A")
     assert(source.modifiers == List())
 
-    source = "sealed class A"
+    source = parse("sealed class A")
     assert(source.modifiers == List(Mod.Sealed()))
 
-    source = "implicit class A"
+    source = parse("implicit class A")
     assert(source.modifiers == List(Mod.Implicit()))
 
-    source = "abstract sealed class A"
+    source = parse("abstract sealed class A")
     assert(source.modifiers == List(Mod.Abstract(), Mod.Sealed()))
   }
 
   @Test def fieldDef = {
-    val source: Tree =
-      """
+    val source =
+      parse("""
         | class A {
         |   lazy var a = ???
         |   lazy private val b = ???
@@ -122,7 +122,7 @@ class ModifiersParsingTest {
         |   abstract override def f: Boolean
         |   transparent def g(n: Int) = ???
         | }
-      """.stripMargin
+      """.stripMargin)
 
     assert(source.field("a").modifiers == List(Mod.Lazy(), Mod.Var()))
     assert(source.field("b").modifiers == List(Mod.Lazy(), Mod.Private()))
@@ -132,29 +132,29 @@ class ModifiersParsingTest {
   }
 
   @Test def paramDef = {
-    var source: Tree = "def f(transparent a: Int) = ???"
+    var source: Tree = parse("def f(transparent a: Int) = ???")
     assert(source.defParam(0).modifiers == List(Mod.Transparent()))
 
-    source = "def f(implicit a: Int, b: Int) = ???"
+    source = parse("def f(implicit a: Int, b: Int) = ???")
     assert(source.defParam(0).modifiers == List(Mod.Implicit()))
     assert(source.defParam(1).modifiers == List(Mod.Implicit()))
 
-    source = "def f(x: Int, y: Int)(implicit a: Int, b: Int) = ???"
+    source = parse("def f(x: Int, y: Int)(implicit a: Int, b: Int) = ???")
     assert(source.defParam(0, 0).modifiers == List())
     assert(source.defParam(1, 0).modifiers == List(Mod.Implicit()))
   }
 
   @Test def blockDef = {
-    var source: Tree = "implicit val x : A = ???"
+    var source: Tree = parse("implicit val x : A = ???")
     assert(source.modifiers == List(Mod.Implicit()))
 
-    source = "implicit var x : A = ???"
+    source = parse("implicit var x : A = ???")
     assert(source.modifiers == List(Mod.Implicit(), Mod.Var()))
 
-    source = "{ implicit var x : A = ??? }"
+    source = parse("{ implicit var x : A = ??? }")
     assert(source.stat(0).modifiers == List(Mod.Implicit(), Mod.Var()))
 
-    source = "{ implicit x => x * x }"
+    source = parse("{ implicit x => x * x }")
     assert(source.stat(0).funParam(0).modifiers == List(Mod.Implicit()))
   }
 }