wip

Author: nicolasstucki

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

@@ -773,20 +773,20 @@ trait CompilerInterface {
   /** NoPrefix for a type selection */
   type NoPrefix <: TypeOrBounds
 
-  def matchNoPrefix(x: TypeOrBounds)(given ctx: Context): Option[NoPrefix]
+  def isInstanceOfNoPrefix(given ctx: Context): IsInstanceOf[NoPrefix]
 
   /** Type bounds */
   type TypeBounds <: TypeOrBounds
 
-  def matchTypeBounds(x: TypeOrBounds)(given ctx: Context): Option[TypeBounds]
+  def isInstanceOfTypeBounds(given ctx: Context): IsInstanceOf[TypeBounds]
 
   def TypeBounds_low(self: TypeBounds)(given ctx: Context): Type
   def TypeBounds_hi(self: TypeBounds)(given ctx: Context): Type
 
   /** A type */
   type Type <: TypeOrBounds
 
-  def matchType(x: TypeOrBounds)(given ctx: Context): Option[Type]
+  def isInstanceOfType(given ctx: Context): IsInstanceOf[Type]
 
   def Type_apply(clazz: Class[_])(given ctx: Context): Type
 
@@ -858,14 +858,14 @@ trait CompilerInterface {
   /** A singleton type representing a known constant value */
   type ConstantType <: Type
 
-  def matchConstantType(tpe: TypeOrBounds)(given ctx: Context): Option[ConstantType]
+  def isInstanceOfConstantType(given ctx: Context): IsInstanceOf[ConstantType]
 
   def ConstantType_constant(self: ConstantType)(given ctx: Context): Constant
 
   /** Type of a reference to a term symbol */
   type TermRef <: Type
 
-  def matchTermRef(tpe: TypeOrBounds)(given ctx: Context): Option[TermRef]
+  def isInstanceOfTermRef(given ctx: Context): IsInstanceOf[TermRef]
 
   def TermRef_apply(qual: TypeOrBounds, name: String)(given ctx: Context): TermRef
 
@@ -875,23 +875,23 @@ trait CompilerInterface {
   /** Type of a reference to a type symbol */
   type TypeRef <: Type
 
-  def matchTypeRef(tpe: TypeOrBounds)(given ctx: Context): Option[TypeRef]
+  def isInstanceOfTypeRef(given ctx: Context): IsInstanceOf[TypeRef]
 
   def TypeRef_qualifier(self: TypeRef)(given ctx: Context): TypeOrBounds
   def TypeRef_name(self: TypeRef)(given Context): String
 
   /** Type of a `super` refernce */
   type SuperType <: Type
 
-  def matchSuperType(tpe: TypeOrBounds)(given ctx: Context): Option[SuperType]
+  def isInstanceOfSuperType(given ctx: Context): IsInstanceOf[SuperType]
 
   def SuperType_thistpe(self: SuperType)(given ctx: Context): Type
   def SuperType_supertpe(self: SuperType)(given ctx: Context): Type
 
   /** A type with a type refinement `T { type U }` */
   type Refinement <: Type
 
-  def matchRefinement(tpe: TypeOrBounds)(given ctx: Context): Option[Refinement]
+  def isInstanceOfRefinement(given ctx: Context): IsInstanceOf[Refinement]
 
   def Refinement_parent(self: Refinement)(given ctx: Context): Type
   def Refinement_name(self: Refinement)(given ctx: Context): String
@@ -900,7 +900,7 @@ trait CompilerInterface {
   /** A higher kinded type applied to some types `T[U]` */
   type AppliedType <: Type
 
-  def matchAppliedType(tpe: TypeOrBounds)(given ctx: Context): Option[AppliedType]
+  def isInstanceOfAppliedType(given ctx: Context): IsInstanceOf[AppliedType]
 
   def AppliedType_tycon(self: AppliedType)(given ctx: Context): Type
   def AppliedType_args(self: AppliedType)(given ctx: Context): List[TypeOrBounds]
@@ -910,31 +910,31 @@ trait CompilerInterface {
   /** A type with an anottation `T @foo` */
   type AnnotatedType <: Type
 
-  def matchAnnotatedType(tpe: TypeOrBounds)(given ctx: Context): Option[AnnotatedType]
+  def isInstanceOfAnnotatedType(given ctx: Context): IsInstanceOf[AnnotatedType]
 
   def AnnotatedType_underlying(self: AnnotatedType)(given ctx: Context): Type
   def AnnotatedType_annot(self: AnnotatedType)(given ctx: Context): Term
 
   /** Intersection type `T & U` */
   type AndType <: Type
 
-  def matchAndType(tpe: TypeOrBounds)(given ctx: Context): Option[AndType]
+  def isInstanceOfAndType(given ctx: Context): IsInstanceOf[AndType]
 
   def AndType_left(self: AndType)(given ctx: Context): Type
   def AndType_right(self: AndType)(given ctx: Context): Type
 
   /** Union type `T | U` */
   type OrType <: Type
 
-  def matchOrType(tpe: TypeOrBounds)(given ctx: Context): Option[OrType]
+  def isInstanceOfOrType(given ctx: Context): IsInstanceOf[OrType]
 
   def OrType_left(self: OrType)(given ctx: Context): Type
   def OrType_right(self: OrType)(given ctx: Context): Type
 
   /** Type match `T match { case U => ... }` */
   type MatchType <: Type
 
-  def matchMatchType(tpe: TypeOrBounds)(given ctx: Context): Option[MatchType]
+  def isInstanceOfMatchType(given ctx: Context): IsInstanceOf[MatchType]
 
   def MatchType_bound(self: MatchType)(given ctx: Context): Type
   def MatchType_scrutinee(self: MatchType)(given ctx: Context): Type
@@ -943,36 +943,36 @@ trait CompilerInterface {
   /** Type of a by by name parameter */
   type ByNameType <: Type
 
-  def matchByNameType(tpe: TypeOrBounds)(given ctx: Context): Option[ByNameType]
+  def isInstanceOfByNameType(given ctx: Context): IsInstanceOf[ByNameType]
 
   def ByNameType_underlying(self: ByNameType)(given ctx: Context): Type
 
   /** Type of a parameter reference */
   type ParamRef <: Type
 
-  def matchParamRef(tpe: TypeOrBounds)(given ctx: Context): Option[ParamRef]
+  def isInstanceOfParamRef(given ctx: Context): IsInstanceOf[ParamRef]
 
   def ParamRef_binder(self: ParamRef)(given ctx: Context): LambdaType[TypeOrBounds]
   def ParamRef_paramNum(self: ParamRef)(given ctx: Context): Int
 
   /** Type of `this` */
   type ThisType <: Type
 
-  def matchThisType(tpe: TypeOrBounds)(given ctx: Context): Option[ThisType]
+  def isInstanceOfThisType(given ctx: Context): IsInstanceOf[ThisType]
 
   def ThisType_tref(self: ThisType)(given ctx: Context): Type
 
   /** A type that is recursively defined `this` */
   type RecursiveThis <: Type
 
-  def matchRecursiveThis(tpe: TypeOrBounds)(given ctx: Context): Option[RecursiveThis]
+  def isInstanceOfRecursiveThis(given ctx: Context): IsInstanceOf[RecursiveThis]
 
   def RecursiveThis_binder(self: RecursiveThis)(given ctx: Context): RecursiveType
 
   /** A type that is recursively defined */
   type RecursiveType <: Type
 
-  def matchRecursiveType(tpe: TypeOrBounds)(given ctx: Context): Option[RecursiveType]
+  def isInstanceOfRecursiveType(given ctx: Context): IsInstanceOf[RecursiveType]
 
   def RecursiveType_underlying(self: RecursiveType)(given ctx: Context): Type
 
@@ -984,7 +984,7 @@ trait CompilerInterface {
   /** Type of the definition of a method taking a single list of parameters. It's return type may be a MethodType. */
   type MethodType <: LambdaType[Type]
 
-  def matchMethodType(tpe: TypeOrBounds)(given ctx: Context): Option[MethodType]
+  def isInstanceOfMethodType(given ctx: Context): IsInstanceOf[MethodType]
 
   def MethodType_isErased(self: MethodType): Boolean
   def MethodType_isImplicit(self: MethodType): Boolean
@@ -995,7 +995,7 @@ trait CompilerInterface {
   /** Type of the definition of a method taking a list of type parameters. It's return type may be a MethodType. */
   type PolyType <: LambdaType[TypeBounds]
 
-  def matchPolyType(tpe: TypeOrBounds)(given ctx: Context): Option[PolyType]
+  def isInstanceOfPolyType(given ctx: Context): IsInstanceOf[PolyType]
 
   def PolyType_paramNames(self: PolyType)(given ctx: Context): List[String]
   def PolyType_paramBounds(self: PolyType)(given ctx: Context): List[TypeBounds]
@@ -1004,7 +1004,7 @@ trait CompilerInterface {
   /** Type of the definition of a type lambda taking a list of type parameters. It's return type may be a TypeLambda. */
   type TypeLambda <: LambdaType[TypeBounds]
 
-  def matchTypeLambda(tpe: TypeOrBounds)(given ctx: Context): Option[TypeLambda]
+  def isInstanceOfTypeLambda(given ctx: Context): IsInstanceOf[TypeLambda]
 
   def TypeLambda_paramNames(self: TypeLambda)(given ctx: Context): List[String]
   def TypeLambda_paramBounds(self: TypeLambda)(given ctx: Context): List[TypeBounds]
@@ -1023,20 +1023,20 @@ trait CompilerInterface {
 
   type SimpleSelector <: ImportSelector
 
-  def matchSimpleSelector(self: ImportSelector)(given ctx: Context): Option[SimpleSelector]
+  def isInstanceOfSimpleSelector(given ctx: Context): IsInstanceOf[SimpleSelector]
 
   def SimpleSelector_selection(self: SimpleSelector)(given ctx: Context): Id
 
   type RenameSelector <: ImportSelector
 
-  def matchRenameSelector(self: ImportSelector)(given ctx: Context): Option[RenameSelector]
+  def isInstanceOfRenameSelector(given ctx: Context): IsInstanceOf[RenameSelector]
 
   def RenameSelector_from(self: RenameSelector)(given ctx: Context): Id
   def RenameSelector_to(self: RenameSelector)(given ctx: Context): Id
 
   type OmitSelector <: ImportSelector
 
-  def matchOmitSelector(self: ImportSelector)(given ctx: Context): Option[OmitSelector]
+  def isInstanceOfOmitSelector(given ctx: Context): IsInstanceOf[OmitSelector]
 
   def SimpleSelector_omitted(self: OmitSelector)(given ctx: Context): Id
 

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

@@ -8,10 +8,10 @@ trait ImportSelectorOps extends Core {
       internal.SimpleSelector_selection(self)
   }
 
-  object SimpleSelector {
-    def unapply(importSelector: ImportSelector)(given ctx: Context): Option[Id] =
-      internal.matchSimpleSelector(importSelector).map(_.selection)
-  }
+  given (given Context): IsInstanceOf[SimpleSelector] = internal.isInstanceOfSimpleSelector
+
+  object SimpleSelector
+    def unapply(x: SimpleSelector)(given ctx: Context): Option[Id] = Some(x.selection)
 
   given (self: RenameSelector) {
     def from(given ctx: Context): Id =
@@ -21,19 +21,19 @@ trait ImportSelectorOps extends Core {
       internal.RenameSelector_to(self)
   }
 
-  object RenameSelector {
-    def unapply(importSelector: ImportSelector)(given ctx: Context): Option[(Id, Id)] =
-      internal.matchRenameSelector(importSelector).map(x => (x.from, x.to))
-  }
+  given (given Context): IsInstanceOf[RenameSelector] = internal.isInstanceOfRenameSelector
+
+  object RenameSelector
+    def unapply(x: RenameSelector)(given ctx: Context): Option[(Id, Id)] = Some((x.from, x.to))
 
   given (self: OmitSelector) {
     def omitted(given ctx: Context): Id =
       internal.SimpleSelector_omitted(self)
   }
 
-  object OmitSelector {
-    def unapply(importSelector: ImportSelector)(given ctx: Context): Option[Id] =
-      internal.matchOmitSelector(importSelector).map(_.omitted)
-  }
+  given (given Context): IsInstanceOf[OmitSelector] = internal.isInstanceOfOmitSelector
+
+  object OmitSelector
+    def unapply(x: OmitSelector)(given ctx: Context): Option[Id] = Some(x.omitted)
 
 }