Scala.js: Handle @JSName annots with constant-folded arguments.

Previously, if an `@JSName` annotation had an argument that was
not a literal, but a reference to a constant expression (such as
a `final val`), it would not be constant-folded in the generated
Scala.js IR.

This produced worse code than necessary. For Wasm, it was
particularly bad, as the names must then be evaluated on the Wasm
side instead of being pushed to the custom JS helpers.

Author: sjrd

compiler/src/dotty/tools/dotc/transform/sjs/JSSymUtils.scala

@@ -164,9 +164,9 @@ object JSSymUtils {
       sym.getAnnotation(jsdefn.JSNameAnnot).fold[JSName] {
         JSName.Literal(defaultJSName)
       } { annotation =>
-        annotation.arguments.head match {
-          case Literal(Constant(name: String)) => JSName.Literal(name)
-          case tree                            => JSName.Computed(tree.symbol)
+        annotation.argumentConstantString(0) match {
+          case Some(name) => JSName.Literal(name)
+          case None       => JSName.Computed(annotation.arguments.head.symbol)
         }
       }
     }

compiler/src/dotty/tools/dotc/transform/sjs/PrepJSInterop.scala

@@ -154,7 +154,7 @@ class PrepJSInterop extends MacroTransform with IdentityDenotTransformer { thisP
       }
 
       checkJSNameAnnots(sym)
-      constFoldJSExportTopLevelAndStaticAnnotations(sym)
+      constantFoldJSAnnotations(sym)
 
       markExposedIfRequired(tree.symbol)
 
@@ -1089,17 +1089,18 @@ class PrepJSInterop extends MacroTransform with IdentityDenotTransformer { thisP
       }
     }
 
-    /** Constant-folds arguments to `@JSExportTopLevel` and `@JSExportStatic`.
+    /** Constant-folds arguments to `@JSName`, `@JSExportTopLevel` and `@JSExportStatic`.
      *
      *  Unlike scalac, dotc does not constant-fold expressions in annotations.
      *  Our back-end needs to have access to the arguments to those two
      *  annotations as literal strings, so we specifically constant-fold them
      *  here.
      */
-    private def constFoldJSExportTopLevelAndStaticAnnotations(sym: Symbol)(using Context): Unit = {
+    private def constantFoldJSAnnotations(sym: Symbol)(using Context): Unit = {
       val annots = sym.annotations
       val newAnnots = annots.mapConserve { annot =>
-        if (annot.symbol == jsdefn.JSExportTopLevelAnnot || annot.symbol == jsdefn.JSExportStaticAnnot) {
+        if (annot.symbol == jsdefn.JSExportTopLevelAnnot || annot.symbol == jsdefn.JSExportStaticAnnot ||
+            annot.symbol == jsdefn.JSNameAnnot) {
           annot.tree match {
             case app @ Apply(fun, args) =>
               val newArgs = args.mapConserve { arg =>
@@ -1109,7 +1110,7 @@ class PrepJSInterop extends MacroTransform with IdentityDenotTransformer { thisP
                   case _ =>
                     arg.tpe.widenTermRefExpr.normalized match {
                       case ConstantType(c) => Literal(c).withSpan(arg.span)
-                      case _               => arg // PrepJSExports will emit an error for those cases
+                      case _               => arg
                     }
                 }
               }