Merge pull request #361 from scala-steward/update/scala3-library-3.4.1

build(deps): bump scala3-library from 3.3.3 to 3.4.1

modules/benchmark/src/test/scala/mess/bench/Bench.scala

@@ -72,8 +72,8 @@ object Foo {
 }
 
 class GenericBench extends Bench {
-  private[this] val foo      = Foo.next()
-  private[this] val fooBytes = Bench.toBytes(foo)
+  private val foo      = Foo.next()
+  private val fooBytes = Bench.toBytes(foo)
 
   @Benchmark
   def decodeFoo(): Either[DecodingFailure, Foo] =
@@ -88,13 +88,13 @@ class ContainerBench extends Bench {
   @Param(Array("5", "10", "50", "100", "1000"))
   var size: Int = _
 
-  private[this] var map: Map[Long, Double] = _
-  private[this] var mapBytes: Array[Byte]  = _
-  private[this] var seq: Seq[Long]         = _
-  private[this] var seqBytes: Array[Byte]  = _
-  private[this] var list: List[Long]       = _
-  private[this] var vec: Vector[Long]      = _
-  private[this] var set: Set[Long]         = _
+  private var map: Map[Long, Double] = _
+  private var mapBytes: Array[Byte]  = _
+  private var seq: Seq[Long]         = _
+  private var seqBytes: Array[Byte]  = _
+  private var list: List[Long]       = _
+  private var vec: Vector[Long]      = _
+  private var set: Set[Long]         = _
 
   @Setup
   def setup(): Unit = {

modules/core/src/main/scala/mess/Fmt.scala

@@ -205,7 +205,10 @@ object Fmt {
       Impl(value)
 
     def from(entries: (Fmt, Fmt)*): MMap =
-      Impl(immutable.Map(entries: _*))
+      fromSeq(entries)
+
+    def fromSeq(entries: Seq[(Fmt, Fmt)]): MMap =
+      Impl(entries.toMap)
 
     private[mess] def newBuilder: MMap =
       BuilderImpl(Map.newBuilder)
@@ -352,14 +355,14 @@ object Fmt {
     }
   }
 
-  private[this] def unpackArr(buffer: MessageUnpacker)(implicit factory: Factory[Fmt, Vector[Fmt]]): Vector[Fmt] = {
+  private def unpackArr(buffer: MessageUnpacker)(implicit factory: Factory[Fmt, Vector[Fmt]]): Vector[Fmt] = {
     @tailrec def loop(size: Int, acc: mutable.Builder[Fmt, Vector[Fmt]]): Vector[Fmt] =
       if (size == 0) acc.result()
       else loop(size - 1, acc += unpack(buffer))
     loop(buffer.unpackArrayHeader(), factory.newBuilder)
   }
 
-  private[this] def unpackMap(
+  private def unpackMap(
     buffer: MessageUnpacker
   )(implicit factory: Factory[(Fmt, Fmt), Map[Fmt, Fmt]]): Map[Fmt, Fmt] = {
     @tailrec def loop(size: Int, acc: mutable.Builder[(Fmt, Fmt), Map[Fmt, Fmt]]): Map[Fmt, Fmt] =
@@ -386,7 +389,7 @@ object Fmt {
     finally buffer.close()
   }
 
-  private[this] val bigintCriteria = BigInteger.valueOf(9223372036854775807L)
+  private val bigintCriteria = BigInteger.valueOf(9223372036854775807L)
 
   def unpack(buffer: MessageUnpacker): Fmt =
     if (!buffer.hasNext) Fmt.MUnit
@@ -457,7 +460,7 @@ object Fmt {
   def fromDouble(value: Double): Fmt                           = MDouble(value)
   def fromString(value: String): Fmt                           = MString(value)
   def fromMap(value: immutable.Map[Fmt, Fmt]): Fmt             = MMap(value)
-  def fromEntries(value: (Fmt, Fmt)*): Fmt                     = MMap.from(value: _*)
+  def fromEntries(value: (Fmt, Fmt)*): Fmt                     = MMap.fromSeq(value)
   def fromVector(value: Vector[Fmt]): Fmt                      = MArray(value)
   def fromLsit(value: List[Fmt]): Fmt                          = MArray(value.toVector)
   def fromSeq(value: Seq[Fmt]): Fmt                            = MArray(value.toVector)

modules/core/src/main/scala_3/mess/codec/MirrorDecoder.scala

@@ -16,21 +16,21 @@ private[codec] trait MirrorDecoder:
     }
 
   inline def summonLabels[T <: Tuple]: Array[String]       = summonLabelsRec[T].toArray
-  inline def summonDecoders[T <: Tuple]: Array[Decoder[_]] = summonDecodersRec[T].toArray
+  inline def summonDecoders[T <: Tuple]: Array[Decoder[?]] = summonDecodersRec[T].toArray
 
   inline def summonLabelsRec[T <: Tuple]: List[String] =
     inline erasedValue[T] match
       case _: EmptyTuple => Nil
       case _: (t *: ts)  => constValue[t].asInstanceOf[String] :: summonLabelsRec[ts]
 
-  inline def summonDecodersRec[T <: Tuple]: List[Decoder[_]] =
+  inline def summonDecodersRec[T <: Tuple]: List[Decoder[?]] =
     inline erasedValue[T] match
       case _: EmptyTuple => Nil
       case _: (t *: ts)  => summonDecoder[t] :: summonDecodersRec[ts]
 
   def iterator[T](t: T) = t.asInstanceOf[Product].productIterator
 
-  def decodeSum[T](s: Mirror.SumOf[T], names: => Array[String], decoders: => Array[Decoder[_]]): Decoder[T] =
+  def decodeSum[T](s: Mirror.SumOf[T], names: => Array[String], decoders: => Array[Decoder[?]]): Decoder[T] =
     new Decoder[T]:
       def apply(m: Fmt): Either[DecodingFailure, T] =
         m match
@@ -58,7 +58,7 @@ private[codec] trait MirrorDecoder:
           case _ =>
             Left(TypeMismatchError("Sum", m))
 
-  def decodeProduct[T](p: Mirror.ProductOf[T], names: => Array[String], decoders: => Array[Decoder[_]]): Decoder[T] =
+  def decodeProduct[T](p: Mirror.ProductOf[T], names: => Array[String], decoders: => Array[Decoder[?]]): Decoder[T] =
     new Decoder[T]:
       def apply(m: Fmt): Either[DecodingFailure, T] =
         m match

modules/core/src/main/scala_3/mess/codec/MirrorEncoder.scala

@@ -17,21 +17,21 @@ private[codec] trait MirrorEncoder:
     }
 
   inline def summonLabels[T <: Tuple]: Array[String]       = summonLabelsRec[T].toArray
-  inline def summonEncoders[T <: Tuple]: Array[Encoder[_]] = summonEncodersRec[T].toArray
+  inline def summonEncoders[T <: Tuple]: Array[Encoder[?]] = summonEncodersRec[T].toArray
 
   inline def summonLabelsRec[T <: Tuple]: List[String] =
     inline erasedValue[T] match
       case _: EmptyTuple => Nil
       case _: (t *: ts)  => constValue[t].asInstanceOf[String] :: summonLabelsRec[ts]
 
-  inline def summonEncodersRec[T <: Tuple]: List[Encoder[_]] =
+  inline def summonEncodersRec[T <: Tuple]: List[Encoder[?]] =
     inline erasedValue[T] match
       case _: EmptyTuple => Nil
       case _: (t *: ts)  => summonEncoder[t] :: summonEncodersRec[ts]
 
   def iterator[T](t: T) = t.asInstanceOf[Product].productIterator
 
-  def encoderSum[T](s: Mirror.SumOf[T], elems: => Array[Encoder[_]]): Encoder.AsMap[T] =
+  def encoderSum[T](s: Mirror.SumOf[T], elems: => Array[Encoder[?]]): Encoder.AsMap[T] =
     new Encoder.AsMap[T]:
       def applyToMap(v: T): Fmt.MMap =
         val ord    = s.ordinal(v)
@@ -41,7 +41,7 @@ private[codec] trait MirrorEncoder:
 
   def encoderProduct[T](p: Mirror.ProductOf[T],
                         names: => Array[String],
-                        encoders: => Array[Encoder[_]]
+                        encoders: => Array[Encoder[?]]
   ): Encoder.AsMap[T] =
     new Encoder.AsMap[T]:
       def applyToMap(v: T): Fmt.MMap =

project/Dependencies.scala

@@ -2,7 +2,7 @@ import sbt._
 
 object Dependencies {
   val Ver = new {
-    val scala3      = "3.3.3"
+    val scala3      = "3.4.1"
     val `scala2.13` = "2.13.13"
     val `scala2.12` = "2.12.19"