update for Scala 3.2.0

Author: AntoineSebert

build.sbt

@@ -1,6 +1,6 @@
-ThisBuild / version := "0.1.0-SNAPSHOT"
+ThisBuild / version := "1.0.0"
 
-ThisBuild / scalaVersion := "3.1.3"
+ThisBuild / scalaVersion := "3.2.0"
 
 lazy val root = (project in file("."))
   .settings(

project/metals.sbt

@@ -2,5 +2,5 @@
 
 // This file enables sbt-bloop to create bloop config files.
 
-addSbtPlugin("ch.epfl.scala" % "sbt-bloop" % "1.5.0-18-003e6c7b")
+addSbtPlugin("ch.epfl.scala" % "sbt-bloop" % "1.5.3")
 

project/project/metals.sbt

@@ -2,5 +2,5 @@
 
 // This file enables sbt-bloop to create bloop config files.
 
-addSbtPlugin("ch.epfl.scala" % "sbt-bloop" % "1.5.0-18-003e6c7b")
+addSbtPlugin("ch.epfl.scala" % "sbt-bloop" % "1.5.3")
 

src/main/scala/actor/Actor.scala

@@ -4,13 +4,13 @@ import java.util.concurrent.LinkedTransferQueue
 import join_patterns.Matcher
 
 abstract class Actor[M, T] extends Runnable {
-  protected val q = LinkedTransferQueue[M]
-  val ref         = ActorRef(q)
+  protected val q: LinkedTransferQueue[M] = LinkedTransferQueue[M]
+  val ref: ActorRef[M]                    = ActorRef(q)
   protected val matcher: Matcher[M, T]
 }
 
 abstract class DynamicActor[M, T] extends Runnable {
-  protected val q = LinkedTransferQueue[M]
-  val ref         = ActorRef(q)
+  protected val q: LinkedTransferQueue[M] = LinkedTransferQueue[M]
+  val ref: ActorRef[M]                    = ActorRef(q)
   protected var matcher: Matcher[M, T]
 }

src/main/scala/actor/ActorRef.scala

@@ -1,8 +1,10 @@
 package actor
 
 import java.util.concurrent.LinkedTransferQueue
+import scala.annotation.targetName
 
 class ActorRef[-M](q: LinkedTransferQueue[M]) {
-  def send(m: M) = q.put(m)
-  def !(m: M)    = send(m)
+  def send(m: M): Unit = q.put(m)
+
+  def !(m: M): Unit = send(m)
 }

src/main/scala/join_patterns/Macro.scala

@@ -1,21 +1,21 @@
 package join_patterns
 
-import java.util.concurrent.{LinkedTransferQueue => Queue}
-
-import scala.quoted.{Expr, Type, Quotes, Varargs}
+import java.util.concurrent.LinkedTransferQueue as Queue
+import scala.quoted.{Expr, Quotes, Type, Varargs}
 import scala.collection.mutable.ListBuffer
-import scala.collection.mutable.{Map => mutMap}
+import scala.collection.mutable.Map as mutMap
+import scala.language.postfixOps
 
 case class JoinPattern[M, T](
-    val extract: List[M] => (List[M], Map[String, Any]),
-    val guard: Map[String, Any] => Boolean,
-    val rhs: Map[String, Any] => T,
-    val size: Int
+    extract: List[M] => (List[M], Map[String, Any]),
+    guard: Map[String, Any] => Boolean,
+    rhs: Map[String, Any] => T,
+    size: Int
 )
 
 class Matcher[M, T](val patterns: List[JoinPattern[M, T]]) {
   // Messages extracted from the queue are saved here to survive across apply() calls
-  private var messages = ListBuffer[M]()
+  private val messages = ListBuffer[M]()
 
   def apply(q: Queue[M]): T =
     import collection.convert.ImplicitConversions._
@@ -25,12 +25,12 @@ class Matcher[M, T](val patterns: List[JoinPattern[M, T]]) {
     while (result.isEmpty)
       for
         pattern <- patterns
-        if !result.isDefined
+        if result.isEmpty
       do
         if messages.size >= pattern.size then
           val (matchedMessages, substs) = pattern.extract(messages.toList)
 
-          if !matchedMessages.isEmpty && pattern.guard(substs) then
+          if matchedMessages.nonEmpty && pattern.guard(substs) then
             result = Some(pattern.rhs(substs))
             messages.subtractAll(matchedMessages)
 
@@ -59,7 +59,7 @@ private def extractInner(using quotes: Quotes)(
     case typed @ Typed(Wildcard(), TypeIdent(_)) => ("_", typed.tpt.tpe.dealias.simplified)
     // add support for Wildcard !!! : (_)
     // add support for Bind(String, WildCard) : (name: _)
-    case default =>
+    case _ =>
       errorTree("Unsupported bottom-level pattern", t)
       ("", TypeRepr.of[Nothing])
 
@@ -103,9 +103,9 @@ private def generateExtractor(using
   Lambda(
     owner = Symbol.spliceOwner,
     tpe = MethodType(List(""))(_ => List(outerType), _ => TypeRepr.of[Map[String, Any]]),
-    rhsFn = (sym: Symbol, params: List[Tree]) =>
+    rhsFn = (_: Symbol, params: List[Tree]) =>
       val p0 = params.head.asInstanceOf[Ident]
-      val isMemberName: (Symbol => Boolean) =
+      val isMemberName: Symbol => Boolean =
         (p: Symbol) => p.name.head == '_' && p.name.tail.toIntOption.isDefined
       val memberSymbols: List[Symbol] = outerType.typeSymbol.methodMembers
         .filter(isMemberName(_))
@@ -137,13 +137,13 @@ private def generateGuard(using quotes: Quotes)(
     override def transformTerm(term: Term)(owner: Symbol): Term = super.transformTerm(term)(owner)
   }
 
-  var _rhsFn = (sym: Symbol, params: List[Tree]) =>
-    _transform.transformTerm(('{ true }).asExprOf[Boolean].asTerm.changeOwner(sym))(sym)
+  var _rhsFn = (sym: Symbol, _: List[Tree]) =>
+    _transform.transformTerm('{ true }.asExprOf[Boolean].asTerm.changeOwner(sym))(sym)
 
   guard match
     case Some(apply: Apply) =>
       if inners.isEmpty then
-        _rhsFn = (sym: Symbol, params: List[Tree]) =>
+        _rhsFn = (sym: Symbol, _: List[Tree]) =>
           _transform.transformTerm(apply.changeOwner(sym))(sym)
       else
         _rhsFn = (sym: Symbol, params: List[Tree]) =>
@@ -152,7 +152,7 @@ private def generateGuard(using quotes: Quotes)(
           val transform = new TreeMap {
             override def transformTerm(term: Term)(owner: Symbol): Term = term match
               case Ident(n) if inners.exists(_._1 == n) =>
-                val inner = '{ ${ p0.asExprOf[Map[String, Any]] }(${ Expr(n) }) }
+                val inner = '{ (${ p0.asExprOf[Map[String, Any]] })(${ Expr(n) }) }
 
                 inners.find(_._1 == n).get._2.asType match
                   case '[innerType] => ('{ ${ inner }.asInstanceOf[innerType] }).asTerm
@@ -195,7 +195,7 @@ private def generateRhs[T](using
       val transform = new TreeMap {
         override def transformTerm(term: Term)(owner: Symbol): Term = term match
           case Ident(n) if inners.exists(_._1 == n) =>
-            val inner = '{ ${ p0.asExprOf[Map[String, Any]] }(${ Expr(n) }) }
+            val inner = '{ (${ p0.asExprOf[Map[String, Any]] })(${ Expr(n) }) }
 
             inners.find(_._1 == n).get._2.asType match
               case '[innerType] => ('{ ${ inner }.asInstanceOf[innerType] }).asTerm
@@ -243,7 +243,7 @@ private def generate[M, T](using quotes: Quotes, tm: Type[M], tt: Type[T])(
                     m.find(_.isInstanceOf[ot]) match
                       case None => (List(), Map())
                       case Some(message) =>
-                        (List(message), ${ extractor }(message.asInstanceOf[ot]))
+                        (List(message), $extractor(message.asInstanceOf[ot]))
                   }
               (List(outer), inners)
             // (A, B, C ...)
@@ -319,7 +319,7 @@ private def getCases[M, T](
 
   expr.asTerm match
     case Inlined(_, _, Block(_, Block(stmts, _))) =>
-      stmts(0) match
+      stmts.head match
         case DefDef(_, _, _, Some(Block(_, Match(_, cases)))) =>
           val code = cases.map { generate[M, T](_) }
           /*

src/main/scala/join_patterns/main.scala

@@ -12,17 +12,17 @@ case class F(b: Int, a: String)                     extends Msg
 case class G(b: Int, a: String, c: Int, d: Boolean) extends Msg
 
 object PatternOrdering extends Ordering[JoinPattern[Msg, Int]] {
-  def compare(a: JoinPattern[Msg, Int], b: JoinPattern[Msg, Int]) = a.size.compare(b.size)
+  def compare(a: JoinPattern[Msg, Int], b: JoinPattern[Msg, Int]): Int = a.size.compare(b.size)
 }
 
 @main
 def main(): Unit =
-  val i: Int                 = 0;
+  val i: Int                 = 0
   val m                      = 0
   val isZero: Int => Boolean = (n: Int) => n == 0
   val q                      = LinkedTransferQueue[Msg]
 
-  var f = receive { (y: Msg) =>
+  val f = receive { (y: Msg) =>
     y match
       case A() => 5
     /*
@@ -53,4 +53,4 @@ def main(): Unit =
   q.add(F(2, "t"))
    */
   val ret1 = f(q)
-  println(f"After receiving A, f returned: ${ret1}")
+  println(f"After receiving A, f returned: $ret1")

src/main/scala/join_patterns/util.scala

@@ -13,7 +13,7 @@ def showExpr[T](expr: Expr[T])(using Quotes): Expr[String] =
   val code: String = expr.show
   Expr(code)
 
-def _println[T](x: Expr[T])(using Quotes) = {
+def _println[T](x: Expr[T])(using Quotes): Unit = {
   import quotes.reflect.*
 
   val tree: Tree = x.asTerm

src/test/scala/scenario/Demo.scala

@@ -0,0 +1,96 @@
+package test.scenario.demo
+
+import java.util.Date
+import java.time.Duration
+import org.scalatest.funsuite.AnyFunSuite
+
+import join_patterns.receive
+import test.classes.Msg
+import test.benchmark.Benchmarkable
+import actor.Actor
+
+case class Motion(status: Boolean, room: String) extends Msg
+case class Light(status: Boolean, room: String)  extends Msg
+case class Contact(open: Boolean, room: String)  extends Msg
+
+class DemoSmartHouse extends Actor[Msg, Unit] {
+  private var lastMotionInBathroom = Date(0L)
+  private var lastNotification     = Date(0L)
+  private val between: (Date, Date) => Duration = (a, b) =>
+    Duration.between(a.toInstant, b.toInstant).abs
+
+  def turnOff(rooms: Seq[String], mStatus: Boolean, lStatus: Boolean, window: Duration) =
+    rooms.forall(_ == "bathroom") && !mStatus && lStatus && between(
+      lastMotionInBathroom,
+      Date()
+    ).compareTo(window) > 0
+
+  def occupiedHome(
+      statuses: Seq[Boolean],
+      mRoom0: String,
+      mRoom1: String,
+      cRoom: String
+  ): Boolean =
+    statuses.forall(
+      _ == true
+    ) && mRoom0 == "front_door" && cRoom == "front_door" && mRoom1 == "entrance_hall"
+
+  protected val matcher = receive { (y: Msg) =>
+    y match
+      // E2. Turn off the lights in a room after two minutes without detecting any movement.
+      case (
+            Motion(mStatus: Boolean, mRoom: String),
+            Light(lStatus: Boolean, lRoom: String)
+          ) if turnOff(List(mRoom, lRoom), mStatus, lStatus, Duration.ofMinutes(2)) =>
+        lastMotionInBathroom = Date()
+        println("turn_off_light()")
+      // E5. Detect home arrival based on a particular sequence of messages, and activate the corresponding scene.
+      case (
+            Motion(mStatus0: Boolean, mRoom0: String),
+            Contact(cStatus: Boolean, cRoom: String),
+            Motion(mStatus1: Boolean, mRoom1: String)
+          )
+          if occupiedHome(
+            List(mStatus0, mStatus1, cStatus),
+            mRoom0,
+            mRoom1,
+            cRoom
+          ) =>
+        lastNotification = Date()
+        println("activate_home_scene(l, i, t)")
+
+  }
+
+  def run(): Unit =
+    matcher(q)
+    Thread.`yield`()
+}
+
+class SmartHouseTest extends AnyFunSuite {
+  test("E2. Turn off the lights in a room after two minutes without detecting any movement.") {
+    val house       = DemoSmartHouse()
+    val houseThread = Thread(house)
+
+    houseThread.start
+
+    house.ref.send(Motion(false, "bathroom"))
+    house.ref.send(Light(true, "bathroom"))
+
+    houseThread.join
+  }
+
+  test(
+    "E5. Detect home arrival based on a particular sequence of messages, and activate the corresponding scene."
+  ) {
+    val house       = DemoSmartHouse()
+    val houseThread = Thread(house)
+
+    houseThread.start
+
+    house.ref.send(Motion(true, "front_door"))
+    house.ref.send(Contact(true, "front_door"))
+    house.ref.send(Motion(true, "entrance_hall"))
+
+    houseThread.join
+  }
+}