Scala.js: Allow default params of JS native defs to be = js.native.

The default accessors matching that property are not emitted
anymore. This is similar to how default accessors for JS native
constructors are not emitted.

Unfortunately, for backward binary compatibility reasons, we must
still emit default accessors of JS native defs that are anything
else than `= js.native`. Until Scala.js 1.7.0, those default
accessors would actually be referenced by calling code (see
scala-js/scala-js#4554),
so removing them now would create dangling references.

This is a forward port of
scala-js/scala-js@e01dc1a

Author: sjrd

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

@@ -1402,6 +1402,53 @@ class JSCodeGen()(using genCtx: Context) {
     val vparamss = dd.termParamss
     val rhs = dd.rhs
 
+    /* Is this method a default accessor that should be ignored?
+     *
+     * This is the case iff one of the following applies:
+     * - It is a constructor default accessor and the linked class is a
+     *   native JS class.
+     * - It is a default accessor for a native JS def, but with the caveat
+     *   that its rhs must be `js.native` because of #4553.
+     *
+     * Both of those conditions can only happen if the default accessor is in
+     * a module class, so we use that as a fast way out. (But omitting that
+     * condition would not change the result.)
+     *
+     * This is different than `isJSDefaultParam` in `genApply`: we do not
+     * ignore default accessors of *non-native* JS types. Neither for
+     * constructor default accessor nor regular default accessors. We also
+     * do not need to worry about non-constructor members of native JS types,
+     * since for those, the entire member list is ignored in `genJSClassData`.
+     */
+    def isIgnorableDefaultParam: Boolean = {
+      sym.name.is(DefaultGetterName) && sym.owner.is(ModuleClass) && {
+        val info = new DefaultParamInfo(sym)
+        if (info.isForConstructor) {
+          /* This is a default accessor for a constructor parameter. Check
+           * whether the attached constructor is a native JS constructor,
+           * which is the case iff the linked class is a native JS type.
+           */
+          info.constructorOwner.hasAnnotation(jsdefn.JSNativeAnnot)
+        } else {
+          /* #4553 We need to ignore default accessors for JS native defs.
+           * However, because Scala.js <= 1.7.0 actually emitted code calling
+           * those accessors, we must keep default accessors that would
+           * compile. The only accessors we can actually get rid of are those
+           * that are `= js.native`.
+           */
+          !sym.owner.isJSType &&
+          info.attachedMethod.hasAnnotation(jsdefn.JSNativeAnnot) && {
+            dd.rhs match {
+              case MaybeAsInstanceOf(Apply(fun, _)) =>
+                fun.symbol == jsdefn.JSPackage_native
+              case _ =>
+                false
+            }
+          }
+        }
+      }
+    }
+
     withPerMethodBodyState(sym) {
       assert(vparamss.isEmpty || vparamss.tail.isEmpty,
           "Malformed parameter list: " + vparamss)
@@ -1421,7 +1468,7 @@ class JSCodeGen()(using genCtx: Context) {
         Some(js.MethodDef(js.MemberFlags.empty, methodName, originalName,
             jsParams, toIRType(patchedResultType(sym)), None)(
             OptimizerHints.empty, None))
-      } else if (sym.isJSNativeCtorDefaultParam) {
+      } else if (isIgnorableDefaultParam) {
         // #11592
         None
       } else if (sym.is(Bridge) && sym.name.is(DefaultGetterName) && currentClassSym.isNonNativeJSClass) {
@@ -2016,6 +2063,12 @@ class JSCodeGen()(using genCtx: Context) {
      * - 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.
+     *
+     * This is different than `isIgnorableDefaultParam` in
+     * `genMethodWithCurrentLocalNameScope`: we include here the default
+     * accessors of *non-native* JS types (unless the corresponding methods are
+     * not exposed). We also need to handle non-constructor members of native
+     * JS types.
      */
     def isJSDefaultParam: Boolean = {
       sym.name.is(DefaultGetterName) && {

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

@@ -156,13 +156,6 @@ object JSSymUtils {
     def isJSBracketCall(using Context): Boolean =
       sym.hasAnnotation(jsdefn.JSBracketCallAnnot)
 
-    /** Is this symbol a default param accessor for the constructor of a native JS class? */
-    def isJSNativeCtorDefaultParam(using Context): Boolean = {
-      sym.name.is(DefaultGetterName)
-        && sym.name.exclude(DefaultGetterName) == nme.CONSTRUCTOR
-        && sym.owner.linkedClass.hasAnnotation(jsdefn.JSNativeAnnot)
-    }
-
     def jsCallingConvention(using Context): JSCallingConvention =
       JSCallingConvention.of(sym)