Scala.js: Correctly identify default accessors of native JS def params.

Previously, we tested whether the default accessor itself had the
`@js.native` annotation. That is however never the case. Instead,
we now test whether the associated method has the annotation.

We still emit the *definitions* of those default accessors, even
though that they are never called anymore, because of backward
binary compatibility. If we stopped emitting them, a library
compiled with a newer Scala.js might not link anymore against an
application built with a previous Scala.js.

This is a forward port of
scala-js/scala-js@7e998b4

Author: sjrd

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -2007,8 +2007,46 @@ class JSCodeGen()(using genCtx: Context) {
     val args = tree.args
     val sym = tree.fun.symbol
 
+    /* Is the method a JS default accessor, which should become an
+     * `UndefinedParam` rather than being compiled normally.
+     *
+     * This is true iff one of the following conditions apply:
+     * - It is a constructor default param for the constructor of a JS class.
+     * - It is a default param of an instance method of a native JS type.
+     * - It is a default param of an instance method of a non-native JS type
+     *   and the attached method is exposed.
+     * - It is a default param for a native JS def.
+     */
+    def isJSDefaultParam: Boolean = {
+      sym.name.is(DefaultGetterName) && {
+        val info = new DefaultParamInfo(sym)
+        if (info.isForConstructor) {
+          /* This is a default accessor for a constructor parameter. Check
+           * whether the attached constructor is a JS constructor, which is
+           * the case iff the linked class is a JS type.
+           */
+          info.constructorOwner.isJSType
+        } else {
+          if (sym.owner.isJSType) {
+            /* The default accessor is in a JS type. It is a JS default
+             * param iff the enclosing class is native or the attached method
+             * is exposed.
+             */
+            !sym.owner.isNonNativeJSClass || info.attachedMethod.isJSExposed
+          } else {
+            /* The default accessor is in a Scala type. It is a JS default
+             * param iff the attached method is a native JS def. This can
+             * only happen if the owner is a module class, which we test
+             * first as a fast way out.
+             */
+            sym.owner.is(ModuleClass) && info.attachedMethod.hasAnnotation(jsdefn.JSNativeAnnot)
+          }
+        }
+      }
+    }
+
     tree.fun match {
-      case _ if sym.isJSDefaultParam =>
+      case _ if isJSDefaultParam =>
         js.Transient(UndefinedParam)
 
       case Select(Super(_, _), _) =>
@@ -4578,4 +4616,31 @@ object JSCodeGen {
       out.print("<undefined-param>")
   }
 
+  /** Info about a default param accessor.
+   *
+   *  The method must have a default getter name for this class to make sense.
+   */
+  private class DefaultParamInfo(sym: Symbol)(using Context) {
+    private val methodName = sym.name.exclude(DefaultGetterName)
+
+    def isForConstructor: Boolean = methodName == nme.CONSTRUCTOR
+
+    /** When `isForConstructor` is true, returns the owner of the attached
+     *  constructor.
+     */
+    def constructorOwner: Symbol = sym.owner.linkedClass
+
+    /** When `isForConstructor` is false, returns the method attached to the
+     *  specified default accessor.
+     */
+    def attachedMethod: Symbol = {
+      // If there are overloads, we need to find the one that has default params.
+      val overloads = sym.owner.info.decl(methodName)
+      if (!overloads.isOverloaded)
+        overloads.symbol
+      else
+        overloads.suchThat(_.is(HasDefaultParams)).symbol
+    }
+  }
+
 }

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

@@ -156,26 +156,6 @@ object JSSymUtils {
     def isJSBracketCall(using Context): Boolean =
       sym.hasAnnotation(jsdefn.JSBracketCallAnnot)
 
-    /** Is this symbol a default param accessor for a JS method?
-     *
-     *  For default param accessors of *constructors*, we need to test whether
-     *  the companion *class* of the owner is a JS type; not whether the owner
-     *  is a JS type.
-     */
-    def isJSDefaultParam(using Context): Boolean = {
-      sym.name.is(DefaultGetterName) && {
-        val owner = sym.owner
-        val methName = sym.name.exclude(DefaultGetterName)
-        if (methName == nme.CONSTRUCTOR) {
-          owner.linkedClass.isJSType
-        } else {
-          def isAttachedMethodExposed: Boolean =
-            owner.info.decl(methName).hasAltWith(_.symbol.isJSExposed)
-          owner.isJSType && (!owner.isNonNativeJSClass || isAttachedMethodExposed)
-        }
-      }
-    }
-
     /** Is this symbol a default param accessor for the constructor of a native JS class? */
     def isJSNativeCtorDefaultParam(using Context): Boolean = {
       sym.name.is(DefaultGetterName)