Update to given

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -617,21 +617,21 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   def Match_copy(original: Tree)(selector: Term, cases: List[CaseDef])(given Context): Match =
     tpd.cpy.Match(original)(selector, cases)
 
-  type ImpliedMatch = tpd.Match
+  type GivenMatch = tpd.Match
 
-  def isInstanceOfImpliedMatch(given ctx: Context): IsInstanceOf[ImpliedMatch] = new {
-    def runtimeClass: Class[?] = classOf[ImpliedMatch]
-    override def unapply(x: Any): Option[ImpliedMatch] = x match
+  def isInstanceOfGivenMatch(given ctx: Context): IsInstanceOf[GivenMatch] = new {
+    def runtimeClass: Class[?] = classOf[GivenMatch]
+    override def unapply(x: Any): Option[GivenMatch] = x match
       case x: tpd.Match if x.selector.isEmpty => Some(x)
       case _ => None
   }
 
-  def ImplicitMatch_cases(self: Match)(given Context): List[CaseDef] = self.cases
+  def GivenMatch_cases(self: Match)(given Context): List[CaseDef] = self.cases
 
-  def ImplicitMatch_apply(cases: List[CaseDef])(given Context): ImpliedMatch =
+  def GivenMatch_apply(cases: List[CaseDef])(given Context): GivenMatch =
     withDefaultPos(tpd.Match(tpd.EmptyTree, cases))
 
-  def ImplicitMatch_copy(original: Tree)(cases: List[CaseDef])(given Context): ImpliedMatch =
+  def GivenMatch_copy(original: Tree)(cases: List[CaseDef])(given Context): GivenMatch =
     tpd.cpy.Match(original)(tpd.EmptyTree, cases)
 
   type Try = tpd.Try

library/src/scala/tasty/reflect/CompilerInterface.scala

@@ -32,7 +32,7 @@ import scala.runtime.quoted.Unpickler
  *           |                             +- Closure
  *           |                             +- If
  *           |                             +- Match
- *           |                             +- ImpliedMatch
+ *           |                             +- GivenMatch
  *           |                             +- Try
  *           |                             +- Return
  *           |                             +- Repeated
@@ -466,15 +466,15 @@ trait CompilerInterface {
   def Match_apply(selector: Term, cases: List[CaseDef])(given ctx: Context): Match
   def Match_copy(original: Tree)(selector: Term, cases: List[CaseDef])(given ctx: Context): Match
 
-  /** Tree representing a pattern match `delegate match  { ... }` in the source code */
-  type ImpliedMatch <: Term
+  /** Tree representing a pattern match `given match  { ... }` in the source code */
+  type GivenMatch <: Term
 
-  def isInstanceOfImpliedMatch(given ctx: Context): IsInstanceOf[ImpliedMatch]
+  def isInstanceOfGivenMatch(given ctx: Context): IsInstanceOf[GivenMatch]
 
-  def ImplicitMatch_cases(self: ImpliedMatch)(given ctx: Context): List[CaseDef]
+  def GivenMatch_cases(self: GivenMatch)(given ctx: Context): List[CaseDef]
 
-  def ImplicitMatch_apply(cases: List[CaseDef])(given ctx: Context): ImpliedMatch
-  def ImplicitMatch_copy(original: Tree)(cases: List[CaseDef])(given ctx: Context): ImpliedMatch
+  def GivenMatch_apply(cases: List[CaseDef])(given ctx: Context): GivenMatch
+  def GivenMatch_copy(original: Tree)(cases: List[CaseDef])(given ctx: Context): GivenMatch
 
   /** Tree representing a tyr catch `try x catch { ... } finally { ... }` in the source code */
   type Try <: Term

library/src/scala/tasty/reflect/Core.scala

@@ -29,7 +29,7 @@ package scala.tasty.reflect
  *           |                             +- Closure
  *           |                             +- If
  *           |                             +- Match
- *           |                             +- ImpliedMatch
+ *           |                             +- GivenMatch
  *           |                             +- Try
  *           |                             +- Return
  *           |                             +- Repeated
@@ -204,8 +204,8 @@ trait Core {
         /** Tree representing a pattern match `x match  { ... }` in the source code */
         type Match = internal.Match
 
-        /** Tree representing a pattern match `delegate match { ... }` in the source code */  // TODO: drop
-        type ImpliedMatch = internal.ImpliedMatch
+        /** Tree representing a pattern match `given match { ... }` in the source code */  // TODO: drop
+        type GivenMatch = internal.GivenMatch
 
         /** Tree representing a try catch `try x catch { ... } finally { ... }` in the source code */
         type Try = internal.Try

library/src/scala/tasty/reflect/ExtractorsPrinter.scala

@@ -91,8 +91,8 @@ class ExtractorsPrinter[R <: Reflection & Singleton](val tasty: R) extends Print
         this += "Closure(" += meth += ", " += tpt += ")"
       case Match(selector, cases) =>
         this += "Match(" += selector += ", " ++= cases += ")"
-      case ImpliedMatch(cases) =>
-        this += "ImpliedMatch(" ++= cases += ")"
+      case GivenMatch(cases) =>
+        this += "GivenMatch(" ++= cases += ")"
       case Return(expr) =>
         this += "Return(" += expr += ")"
       case While(cond, body) =>

library/src/scala/tasty/reflect/SourceCodePrinter.scala

@@ -476,8 +476,8 @@ class SourceCodePrinter[R <: Reflection & Singleton](val tasty: R)(syntaxHighlig
         this += highlightKeyword(" match")
         inBlock(printCases(cases, lineBreak()))
 
-      case ImpliedMatch(cases) =>
-        this += highlightKeyword("delegate match")  // TODO: drop
+      case GivenMatch(cases) =>
+        this += highlightKeyword("given match")  // TODO: drop
         inBlock(printCases(cases, lineBreak()))
 
       case Try(body, cases, finallyOpt) =>

library/src/scala/tasty/reflect/TreeOps.scala

@@ -672,29 +672,29 @@ trait TreeOps extends Core {
     def cases(given ctx: Context): List[CaseDef] = internal.Match_cases(self)
   }
 
-  given (given Context): IsInstanceOf[ImpliedMatch] = internal.isInstanceOfImpliedMatch
+  given (given Context): IsInstanceOf[GivenMatch] = internal.isInstanceOfGivenMatch
 
   /** Scala implicit `match` term */
-  object IsImpliedMatch
-    @deprecated("Use _: ImpliedMatch", "")
-    def unapply(x: ImpliedMatch): Some[ImpliedMatch] = Some(x)
+  object IsGivenMatch
+    @deprecated("Use _: GivenMatch", "")
+    def unapply(x: GivenMatch): Some[GivenMatch] = Some(x)
 
-  object ImpliedMatch {
+  object GivenMatch {
 
-    /** Creates a pattern match `delegate match { <cases: List[CaseDef]> }` */
-    def apply(cases: List[CaseDef])(given ctx: Context): ImpliedMatch =
-      internal.ImplicitMatch_apply(cases)
+    /** Creates a pattern match `given match { <cases: List[CaseDef]> }` */
+    def apply(cases: List[CaseDef])(given ctx: Context): GivenMatch =
+      internal.GivenMatch_apply(cases)
 
-    def copy(original: Tree)(cases: List[CaseDef])(given ctx: Context): ImpliedMatch =
-      internal.ImplicitMatch_copy(original)(cases)
+    def copy(original: Tree)(cases: List[CaseDef])(given ctx: Context): GivenMatch =
+      internal.GivenMatch_copy(original)(cases)
 
-    /** Matches a pattern match `delegate match { <cases: List[CaseDef]> }` */
-    def unapply(x: ImpliedMatch)(given ctx: Context): Option[List[CaseDef]] = Some(x.cases)
+    /** Matches a pattern match `given match { <cases: List[CaseDef]> }` */
+    def unapply(x: GivenMatch)(given ctx: Context): Option[List[CaseDef]] = Some(x.cases)
 
   }
 
-  given ImpliedMatchOps: (self: ImpliedMatch) {
-    def cases(given ctx: Context): List[CaseDef] = internal.ImplicitMatch_cases(self)
+  given GivenMatchOps: (self: GivenMatch) {
+    def cases(given ctx: Context): List[CaseDef] = internal.GivenMatch_cases(self)
   }
 
   given (given Context): IsInstanceOf[Try] = internal.isInstanceOfTry