Use given syntax in TASTy Reflect

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

@@ -21,7 +21,7 @@ object ReflectionImpl {
     val syntaxHighlight =
       if (ctx.settings.color.value == "always") SyntaxHighlight.ANSI
       else SyntaxHighlight.plain
-    new refl.SourceCodePrinter(syntaxHighlight).showTree(reflTree)(reflCtx)
+    new refl.SourceCodePrinter(syntaxHighlight).showTree(reflTree) given reflCtx
   }
 
 }

library/src/scala/tasty/Reflection.scala

@@ -37,7 +37,7 @@ class Reflection(val kernel: Kernel)
     *
     *  The code should be a sequence of expressions or statements that may appear in a block.
     */
-    def typeChecks(code: String)(implicit ctx: Context): Boolean = kernel.typeChecks(code)(ctx)
+    def typeChecks(code: String)(implicit ctx: Context): Boolean = kernel.typeChecks(code)
   }
 
   // TODO integrate with TreeUtils

library/src/scala/tasty/reflect/ConstantOps.scala

@@ -19,7 +19,7 @@ trait ConstantOps extends Core {
     /** Module of ClassTag literals */
     object ClassTag {
       /** scala.reflect.ClassTag literal */
-      def apply[T](implicit x: Type): Constant =
+      def apply[T] given (x: Type): Constant =
         kernel.Constant_ClassTag_apply(x)
 
       /** Extractor for ClassTag literals */

library/src/scala/tasty/reflect/IdOps.scala

@@ -6,15 +6,15 @@ trait IdOps extends Core {
   implicit class IdAPI(id: Id) {
 
     /** Position in the source code */
-    def pos(implicit ctx: Context): Position = kernel.Id_pos(id)
+    def pos given (ctx: Context): Position = kernel.Id_pos(id)
 
     /** Name of the identifier */
-    def name(implicit ctx: Context): String = kernel.Id_name(id)
+    def name given (ctx: Context): String = kernel.Id_name(id)
 
   }
 
   object Id {
-    def unapply(id: Id)(implicit ctx: Context): Option[String] = Some(id.name)
+    def unapply(id: Id) given (ctx: Context): Option[String] = Some(id.name)
   }
 
 }

library/src/scala/tasty/reflect/ImplicitsOps.scala

@@ -2,39 +2,39 @@ package scala.tasty.reflect
 
 trait ImplicitsOps extends Core {
 
-  def searchImplicit(tpe: Type)(implicit ctx: Context): ImplicitSearchResult =
+  def searchImplicit(tpe: Type) given (ctx: Context): ImplicitSearchResult =
     kernel.searchImplicit(tpe)
 
   object IsImplicitSearchSuccess {
-    def unapply(isr: ImplicitSearchResult)(implicit ctx: Context): Option[ImplicitSearchSuccess] =
+    def unapply(isr: ImplicitSearchResult) given (ctx: Context): Option[ImplicitSearchSuccess] =
       kernel.matchImplicitSearchSuccess(isr)
   }
 
   implicit class IsImplicitSearchSuccessAPI(self: ImplicitSearchSuccess) {
-    def tree(implicit ctx: Context): Term = kernel.ImplicitSearchSuccess_tree(self)
+    def tree given (ctx: Context): Term = kernel.ImplicitSearchSuccess_tree(self)
   }
 
   object IsImplicitSearchFailure {
-    def unapply(isr: ImplicitSearchResult)(implicit ctx: Context): Option[ImplicitSearchFailure] =
+    def unapply(isr: ImplicitSearchResult) given (ctx: Context): Option[ImplicitSearchFailure] =
       kernel.matchImplicitSearchFailure(isr)
   }
 
   implicit class ImplicitSearchFailureAPI(self: ImplicitSearchFailure) {
-    def explanation(implicit ctx: Context): String = kernel.ImplicitSearchFailure_explanation(self)
+    def explanation given (ctx: Context): String = kernel.ImplicitSearchFailure_explanation(self)
   }
 
   object IsDivergingImplicit {
-    def unapply(isr: ImplicitSearchResult)(implicit ctx: Context): Option[DivergingImplicit] =
+    def unapply(isr: ImplicitSearchResult) given (ctx: Context): Option[DivergingImplicit] =
       kernel.matchDivergingImplicit(isr)
   }
 
   object IsNoMatchingImplicits {
-    def unapply(isr: ImplicitSearchResult)(implicit ctx: Context): Option[NoMatchingImplicits] =
+    def unapply(isr: ImplicitSearchResult) given (ctx: Context): Option[NoMatchingImplicits] =
       kernel.matchNoMatchingImplicits(isr)
   }
 
   object IsAmbiguousImplicits {
-    def unapply(isr: ImplicitSearchResult)(implicit ctx: Context): Option[AmbiguousImplicits] =
+    def unapply(isr: ImplicitSearchResult) given (ctx: Context): Option[AmbiguousImplicits] =
       kernel.matchAmbiguousImplicits(isr)
   }
 

library/src/scala/tasty/reflect/ImportSelectorOps.scala

@@ -4,35 +4,35 @@ package reflect
 trait ImportSelectorOps extends Core {
 
   implicit class SimpleSelectorAPI(self: SimpleSelector) {
-    def selection(implicit ctx: Context): Id =
+    def selection given (ctx: Context): Id =
       kernel.SimpleSelector_selection(self)
   }
 
   object SimpleSelector {
-    def unapply(importSelector: ImportSelector)(implicit ctx: Context): Option[Id] =
+    def unapply(importSelector: ImportSelector) given (ctx: Context): Option[Id] =
       kernel.matchSimpleSelector(importSelector).map(_.selection)
   }
 
   implicit class RenameSelectorAPI(self: RenameSelector) {
-    def from(implicit ctx: Context): Id =
+    def from given (ctx: Context): Id =
       kernel.RenameSelector_from(self)
 
-    def to(implicit ctx: Context): Id =
+    def to given (ctx: Context): Id =
       kernel.RenameSelector_to(self)
   }
 
   object RenameSelector {
-    def unapply(importSelector: ImportSelector)(implicit ctx: Context): Option[(Id, Id)] =
+    def unapply(importSelector: ImportSelector) given (ctx: Context): Option[(Id, Id)] =
       kernel.matchRenameSelector(importSelector).map(x => (x.from, x.to))
   }
 
   implicit class OmitSelectorAPI(self: OmitSelector) {
-    def omitted(implicit ctx: Context): Id =
+    def omitted given (ctx: Context): Id =
       kernel.SimpleSelector_omited(self)
   }
 
   object OmitSelector {
-    def unapply(importSelector: ImportSelector)(implicit ctx: Context): Option[Id] =
+    def unapply(importSelector: ImportSelector) given (ctx: Context): Option[Id] =
       kernel.matchOmitSelector(importSelector).map(_.omitted)
   }