Replace rest field in ir.ParamDef with special members

Author: gzm0

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

@@ -346,7 +346,7 @@ trait GenJSExports[G <: Global with Singleton] extends SubComponent {
           None
         } else {
           val formalArgsRegistry = new FormalArgsRegistry(1, false)
-          val List(arg) = formalArgsRegistry.genFormalArgs()
+          val (List(arg), None) = formalArgsRegistry.genFormalArgs()
           val body = genExportSameArgc(jsName, formalArgsRegistry,
               alts = setters.map(ExportedSymbol),
               paramIndex = 0, static = static)
@@ -430,7 +430,7 @@ trait GenJSExports[G <: Global with Singleton] extends SubComponent {
       val formalArgsRegistry = new FormalArgsRegistry(minArgc, needsRestParam)
 
       // List of formal parameters
-      val formalArgs = formalArgsRegistry.genFormalArgs()
+      val (formalArgs, restParam) = formalArgsRegistry.genFormalArgs()
 
       // Create tuples: (methods, argCounts). This will be the cases we generate
       val caseDefinitions =
@@ -483,7 +483,7 @@ trait GenJSExports[G <: Global with Singleton] extends SubComponent {
         }
       }
 
-      js.JSMethodDef(flags, genExpr(jsName), formalArgs, body)(
+      js.JSMethodDef(flags, genExpr(jsName), formalArgs, restParam, body)(
           OptimizerHints.empty, None)
     }
 
@@ -796,21 +796,16 @@ trait GenJSExports[G <: Global with Singleton] extends SubComponent {
           js.This()(encodeClassType(sym.owner))
       }
 
-      def boxIfNeeded(call: js.Tree): js.Tree = {
-        ensureBoxed(call,
-            enteringPhase(currentRun.posterasurePhase)(sym.tpe.resultType))
-      }
-
       if (isNonNativeJSClass(currentClassSym)) {
         assert(sym.owner == currentClassSym.get, sym.fullName)
-        boxIfNeeded(genApplyJSClassMethod(receiver, sym, args))
+        ensureResultBoxed(genApplyJSClassMethod(receiver, sym, args), sym)
       } else {
         if (sym.isClassConstructor)
           genNew(currentClassSym, sym, args)
         else if (sym.isPrivate)
-          boxIfNeeded(genApplyMethodStatically(receiver, sym, args))
+          ensureResultBoxed(genApplyMethodStatically(receiver, sym, args), sym)
         else
-          boxIfNeeded(genApplyMethod(receiver, sym, args))
+          ensureResultBoxed(genApplyMethod(receiver, sym, args), sym)
       }
     }
 
