WIP

Author: nicolasstucki

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

@@ -174,82 +174,154 @@ trait TreeOps extends Core {
   val Term: TermModule
   abstract class TermModule extends TermCoreModule {
 
+    val Ident: IsIdentExtractor
+    abstract class IsIdentExtractor {
+      /** Matches any Ident and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[Ident]
+    }
+
     /** Scala term identifier */
     val Ident: IdentExtractor
     abstract class IdentExtractor {
       /** Matches a term identifier and returns its name */
       def unapply(tree: Tree)(implicit ctx: Context): Option[String]
     }
 
+    val Select: IsSelectExtractor
+    abstract class IsSelectExtractor {
+      /** Matches any Select and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[Select]
+    }
+
     /** Scala term selection */
     val Select: SelectExtractor
     abstract class SelectExtractor {
       /** Matches `<qual: Term>.<name: String>: <sig: Signature>` */
       def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, String, Option[Signature])]
     }
 
+    val Literal: IsLiteralExtractor
+    abstract class IsLiteralExtractor {
+      /** Matches any Literal and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[Literal]
+    }
+
     /** Scala literal constant */
     val Literal: LiteralExtractor
     abstract class LiteralExtractor {
       def unapply(tree: Tree)(implicit ctx: Context): Option[Constant]
     }
 
+    val This: IsThisExtractor
+    abstract class IsThisExtractor {
+      /** Matches any This and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[This]
+    }
+
     /** Scala `this` or `this[id]` */
     val This: ThisExtractor
     abstract class ThisExtractor {
       /** Matches new `this[<id: Option[Id]>` */
       def unapply(tree: Tree)(implicit ctx: Context): Option[Option[Id]]
     }
 
+    val New: IsNewExtractor
+    abstract class IsNewExtractor {
+      /** Matches any New and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[New]
+    }
+
     /** Scala `new` */
     val New: NewExtractor
     abstract class NewExtractor {
       /** Matches new `new <tpt: TypeTree>` */
       def unapply(tree: Tree)(implicit ctx: Context): Option[TypeTree]
     }
 
+    val NamedArg: IsNamedArgExtractor
+    abstract class IsNamedArgExtractor {
+      /** Matches any NamedArg and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[NamedArg]
+    }
+
     /** Scala named argument `x = y` in argument position */
     val NamedArg: NamedArgExtractor
     abstract class NamedArgExtractor {
       /** Matches `<name: String> = <value: Term>` */
       def unapply(tree: Tree)(implicit ctx: Context): Option[(String, Term)]
     }
 
+    val Apply: IsApplyExtractor
+    abstract class IsApplyExtractor {
+      /** Matches any Apply and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[Apply]
+    }
+
     /** Scala parameter application */
     val Apply: ApplyExtractor
     abstract class ApplyExtractor {
       /** Matches function application `<fun: Term>(<args: List[Term]>)` */
       def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[Term])]
     }
 
+    val TypeApply: IsTypeApplyExtractor
+    abstract class IsTypeApplyExtractor {
+      /** Matches any TypeApply and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[TypeApply]
+    }
+
     /** Scala type parameter application */
     val TypeApply: TypeApplyExtractor
     abstract class TypeApplyExtractor {
       /** Matches function type application `<fun: Term>[<args: List[TypeTree]>]` */
       def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[TypeTree])]
     }
 
+    val Super: IsSuperExtractor
+    abstract class IsSuperExtractor {
+      /** Matches any Super and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[Super]
+    }
+
     /** Scala `x.super` or `x.super[id]` */
     val Super: SuperExtractor
     abstract class SuperExtractor {
       /** Matches new `<qualifier: Term>.super[<id: Option[Id]>` */
       def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Option[Id])]
     }
 
+    val Typed: IsTypedExtractor
+    abstract class IsTypedExtractor {
+      /** Matches any Typed and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[Typed]
+    }
+
     /** Scala ascription `x: T` */
     val Typed: TypedExtractor
     abstract class TypedExtractor {
       /** Matches `<x: Term>: <tpt: Term>` */
       def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, TypeTree)]
     }
 
+    val Assign: IsAssignExtractor
+    abstract class IsAssignExtractor {
+      /** Matches any Assign and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[Assign]
+    }
+
     /** Scala assign `x = y` */
     val Assign: AssignExtractor
     abstract class AssignExtractor {
       /** Matches `<lhs: Term> = <rhs: Term>` */
       def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Term)]
     }
 
+    val Block: IsBlockExtractor
+    abstract class IsBlockExtractor {
+      /** Matches any Block and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[Block]
+    }
+
     /** Scala code block `{ stat0; ...; statN; expr }` term */
     val Block: BlockExtractor
     abstract class BlockExtractor {
@@ -262,49 +334,97 @@ trait TreeOps extends Core {
       def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Option[TypeTree])]
     }
 
+    val XYZ: IsXYZExtractor
+    abstract class IsXYZExtractor {
+      /** Matches any XYZ and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[XYZ]
+    }
+
     /** Scala `if`/`else` term */
     val If: IfExtractor
     abstract class IfExtractor {
       /** Matches `if (<cond: Term>) <thenp: Term> else <elsep: Term>` */
       def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Term, Term)]
     }
 
