Merge pull request #15664 from lenguyenthanh/3.5.0-rc3

Bump scala 3.5.0 rc3 and adapt to new implicit resolution rules

modules/chat/src/main/Chat.scala

@@ -107,10 +107,10 @@ object Chat:
 
  import BSONFields.*
  import reactivemongo.api.bson.BSONDocument
- import lila.chat.Line.given
  import lila.db.dsl.given
 
  given BSONDocumentHandler[MixedChat] = new BSON[MixedChat]:
+ import lila.chat.Line.given
  def reads(r: BSON.Reader): MixedChat =
  MixedChat(
  id = r.get[ChatId](id),

modules/chat/src/main/Line.scala

@@ -1,5 +1,7 @@
 package lila.chat
 
+import reactivemongo.api.bson.*
+
 import chess.{ Color, PlayerTitle }
 
 case class UserLine(
@@ -23,6 +25,12 @@ case class UserLine(
 
  def isLichess = userId.is(UserId.lichess)
 
+object UserLine:
+ private[chat] given BSONHandler[UserLine] = BSONStringHandler.as[UserLine](
+ v => Line.strToUserLine(v).getOrElse(Line.invalidLine),
+ Line.userLineToStr
+ )
+
 case class PlayerLine(color: Color, text: String) extends Line:
  def deleted = false
  def author = color.name
@@ -35,16 +43,9 @@ object Line:
  val textMaxSize = 140
  val titleSep = '~'
 
- import reactivemongo.api.bson.*
-
- private val invalidLine =
+ private[chat] val invalidLine =
  UserLine(UserName(""), None, false, false, "[invalid character]", troll = false, deleted = true)
 
- private[chat] given BSONHandler[UserLine] = BSONStringHandler.as[UserLine](
- v => strToUserLine(v).getOrElse(invalidLine),
- userLineToStr
- )
-
  private[chat] given lineHandler: BSONHandler[lila.core.chat.Line] =
  BSONStringHandler.as[lila.core.chat.Line](
  v => strToLine(v).getOrElse(invalidLine),
@@ -59,7 +60,7 @@ object Line:
  private val UserLineRegex = {
  """(?s)([\w-~]{2,}+)([ """ + s"$trollChar$deletedChar$patronChar$flairChar$patronFlairChar" + """])(.++)"""
  }.r
- private def strToUserLine(str: String): Option[UserLine] = str match
+ private[chat] def strToUserLine(str: String): Option[UserLine] = str match
  case UserLineRegex(username, sep, text) =>
  val troll = sep == trollChar
  val deleted = sep == deletedChar

modules/common/src/main/Json.scala

@@ -1,7 +1,6 @@
 package lila.common
 
 import play.api.libs.json.{ Json as PlayJson, * }
-import scala.util.NotGiven
 import io.mola.galimatias.URL
 
 object Json:
@@ -20,11 +19,14 @@ object Json:
 
  given Writes[URL] = url => JsString(url.toString)
 
- given [A](using Show[A]): KeyWrites[A] with
- def writeKey(key: A) = key.show
+ given Writes[chess.PlayerTitle] = tile => JsString(tile.value)
 
  given NoJsonHandler[chess.Square] with {}
 
+ // could be in scalalib
+ given [A](using sr: SameRuntime[A, String]): KeyWrites[A] with
+ def writeKey(key: A) = sr(key)
+
  import lila.core.LightUser
  given lightUserWrites: OWrites[LightUser] = OWrites(lightUser.write)
  object lightUser:

modules/core/src/main/perf.scala

@@ -71,7 +71,8 @@ object perf:
  def value: String = key
  def id: PerfId = keyIdMap(key)
 
- given Show[PerfKey] = _.value
+ given Show[PerfKey] = _.value
+ given SameRuntime[PerfKey, String] = _.value
 
  def apply(key: String): Option[PerfKey] = Option.when(all.contains(key))(key)
  def apply(variant: Variant, speed: Speed): PerfKey = byVariant(variant) | standardBySpeed(speed)

modules/db/src/main/Handlers.scala

@@ -17,21 +17,24 @@ trait Handlers:
 
  // free handlers for all types with TotalWrapper
  // unless they are given an instance of lila.db.NoDbHandler[T]
- given opaqueHandler[T, A](using
- sr: SameRuntime[A, T],
+ given opaqueWriter[T, A](using
  rs: SameRuntime[T, A],
- handler: BSONHandler[A]
- )(using NotGiven[NoDbHandler[T]]): BSONHandler[T] =
- handler.as(sr.apply, rs.apply)
+ writer: BSONWriter[A]
+ )(using NotGiven[NoDbHandler[T]]): BSONWriter[T] with
+ def writeTry(t: T) = writer.writeTry(rs(t))
 
- given listHandler[T: BSONHandler]: BSONHandler[List[T]] with
- val reader = collectionReader[List, T]
- val writer = BSONWriter.collectionWriter[T, List[T]]
-  def readTry(bson: BSONValue): Try[List[T]] = reader.readTry(bson)
- def writeTry(t: List[T]): Try[BSONValue] = writer.writeTry(t)
+ given opaqueReader[T, A](using
+  sr: SameRuntime[A, T],
+  reader: BSONReader[A]
+ ): BSONReader[T] with
+ def readTry(bson: BSONValue) = reader.readTry(bson).map(sr.apply)
 
- given userIdOfWriter[U: UserIdOf, T](using writer: BSONWriter[UserId]): BSONWriter[U] with
+ given userIdOfWriter[U: UserIdOf](using writer: BSONWriter[UserId]): BSONWriter[U] with
  inline def writeTry(u: U) = writer.writeTry(u.id)
+ given noUserIdOf[A: lila.core.userId.UserIdOf]: NoDbHandler[A] with {}
+
+ given NoDbHandler[UserId] with {}
+ given userIdHandler: BSONHandler[UserId] = stringIsoHandler
 
  given dateTimeHandler: BSONHandler[LocalDateTime] = quickHandler[LocalDateTime](
  { case v: BSONDateTime => millisToDateTime(v.value) },
@@ -108,18 +111,18 @@ trait Handlers:
  leftHandler.readTry(bson).map(Left.apply).orElse(rightHandler.readTry(bson).map(Right.apply))
  def writeTry(e: Either[L, R]) = e.fold(leftHandler.writeTry, rightHandler.writeTry)
 
- def stringMapHandler[V](using
- reader: BSONReader[Map[String, V]],
- writer: BSONWriter[Map[String, V]]
- ): BSONHandler[Map[String, V]] = new:
- def readTry(bson: BSONValue) = reader.readTry(bson)
- def writeTry(v: Map[String, V]) = writer.writeTry(v)
+ given mapHandler[V: BSONHandler]: BSONHandler[Map[String, V]] = new:
+ def readTry(bson: BSONValue) = BSONReader.mapReader.readTry(bson)
+ def writeTry(v: Map[String, V]) = BSONWriter.mapWriter.writeTry(v)
 
- def typedMapHandler[K, V: BSONHandler](using sr: SameRuntime[K, String], rs: SameRuntime[String, K]) =
- stringMapHandler[V].as[Map[K, V]](_.mapKeys(rs(_)), _.mapKeys(sr(_)))
+ def typedMapHandler[K, V: BSONHandler](using
+ sr: SameRuntime[K, String],
+ rs: SameRuntime[String, K]
+ ): BSONHandler[Map[K, V]] =
+ mapHandler[V].as[Map[K, V]](_.mapKeys(rs(_)), _.mapKeys(sr(_)))
 
- def typedMapHandlerIso[K, V: BSONHandler](using keyIso: StringIso[K]) =
- stringMapHandler[V].as[Map[K, V]](_.mapKeys(keyIso.from), _.mapKeys(keyIso.to))
+ def typedMapHandlerIso[K, V: BSONHandler](using keyIso: StringIso[K]): BSONHandler[Map[K, V]] =
+ mapHandler[V].as[Map[K, V]](_.mapKeys(keyIso.from), _.mapKeys(keyIso.to))
 
  def ifPresentHandler[A](a: A) = quickHandler({ case BSONBoolean(true) => a }, _ => BSONBoolean(true))
 
@@ -135,12 +138,6 @@ trait Handlers:
  nel => listWriter.writeTry(nel.toList).get
  )
 
- given vectorHandler[T: BSONHandler]: BSONHandler[Vector[T]] with
- val reader = collectionReader[Vector, T]
- val writer = BSONWriter.collectionWriter[T, Vector[T]]
- def readTry(bson: BSONValue): Try[Vector[T]] = reader.readTry(bson)
- def writeTry(t: Vector[T]): Try[BSONValue] = writer.writeTry(t)
-
  given BSONWriter[BSONNull.type] with
  def writeTry(n: BSONNull.type) = Success(BSONNull)
 

modules/notify/src/main/NotificationPref.scala

@@ -76,7 +76,7 @@ object NotificationPref:
  )(NotificationPref.apply)(lila.notify.unapply)
  )
 
- import lila.db.dsl.opaqueHandler
+ import lila.db.dsl.given
  given BSONDocumentHandler[NotificationPref] = Macros.handler
 
  import play.api.libs.json.{ Json, Writes, OWrites }

modules/plan/src/main/Currency.scala

@@ -12,6 +12,7 @@ import scala.util.Try
 import lila.common.autoconfig.AutoConfig
 import lila.common.config.given
 import lila.core.config.Secret
+import lila.db.dsl.mapHandler
 
 case class CurrencyWithRate(currency: Currency, rate: Double)
 

modules/relay/src/main/BSONHandlers.scala

@@ -1,6 +1,6 @@
 package lila.relay
 
-import reactivemongo.api.bson.*
+import reactivemongo.api.bson.{ BSONDocumentHandler, BSONHandler, Macros }
 
 import lila.db.BSON
 import lila.db.dsl.{ *, given }

modules/study/src/main/BSONHandlers.scala

@@ -359,6 +359,7 @@ object BSONHandlers:
  private[study] given dbMemberHandler: BSONDocumentHandler[DbMember] = Macros.handler
  private[study] given BSONDocumentWriter[StudyMember] with
  def writeTry(x: StudyMember) = Success($doc("role" -> x.role))
+
  private[study] given (using handler: BSONHandler[Map[String, DbMember]]): BSONHandler[StudyMembers] =
  handler.as[StudyMembers](
  members =>
@@ -367,6 +368,7 @@ object BSONHandlers:
  }),
  _.members.view.map((id, m) => id.value -> DbMember(m.role)).toMap
  )