@@ -1061,22 +1056,22 @@ trait GenJSExports[G <: Global with Singleton] extends SubComponent {
       if (needsRestParam) freshLocalIdent("rest")(NoPosition).name
       else null
 
-    def genFormalArgs()(implicit pos: Position): List[js.ParamDef] = {
+    def genFormalArgs()(implicit pos: Position): (List[js.ParamDef], Option[js.ParamDef]) = {
       val fixedParamDefs = fixedParamNames.toList.map { paramName =>
         js.ParamDef(js.LocalIdent(paramName), NoOriginalName, jstpe.AnyType,
-            mutable = false, rest = false)
+            mutable = false)
       }
 
-      if (needsRestParam) {
-        val restParamDef = {
-          js.ParamDef(js.LocalIdent(restParamName),
-              NoOriginalName, jstpe.AnyType,
-              mutable = false, rest = true)
+      val restParam = {
+        if (needsRestParam) {
+          Some(js.ParamDef(js.LocalIdent(restParamName),
+              NoOriginalName, jstpe.AnyType, mutable = false))
+        } else {
+          None
         }
-        fixedParamDefs :+ restParamDef
-      } else {
-        fixedParamDefs
       }
+
+      (fixedParamDefs, restParam)
     }
 
     def genArgRef(index: Int)(implicit pos: Position): js.Tree = {

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

@@ -48,18 +48,19 @@ object Hashers {
     if (methodDef.hash.isDefined) methodDef
     else {
       val hasher = new TreeHasher()
-      val JSMethodDef(flags, name, args, body) = methodDef
+      val JSMethodDef(flags, name, params, restParam, body) = methodDef
 
       hasher.mixPos(methodDef.pos)
       hasher.mixInt(MemberFlags.toBits(flags))
       hasher.mixTree(name)
-      hasher.mixParamDefs(args)
+      hasher.mixParamDefs(params)
+      restParam.foreach(hasher.mixParamDef(_))
       hasher.mixTree(body)
       hasher.mixInt(OptimizerHints.toBits(methodDef.optimizerHints))
 
       val hash = hasher.finalizeHash()
 
-      JSMethodDef(flags, name, args, body)(
+      JSMethodDef(flags, name, params, restParam, body)(
           methodDef.optimizerHints, Some(hash))(methodDef.pos)
     }
   }
@@ -121,7 +122,6 @@ object Hashers {
       mixOriginalName(paramDef.originalName)
       mixType(paramDef.ptpe)
       mixBoolean(paramDef.mutable)
-      mixBoolean(paramDef.rest)
     }
 
     def mixParamDefs(paramDefs: List[ParamDef]): Unit =
@@ -494,11 +494,12 @@ object Hashers {
           mixTag(TagThis)
           mixType(tree.tpe)
 
-        case Closure(arrow, captureParams, params, body, captureValues) =>
+        case Closure(arrow, captureParams, params, restParam, body, captureValues) =>
           mixTag(TagClosure)
           mixBoolean(arrow)
           mixParamDefs(captureParams)
           mixParamDefs(params)
+          restParam.foreach(mixParamDef(_))
           mixTree(body)
           mixTrees(captureValues)
 

ir/shared/src/main/scala/org/scalajs/ir/Hashers.scala

@@ -89,8 +89,24 @@ object Printers {
       }
     }
 
-    protected def printSig(args: List[ParamDef], resultType: Type): Unit = {
-      printRow(args, "(", ", ", ")")
+    protected def printSig(args: List[ParamDef], restParam: Option[ParamDef],
+        resultType: Type): Unit = {
+      print("(")
+      var rem = args
+      while (rem.nonEmpty) {
+        printAnyNode(rem.head)
+        rem = rem.tail
+        if (rem.nonEmpty || restParam.nonEmpty)
+          print(", ")
+      }
+
+      restParam.foreach { p =>
+        print("...")
+        printAnyNode(p)
+      }
+
+      print(")")
+
       if (resultType != NoType) {
         print(": ")
         print(resultType)
@@ -121,12 +137,9 @@ object Printers {
     }
 
     def print(paramDef: ParamDef): Unit = {
-      val ParamDef(ident, originalName, ptpe, mutable, rest) = paramDef
-
+      val ParamDef(ident, originalName, ptpe, mutable) = paramDef
       if (mutable)
         print("var ")
-      if (rest)
-        print("...")
       print(ident)
       print(originalName)
       print(": ")
@@ -828,7 +841,7 @@ object Printers {
         case This() =>
           print("this")
 
-        case Closure(arrow, captureParams, params, body, captureValues) =>
+        case Closure(arrow, captureParams, params, restParam, body, captureValues) =>
           if (arrow)
             print("(arrow-lambda<")
           else
@@ -843,7 +856,8 @@ object Printers {
             print(" = ")
             print(value)
           }
-          printRow(params, ">(", ", ", ") = ")
+          print(">")
+          printSig(params, restParam, AnyType)
           printBlock(body)
           print(')')
 
@@ -944,28 +958,28 @@ object Printers {
           print("def ")
           print(name)
           print(originalName)
-          printSig(args, resultType)
+          printSig(args, restParam = None, resultType)
           body.fold {
             print("<abstract>")
           } { body =>
             printBlock(body)
           }
 
         case tree: JSMethodDef =>
-          val JSMethodDef(flags, name, args, body) = tree
+          val JSMethodDef(flags, name, args, restParam, body) = tree
           print(tree.optimizerHints)
           print(flags.namespace.prefixString)
           print("def ")
           printJSMemberName(name)
-          printSig(args, AnyType)
+          printSig(args, restParam, AnyType)
           printBlock(body)
 
         case JSPropertyDef(flags, name, getterBody, setterArgAndBody) =>
           getterBody foreach { body =>
             print(flags.namespace.prefixString)
             print("get ")
             printJSMemberName(name)
-            printSig(Nil, AnyType)
+            printSig(Nil, None, AnyType)
             printBlock(body)
           }
 
@@ -977,7 +991,7 @@ object Printers {
             print(flags.namespace.prefixString)
             print("set ")
             printJSMemberName(name)
-            printSig(arg :: Nil, NoType)
+            printSig(arg :: Nil, None, NoType)
             printBlock(body)
           }
 

ir/shared/src/main/scala/org/scalajs/ir/Printers.scala

@@ -546,11 +546,11 @@ object Serializers {
           writeTagAndPos(TagThis)
           writeType(tree.tpe)
 
-        case Closure(arrow, captureParams, params, body, captureValues) =>
+        case Closure(arrow, captureParams, params, restParam, body, captureValues) =>
           writeTagAndPos(TagClosure)
           writeBoolean(arrow)
           writeParamDefs(captureParams)
-          writeParamDefs(params)
+          writeParamDefs(params, restParam)
           writeTree(body)
           writeTrees(captureValues)
 
@@ -653,7 +653,7 @@ object Serializers {
           bufferUnderlying.continue()
 
         case methodDef: JSMethodDef =>
-          val JSMethodDef(flags, name, args, body) = methodDef
+          val JSMethodDef(flags, name, args, restParam, body) = methodDef
 
           writeByte(TagJSMethodDef)
           writeOptHash(methodDef.hash)
@@ -664,7 +664,7 @@ object Serializers {
 
           // Write out method def
           writeInt(MemberFlags.toBits(flags)); writeTree(name)
-          writeParamDefs(args); writeTree(body)
+          writeParamDefs(args, restParam); writeTree(body)
           writeInt(OptimizerHints.toBits(methodDef.optimizerHints))
 
           // Jump back and write true length
@@ -770,18 +770,26 @@ object Serializers {
         buffer.writeInt(encodedNameToIndex(originalName.get))
     }
 
-    def writeParamDef(paramDef: ParamDef): Unit = {
+    def writeParamDef(paramDef: ParamDef, rest: Boolean = false): Unit = {
+      // rest is tmp for backwards compat testing.
       writePosition(paramDef.pos)
       writeLocalIdent(paramDef.name)
       writeOriginalName(paramDef.originalName)
       writeType(paramDef.ptpe)
       buffer.writeBoolean(paramDef.mutable)
-      buffer.writeBoolean(paramDef.rest)
+      buffer.writeBoolean(rest)
     }
 
-    def writeParamDefs(paramDefs: List[ParamDef]): Unit = {
-      buffer.writeInt(paramDefs.size)
-      paramDefs.foreach(writeParamDef)
+    def writeParamDefs(paramDefs: List[ParamDef],
+        restParamDef: Option[ParamDef] = None): Unit = {
+      // restParamDef is tmp for backwards compat testing.
+      val totalSize =
+        if (restParamDef.isEmpty) paramDefs.size
+        else paramDefs.size + 1
+
+      buffer.writeInt(totalSize)
+      paramDefs.foreach(writeParamDef(_))
+      restParamDef.foreach(writeParamDef(_, rest = true))
     }
 
     def writeType(tpe: Type): Unit = {
@@ -1171,8 +1179,10 @@ object Serializers {
         case TagThis =>
           This()(readType())
         case TagClosure =>
-          Closure(readBoolean(), readParamDefs(), readParamDefs(), readTree(),
-              readTrees())
+          val arrow = readBoolean()
+          val captureParams = readParamDefs()
+          val (params, restParam) = readParamDefsWithRest()
+          Closure(arrow, captureParams, params, restParam, readTree(), readTrees())
         case TagCreateJSClass =>
           CreateJSClass(readClassName(), readTrees())
       }
@@ -1315,8 +1325,11 @@ object Serializers {
           // read and discard the length
           val len = readInt()
           assert(len >= 0)
-          JSMethodDef(MemberFlags.fromBits(readInt()), readTree(),
-              readParamDefs(), readTree())(
+
+          val flags = MemberFlags.fromBits(readInt())
+          val name = readTree()
+          val (params, restParam) = readParamDefsWithRest()
+          JSMethodDef(flags, name, params, restParam, readTree())(
               OptimizerHints.fromBits(readInt()), optHash)
 
         case TagJSPropertyDef =>
@@ -1402,13 +1415,46 @@ object Serializers {
 
     def readParamDef(): ParamDef = {
       implicit val pos = readPosition()
-      ParamDef(readLocalIdent(), readOriginalName(), readType(), readBoolean(),
-          readBoolean())
+      val name = readLocalIdent()
+      val originalName = readOriginalName()
+      val ptpe = readType()
+      val mutable = readBoolean()
+
+      if (true) { // tmp: test backwards compat
+        val rest = readBoolean()
+        assert(!rest, "Illegal rest parameter")
+      }
+
+      ParamDef(name, originalName, ptpe, mutable)
     }
 
     def readParamDefs(): List[ParamDef] =
       List.fill(readInt())(readParamDef())
 
+    def readParamDefsWithRest(): (List[ParamDef], Option[ParamDef]) = {
+      if (true) { // tmp: test backwards compat
+        val (params, isRest) = List.fill(readInt()) {
+          implicit val pos = readPosition()
+          (ParamDef(readLocalIdent(), readOriginalName(), readType(), readBoolean()), readBoolean())
+        }.unzip
+
+        if (isRest.forall(!_)) {
+          (params, None)
+        } else {
+          assert(isRest.init.forall(!_), "illegal non-last rest parameter")
+          (params.init, Some(params.last))
+        }
+      } else {
+        val params = readParamDefs()
+
+        val restParam =
+          if (readBoolean()) Some(readParamDef())
+          else None
+
+        (params, restParam)
+      }
+    }
+
     def readType(): Type = {
       val tag = readByte()
       (tag: @switch) match {

ir/shared/src/main/scala/org/scalajs/ir/Serializers.scala

@@ -203,8 +203,8 @@ object Transformers {
 
         // Atomic expressions
 
-        case Closure(arrow, captureParams, params, body, captureValues) =>
-          Closure(arrow, captureParams, params, transformExpr(body),
+        case Closure(arrow, captureParams, params, restParam, body, captureValues) =>
+          Closure(arrow, captureParams, params, restParam, transformExpr(body),
               captureValues.map(transformExpr))
 
         case CreateJSClass(className, captureValues) =>
@@ -248,8 +248,8 @@ object Transformers {
               memberDef.optimizerHints, None)
 
         case memberDef: JSMethodDef =>
-          val JSMethodDef(flags, name, args, body) = memberDef
-          JSMethodDef(flags, name, args, transformExpr(body))(
+          val JSMethodDef(flags, name, args, restParam, body) = memberDef
+          JSMethodDef(flags, name, args, restParam, transformExpr(body))(
               memberDef.optimizerHints, None)
 
         case JSPropertyDef(flags, name, getterBody, setterArgAndBody) =>