+    val XYZ: IsXYZExtractor
+    abstract class IsXYZExtractor {
+      /** Matches any XYZ and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[XYZ]
+    }
+
     /** Scala `match` term */
     val Match: MatchExtractor
     abstract class MatchExtractor {
       /** Matches `<scrutinee: Trem> match { <cases: List[CaseDef]> }` */
       def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[CaseDef])]
     }
 
+    val XYZ: IsXYZExtractor
+    abstract class IsXYZExtractor {
+      /** Matches any XYZ and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[XYZ]
+    }
+
     /** Scala `try`/`catch`/`finally` term */
     val Try: TryExtractor
     abstract class TryExtractor {
       /** Matches `try <body: Term> catch { <cases: List[CaseDef]> } finally <finalizer: Option[Term]>` */
       def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[CaseDef], Option[Term])]
     }
 
+    val XYZ: IsXYZExtractor
+    abstract class IsXYZExtractor {
+      /** Matches any XYZ and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[XYZ]
+    }
+
     /** Scala local `return` */
     val Return: ReturnExtractor
     abstract class ReturnExtractor {
       /** Matches `return <expr: Term>` */
       def unapply(tree: Tree)(implicit ctx: Context): Option[Term]
     }
 
+    val XYZ: IsXYZExtractor
+    abstract class IsXYZExtractor {
+      /** Matches any XYZ and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[XYZ]
+    }
+
     val Repeated: RepeatedExtractor
     abstract class RepeatedExtractor {
       def unapply(tree: Tree)(implicit ctx: Context): Option[List[Term]]
     }
 
+    val XYZ: IsXYZExtractor
+    abstract class IsXYZExtractor {
+      /** Matches any XYZ and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[XYZ]
+    }
+
     val Inlined: InlinedExtractor
     abstract class InlinedExtractor {
       def unapply(tree: Tree)(implicit ctx: Context): Option[(Option[TermOrTypeTree], List[Definition], Term)]
     }
 
+    val XYZ: IsXYZExtractor
+    abstract class IsXYZExtractor {
+      /** Matches any XYZ and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[XYZ]
+    }
+
     val SelectOuter: SelectOuterExtractor
     abstract class SelectOuterExtractor {
       def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Int, Type)]
     }
 
+    val XYZ: IsXYZExtractor
+    abstract class IsXYZExtractor {
+      /** Matches any XYZ and returns it */
+      def unapply(tree: Tree)(implicit ctx: Context): Option[XYZ]
+    }
+
     val While: WhileExtractor
     abstract class WhileExtractor {
       /** Extractor for while loops. Matches `while (<cond>) <body>` and returns (<cond>, <body>) */