Fix #1997: @JSSymbol support for native JS classes

We introduce @JSSymbol as a pendant to @JsName to define member access
through ES6 symbols. On a high level, the following happens in the
compiler:

**PrepJSInterop / Definition Site**

Take the content of @JSSymbol annotations and put it into a special
method, the "symbol forwarder". This is necessary, since otherwise the
trees won't get compiled. As a nice side effect, it allows changing the
symbol without breaking binary compatibility.

Further, we replace the tree inside @JSSymbol with a simple tree calling
the symbol forwarder. This tree will not get compiled, but we will only
use its symbol.

**PrepJSInterop / Call Site**

Nothing.

**GenJSCode / Definition Site**

We emit symbol forwarders as static methods on the native JS class. This
does not need an IR change, since this is already supported (but was
unused so far).

For traits pre 2.12.0, this is a bit more involved, since the symbol
forwarder gets moved to the implementation class. We retrieve the
implementation class and move the forwarder.

**GenJSCode / Call Site**

Instead of generating a string literal inside the bracket select, we
generate a call to the symbol forwarder. The symbol forwarder's symbol
is conveniently available inside the tree of the @JSSymbol annotation.

**Caveat**

Since we generate number suffixes to disambiguate symbol forwarder
overloads, adding an overload to a method with @JSSymbol is a
potentially binary breaking change.

Author: gzm0

compiler/src/main/scala/org/scalajs/core/compiler/GenJSCode.scala

@@ -183,11 +183,11 @@ abstract class GenJSCode extends plugins.PluginComponent
 
     // Global class generation state -------------------------------------------
 
-    private val lazilyGeneratedAnonClasses = mutable.Map.empty[Symbol, ClassDef]
+    private val lazilyGeneratedClasses = mutable.Map.empty[Symbol, ClassDef]
     private val generatedClasses =
       ListBuffer.empty[(Symbol, Option[String], js.ClassDef)]
 
