Pat

abstract def internalDenot: Denotation

abstract def internalExpansion: Expansion

abstract def internalParent: Tree

abstract def internalPrototype: ThisType

abstract def internalTag: Int

abstract def internalTokens: meta.Tokens

abstract def internalTyping: Typing

abstract def parent: Option[Tree]

abstract def productArity: Int

abstract def productElement(n: Int): Any

abstract def tokens: meta.Tokens

abstract def withTokens(tokens: meta.Tokens): ThisType

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (Pat, B)

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def bottomUp: tql.EvaluatorMeta[Pat]

def bottomUpBreak: tql.EvaluatorMeta[Pat]

final def canEqual(that: Any): Boolean

def children: tql.EvaluatorMeta[Pat]

def clone(): AnyRef

def collect[C[_]]: tql.EvaluatorCollector[Pat, C]

def combine[B](x: tql.Matcher[B]): tql.EvaluatorAndThen[Pat, B]

Allows to use other combinators which are not defined in the CollectionLikeUI framework

def dialect: Dialect

def end: meta.Point

def ensuring(cond: (Pat) ⇒ Boolean, msg: ⇒ Any): Pat

def ensuring(cond: (Pat) ⇒ Boolean): Pat

def ensuring(cond: Boolean, msg: ⇒ Any): Pat

def ensuring(cond: Boolean): Pat

final def eq(arg0: AnyRef): Boolean

final def equals(that: Any): Boolean

def finalize(): Unit

macro def focus(f: PartialFunction[Tree, Boolean]): tql.EvaluatorAndThen[Pat, Tree]

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def guard[U <: T](f: PartialFunction[U, Boolean])(implicit arg0: ClassTag[U]): tql.EvaluatorAndThen[Pat, U]

final def hashCode(): Int

def input: meta.Input

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def parse[U](implicit convert: Convert[Pat, meta.Input], dialect: Dialect, parse: meta.Parse[U]): U

def point: meta.Point

def position: meta.Position

def productIterator: Iterator[Any]

def productPrefix: String

def show[Style[X] <: Show[X]](implicit style: Style[Pat]): String

def start: meta.Point

final def synchronized[T0](arg0: ⇒ T0): T0

final def toString(): String

def topDown: tql.EvaluatorMeta[Pat]

def topDownBreak: tql.EvaluatorMeta[Pat]

macro def transform(f: PartialFunction[Tree, Any]): Any

def transformWithResult[I <: T, O <: T, A](f: PartialFunction[I, (O, A)])(implicit arg0: ClassTag[I], x: AllowedTransformation[I, O]): tql.Matcher[A]

This is required for the transform macro as it cannot access self.transformWithResult by itself

def transforms[A, R, L](f: tql.Matcher[A])(implicit arg0: Monoid[A], r: tql.TransformResultTr[A, R], l: tql.MatcherApply[A, R, Pat, L]): L

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def →[B](y: B): (Pat, B)

def tokens(implicit convert: Convert[Pat, meta.Input], dialect: Dialect): meta.Tokens