SelectStart

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: Any): Boolean

def ===(rhs: Global.Tree): Global.Assign

Assignment

def AND(other: Global.Tree): Global.Tree

def ANY_!=(other: Global.Tree): Global.Apply

def ANY_==(other: Global.Tree): Global.Apply

def ANY_EQ(other: Global.Tree): Global.Apply

def APPLY(params: List[Global.Tree]): Global.Apply

def APPLY(params: Global.Tree*): Global.Apply

Apply, Select, Match *

def AS(tpe: Global.Type): Global.Tree

Casting & type tests -- working our way toward understanding exactly what differs between the different forms of IS and AS.

def DOT(sym: Global.Symbol): SelectStart

def DOT(member: Global.Name): SelectStart

def GEN_!=(other: Global.Tree, kind: Global.ClassSymbol): Global.Apply

def GEN_&(other: Global.Tree, kind: Global.ClassSymbol): Global.Apply

def GEN_==(other: Global.Tree, kind: Global.ClassSymbol): Global.Apply

def GEN_|(other: Global.Tree, kind: Global.ClassSymbol): Global.Apply

def GETCLASS(): Global.Apply

def INT_-(other: Global.Tree): Global.Apply

def INT_==(other: Global.Tree): Global.Apply

def INT_>=(other: Global.Tree): Global.Apply

def IS_OBJ(tpe: Global.Type): Global.Tree

def MEMBER_==(other: Global.Tree): Global.Apply

Note - calling ANY_== in the matcher caused primitives to get boxed for the comparison, whereas looking up nme.

def OBJ_EQ(other: Global.Tree): Global.Apply

def OBJ_NE(other: Global.Tree): Global.Apply

def OR(other: Global.Tree): Global.Tree

logical/comparison ops *

def apply(args: Global.Tree*): Global.Apply

final def asInstanceOf[T0]: T0

def attachments: Attachments { type Pos = TreeDSL.this.global.Position }

def canHaveAttrs: Boolean

def changeOwner(pairs: (Global.Symbol, Global.Symbol)*): Global.Tree

def children: List[Global.Tree]

def clearType(): Global.Select

def clone(): AnyRef

def collect[T](pf: PartialFunction[Global.Tree, T]): List[T]

def correspondsStructure(that: Global.Tree)(f: (Global.Tree, Global.Tree) ⇒ Boolean): Boolean

def defineType(tp: Global.Type): Global.Select

def duplicate: Global.Select

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

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

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

def ensuring(cond: Boolean): SelectStart

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def equalsStructure(that: Global.Tree): Boolean

def exists(p: (Global.Tree) ⇒ Boolean): Boolean

def filter(f: (Global.Tree) ⇒ Boolean): List[Global.Tree]

def finalize(): Unit

def find(p: (Global.Tree) ⇒ Boolean): Option[Global.Tree]

def forAll(p: (Global.Tree) ⇒ Boolean): Boolean

def foreach(f: (Global.Tree) ⇒ Unit): Unit

def foreachPartial(pf: PartialFunction[Global.Tree, Global.Tree]): Unit

def formatted(fmtstr: String): String

def freeTerms: List[Global.FreeTermSymbol]

def freeTypes: List[Global.FreeTypeSymbol]

final def getClass(): Class[_]

def getterName: Global.TermName

def hasAttachment[T](implicit arg0: ClassTag[T]): Boolean

def hasExistingSymbol: Boolean

def hasSymbolField: Boolean

def hasSymbolWhich(f: (Global.Symbol) ⇒ Boolean): Boolean

def hashCode(): Int

val id: Int

def isDef: Boolean

def isEmpty: Boolean

def isErroneous: Boolean

def isErrorTyped: Boolean

final def isInstanceOf[T0]: Boolean

def isTerm: Boolean

def isType: Boolean

def isTyped: Boolean

def localName: Global.TermName

def modifyType(f: (Global.Type) ⇒ Global.Type): Global.Tree

val name: Global.Name

final def ne(arg0: AnyRef): Boolean

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def orElse(alt: ⇒ Global.Tree): Global.Tree

final def pos: Global.Position

def pos_=(pos: Global.Position): Unit

val qualifier: Global.Tree

def removeAttachment[T](implicit arg0: ClassTag[T]): Global.Select

def setAttachments(attachments: Attachments { type Pos = scala.reflect.internal.util.Position }): Global.Select

def setPos(newpos: Position): Global.Select

def setSymbol(sym: Global.Symbol): Global.Select

def setType(tp: Global.Type): Global.Select

def setterName: Global.TermName

def shallowDuplicate: Global.Tree

def shortClass: String

def substituteSymbols(from: List[Global.Symbol], to: List[Global.Symbol]): Global.Tree

def substituteThis(clazz: Global.Symbol, to: Global.Tree): Global.Tree

def substituteTypes(from: List[Global.Symbol], to: List[Global.Type]): Global.Tree

def summaryString: String

var symbol: Global.Symbol

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

def toString(): String

final def tpe: Global.Type

val tree: Global.Select

def updateAttachment[T](attachment: T)(implicit arg0: ClassTag[T]): Global.Select

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter(f: (Global.Tree) ⇒ Boolean): List[Global.Tree]

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

def hasSymbol: Boolean

def tpe_=(t: Global.Type): Unit