Scala.js: Allow delegating JS Class constructor calls with default params

Previously this was not allowed, since implementing it was
difficult. After the refactoring of the JS Class constrcutor call
generation (a6cd84f), implementing
this is not hard anymore, so we lift the implementation restriction.

Forward port of
scala-js/scala-js@2249ba6

Author: sjrd

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

@@ -1067,7 +1067,8 @@ class JSCodeGen()(using genCtx: Context) {
       val jsClassCaptures = List.newBuilder[js.ParamDef]
 
       def add(tree: ConstructorTree[_ <: JSCtor]): Unit = {
-        val (e, c) = genJSClassCtorDispatch(tree.ctor.sym, tree.ctor.params, tree.overloadNum)
+        val (e, c) = genJSClassCtorDispatch(tree.ctor.sym,
+            tree.ctor.paramsAndInfo, tree.overloadNum)
         exports += e
         jsClassCaptures ++= c
         tree.subCtors.foreach(add(_))
@@ -1133,9 +1134,7 @@ class JSCodeGen()(using genCtx: Context) {
     assert(jsSuperCall.isDefined,
         s"Did not find Super call in primary JS construtor at ${dd.sourcePos}")
 
-    val params = dd.paramss.flatten.map(_.symbol)
-
-    new PrimaryJSCtor(sym, params, jsSuperCall.get :: jsStats.result())
+    new PrimaryJSCtor(sym, genParamsAndInfo(sym, dd.paramss), jsSuperCall.get :: jsStats.result())
   }
 
   private def genSecondaryJSClassCtor(dd: DefDef): SplitSecondaryJSCtor = {
@@ -1176,19 +1175,24 @@ class JSCodeGen()(using genCtx: Context) {
         i"could not find the this() call in secondary JS constructor at ${dd.sourcePos}:\n${stats.map(_.show).mkString("\n")}")
     val Some((targetCtor, ctorArgs)) = thisCall
 
-    val params = dd.paramss.flatten.map(_.symbol)
+    new SplitSecondaryJSCtor(sym, genParamsAndInfo(sym, dd.paramss),
+        beforeThisCall.result(), targetCtor, ctorArgs, afterThisCall.result())
+  }
 
-    new SplitSecondaryJSCtor(sym, params, beforeThisCall.result(), targetCtor,
-        ctorArgs, afterThisCall.result())
+  private def genParamsAndInfo(ctorSym: Symbol,
+      vparamss: List[ParamClause]): List[(Symbol, JSParamInfo)] = {
+    implicit val pos: SourcePosition = ctorSym.sourcePos
+
+    val paramSyms = if (vparamss.isEmpty) Nil else vparamss.head.map(_.symbol)
+    paramSyms.zip(ctorSym.jsParamInfos)
   }
 
-  private def genJSClassCtorDispatch(ctorSym: Symbol, allParamSyms: List[Symbol],
+  private def genJSClassCtorDispatch(ctorSym: Symbol,
+      allParamsAndInfos: List[(Symbol, JSParamInfo)],
       overloadNum: Int): (jsExportsGen.Exported, List[js.ParamDef]) = {
 
     implicit val pos: SourcePosition = ctorSym.sourcePos
 
-    val allParamsAndInfos = allParamSyms.zip(ctorSym.jsParamInfos)
-
     /* `allParams` are the parameters as seen from inside the constructor body,
      * i.e., the ones generated by the trees in the constructor body.
      */
@@ -1266,40 +1270,58 @@ class JSCodeGen()(using genCtx: Context) {
      */
 
     def preStats(tree: ConstructorTree[SplitSecondaryJSCtor],
-        nextParams: List[Symbol]): js.Tree = {
-      assert(tree.ctor.ctorArgs.size == nextParams.size, "param count mismatch")
+        nextParamsAndInfo: List[(Symbol, JSParamInfo)]): js.Tree = {
+      val inner = tree.subCtors.map(preStats(_, tree.ctor.paramsAndInfo))
 
-      val inner = tree.subCtors.map(preStats(_, tree.ctor.params))
+      assert(tree.ctor.ctorArgs.size == nextParamsAndInfo.size, "param count mismatch")
+      val paramsInfosAndArgs = nextParamsAndInfo.zip(tree.ctor.ctorArgs)
 
-      /* Reject undefined params (i.e. using a default value of another
-       * constructor) via implementation restriction.
-       *
-       * This is mostly for historical reasons. The ideal solution here would
-       * be to recognize calls to default param getters of JS class
-       * constructors and not even translate them to UndefinedParam in the
-       * first place.
-       */
-      def isUndefinedParam(tree: js.Tree): Boolean = tree match {
-        case js.Transient(UndefinedParam) => true
-        case _                            => false
-      }
+      val (captureParamsInfosAndArgs, normalParamsInfosAndArgs) =
+        paramsInfosAndArgs.partition(_._1._2.capture)
 
-      if (tree.ctor.ctorArgs.exists(isUndefinedParam)) {
-        report.error(
-            "Implementation restriction: " +
-            "in a JS class, a secondary constructor calling another constructor " +
-            "with default parameters must provide the values of all parameters.",
-            tree.ctor.sym.sourcePos)
+      val captureAssigns = for {
+        ((param, _), arg) <- captureParamsInfosAndArgs
+      } yield {
+        js.Assign(genVarRef(param), arg)
       }
 
-      val assignments = for {
-        (param, arg) <- nextParams.zip(tree.ctor.ctorArgs)
-        if !isUndefinedParam(arg)
+      val normalAssigns = for {
+        (((param, info), arg), i) <- normalParamsInfosAndArgs.zipWithIndex
       } yield {
-        js.Assign(genVarRef(param), arg)
+        val newArg = arg match {
+          case js.Transient(UndefinedParam) =>
+            /* Go full circle: We have ignored the default param getter for
+             * this, we'll create it again.
+             *
+             * This seems not optimal: We could simply not ignore the calls to
+             * default param getters in the first place.
+             *
+             * However, this proves to be difficult: Because of translations in
+             * earlier phases, calls to default param getters may be assigned
+             * to temporary variables first (see the undefinedDefaultParams
+             * ScopedVar). If this happens, it becomes increasingly difficult
+             * to distinguish a default param getter call for a constructor
+             * call of *this* instance (in which case we would want to keep
+             * the default param getter call) from one for a *different*
+             * instance (in which case we would want to discard the default
+             * param getter call)
+             *
+             * Because of this, it ends up being easier to just re-create the
+             * default param getter call if necessary.
+             */
+            implicit val pos: SourcePosition = tree.ctor.sym.sourcePos
+            jsExportsGen.genCallDefaultGetter(tree.ctor.sym, i, static = false,
+                captures = captureParamsInfosAndArgs.map(p => genVarRef(p._1._1)))(
+                prevArgsCount => normalParamsInfosAndArgs.take(prevArgsCount).map(p => genVarRef(p._1._1)))
+
+          case arg => arg
+        }
+
+        js.Assign(genVarRef(param), newArg)
       }
 
-      ifOverload(tree, js.Block(inner ++ tree.ctor.beforeCall ++ assignments))
+      ifOverload(tree, js.Block(
+          inner ++ tree.ctor.beforeCall ++ captureAssigns ++ normalAssigns))
     }
 
     def postStats(tree: ConstructorTree[SplitSecondaryJSCtor]): js.Tree = {
@@ -1311,22 +1333,24 @@ class JSCodeGen()(using genCtx: Context) {
     val secondaryCtorTrees = ctorTree.subCtors
 
     js.Block(
-        secondaryCtorTrees.map(preStats(_, primaryCtor.params)) ++
+        secondaryCtorTrees.map(preStats(_, primaryCtor.paramsAndInfo)) ++
         primaryCtor.body ++
         secondaryCtorTrees.map(postStats(_))
     )
   }
 
   private sealed trait JSCtor {
     val sym: Symbol
-    val params: List[Symbol]
+    val paramsAndInfo: List[(Symbol, JSParamInfo)]
   }
 
   private class PrimaryJSCtor(val sym: Symbol,
-      val params: List[Symbol], val body: List[js.Tree]) extends JSCtor
+      val paramsAndInfo: List[(Symbol, JSParamInfo)],
+      val body: List[js.Tree]) extends JSCtor
 
   private class SplitSecondaryJSCtor(val sym: Symbol,
-      val params: List[Symbol], val beforeCall: List[js.Tree],
+      val paramsAndInfo: List[(Symbol, JSParamInfo)],
+      val beforeCall: List[js.Tree],
       val targetCtor: Symbol, val ctorArgs: List[js.Tree],
       val afterCall: List[js.Tree]) extends JSCtor
 

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

@@ -725,7 +725,7 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
     }
   }
 
-  private def genCallDefaultGetter(sym: Symbol, paramIndex: Int,
+  def genCallDefaultGetter(sym: Symbol, paramIndex: Int,
       static: Boolean, captures: List[js.Tree])(
       previousArgsValues: Int => List[js.Tree])(
       implicit pos: SourcePosition): js.Tree = {