Address my self-review.

Author: sjrd

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

@@ -789,13 +789,11 @@ class JSCodeGen()(using genCtx: Context) {
          * initialized to an instance of the boxed representation, with
          * an underlying value set to the zero of its type. However we
          * cannot implement that, so we live with the discrepancy.
-         * Anyway, scalac also has problems with uninitialized value
-         * class values, if they come from a generic context.
          *
-         * TODO Evaluate how much of this needs to be adapted for dotc,
-         * which unboxes `null` to the zero of their underlying.
+         * In dotc this is usually not an issue, because it unboxes `null` to
+         * the zero of the underlying type, unlike scalac which throws an NPE.
          */
-        jstpe.ClassType(encodeClassName(tpe.valueClassSymbol))
+        jstpe.ClassType(encodeClassName(tpe.tycon.typeSymbol))
 
       case _ =>
         // Other types are not boxed, so we can initialized them to their true zero.

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

@@ -652,6 +652,7 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
     val isLiftedJSConstructor =
       sym.isClassConstructor && sym.owner.isNestedJSClass
 
+    // params: List[ParamSpec] ; captureParams and captureParamsBack: List[js.ParamDef]
     val (params, captureParamsFront, captureParamsBack) = {
       val paramNamessNow = sym.info.paramNamess
       val paramInfosNow = sym.info.paramInfoss.flatten
@@ -684,9 +685,10 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
          * by explicitouter, while the other capture params are added by
          * lambdalift (between elimErasedValueType and now).
          *
-         * scalac: Note that lambdalift creates new symbols even for parameters that
-         * are not the result of lambda lifting, but it preserves their
-         * `name`s.
+         * Since we cannot reliably get Symbols for parameters created by
+         * intermediate phases, we have to perform some dance with the
+         * paramNamess and paramInfoss observed at some phases, combined with
+         * the paramSymss observed at elimRepeated.
          */
 
         val hasOuterParam = {
@@ -724,7 +726,8 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
           // For an anonymous JS class constructor, we put the capture parameters back as formal parameters.
           val allFormalParams = captureParamsFront.toIndexedSeq ++ formalParams ++ captureParamsBack.toIndexedSeq
           (allFormalParams, Nil, Nil)
-        } else {*/          (formalParams, captureParamsFront, captureParamsBack)
+        } else {*/
+          (formalParams, captureParamsFront, captureParamsBack)
         //}
       }
     }

compiler/src/dotty/tools/dotc/core/TypeErasure.scala

@@ -95,8 +95,6 @@ object TypeErasure {
   abstract case class ErasedValueType(tycon: TypeRef, erasedUnderlying: Type)
   extends CachedGroundType with ValueType {
     override def computeHash(bs: Hashable.Binders): Int = doHash(bs, tycon, erasedUnderlying)
-
-    final def valueClassSymbol(using Context): ClassSymbol = tycon.typeSymbol.asClass
   }
 
   final class CachedErasedValueType(tycon: TypeRef, erasedUnderlying: Type)

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

@@ -250,20 +250,17 @@ class ExplicitJSClasses extends MiniPhase with InfoTransformer { thisPhase =>
 
   override def changesMembers: Boolean = true // the phase adds fields for inner JS classes
 
-  /** Is the given symbol an owner for which this transformation applies?
+  /** Is the given symbol an owner that might receive `\$jsclass` and/or `\$jsobject` fields?
    *
    *  This applies if either or both of the following are true:
    *  - It is not a static owner, or
    *  - It is a non-native JS object.
    *
    *  The latter is necessary for scala-js/scala-js#4086.
    */
-  private def isApplicableOwner(sym: Symbol)(using Context): Boolean = {
-    !sym.isStaticOwner || (
-        sym.is(ModuleClass) &&
-        sym.hasAnnotation(jsdefn.JSTypeAnnot) &&
-        !sym.hasAnnotation(jsdefn.JSNativeAnnot)
-    )
+  private def mayNeedJSClassOrJSObjectFields(sym: Symbol)(using Context): Boolean = {
+    !sym.isStaticOwner
+      || (sym.is(ModuleClass) && sym.hasAnnotation(jsdefn.JSTypeAnnot) && !sym.hasAnnotation(jsdefn.JSNativeAnnot))
   }
 
   /** Is the given symbol a JS class (that is not a trait nor an object)? */
@@ -329,7 +326,7 @@ class ExplicitJSClasses extends MiniPhase with InfoTransformer { thisPhase =>
   }
 
   override def transformInfo(tp: Type, sym: Symbol)(using Context): Type = tp match {
-    case tp @ ClassInfo(_, cls, _, decls, _) if !cls.is(JavaDefined) && isApplicableOwner(cls) =>
+    case tp @ ClassInfo(_, cls, _, decls, _) if !cls.is(JavaDefined) && mayNeedJSClassOrJSObjectFields(cls) =>
       val innerJSClasses = decls.filter(isJSClass)
 
       val innerObjectsForAdHocExposed =
@@ -451,7 +448,7 @@ class ExplicitJSClasses extends MiniPhase with InfoTransformer { thisPhase =>
       if (!cls.isJSType) tree.parents // fast path
       else tree.parents.mapConserve(unwrapWithContextualJSClassValue(_))
 
-    if (!isApplicableOwner(cls)) {
+    if (!mayNeedJSClassOrJSObjectFields(cls)) {
       if (fixedParents eq tree.parents) tree
       else cpy.Template(tree)(parents = fixedParents)
     } else {

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

@@ -53,8 +53,9 @@ object JSSymUtils {
     def isNonNativeJSClass(using Context): Boolean =
       sym.isJSType && !sym.hasAnnotation(jsdefn.JSNativeAnnot)
 
+    /** Is this symbol a nested JS class, i.e., an inner or local JS class? */
     def isNestedJSClass(using Context): Boolean =
-      !sym.isStatic /*&& !isStaticModule(sym.originalOwner)*/ && sym.isJSType
+      !sym.isStatic && sym.isJSType
 
     /** Tests whether the given member is exposed, i.e., whether it was
      *  originally a public or protected member of a non-native JS class.