Universe

new Universe()

class AbsDefinitions extends AnyRef

trait AbsLazyType extends AbsType

class AbsScope extends Iterable[Symbol]

class AbsSymbol extends AnyRef

class AbsTreePrinter extends AnyRef

class AbsType extends AnyRef

class AbsTypeTree extends Tree with TypTree

A synthetic term holding an arbitrary type.

class Alternative(trees: List[Tree]) extends Tree with TermTree with Product

Alternatives of patterns, eliminated by TransMatch, except for occurrences in encoded Switch stmt (=remaining Match(CaseDef(.

class Annotated(annot: Tree, arg: Tree) extends Tree with Product

A tree that has an annotation attached to it.

type AnnotatedType <: Type

class AnnotatedTypeExtractor extends AnyRef

type AnnotationInfo <: AnyRef

class AnnotationInfoExtractor extends AnyRef

class AppliedTypeTree(tpt: Tree, args: List[Tree]) extends Tree with TypTree with Product

Applied type <tpt> [ <args> ], eliminated by RefCheck

class Apply(fun: Tree, args: List[Tree]) extends GenericApply with Product

Value application

class ApplyDynamic(qual: Tree, args: List[Tree]) extends Tree with TermTree with SymTree with Product

Dynamic value application.

type ArrayAnnotArg <: ClassfileAnnotArg

class ArrayAnnotArgExtractor extends AnyRef

class ArrayValue(elemtpt: Tree, elems: List[Tree]) extends Tree with TermTree with Product

Array of expressions, needs to be translated in backend,

class Assign(lhs: Tree, rhs: Tree) extends Tree with TermTree with Product

Assignment

class BackQuotedIdent extends Ident

class Bind(name: Name, body: Tree) extends DefTree with Product

Bind of a variable to a rhs pattern, eliminated by TransMatch

class Block(stats: List[Tree], expr: Tree) extends Tree with TermTree with Product

Block of expressions (semicolon separated expressions)

class CaseDef(pat: Tree, guard: Tree, body: Tree) extends Tree with Product

Case clause in a pattern match, eliminated by TransMatch (except for occurrences in switch statements)

class ClassDef(mods: Modifiers, name: Name, tparams: List[TypeDef], impl: Template) extends ImplDef with Product

Class definition

type ClassInfoType <: CompoundType

class ClassInfoTypeExtractor extends AnyRef

type ClassfileAnnotArg <: AnyRef

type CompoundType <: Type

class CompoundTypeTree(templ: Template) extends Tree with TypTree with Product

Intersection type <parent1> with .

class Constant(value: Any) extends Product

type ConstantType <: Type

class ConstantTypeExtractor extends AnyRef

class DefDef(mods: Modifiers, name: Name, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree) extends ValOrDefDef with Product

Method definition

class DefTree extends Tree with SymTree

type ExistentialType <: Type

class ExistentialTypeExtractor extends AnyRef

class ExistentialTypeTree(tpt: Tree, whereClauses: List[Tree]) extends Tree with TypTree with Product

class Function(vparams: List[ValDef], body: Tree) extends Tree with TermTree with SymTree with Product

Anonymous function, eliminated by analyzer

class GenericApply extends Tree with TermTree

class Ident(name: Name) extends Tree with RefTree with Product

Identifier <name>

class If(cond: Tree, thenp: Tree, elsep: Tree) extends Tree with TermTree with Product

Conditional expression

class ImplDef extends MemberDef

class Import(expr: Tree, selectors: List[ImportSelector]) extends Tree with SymTree with Product

Import clause

class ImportSelector(name: Name, namePos: Int, rename: Name, renamePos: Int) extends Product

Import selector

class LabelDef(name: Name, params: List[Ident], rhs: Tree) extends DefTree with TermTree with Product

Labelled expression - the symbols in the array (must be Idents!) are those the label takes as argument

type LazyType <: Type with AbsLazyType

class Literal(value: Constant) extends Tree with TermTree with Product

Literal

type LiteralAnnotArg <: ClassfileAnnotArg

class LiteralAnnotArgExtractor extends AnyRef

class Match(selector: Tree, cases: List[CaseDef]) extends Tree with TermTree with Product

Pattern matching expression (before TransMatch) Switch statements (after TransMatch)

class MemberDef extends DefTree

type MethodType <: Type

class MethodTypeExtractor extends AnyRef

class Modifiers(flags: Long, privateWithin: Name, annotations: List[Tree], positions: Map[Long, Position]) extends Product

no summary matey

class ModuleDef(mods: Modifiers, name: Name, impl: Template) extends ImplDef with Product

Singleton object definition

type Name <: AnyRef >: Null

type NestedAnnotArg <: ClassfileAnnotArg

class NestedAnnotArgExtractor extends AnyRef

class New(tpt: Tree) extends Tree with TermTree with Product

Object instantiation One should always use factory method below to build a user level new.

class PackageDef(pid: RefTree, stats: List[Tree]) extends MemberDef with Product

Package clause

type PolyType <: Type

class PolyTypeExtractor extends AnyRef

type Position

trait RefTree extends Tree with SymTree

type RefinedType <: CompoundType

class RefinedTypeExtractor extends AnyRef

class Return(expr: Tree) extends Tree with TermTree with SymTree with Product

Return expression

type Scope <: AbsScope

class Select(qualifier: Tree, name: Name) extends Tree with RefTree with Product

Designator <qualifier> .

class SelectFromArray(qualifier: Tree, name: Name, erasure: Type) extends Tree with TermTree with RefTree with Product

Array selection <qualifier> .

class SelectFromTypeTree(qualifier: Tree, name: Name) extends Tree with TypTree with RefTree with Product

Type selection <qualifier> # <name>, eliminated by RefCheck

type SingleType <: Type

class SingleTypeExtractor extends AnyRef

class SingletonTypeTree(ref: Tree) extends Tree with TypTree with Product

Singleton type, eliminated by RefCheck

class StandardNames extends AnyRef

class Star(elem: Tree) extends Tree with TermTree with Product

Repetition of pattern, eliminated by TransMatch

class Super(qual: Name, mix: Name) extends Tree with TermTree with SymTree with Product

Super reference

type SuperType <: Type

class SuperTypeExtractor extends AnyRef

trait SymTree extends Tree

type Symbol <: AbsSymbol >: Null

class Template(parents: List[Tree], self: ValDef, body: List[Tree]) extends Tree with SymTree with Product

Instantiation template of a class or trait

trait TermTree extends Tree

class This(qual: Name) extends Tree with TermTree with SymTree with Product

Self reference

type ThisType <: Type

class ThisTypeExtractor extends AnyRef

class Throw(expr: Tree) extends Tree with TermTree with Product

Throw expression

class Traverser extends AnyRef

class Tree extends Product

class Try(block: Tree, catches: List[CaseDef], finalizer: Tree) extends Tree with TermTree with Product

trait TypTree extends Tree

A tree for a type.

type Type <: AbsType >: Null

class TypeApply(fun: Tree, args: List[Tree]) extends GenericApply with Product

Type application

type TypeBounds <: Type

class TypeBoundsExtractor extends AnyRef

class TypeBoundsTree(lo: Tree, hi: Tree) extends Tree with TypTree with Product

class TypeDef(mods: Modifiers, name: Name, tparams: List[TypeDef], rhs: Tree) extends MemberDef with Product

Abstract type, type parameter, or type alias

type TypeRef <: Type

class TypeRefExtractor extends AnyRef

type TypeTree <: AbsTypeTree

class TypeTreeExtractor extends AnyRef

class Typed(expr: Tree, tpt: Tree) extends Tree with TermTree with Product

Type annotation, eliminated by explicit outer

class UnApply(fun: Tree, args: List[Tree]) extends Tree with TermTree with Product

class ValDef(mods: Modifiers, name: Name, tpt: Tree, rhs: Tree) extends ValOrDefDef with Product

Value definition

class ValOrDefDef extends MemberDef

def !=(arg0: AnyRef): Boolean

def !=(arg0: Any): Boolean

o != arg0 is the same as !(o == (arg0)).

def ##(): Int

def $asInstanceOf[T0](): T0

def $isInstanceOf[T0](): Boolean

def ==(arg0: AnyRef): Boolean

o == arg0 is the same as if (o eq null) arg0 eq null else o.equals(arg0).

def ==(arg0: Any): Boolean

o == arg0 is the same as o.equals(arg0).

val AnnotatedType: AnnotatedTypeExtractor

val AnnotationInfo: AnnotationInfoExtractor

val ArrayAnnotArg: ArrayAnnotArgExtractor

val BooleanTag: Int

val ByteTag: Int

val CharTag: Int

val ClassInfoType: ClassInfoTypeExtractor

val ClassTag: Int

val ConstantType: ConstantTypeExtractor

val DoubleTag: Int

object EmptyTree extends Tree with TermTree with Product

The empty tree

val EnumTag: Int

val ExistentialType: ExistentialTypeExtractor

val FloatTag: Int

val IntTag: Int

def Literal(value: Any): Literal

val LiteralAnnotArg: LiteralAnnotArgExtractor

val LongTag: Int

val MethodType: MethodTypeExtractor

def Modifiers(flags: Long): Modifiers

def Modifiers(flags: Long, privateWithin: Name): Modifiers

val NestedAnnotArg: NestedAnnotArgExtractor

lazy val NoMods: Modifiers

val NoPosition: Position

val NoPrefix: Type

val NoSymbol: Symbol

val NoTag: Int

val NoType: Type

val NullTag: Int

val PolyType: PolyTypeExtractor

val RefinedType: RefinedTypeExtractor

val ShortTag: Int

val SingleType: SingleTypeExtractor

val StringTag: Int

val SuperType: SuperTypeExtractor

val ThisType: ThisTypeExtractor

val TypeBounds: TypeBoundsExtractor

val TypeRef: TypeRefExtractor

val TypeTree: TypeTreeExtractor

val UnitTag: Int

def asInstanceOf[T0]: T0

This method is used to cast the receiver object to be of type T0.

implicit def classfileAnnotArgManifest: ClassManifest[ClassfileAnnotArg]

def clone(): AnyRef

This method creates and returns a copy of the receiver object.

val definitions: AbsDefinitions

def eq(arg0: AnyRef): Boolean

This method is used to test whether the argument (arg0) is a reference to the receiver object (this).

def equals(arg0: Any): Boolean

This method is used to compare the receiver object (this) with the argument object (arg0) for equivalence.

def finalize(): Unit

This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object.

def getClass(): java.lang.Class[_ <: java.lang.Object]

Returns a representation that corresponds to the dynamic class of the receiver object.

def hashCode(): Int

Returns a hash code value for the object.

def isInstanceOf[T0]: Boolean

This method is used to test whether the dynamic type of the receiver object is T0.

val maxTostringRecursions: Int

The maximum number of recursions allowed in toString

def mkTermName(name: Name): Name

def mkTypeName(name: Name): Name

def ne(arg0: AnyRef): Boolean

o.ne(arg0) is the same as !(o.eq(arg0)).

def newScope(): Scope

def newTermName(s: String): Name

def newTermName(cs: Array[Byte], offset: Int, len: Int): Name

def newTermName(cs: Array[Char], offset: Int, len: Int): Name

def newTreePrinter(out: PrintWriter): AbsTreePrinter

def newTypeName(s: String): Name

def newTypeName(cs: Array[Byte], offset: Int, len: Int): Name

def newTypeName(cs: Array[Char], offset: Int, len: Int): Name

val nme: StandardNames

def notify(): Unit

Wakes up a single thread that is waiting on the receiver object's monitor.

def notifyAll(): Unit

Wakes up all threads that are waiting on the receiver object's monitor.

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

def toString(): String

Returns a string representation of the object.

def wait(): Unit

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

def wait(arg0: Long): Unit