-    private def consumeLazilyGeneratedAnonClass(sym: Symbol): ClassDef = {
+    private def consumeLazilyGeneratedClass(sym: Symbol): ClassDef = {
       /* If we are trying to generate an method as JSFunction, we cannot
        * actually consume the symbol, since we might fail trying and retry.
        * We will then see the same tree again and not find the symbol anymore.
@@ -197,9 +197,9 @@ abstract class GenJSCode extends plugins.PluginComponent
        */
       val optDef = {
         if (tryingToGenMethodAsJSFunction)
-          lazilyGeneratedAnonClasses.get(sym)
+          lazilyGeneratedClasses.get(sym)
         else
-          lazilyGeneratedAnonClasses.remove(sym)
+          lazilyGeneratedClasses.remove(sym)
       }
 
       optDef.getOrElse {
@@ -233,7 +233,7 @@ abstract class GenJSCode extends plugins.PluginComponent
      *
      *  Other ClassDefs are emitted according to their nature:
      *  * Scala.js-defined JS class     -> `genScalaJSDefinedJSClass()`
-     *  * Other raw JS type (<: js.Any) -> `genRawJSClassData()`
+     *  * Other raw JS type (<: js.Any) -> `genRawJSClass()`
      *  * Interface                     -> `genInterface()`
      *  * Implementation class          -> `genImplClass()`
      *  * Normal class                  -> `genClass()`
@@ -249,8 +249,8 @@ abstract class GenJSCode extends plugins.PluginComponent
         }
         val allClassDefs = collectClassDefs(cunit.body)
 
-        /* There are three types of anonymous classes we want to generate
-         * only once we need them so we can inline them at construction site:
+        /* There are four types of classes we want to generate only once we need
+         * them so we can inline them at usage site:
          *
          * - lambdas for js.FunctionN and js.ThisFunctionN (SAMs). (We may not
          *   generate actual Scala classes for these).
@@ -260,33 +260,36 @@ abstract class GenJSCode extends plugins.PluginComponent
          * - lambdas for scala.FunctionN. This is only an optimization and may
          *   fail. In the case of failure, we fall back to generating a
          *   fully-fledged Scala class.
+         * - Implementation classes for native JS classes. The only useful
+         *   thing they contain are symbol forwarders for @JSSymbol access.
+         *   We want to emit the symbol forwarders as static methods on the
+         *   native JS class so we do not need to generate another class file.
          *
          * Since for all these, we don't know how they inter-depend, we just
          * store them in a map at this point.
          */
-        val (lazyAnons, fullClassDefs) = allClassDefs.partition { cd =>
+        def isRawJSImplClass(sym: Symbol) = {
+          sym.isImplClass && isRawJSType(sym.owner.info.decl(
+              sym.name.dropRight(nme.IMPL_CLASS_SUFFIX.length)).tpe)
+        }
+
+        val (lazyClasses, fullClassDefs) = allClassDefs.partition { cd =>
           val sym = cd.symbol
           isRawJSFunctionDef(sym) || sym.isAnonymousFunction ||
-          isScalaJSDefinedAnonJSClass(sym)
+          isScalaJSDefinedAnonJSClass(sym) || isRawJSImplClass(sym)
         }
 
-        lazilyGeneratedAnonClasses ++= lazyAnons.map(cd => cd.symbol -> cd)
+        lazilyGeneratedClasses ++= lazyClasses.map(cd => cd.symbol -> cd)
 
         /* Finally, we emit true code for the remaining class defs. */
         for (cd <- fullClassDefs) {
           val sym = cd.symbol
           implicit val pos = sym.pos
 
           /* Do not actually emit code for primitive types nor scala.Array. */
-          val isPrimitive =
-            isPrimitiveValueClass(sym) || (sym == ArrayClass)
+          val isPrimitive = isPrimitiveValueClass(sym) || (sym == ArrayClass)
 
-          /* Similarly, do not emit code for impl classes of raw JS traits. */
-          val isRawJSImplClass =
-            sym.isImplClass && isRawJSType(
-                sym.owner.info.decl(sym.name.dropRight(nme.IMPL_CLASS_SUFFIX.length)).tpe)
-
-          if (!isPrimitive && !isRawJSImplClass) {
+          if (!isPrimitive) {
             withScopedVars(
                 currentClassSym          := sym,
                 unexpectedMutatedFields  := mutable.Set.empty,
@@ -298,7 +301,7 @@ abstract class GenJSCode extends plugins.PluginComponent
                 if (!sym.isTraitOrInterface && isScalaJSDefinedJSClass(sym))
                   genScalaJSDefinedJSClass(cd)
                 else
-                  genRawJSClassData(cd)
+                  genRawJSClass(cd)
               } else if (sym.isTraitOrInterface) {
                 genInterface(cd)
               } else if (sym.isImplClass) {
@@ -319,7 +322,7 @@ abstract class GenJSCode extends plugins.PluginComponent
           genIRFile(cunit, sym, suffix, tree)
         }
       } finally {
-        lazilyGeneratedAnonClasses.clear()
+        lazilyGeneratedClasses.clear()
         generatedClasses.clear()
         pos2irPosCache.clear()
       }
@@ -531,7 +534,7 @@ abstract class GenJSCode extends plugins.PluginComponent
           "Generating AnonSJSDefinedNew of non anonymous SJSDefined JS class")
 
       // Find the ClassDef for this anonymous class
-      val classDef = consumeLazilyGeneratedAnonClass(sym)
+      val classDef = consumeLazilyGeneratedClass(sym)
 
       // Generate a normal SJSDefinedJSClass
       val origJsClass =
@@ -685,9 +688,8 @@ abstract class GenJSCode extends plugins.PluginComponent
 
     // Generate the class data of a raw JS class -------------------------------
 
-    /** Gen the IR ClassDef for a raw JS class or trait.
-     */
-    def genRawJSClassData(cd: ClassDef): js.ClassDef = {
+    /** Gen the IR ClassDef for a raw JS class or trait. */
+    def genRawJSClass(cd: ClassDef): js.ClassDef = {
       val sym = cd.symbol
       implicit val pos = sym.pos
 
@@ -704,8 +706,56 @@ abstract class GenJSCode extends plugins.PluginComponent
         if (sym.isTraitOrInterface) None
         else Some(jsNativeLoadSpecOf(sym))
 
+      lazy val implMethodsByName: Map[String, DefDef] = {
+        val implClassDef = consumeLazilyGeneratedClass(sym.implClass)
+
+        def gen(tree: Tree): List[(String, DefDef)] = tree match {
+          case Template(_, _, body) => body.flatMap(gen)
+
+          case dd: DefDef =>
+            List(dd.symbol.unexpandedName.encoded -> dd)
+
+          case _ => Nil
+        }
+
+        gen(implClassDef.impl).toMap
+      }
+
+      // Generates symbol forwarders
+      def gen(tree: Tree): List[js.MethodDef] = tree match {
+        case Template(_, _, body) => body.flatMap(gen)
+
+        case dd: DefDef if jsInterop.isSymbolForwarder(dd.symbol) =>
+          val sym = dd.symbol
+          val patchedDef = {
+            if (scalaUsesImplClasses && sym.owner.isTraitOrInterface) {
+              assert(sym.isDeferred, "Found non-abstract method in trait at " +
+                s"${dd.pos}: ${sym.fullName}")
+
+              /* We grab the body from the implementation class. This does not
+               * work so directly in general, since the parameter symbols and
+               * the `this` reference would be wrong in the body. Here it works,
+               * because we have a static, parameterless method.
+               */
+              val nrhs = implMethodsByName(sym.unexpandedName.encoded).rhs
+              treeCopy.DefDef(dd, dd.mods, dd.name, dd.tparams,
+                  dd.vparamss, dd.tpt, nrhs)
+            } else {
+              assert(!sym.isDeferred, "Found an abstract symbol forwarder at " +
+                  s"${dd.pos}: ${sym.fullName}")
+              dd  // No patching necessary.
+            }
+          }
+
+          genMethod(patchedDef).toList
+
+        case _ => Nil
+      }
+
+      val generatedMethods = Hashers.hashDefs(gen(cd.impl))
+
       js.ClassDef(classIdent, kind, superClass, genClassInterfaces(sym),
-          jsNativeLoadSpec, Nil)(
+          jsNativeLoadSpec, generatedMethods)(
           OptimizerHints.empty)
     }
 
@@ -1255,7 +1305,8 @@ abstract class GenJSCode extends plugins.PluginComponent
         if (scalaPrimitives.isPrimitive(sym) &&
             !jsPrimitives.shouldEmitPrimitiveBody(sym)) {
           None
-        } else if (isAbstractMethod(dd)) {
+        } else if (isAbstractMethod(dd) && !(scalaUsesImplClasses &&
+            jsInterop.isSymbolForwarder(sym))) {
           val body = if (scalaUsesImplClasses &&
               sym.hasAnnotation(JavaDefaultMethodAnnotation)) {
             /* For an interface method with @JavaDefaultMethod, make it a
@@ -1297,10 +1348,13 @@ abstract class GenJSCode extends plugins.PluginComponent
               case _          => false
             }
 
+            val isSymbolForwarder = jsInterop.isSymbolForwarder(sym)
+
             val shouldMarkInline = {
               sym.hasAnnotation(InlineAnnotationClass) ||
               sym.name.startsWith(nme.ANON_FUN_NAME) ||
-              adHocInlineMethods.contains(sym.fullName)
+              adHocInlineMethods.contains(sym.fullName) ||
+              isSymbolForwarder
             }
 
             val shouldMarkNoinline = {
@@ -1328,8 +1382,9 @@ abstract class GenJSCode extends plugins.PluginComponent
                     Some(genStat(rhs)))(optimizerHints, None)
               } else {
                 val resultIRType = toIRType(sym.tpe.resultType)
-                genMethodDef(static = sym.owner.isImplClass, methodName,
-                    params, resultIRType, rhs, optimizerHints)
+                val static = sym.owner.isImplClass || isSymbolForwarder
+                genMethodDef(static, methodName, params, resultIRType, rhs,
+                    optimizerHints)
               }
             }
 
@@ -2173,10 +2228,10 @@ abstract class GenJSCode extends plugins.PluginComponent
       } else if (isHijackedBoxedClass(clsSym)) {
         genNewHijackedBoxedClass(clsSym, ctor, args map genExpr)
       } else if (isRawJSFunctionDef(clsSym)) {
-        val classDef = consumeLazilyGeneratedAnonClass(clsSym)
+        val classDef = consumeLazilyGeneratedClass(clsSym)
         genRawJSFunction(classDef, args.map(genExpr))
       } else if (clsSym.isAnonymousFunction) {
-        val classDef = consumeLazilyGeneratedAnonClass(clsSym)
+        val classDef = consumeLazilyGeneratedClass(clsSym)
         tryGenAnonFunctionClass(classDef, args.map(genExpr)).getOrElse {
           // Cannot optimize anonymous function class. Generate full class.
           generatedClasses +=
@@ -3949,7 +4004,8 @@ abstract class GenJSCode extends plugins.PluginComponent
       def hasExplicitJSEncoding =
         sym.hasAnnotation(JSNameAnnotation) ||
         sym.hasAnnotation(JSBracketAccessAnnotation) ||
-        sym.hasAnnotation(JSBracketCallAnnotation)
+        sym.hasAnnotation(JSBracketCallAnnotation) ||
+        sym.hasAnnotation(JSSymbolAnnotation)
 
       val boxedResult = sym.name match {
         case JSUnaryOpMethodName(code) if argc == 0 =>
@@ -3969,7 +4025,13 @@ abstract class GenJSCode extends plugins.PluginComponent
           js.JSFunctionApply(receiver, args)
 
         case _ =>
-          def jsFunName = js.StringLiteral(jsNameOf(sym))
+          def jsFunName: js.Tree = {
+            sym.getAnnotation(JSSymbolAnnotation).fold[js.Tree] {
+              js.StringLiteral(jsNameOf(sym))
+            } { annot =>
+              genApplyStatic(annot.args(0).symbol, Nil)
+            }
+          }
 
           def genSuperReference(propName: js.Tree): js.Tree = {
             superIn.fold[js.Tree] {

compiler/src/main/scala/org/scalajs/core/compiler/JSDefinitions.scala

@@ -55,6 +55,7 @@ trait JSDefinitions { self: JSGlobalAddons =>
     lazy val JavaScriptExceptionClass = getClassIfDefined("scala.scalajs.js.JavaScriptException")
 
     lazy val JSNameAnnotation          = getRequiredClass("scala.scalajs.js.annotation.JSName")
+    lazy val JSSymbolAnnotation        = getRequiredClass("scala.scalajs.js.annotation.JSSymbol")
     lazy val JSFullNameAnnotation      = getRequiredClass("scala.scalajs.js.annotation.JSFullName")
     lazy val JSBracketAccessAnnotation = getRequiredClass("scala.scalajs.js.annotation.JSBracketAccess")
     lazy val JSBracketCallAnnotation   = getRequiredClass("scala.scalajs.js.annotation.JSBracketCall")

compiler/src/main/scala/org/scalajs/core/compiler/JSGlobalAddons.scala

@@ -43,9 +43,11 @@ trait JSGlobalAddons extends JSDefinitions
     private val jsNativeLoadSpecs =
       mutable.Map.empty[Symbol, JSNativeLoadSpec]
 
-    private val exportPrefix = "$js$exported$"
+    private val jsPrefix = "$js$"
+    private val exportPrefix = jsPrefix + "exported$"
     private val methodExportPrefix = exportPrefix + "meth$"
     private val propExportPrefix = exportPrefix + "prop$"
+    private val symbolForwarderPrefix = jsPrefix + "jssym$"
 
     trait ExportInfo {
       val jsName: String
@@ -86,6 +88,14 @@ trait JSGlobalAddons extends JSDefinitions
       sym.unexpandedName.startsWith(exportPrefix) &&
       !sym.hasFlag(Flags.DEFAULTPARAM)
 
+    def symbolForwarderName(target: Symbol, num: Int): TermName = {
+      val suffix = target.unexpandedName.encodedName + "$" + num
+      newTermName(symbolForwarderPrefix + suffix)
+    }
+
+    def isSymbolForwarder(sym: Symbol): Boolean =
+      sym.unexpandedName.startsWith(symbolForwarderPrefix)
+
     /** retrieves the originally assigned jsName of this export and whether it
      *  is a property
      */