Fix #4526: Find module accessor of nested private companions

Author: gzm0

compiler/src/main/scala/org/scalajs/nscplugin/GenJSExports.scala

@@ -697,24 +697,78 @@ trait GenJSExports[G <: Global with Singleton] extends SubComponent {
         previousArgsValues: Int => List[js.Tree])(
         implicit pos: Position): js.Tree = {
 
-      val trgSym = {
-        if (sym.isClassConstructor) {
-          /* Get the companion module class.
-           * For inner classes the sym.owner.companionModule can be broken,
-           * therefore companionModule is fetched at uncurryPhase.
+      val owner = sym.owner
+      val isNested = owner.isLifted && !isStaticModule(owner.originalOwner)
+
+      val (trgSym, trgTree) = {
+        if (!sym.isClassConstructor && !static) {
+          /* Default getter is on the receiver.
+           *
+           * Since we only use this method for class internal exports
+           * dispatchers, we know the default getter is on `this`. This applies
+           * to both top-level and nested classes.
+           */
+          (owner, js.This()(encodeClassType(owner)))
+        } else if (isNested) {
+          assert(captures.size == 1,
+              s"expected exactly one capture got $captures ($sym at $pos)")
+
+          /* Find the module accessor.
            *
            * #4465: If owner is a nested class, the linked class is *not* a
            * module value, but another class. In this case we need to call the
            * module accessor on the enclosing class to retrieve this.
+           *
+           * #4526: If the companion module is private, linkedClassOfClass
+           * does not work (because the module name is prefixed with the full
+           * path). So we find the module accessor first and take its result
+           * type to be the companion module type.
+           */
+          val outer = owner.originalOwner
+
+          val modAccessor = {
+            val name = enteringPhase(currentRun.typerPhase) {
+              owner.unexpandedName.toTermName
+            }
+
+            outer.info.members.find { sym =>
+              sym.isModule && sym.unexpandedName == name
+            }.getOrElse {
+              throw new AssertionError(
+                  s"couldn't find module accessor for ${owner.fullName} at $pos")
+            }
+          }
+
+          val receiver = captures.head
+
+          val trgSym = modAccessor.tpe.resultType.typeSymbol
+
+          val trgTree = if (isJSType(outer)) {
+            genApplyJSClassMethod(receiver, modAccessor, Nil)
+          } else {
+            genApplyMethodMaybeStatically(receiver, modAccessor, Nil)
+          }
+
+          (trgSym, trgTree)
+        } else if (sym.isClassConstructor) {
+          assert(captures.isEmpty, "expected empty captures")
+
+          /* Get the companion module class.
+           * For classes nested inside modules the sym.owner.companionModule
+           * can be broken, therefore companionModule is fetched at
+           * uncurryPhase.
            */
-          val companionModule = enteringPhase(currentRun.uncurryPhase) {
-            sym.owner.companionModule
+          val trgSym = enteringPhase(currentRun.uncurryPhase) {
+            owner.linkedClassOfClass
           }
-          companionModule.moduleClass
+          (trgSym, genLoadModule(trgSym))
         } else {
-          sym.owner
+          assert(static, "expected static")
+          assert(captures.isEmpty, "expected empty captures")
+          (owner, genLoadModule(owner))
         }
       }
+
       val defaultGetter = trgSym.tpe.member(
           nme.defaultGetterName(sym.name, paramIndex + 1))
 
@@ -723,31 +777,6 @@ trait GenJSExports[G <: Global with Singleton] extends SubComponent {
       assert(!defaultGetter.isOverloaded,
           s"found overloaded default getter $defaultGetter")
 
-      val trgTree = {
-        if (sym.isClassConstructor || static) {
-          if (!trgSym.isLifted) {
-            assert(captures.isEmpty, "expected empty captures")
-            genLoadModule(trgSym)
-          } else {
-            assert(captures.size == 1, "expected exactly one capture")
-
-            // Find the module accessor.
-            val outer = trgSym.originalOwner
-            val name = enteringPhase(currentRun.typerPhase)(trgSym.unexpandedName)
-
-            val modAccessor = outer.info.members.lookupModule(name)
-            val receiver = captures.head
-            if (isJSType(outer)) {
-              genApplyJSClassMethod(receiver, modAccessor, Nil)
-            } else {
-              genApplyMethodMaybeStatically(receiver, modAccessor, Nil)
-            }
-          }
-        } else {
-          js.This()(encodeClassType(trgSym))
-        }
-      }
-
       // Pass previous arguments to defaultGetter
       val defaultGetterArgs = previousArgsValues(defaultGetter.tpe.params.size)
 

test-suite/js/src/test/scala/org/scalajs/testsuite/jsinterop/NestedJSClassTest.scala

@@ -469,6 +469,13 @@ class NestedJSClassTest {
     assertEquals(1, container.moduleSideEffect)
   }
 
+  @Test def defaultCtorParamsInnerJSClassPrivateCompanion_Issue4526(): Unit = {
+    val container = new ScalaClassContainer("container")
+
+    val inner = new container.InnerJSClassDefaultParamsPrivateCompanion_Issue4526()
+    assertEquals("container inner foo", inner.foo())
+  }
+
   @Test def doublyNestedInnerObject_Issue4114(): Unit = {
     val outer1 = new DoublyNestedInnerObject_Issue4114().asInstanceOf[js.Dynamic]
     val outer2 = new DoublyNestedInnerObject_Issue4114().asInstanceOf[js.Dynamic]
@@ -696,6 +703,14 @@ object NestedJSClassTest {
     object InnerJSClassDefaultParams_Issue4465 {
       moduleSideEffect += 1
     }
+
+    class InnerJSClassDefaultParamsPrivateCompanion_Issue4526(
+        withDefault: String = "inner") extends js.Object {
+      def foo(methodDefault: String = "foo"): String =
+        s"$xxx $withDefault $methodDefault"
+    }
+
+    private object InnerJSClassDefaultParamsPrivateCompanion_Issue4526
   }
 
   trait ScalaTraitContainer {