+
  import lila.core.study.Visibility
  private[study] given BSONHandler[Visibility] = tryHandler[Visibility](
  { case BSONString(v) => Visibility.byKey.get(v).toTry(s"Invalid visibility $v") },

modules/study/src/main/StudyMember.scala

@@ -29,7 +29,7 @@ case class StudyMembers(members: StudyMember.MemberMap):
  }.toMap
  )
 
- def contains[U: UserIdOf](u: U): Boolean = members contains u.id
+ def contains[U: UserIdOf](u: U): Boolean = members.contains(u.id)
 
  export members.{ get, keys as ids, keySet as idSet }
 

modules/tutor/src/main/TutorBsonHandlers.scala

@@ -15,7 +15,7 @@ private object TutorBsonHandlers:
  given BSONHandler[GoodPercent] = percentAsIntHandler[GoodPercent]
 
  given [A](using handler: BSONHandler[A]): BSONHandler[ByColor[A]] =
- summon[BSONHandler[Map[String, A]]]
+ mapHandler[A]
  .as[ByColor[A]](
  doc => ByColor(doc("w"), doc("b")),
  map => Map("w" -> map.white, "b" -> map.black)

project/BuildSettings.scala

@@ -6,7 +6,7 @@ object BuildSettings {
  import Dependencies._
 
  val lilaVersion = "4.0"
- val globalScalaVersion = "3.5.0-RC1"
+ val globalScalaVersion = "3.5.0-RC3"
 
  def buildSettings =
  Defaults.coreDefaultSettings ++ Seq(
@@ -47,7 +47,7 @@ object BuildSettings {
  "-Ybackend-parallelism:16", // https://github.com/scala/scala3/pull/15392
  // "-nowarn", // during migration
  // "-rewrite",
- // "-source:3.4-migration",
+ "-source:3.6-migration",
  "-indent",
  // "-explaintypes",
  // "-explain",

project/Dependencies.scala

@@ -42,15 +42,15 @@ object Dependencies {
  }
 
  object chess {
- val version = "16.0.8"
+ val version = "16.0.9"
  val core = "org.lichess" %% "scalachess" % version
  val testKit = "org.lichess" %% "scalachess-test-kit" % version % Test
  val playJson = "org.lichess" %% "scalachess-play-json" % version
  def bundle = Seq(core, testKit, playJson)
  }
 
  object scalalib {
- val version = "11.2.2"
+ val version = "11.2.3"
  val core = "org.lichess" %% "scalalib-core" % version
  val model = "org.lichess" %% "scalalib-model" % version
  val playJson = "org.lichess" %% "scalalib-play-json" % version