Case

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): (Case, B)

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def bottomUp: tql.EvaluatorMeta[Case]

def bottomUpBreak: tql.EvaluatorMeta[Case]

final def canEqual(that: Any): Boolean

def children: tql.EvaluatorMeta[Case]

def classes(name: Symbol)(implicit arg0: Context): Member.Type

def classes(name: String)(implicit arg0: Context): Member.Type

def classes(implicit arg0: Context): collection.immutable.Seq[Member.Type]

def clone(): AnyRef

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

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

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

def ctor(implicit arg0: Context): Member.Term

def ctors(implicit arg0: Context): collection.immutable.Seq[Member.Term]

def defs(name: Symbol)(implicit arg0: Context): Member.Term

def defs(name: String)(implicit arg0: Context): Member.Term

def defs(implicit arg0: Context): collection.immutable.Seq[Member.Term]

def dialect: Dialect

def end: meta.Point

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

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

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

def ensuring(cond: Boolean): Case

final def eq(arg0: AnyRef): Boolean

final def equals(that: Any): Boolean

def finalize(): Unit

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

def formatted(fmtstr: String): String

final def getClass(): Class[_]

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

final def hashCode(): Int

def input: meta.Input

final def isInstanceOf[T0]: Boolean

def members[T, U](param: T)(implicit arg0: ClassTag[T], arg1: ClassTag[U], ev: meta.XtensionMembersSignature[T, U], arg3: Context): U

def members(implicit arg0: Context): collection.immutable.Seq[Member]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def objects(name: Symbol)(implicit arg0: Context): Member.Term

def objects(name: String)(implicit arg0: Context): Member.Term

def objects(implicit arg0: Context): collection.immutable.Seq[Member.Term]

def overloads(name: Symbol)(implicit arg0: Context): collection.immutable.Seq[Member.Term]

def overloads(name: String)(implicit arg0: Context): collection.immutable.Seq[Member.Term]

def owner(implicit arg0: Context): Scope

def packageObject(implicit arg0: Context): Member.Term

def packages(name: Symbol)(implicit arg0: Context): Member.Term

def packages(name: String)(implicit arg0: Context): Member.Term

def packages(implicit arg0: Context): collection.immutable.Seq[Member.Term]

def params(name: Symbol)(implicit arg0: Context): Param

def params(name: String)(implicit arg0: Context): Param

def params(implicit arg0: Context): collection.immutable.Seq[Param]

def paramss(implicit arg0: Context): collection.immutable.Seq[collection.immutable.Seq[Param]]

def parse[U](implicit convert: Convert[Case, 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[Case]): String

def start: meta.Point

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

final def toString(): String

def topDown: tql.EvaluatorMeta[Case]

def topDownBreak: tql.EvaluatorMeta[Case]

def tparams(name: Symbol)(implicit arg0: Context): Param

def tparams(name: String)(implicit arg0: Context): Param

def tparams(implicit arg0: Context): collection.immutable.Seq[Param]

def traits(name: Symbol)(implicit arg0: Context): Member.Type

def traits(name: String)(implicit arg0: Context): Member.Type

def traits(implicit arg0: Context): collection.immutable.Seq[Member.Type]

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, Case, L]): L

def types(name: Symbol)(implicit arg0: Context): Member.Type

def types(name: String)(implicit arg0: Context): Member.Type

def types(implicit arg0: Context): collection.immutable.Seq[Member.Type]

def vals(name: Symbol)(implicit arg0: Context): Member.Term

def vals(name: String)(implicit arg0: Context): Member.Term

def vals(implicit arg0: Context): collection.immutable.Seq[Member.Term]

def vars(name: Symbol)(implicit arg0: Context): Member.Term

def vars(name: String)(implicit arg0: Context): Member.Term

def vars(implicit arg0: Context): collection.immutable.Seq[Member.Term]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

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