SI-7974 Clean up and test 'Symbol-handling code in CleanUp

Looks like the transformation did never happen because the pattern
failed to match. Why did the pattern fail to match? Because the
Symbol.apply we see in the tree claims to be a method while
Symbol_apply defined in Definitions wants to be a value.

This issue was caused because nonPrivateMember starts spitting out
overloaded symbols after erasure.
This issue has been fixed in the earlier commit, so what happens in
this commit is adding tests and fixing documentation.

Author: soc

src/compiler/scala/tools/nsc/transform/CleanUp.scala

@@ -481,18 +481,33 @@ abstract class CleanUp extends Statics with Transform with ast.TreeDSL {
       * For instance, say we have a Scala class:
       *
       * class Cls {
-      *   // ...
-      *   def someSymbol = `symbolic
-      *   // ...
+      *   def someSymbol1 = 'Symbolic1
+      *   def someSymbol2 = 'Symbolic2
+      *   def sameSymbol1 = 'Symbolic1
+      *   val someSymbol3 = 'Symbolic3
       * }
       *
       * After transformation, this class looks like this:
       *
       * class Cls {
-      *   private "static" val <some_name>$symbolic = Symbol("symbolic")
-      *   // ...
-      *   def someSymbol = <some_name>$symbolic
-      *   // ...
+      *   private <static> var symbol$1: scala.Symbol
+      *   private <static> var symbol$2: scala.Symbol
+      *   private <static> var symbol$3: scala.Symbol
+      *   private          val someSymbol3: scala.Symbol
+      *
+      *   private <static> def <clinit> = {
+      *     symbol$1 = Symbol.apply("Symbolic1")
+      *     symbol$2 = Symbol.apply("Symbolic2")
+      *   }
+      *
+      *   private def <init> = {
+      *     someSymbol3 = symbol$3
+      *   }
+      *
+      *   def someSymbol1 = symbol$1
+      *   def someSymbol2 = symbol$2
+      *   def sameSymbol1 = symbol$1
+      *   val someSymbol3 = someSymbol3
       * }
       *
       * The reasoning behind this transformation is the following. Symbols get interned - they are stored
@@ -502,17 +517,17 @@ abstract class CleanUp extends Statics with Transform with ast.TreeDSL {
       * is accessed only once during class loading, and after that, the unique symbol is in the static
       * member. Hence, it is cheap to both reach the unique symbol and do equality checks on it.
       *
-      * And, finally, be advised - scala symbol literal and the Symbol class of the compiler
+      * And, finally, be advised - Scala's Symbol literal (scala.Symbol) and the Symbol class of the compiler
       * have little in common.
       */
       case Apply(fn, (arg @ Literal(Constant(symname: String))) :: Nil) if fn.symbol == Symbol_apply =>
         def transformApply = {
-        // add the symbol name to a map if it's not there already
-        val rhs = gen.mkMethodCall(Symbol_apply, arg :: Nil)
-        val staticFieldSym = getSymbolStaticField(tree.pos, symname, rhs, tree)
-        // create a reference to a static field
-        val ntree = typedWithPos(tree.pos)(REF(staticFieldSym))
-        super.transform(ntree)
+          // add the symbol name to a map if it's not there already
+          val rhs = gen.mkMethodCall(Symbol_apply, arg :: Nil)
+          val staticFieldSym = getSymbolStaticField(tree.pos, symname, rhs, tree)
+          // create a reference to a static field
+          val ntree = typedWithPos(tree.pos)(REF(staticFieldSym))
+          super.transform(ntree)
         }
         transformApply
 

test/files/run/t7974.check

@@ -0,0 +1,104 @@
+public class Symbols {
+
+  // compiled from: Symbols.scala
+
+
+
+  // access flags 0x12
+  private final Lscala/Symbol; someSymbol3
+
+  // access flags 0xA
+  private static Lscala/Symbol; symbol$1
+
+  // access flags 0xA
+  private static Lscala/Symbol; symbol$2
+
+  // access flags 0xA
+  private static Lscala/Symbol; symbol$3
+
+  // access flags 0x9
+  public static <clinit>()V
+   L0
+    LINENUMBER 2 L0
+    GETSTATIC scala/Symbol$.MODULE$ : Lscala/Symbol$;
+    LDC "Symbolic1"
+    INVOKEVIRTUAL scala/Symbol$.apply (Ljava/lang/String;)Lscala/Symbol;
+    PUTSTATIC Symbols.symbol$1 : Lscala/Symbol;
+   L1
+    LINENUMBER 3 L1
+    GETSTATIC scala/Symbol$.MODULE$ : Lscala/Symbol$;
+    LDC "Symbolic2"
+    INVOKEVIRTUAL scala/Symbol$.apply (Ljava/lang/String;)Lscala/Symbol;
+    PUTSTATIC Symbols.symbol$2 : Lscala/Symbol;
+   L2
+    LINENUMBER 5 L2
+    GETSTATIC scala/Symbol$.MODULE$ : Lscala/Symbol$;
+    LDC "Symbolic3"
+    INVOKEVIRTUAL scala/Symbol$.apply (Ljava/lang/String;)Lscala/Symbol;
+    PUTSTATIC Symbols.symbol$3 : Lscala/Symbol;
+    RETURN
+    MAXSTACK = 2
+    MAXLOCALS = 0
+
+  // access flags 0x1
+  public someSymbol1()Lscala/Symbol;
+   L0
+    LINENUMBER 2 L0
+    GETSTATIC Symbols.symbol$1 : Lscala/Symbol;
+    ARETURN
+   L1
+    LOCALVARIABLE this LSymbols; L0 L1 0
+    MAXSTACK = 1
+    MAXLOCALS = 1
+
+  // access flags 0x1
+  public someSymbol2()Lscala/Symbol;
+   L0
+    LINENUMBER 3 L0
+    GETSTATIC Symbols.symbol$2 : Lscala/Symbol;
+    ARETURN
+   L1
+    LOCALVARIABLE this LSymbols; L0 L1 0
+    MAXSTACK = 1
+    MAXLOCALS = 1
+
+  // access flags 0x1
+  public sameSymbol1()Lscala/Symbol;
+   L0
+    LINENUMBER 4 L0
+    GETSTATIC Symbols.symbol$1 : Lscala/Symbol;
+    ARETURN
+   L1
+    LOCALVARIABLE this LSymbols; L0 L1 0
+    MAXSTACK = 1
+    MAXLOCALS = 1
+
+  // access flags 0x1
+  public someSymbol3()Lscala/Symbol;
+   L0
+    LINENUMBER 5 L0
+    ALOAD 0
+    GETFIELD Symbols.someSymbol3 : Lscala/Symbol;
+    ARETURN
+   L1
+    LOCALVARIABLE this LSymbols; L0 L1 0
+    MAXSTACK = 1
+    MAXLOCALS = 1
+
+  // access flags 0x1
+  public <init>()V
+   L0
+    LINENUMBER 6 L0
+    ALOAD 0
+    INVOKESPECIAL java/lang/Object.<init> ()V
+   L1
+    LINENUMBER 5 L1
+    ALOAD 0
+    GETSTATIC Symbols.symbol$3 : Lscala/Symbol;
+    PUTFIELD Symbols.someSymbol3 : Lscala/Symbol;
+    RETURN
+   L2
+    LOCALVARIABLE this LSymbols; L0 L2 0
+    MAXSTACK = 2
+    MAXLOCALS = 1
+}

test/files/run/t7974/Symbols.scala

@@ -0,0 +1,6 @@
+class Symbols {
+  def someSymbol1 = 'Symbolic1
+  def someSymbol2 = 'Symbolic2
+  def sameSymbol1 = 'Symbolic1
+  val someSymbol3 = 'Symbolic3
+}

test/files/run/t7974/Test.scala

@@ -0,0 +1,20 @@
+import java.io.PrintWriter;
+
+import scala.tools.partest.BytecodeTest
+import scala.tools.asm.util._
+import scala.tools.nsc.util.stringFromWriter
+
+object Test extends BytecodeTest {
+  def show {
+    val classNode = loadClassNode("Symbols", skipDebugInfo = false)
+    val textifier = new Textifier
+    classNode.accept(new TraceClassVisitor(null, textifier, null))
+    
+    val classString = stringFromWriter(w => textifier.print(w))
+    val result =
+      classString.split('\n')
+        .dropWhile(elem => elem != "public class Symbols {")
+        .filterNot(elem => elem.startsWith("  @Lscala/reflect/ScalaSignature") || elem.startsWith("  ATTRIBUTE ScalaSig"))
+    result foreach println
+  }
+}