Rename ArraySeqBuilder to VarArgsBuilder and apply review suggestions

Author: odersky

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

@@ -524,7 +524,7 @@ class Definitions {
     @tu lazy val newGenericArrayMethod: TermSymbol = DottyArraysModule.requiredMethod("newGenericArray")
     @tu lazy val newArrayMethod: TermSymbol = DottyArraysModule.requiredMethod("newArray")
 
-  @tu lazy val ArraySeqBuilderModule: Symbol = requiredModule("scala.runtime.ArraySeqBuilder")
+  @tu lazy val VarArgsBuilderModule: Symbol = requiredModule("scala.runtime.VarArgsBuilder")
 
   def getWrapVarargsArrayModule: Symbol = ScalaRuntimeModule
 

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -437,30 +437,17 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
             acc.select(defn.Int_+).appliedTo(len)
 
         def makeBuilder(name: String) =
-          ref(defn.ArraySeqBuilderModule).select(name.toTermName)
-        def genericBuilder = makeBuilder("generic")
-          .appliedToType(elemType)
-          .appliedTo(totalLength)
+          ref(defn.VarArgsBuilderModule).select(name.toTermName)
 
         val builder =
           if defn.ScalaValueClasses().contains(elemCls) then
-            makeBuilder(s"of${elemCls.name}").appliedTo(totalLength)
+            makeBuilder(s"of${elemCls.name}")
           else if elemCls.derivesFrom(defn.ObjectClass) then
-            val classTagType = defn.ClassTagClass.typeRef.appliedTo(elemType)
-            val classTag = atPhase(Phases.typerPhase):
-              ctx.typer.inferImplicitArg(classTagType, tree.span.startPos)
-            classTag.tpe match
-              case _: SearchFailureType =>
-                genericBuilder
-              case _ =>
-                makeBuilder("ofRef")
-                  .appliedToType(elemType)
-                  .appliedTo(totalLength)
-                  .appliedTo(classTag)
+            makeBuilder("ofRef").appliedToType(elemType)
           else
-            genericBuilder
+            makeBuilder("generic").appliedToType(elemType)
 
-        elems.foldLeft(builder): (bldr, elem) =>
+        elems.foldLeft(builder.appliedTo(totalLength)): (bldr, elem) =>
           elem match
             case spread(arg) =>
               val selector =
@@ -469,6 +456,7 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
               bldr.select(selector.toTermName).appliedTo(arg)
             case _ => bldr.select("add".toTermName).appliedTo(elem)
         .select("result".toTermName)
+        .appliedToNone
     end flattenSpreads
 
     override def transform(tree: Tree)(using Context): Tree =

library/src/scala/runtime/ArraySeqBuilder.scala renamed to library/src/scala/runtime/VarArgsBuilder.scala

@@ -3,17 +3,17 @@ package scala.runtime
 import scala.collection.immutable.ArraySeq
 import scala.reflect.ClassTag
 
-sealed abstract class ArraySeqBuilder[T]:
+sealed abstract class VarArgsBuilder[T]:
   def add(elem: T): this.type
   def addSeq(elems: Seq[T]): this.type
   def addArray(elems: Array[T]): this.type
-  def result: ArraySeq[T]
+  def result(): Seq[T]
 
-object ArraySeqBuilder:
+object VarArgsBuilder:
 
-  def generic[T](n: Int) = new ArraySeqBuilder[T]:
+  def generic[T](n: Int): VarArgsBuilder[T] = new VarArgsBuilder[T]:
     private val xs = new Array[AnyRef](n)
-    def result = ArraySeq.ofRef(xs).asInstanceOf[ArraySeq[T]]
+    def result() = ArraySeq.ofRef(xs).asInstanceOf[ArraySeq[T]]
     private var i = 0
     def add(elem: T): this.type =
       xs(i) = elem.asInstanceOf[AnyRef]
@@ -30,9 +30,9 @@ object ArraySeqBuilder:
         i += 1
       this
 
-  def ofRef[T <: AnyRef](n: Int)(using ClassTag[T]) = new ArraySeqBuilder[T]:
-    private val xs = new Array[T](n)
-    def result = ArraySeq.ofRef(xs)
+  def ofRef[T <: AnyRef](n: Int): VarArgsBuilder[T] = new VarArgsBuilder[T]:
+    private val xs = new Array[AnyRef](n)
+    def result() = ArraySeq.ofRef(xs).asInstanceOf[ArraySeq[T]]
     private var i = 0
     def add(elem: T): this.type =
       xs(i) = elem
@@ -49,9 +49,9 @@ object ArraySeqBuilder:
         i += 1
       this
 
-  def ofByte(n: Int) = new ArraySeqBuilder[Byte]:
+  def ofByte(n: Int): VarArgsBuilder[Byte] = new VarArgsBuilder[Byte]:
     private val xs = new Array[Byte](n)
-    def result = ArraySeq.ofByte(xs)
+    def result() = ArraySeq.ofByte(xs)
     private var i = 0
     def add(elem: Byte): this.type =
       xs(i) = elem
@@ -68,9 +68,9 @@ object ArraySeqBuilder:
         i += 1
       this
 
-  def ofShort(n: Int) = new ArraySeqBuilder[Short]:
+  def ofShort(n: Int): VarArgsBuilder[Short] = new VarArgsBuilder[Short]:
     private val xs = new Array[Short](n)
-    def result = ArraySeq.ofShort(xs)
+    def result() = ArraySeq.ofShort(xs)
     private var i = 0
     def add(elem: Short): this.type =
       xs(i) = elem
@@ -87,9 +87,9 @@ object ArraySeqBuilder:
         i += 1
       this
 
-  def ofChar(n: Int) = new ArraySeqBuilder[Char]:
+  def ofChar(n: Int): VarArgsBuilder[Char] = new VarArgsBuilder[Char]:
     private val xs = new Array[Char](n)
-    def result = ArraySeq.ofChar(xs)
+    def result() = ArraySeq.ofChar(xs)
     private var i = 0
     def add(elem: Char): this.type =
       xs(i) = elem
@@ -106,9 +106,9 @@ object ArraySeqBuilder:
         i += 1
       this
 
-  def ofInt(n: Int) = new ArraySeqBuilder[Int]:
+  def ofInt(n: Int): VarArgsBuilder[Int] = new VarArgsBuilder[Int]:
     private val xs = new Array[Int](n)
-    def result = ArraySeq.ofInt(xs)
+    def result() = ArraySeq.ofInt(xs)
     private var i = 0
     def add(elem: Int): this.type =
       xs(i) = elem
@@ -125,9 +125,9 @@ object ArraySeqBuilder:
         i += 1
       this
 
-  def ofLong(n: Int) = new ArraySeqBuilder[Long]:
+  def ofLong(n: Int): VarArgsBuilder[Long] = new VarArgsBuilder[Long]:
     private val xs = new Array[Long](n)
-    def result = ArraySeq.ofLong(xs)
+    def result() = ArraySeq.ofLong(xs)
     private var i = 0
     def add(elem: Long): this.type =
       xs(i) = elem
@@ -144,9 +144,9 @@ object ArraySeqBuilder:
         i += 1
       this
 
-  def ofFloat(n: Int) = new ArraySeqBuilder[Float]:
+  def ofFloat(n: Int): VarArgsBuilder[Float] = new VarArgsBuilder[Float]:
     private val xs = new Array[Float](n)
-    def result = ArraySeq.ofFloat(xs)
+    def result() = ArraySeq.ofFloat(xs)
     private var i = 0
     def add(elem: Float): this.type =
       xs(i) = elem
@@ -163,9 +163,9 @@ object ArraySeqBuilder:
         i += 1
       this
 
-  def ofDouble(n: Int) = new ArraySeqBuilder[Double]:
+  def ofDouble(n: Int): VarArgsBuilder[Double] = new VarArgsBuilder[Double]:
     private val xs = new Array[Double](n)
-    def result = ArraySeq.ofDouble(xs)
+    def result() = ArraySeq.ofDouble(xs)
     private var i = 0
     def add(elem: Double): this.type =
       xs(i) = elem
@@ -182,9 +182,9 @@ object ArraySeqBuilder:
         i += 1
       this
 
-  def ofBoolean(n: Int) = new ArraySeqBuilder[Boolean]:
+  def ofBoolean(n: Int): VarArgsBuilder[Boolean] = new VarArgsBuilder[Boolean]:
     private val xs = new Array[Boolean](n)
-    def result = ArraySeq.ofBoolean(xs)
+    def result() = ArraySeq.ofBoolean(xs)
     private var i = 0
     def add(elem: Boolean): this.type =
       xs(i) = elem
@@ -201,9 +201,9 @@ object ArraySeqBuilder:
         i += 1
       this
 
-  def ofUnit(n: Int) = new ArraySeqBuilder[Unit]:
+  def ofUnit(n: Int): VarArgsBuilder[Unit] = new VarArgsBuilder[Unit]:
     private val xs = new Array[Unit](n)
-    def result = ArraySeq.ofUnit(xs)
+    def result() = ArraySeq.ofUnit(xs)
     private var i = 0
     def add(elem: Unit): this.type =
       xs(i) = elem
@@ -220,4 +220,4 @@ object ArraySeqBuilder:
         i += 1
       this
 
-end ArraySeqBuilder
+end VarArgsBuilder

project/Build.scala

@@ -1171,7 +1171,7 @@ object Build {
         file(s"${baseDirectory.value}/src/scala/quoted/runtime/StopMacroExpansion.scala"),
         file(s"${baseDirectory.value}/src/scala/compiletime/Erased.scala"),
         file(s"${baseDirectory.value}/src/scala/annotation/internal/onlyCapability.scala"),
-        file(s"${baseDirectory.value}/src/scala/runtime/ArraySeqBuilder.scala"),
+        file(s"${baseDirectory.value}/src/scala/runtime/VarArgsBuilder.scala"),
       )
     )
   lazy val `scala3-library-bootstrapped`: Project = project.in(file("library")).asDottyLibrary(Bootstrapped)
@@ -1310,7 +1310,7 @@ object Build {
         file(s"${baseDirectory.value}/src/scala/quoted/runtime/StopMacroExpansion.scala"),
         file(s"${baseDirectory.value}/src/scala/compiletime/Erased.scala"),
         file(s"${baseDirectory.value}/src/scala/annotation/internal/onlyCapability.scala"),
-        file(s"${baseDirectory.value}/src/scala/runtime/ArraySeqBuilder.scala"),
+        file(s"${baseDirectory.value}/src/scala/runtime/VarArgsBuilder.scala"),
       )
     )