Update tests to not use symbol literals

All tests were automatically rewritten

Author: odersky

tests/pos/sip23-symbols.scala renamed to tests/invalid/pos/sip23-symbols.scala

@@ -1,7 +1,7 @@
 object Test {
-  val sym0 = 's
+  val sym0 = 's // error: no longer supported
   //sym0: Symbol
-  sym0: 's // error
+  sym0: 's // error // error: no longer supported
 
   //val sym1: 's = 's
   //sym1: Symbol
@@ -15,9 +15,9 @@ object Test {
   type Identity[T] = T
   def narrow[T <: Singleton](t: T): Identity[T] = t
 
-  final val sym3 = id('s)
+  final val sym3 = id('s)   // error: no longer supported
   //sym3: Symbol
-  sym3: 's // error
+  sym3: 's // error // error: no longer supported
 
   //val sym4 = narrow('s)
   //sym4: Symbol

tests/neg/sip23-symbols.scala

@@ -70,7 +70,7 @@ object desugar {
   }
 
   object misc {
-    'hello
+    Symbol("hello")
     s"this is a $x + ${x + y} string"
     type ~[X, Y] = Tuple2[X, Y]
     val pair: Int ~ String = 1 -> "abc"

tests/pos/desugar.scala

@@ -5,5 +5,4 @@ object Test {
   val d: 1.0 = 1.0
   val e: true = true
   val f: '*' = '*'
-  val g: 'a = 'a
 }

tests/pos/literals.scala

@@ -1,7 +1,7 @@
 object Test {
-  def a = 'a
-  def b = 'B
-  def c = '+
+  def a = Symbol("a")
+  def b = Symbol("B")
+  def c = Symbol("+")
   //def d = '`\n` //error: unclosed character literal
-  def e = '\u0041
+  def e = Symbol("\u0041")
 }

tests/pos/t389.scala

@@ -303,17 +303,17 @@ object LispAny extends Lisp {
   def asBoolean(x: Data): Boolean = x != 0
 
   def normalize(x: Data): Data = x match {
-    case 'and :: x :: y :: Nil =>
-      normalize('if :: x :: y :: 0 :: Nil)
-    case 'or :: x :: y :: Nil =>
-      normalize('if :: x :: 1 :: y :: Nil)
-    case 'def :: (name :: args) :: body :: expr :: Nil =>
-      normalize('def :: name :: ('lambda :: args :: body :: Nil) :: expr :: Nil)
-    case 'cond :: ('else :: expr :: Nil) :: rest =>
+    case Symbol("and") :: x :: y :: Nil =>
+      normalize(Symbol("if") :: x :: y :: 0 :: Nil)
+    case Symbol("or") :: x :: y :: Nil =>
+      normalize(Symbol("if") :: x :: 1 :: y :: Nil)
+    case Symbol("def") :: (name :: args) :: body :: expr :: Nil =>
+      normalize(Symbol("def") :: name :: (Symbol("lambda") :: args :: body :: Nil) :: expr :: Nil)
+    case Symbol("cond") :: (Symbol("else") :: expr :: Nil) :: rest =>
         normalize(expr);
-    case 'cond :: (test :: expr :: Nil) :: rest =>
-    normalize('if :: test :: expr :: ('cond :: rest) :: Nil)
-    case 'cond :: 'else :: expr :: Nil =>
+    case Symbol("cond") :: (test :: expr :: Nil) :: rest =>
+    normalize(Symbol("if") :: test :: expr :: (Symbol("cond") :: rest) :: Nil)
+    case Symbol("cond") :: Symbol("else") :: expr :: Nil =>
       normalize(expr)
     case h :: t =>
       normalize(h) :: asList(normalize(t))
@@ -342,15 +342,15 @@ object LispAny extends Lisp {
   def eval1(x: Data, env: Environment): Data = x match {
     case Symbol(name) =>
       env lookup name
-    case 'def :: Symbol(name) :: y :: z :: Nil =>
+    case Symbol("def") :: Symbol(name) :: y :: z :: Nil =>
       eval(z, env.extendRec(name, (env1 => eval(y, env1))))
-    case 'val :: Symbol(name) :: y :: z :: Nil =>
+    case Symbol("val") :: Symbol(name) :: y :: z :: Nil =>
       eval(z, env.extend(name, eval(y, env)))
-    case 'lambda :: params :: y :: Nil =>
+    case Symbol("lambda") :: params :: y :: Nil =>
       mkLambda(params, y, env)
-    case 'if :: c :: y :: z :: Nil =>
+    case Symbol("if") :: c :: y :: z :: Nil =>
       if (asBoolean(eval(c, env))) eval(y, env) else eval(z, env)
-    case 'quote :: y :: Nil =>
+    case Symbol("quote") :: y :: Nil =>
       y
     case y :: z =>
       apply(eval(y, env), z map (x => eval(x, env)))

tests/pos/t4579.scala

@@ -1,4 +1,4 @@
 trait Test1 {
-  def m1(sym: Symbol = 'TestSym): Unit
+  def m1(sym: Symbol = Symbol("TestSym")): Unit
   def m2(s: String = "TestString"): Unit
 }

tests/pos/t4812.scala

@@ -206,7 +206,7 @@ object Test {
   val a2: Int     = 0;
   val a3: Null  = null;
   val a4: String  = "a-z";
-  val a5: Symbol  = 'token;
+  val a5: Symbol  = Symbol("token");
   val a6: HashMap = new HashMap();
   val a7: TreeMap = scala.collection.immutable.TreeMap.empty[Int, Any];
   val a8: Strings = List("a", "z");

tests/run/arrays.scala

@@ -6,7 +6,7 @@
 
 object Test extends dotty.runtime.LegacyApp {
   val xs = List(1, 2, 3)
-  val ys = List('a, 'b, 'c)
+  val ys = List(Symbol("a"), Symbol("b"), Symbol("c"))
 
   def it = 0 until 10
 

tests/run/fors.scala

@@ -4,7 +4,7 @@ trait B {
   self: A =>
 
   def test: Unit = {
-    println('blubber)
+    println(Symbol("blubber"))
   }
 }
 

tests/run/t4601.scala

@@ -1,22 +1,22 @@
 object Test extends dotty.runtime.LegacyApp {
   import collection.mutable.ListBuffer
 
-  def newLB = ListBuffer('a, 'b, 'c, 'd, 'e)
+  def newLB = ListBuffer(Symbol("a"), Symbol("b"), Symbol("c"), Symbol("d"), Symbol("e"))
 
   def iiobe[A](f: => A) =
     try { f }
     catch { case ex: IndexOutOfBoundsException => println(ex) }
 
   val lb0 = newLB
-  iiobe( lb0.insert(-1, 'x) )
+  iiobe( lb0.insert(-1, Symbol("x")) )
 
   val lb1 = newLB
-  iiobe( lb1.insertAll(-2, Array('x, 'y, 'z)) )
+  iiobe( lb1.insertAll(-2, Array(Symbol("x"), Symbol("y"), Symbol("z"))) )
 
   val lb2 = newLB
-  iiobe( lb2.update(-3, 'u) )
+  iiobe( lb2.update(-3, Symbol("u")) )
 
   val lb3 = newLB
-  iiobe( lb3.updated(-1, 'u) )
-  iiobe( lb3.updated(5, 'u) )
+  iiobe( lb3.updated(-1, Symbol("u")) )
+  iiobe( lb3.updated(5, Symbol("u")) )
 }

tests/run/t6632.scala

@@ -1,20 +1,20 @@
 object Test extends dotty.runtime.LegacyApp {
   import collection.mutable.ListBuffer
 
-  def newLB = ListBuffer('a, 'b, 'c, 'd, 'e)
+  def newLB = ListBuffer(Symbol("a"), Symbol("b"), Symbol("c"), Symbol("d"), Symbol("e"))
 
   val lb0 = newLB
 
   try {
-    lb0.insert(9, 'x)
+    lb0.insert(9, Symbol("x"))
   } catch {
     case ex: IndexOutOfBoundsException => println(ex)
   }
 
   val lb1 = newLB
 
   try {
-    lb1.insert(9, 'x)
+    lb1.insert(9, Symbol("x"))
   } catch {
     case ex: IndexOutOfBoundsException =>
   }

tests/run/t6633.scala

@@ -2,7 +2,7 @@ import collection.mutable.ListBuffer
 
 //object Test extends dotty.runtime.LegacyApp {
 object Test extends App {
-  def newLB = ListBuffer('a, 'b, 'c, 'd, 'e)
+  def newLB = ListBuffer(Symbol("a"), Symbol("b"), Symbol("c"), Symbol("d"), Symbol("e"))
 
   val lb0 = newLB
   println("Trying lb0 ...")

tests/run/t6634.scala

@@ -1,4 +1,4 @@
 trait MixinWithSymbol {
   self: MotherClass =>
-  def symbolFromTrait: Any = 'traitSymbol
+  def symbolFromTrait: Any = Symbol("traitSymbol")
 }

tests/run/t8933b/A.scala

@@ -1,5 +1,5 @@
 class MotherClass extends MixinWithSymbol {
-  def foo = 'sym1
+  def foo = Symbol("sym1")
 }
 
 object Test {