Base

Instance Constructors

new Base()

Type Members

trait AbsTypeTag[T] extends Equals with Serializable

If an implicit value of type u.
case class Alternative(trees: List[Tree]) extends Tree with TermTree with Product with Serializable

Alternatives of patterns, eliminated by explicitouter, except for occurrences in encoded Switch stmt (=remaining Match(CaseDef(.
abstract class AlternativeExtractor extends AnyRef

An extractor class to create and pattern match with syntax Alternative(trees).
case class Annotated(annot: Tree, arg: Tree) extends Tree with Product with Serializable

A tree that has an annotation attached to it.
abstract class AnnotatedExtractor extends AnyRef

An extractor class to create and pattern match with syntax Annotated(annot, arg).
case class AnnotatedType(annotations: List[AnnotationInfo], underlying: Type, selfsym: Symbol) extends Type with Product with Serializable

The AnnotatedType type signature is used for annotated types of the for <type> @<annotation>.
abstract class AnnotatedTypeExtractor extends AnyRef

An extractor class to create and pattern match with syntax AnnotatedType(annotations, underlying, selfsym).
case class AnnotationInfo(atp: Type, args: List[Tree], assocs: List[(Name, ClassfileAnnotArg)]) extends Product with Serializable

Definition Classes
Base → AnnotationInfos
abstract class AnnotationInfoExtractor extends AnyRef

Definition Classes
AnnotationInfos
case class AppliedTypeTree(tpt: Tree, args: List[Tree]) extends Tree with TypTree with Product with Serializable

Applied type <tpt> [ <args> ], eliminated by RefCheck
abstract class AppliedTypeTreeExtractor extends AnyRef

An extractor class to create and pattern match with syntax AppliedTypeTree(tpt, args).
case class Apply(fun: Tree, args: List[Tree]) extends GenericApply with Product with Serializable

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

Dynamic value application.
abstract class ApplyDynamicExtractor extends AnyRef

An extractor class to create and pattern match with syntax ApplyDynamic(qual, args).
abstract class ApplyExtractor extends AnyRef

An extractor class to create and pattern match with syntax Apply(fun, args).
case class ArrayAnnotArg(args: Array[ClassfileAnnotArg]) extends ClassfileAnnotArg with Product with Serializable

Definition Classes
Base → AnnotationInfos
abstract class ArrayAnnotArgExtractor extends AnyRef

Definition Classes
AnnotationInfos
case class ArrayValue(elemtpt: Tree, elems: List[Tree]) extends Tree with TermTree with Product with Serializable

Array of expressions, needs to be translated in backend.
abstract class ArrayValueExtractor extends AnyRef

An extractor class to create and pattern match with syntax ArrayValue(elemtpt, elems).
case class Assign(lhs: Tree, rhs: Tree) extends Tree with TermTree with Product with Serializable

Assignment
abstract class AssignExtractor extends AnyRef

An extractor class to create and pattern match with syntax Assign(lhs, rhs).
case class AssignOrNamedArg(lhs: Tree, rhs: Tree) extends Tree with TermTree with Product with Serializable

Either an assignment or a named argument.
abstract class AssignOrNamedArgExtractor extends AnyRef

An extractor class to create and pattern match with syntax AssignOrNamedArg(lhs, rhs).
case class Bind(name: Name, body: Tree) extends DefTree with Product with Serializable

Bind of a variable to a rhs pattern, eliminated by explicitouter Eliminated by patmat/explicitouter.
abstract class BindExtractor extends AnyRef

An extractor class to create and pattern match with syntax Bind(name, body).
case class Block(stats: List[Tree], expr: Tree) extends Tree with TermTree with Product with Serializable

Block of expressions (semicolon separated expressions)
abstract class BlockExtractor extends AnyRef

An extractor class to create and pattern match with syntax Block(stats, expr).
case class BoundedWildcardType(bounds: TypeBounds) extends Type with Product with Serializable

BoundedWildcardTypes, used only during type inference, are created in two places that I can find:
abstract class BoundedWildcardTypeExtractor extends AnyRef

Definition Classes
Types
abstract class BuildBase extends AnyRef

Definition Classes
BuildUtils
case class CaseDef(pat: Tree, guard: Tree, body: Tree) extends Tree with Product with Serializable

Case clause in a pattern match, eliminated during explicitouter (except for occurrences in switch statements).
abstract class CaseDefExtractor extends AnyRef

An extractor class to create and pattern match with syntax CaseDef(pat, guard, body).
case class ClassDef(mods: Modifiers, name: TypeName, tparams: List[TypeDef], impl: Template) extends ImplDef with Product with Serializable

A class definition.
abstract class ClassDefExtractor extends AnyRef

An extractor class to create and pattern match with syntax ClassDef(mods, name, tparams, impl).
case class ClassInfoType(parents: List[Type], decls: Scope, typeSymbol: Symbol) extends CompoundType with Product with Serializable

The ClassInfo type signature is used to define parents and declarations of classes, traits, and objects.
abstract class ClassInfoTypeExtractor extends AnyRef

An extractor class to create and pattern match with syntax ClassInfo(parents, decls, clazz) Here, parents is the list of parent types of the class, decls is the scope containing all declarations in the class, and clazz is the symbol of the class itself.
class ClassSymbol extends TypeSymbol with ClassSymbolBase

The abstract type of class symbols representing class and trait definitions
trait ClassSymbolBase extends Universe.TypeSymbolBase

The base API that all class symbols support
abstract class ClassfileAnnotArg extends AnyRef

Definition Classes
Base → AnnotationInfos
abstract class CompoundType extends Type

A subtype of Type representing refined types as well as ClassInfo signatures.
case class CompoundTypeTree(templ: Template) extends Tree with TypTree with Product with Serializable

Intersection type <parent1> with .
abstract class CompoundTypeTreeExtractor extends AnyRef

An extractor class to create and pattern match with syntax CompoundTypeTree(templ).
case class Constant(value: Any) extends Product with Serializable

Definition Classes
Base → Constants
abstract class ConstantExtractor extends AnyRef

Definition Classes
Constants
case class ConstantType(value: Constant) extends SingletonType with Product with Serializable

The ConstantType type is not directly written in user programs, but arises as the type of a constant.
abstract class ConstantTypeExtractor extends AnyRef

An extractor class to create and pattern match with syntax ConstantType(constant) Here, constant is the constant value represented by the type.
case class DefDef(mods: Modifiers, name: Name, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree) extends ValOrDefDef with Product with Serializable

A method or macro definition.
abstract class DefDefExtractor extends AnyRef

An extractor class to create and pattern match with syntax DefDef(mods, name, tparams, vparamss, tpt, rhs).
abstract class DefTree extends Tree with SymTree with NameTree

A tree which defines a symbol-carrying entity.
trait DefinitionsBase extends Universe.StandardTypes

Definition Classes
StandardDefinitions
case class ExistentialType(quantified: List[Symbol], underlying: Type) extends Type with Product with Serializable

The ExistentialType type signature is used for existential types and wildcard types.
abstract class ExistentialTypeExtractor extends AnyRef

An extractor class to create and pattern match with syntax ExistentialType(quantified, underlying).
case class ExistentialTypeTree(tpt: Tree, whereClauses: List[Tree]) extends Tree with TypTree with Product with Serializable

Document me!
abstract class ExistentialTypeTreeExtractor extends AnyRef

An extractor class to create and pattern match with syntax ExistentialTypeTree(tpt, whereClauses).
trait Expr[+T] extends Equals with Serializable

An expression tree tagged with its type
type FlagSet = Long

An abstract type representing sets of flags that apply to definition trees and symbols
An abstract type representing sets of flags that apply to definition trees and symbols

Definition Classes
Base → FlagSets
class FreeTermSymbol extends TermSymbol with FreeTermSymbolBase

The abstract type of free terms introduced by reification
trait FreeTermSymbolBase extends Universe.TermSymbolBase

The base API that all free term symbols support
class FreeTypeSymbol extends TypeSymbol with FreeTypeSymbolBase

The abstract type of free types introduced by reification
trait FreeTypeSymbolBase extends Universe.TypeSymbolBase

The base API that all free type symbols support
case class Function(vparams: List[ValDef], body: Tree) extends Tree with TermTree with SymTree with Product with Serializable

Anonymous function, eliminated by lambdalift
abstract class FunctionExtractor extends AnyRef

An extractor class to create and pattern match with syntax Function(vparams, body).
abstract class GenericApply extends Tree with TermTree

Common base class for Apply and TypeApply.
case class Ident(name: Name) extends Tree with RefTree with Product with Serializable

Identifier <name>
abstract class IdentExtractor extends AnyRef

An extractor class to create and pattern match with syntax Ident(qual, name).
case class If(cond: Tree, thenp: Tree, elsep: Tree) extends Tree with TermTree with Product with Serializable

Conditional expression
abstract class IfExtractor extends AnyRef

An extractor class to create and pattern match with syntax If(cond, thenp, elsep).
abstract class ImplDef extends MemberDef

A common base class for class and object definitions.
case class Import(expr: Tree, selectors: List[ImportSelector]) extends Tree with SymTree with Product with Serializable

Import clause
abstract class ImportExtractor extends AnyRef

An extractor class to create and pattern match with syntax Import(expr, selectors).
case class ImportSelector(name: Name, namePos: Int, rename: Name, renamePos: Int) extends Product with Serializable

Import selector
abstract class ImportSelectorExtractor extends AnyRef

An extractor class to create and pattern match with syntax ImportSelector(name:, namePos, rename, renamePos).
case class LabelDef(name: TermName, params: List[Ident], rhs: Tree) extends DefTree with TermTree with Product with Serializable

A labelled expression.
abstract class LabelDefExtractor extends AnyRef

An extractor class to create and pattern match with syntax LabelDef(name, params, rhs).
case class Literal(value: Constant) extends Tree with TermTree with Product with Serializable

Literal
case class LiteralAnnotArg(const: Constant) extends ClassfileAnnotArg with Product with Serializable

Definition Classes
Base → AnnotationInfos
abstract class LiteralAnnotArgExtractor extends AnyRef

Definition Classes
AnnotationInfos
abstract class LiteralExtractor extends AnyRef

An extractor class to create and pattern match with syntax Literal(value).
case class Match(selector: Tree, cases: List[CaseDef]) extends Tree with TermTree with Product with Serializable

- Pattern matching expression (before explicitouter)
abstract class MatchExtractor extends AnyRef

An extractor class to create and pattern match with syntax Match(selector, cases).
abstract class MemberDef extends DefTree

Common base class for all member definitions: types, classes, objects, packages, vals and vars, defs.
type MemberScope = Scope

Definition Classes
Base → Scopes
trait MemberScopeBase extends Universe.ScopeBase

The base API that all member scopes support
class MethodSymbol extends TermSymbol with MethodSymbolBase

The abstract type of method symbols representing def declarations
trait MethodSymbolBase extends Universe.TermSymbolBase

The base API that all method symbols support
case class MethodType(params: List[Symbol], resultType: Type) extends Type with Product with Serializable

The MethodType type signature is used to indicate parameters and result type of a method
abstract class MethodTypeExtractor extends AnyRef

An extractor class to create and pattern match with syntax MethodType(params, respte) Here, params is a potentially empty list of parameter symbols of the method, and restpe is the result type of the method.
class Mirror extends MirrorOf[Base.this.type]

.
class Modifiers extends ModifiersBase

.
abstract class ModifiersBase extends AnyRef

.
abstract class ModifiersCreator extends AnyRef

Definition Classes
Trees
class ModuleClassSymbol extends ClassSymbol
case class ModuleDef(mods: Modifiers, name: TermName, impl: Template) extends ImplDef with Product with Serializable

An object definition, e.
abstract class ModuleDefExtractor extends AnyRef

An extractor class to create and pattern match with syntax ModuleDef(mods, name, impl).
class ModuleSymbol extends TermSymbol with ModuleSymbolBase

The abstract type of module symbols representing object declarations
trait ModuleSymbolBase extends Universe.TermSymbolBase

The base API that all module symbols support
abstract class Name extends NameBase

The abstract type of names
abstract class NameBase extends AnyRef

The base API that all names support
trait NameTree extends Tree

A tree with a name - effectively, a DefTree or RefTree.
trait NamesBase extends AnyRef

Definition Classes
StandardNames
case class NestedAnnotArg(annInfo: AnnotationInfo) extends ClassfileAnnotArg with Product with Serializable

Definition Classes
Base → AnnotationInfos
abstract class NestedAnnotArgExtractor extends AnyRef

Definition Classes
AnnotationInfos
case class New(tpt: Tree) extends Tree with TermTree with Product with Serializable

Object instantiation One should always use factory method below to build a user level new.
abstract class NewExtractor extends AnyRef

An extractor class to create and pattern match with syntax New(tpt).
case class NullaryMethodType(resultType: Type) extends Type with Product with Serializable

The NullaryMethodType type signature is used for parameterless methods with declarations of the form def foo: T
abstract class NullaryMethodTypeExtractor extends AnyRef

An extractor class to create and pattern match with syntax NullaryMethodType(resultType).
case class PackageDef(pid: RefTree, stats: List[Tree]) extends MemberDef with Product with Serializable

A packaging, such as package pid { stats }
abstract class PackageDefExtractor extends AnyRef

An extractor class to create and pattern match with syntax PackageDef(pid, stats).
case class PolyType(typeParams: List[Symbol], resultType: Type) extends Type with Product with Serializable

The PolyType type signature is used for polymorphic methods that have at least one type parameter.
abstract class PolyTypeExtractor extends AnyRef

An extractor class to create and pattern match with syntax PolyType(typeParams, resultType).
class Position extends Attachments

.
trait RefTree extends Tree with SymTree with NameTree

A tree which references a symbol-carrying entity.
case class ReferenceToBoxed(ident: Ident) extends Tree with TermTree with Product with Serializable

Marks underlying reference to id as boxed.
abstract class ReferenceToBoxedExtractor extends AnyRef

An extractor class to create and pattern match with syntax ReferenceToBoxed(ident).
case class RefinedType(parents: List[Type], decls: Scope) extends CompoundType with Product with Serializable

The RefinedType type defines types of any of the forms on the left, with their RefinedType representations to the right.
abstract class RefinedTypeExtractor extends AnyRef

An extractor class to create and pattern match with syntax RefinedType(parents, decls) Here, parents is the list of parent types of the class, and decls is the scope containing all declarations in the class.
case class Return(expr: Tree) extends Tree with TermTree with SymTree with Product with Serializable

Return expression
abstract class ReturnExtractor extends AnyRef

An extractor class to create and pattern match with syntax Return(expr).
class Scope extends ScopeBase with MemberScopeBase

Definition Classes
Base → Scopes
trait ScopeBase extends Iterable[Universe.Symbol]

The base API that all scopes support
case class Select(qualifier: Tree, name: Name) extends Tree with RefTree with Product with Serializable

Designator <qualifier> .
abstract class SelectExtractor extends AnyRef

An extractor class to create and pattern match with syntax Select(qual, name).
case class SelectFromTypeTree(qualifier: Tree, name: TypeName) extends Tree with TypTree with RefTree with Product with Serializable

Type selection <qualifier> # <name>, eliminated by RefCheck
abstract class SelectFromTypeTreeExtractor extends AnyRef

An extractor class to create and pattern match with syntax SelectFromTypeTree(qualifier, name).
case class SingleType(pre: Type, sym: Symbol) extends SingletonType with Product with Serializable

The SingleType type describes types of any of the forms on the left, with their TypeRef representations to the right.
abstract class SingleTypeExtractor extends AnyRef

An extractor class to create and pattern match with syntax SingleType(pre, sym) Here, pre is the prefix of the single-type, and sym is the stable value symbol referred to by the single-type.
class SingletonType extends Type

The type of Scala singleton types, i.
case class SingletonTypeTree(ref: Tree) extends Tree with TypTree with Product with Serializable

Singleton type, eliminated by RefCheck
abstract class SingletonTypeTreeExtractor extends AnyRef

An extractor class to create and pattern match with syntax SingletonTypeTree(ref).
trait StandardTypes extends AnyRef

Definition Classes
StandardDefinitions
case class Star(elem: Tree) extends Tree with TermTree with Product with Serializable

Repetition of pattern.
abstract class StarExtractor extends AnyRef

An extractor class to create and pattern match with syntax Star(elem).
case class Super(qual: Tree, mix: TypeName) extends Tree with TermTree with Product with Serializable

Super reference, qual = corresponding this reference A super reference C.
abstract class SuperExtractor extends AnyRef

An extractor class to create and pattern match with syntax Super(qual, mix).
case class SuperType(thistpe: Type, supertpe: Type) extends SingletonType with Product with Serializable

The SuperType type is not directly written, but arises when C.super is used as a prefix in a TypeRef or SingleType.
abstract class SuperTypeExtractor extends AnyRef

An extractor class to create and pattern match with syntax SingleType(thistpe, supertpe)
trait SymTree extends Tree

A tree with a mutable symbol field, initialized to NoSymbol.
abstract class Symbol extends SymbolBase

The abstract type of symbols representing declarations
trait SymbolBase extends AnyRef

The base API that all symbols support
case class Template(parents: List[Tree], self: ValDef, body: List[Tree]) extends Tree with SymTree with Product with Serializable

Instantiation template of a class or trait
abstract class TemplateExtractor extends AnyRef

An extractor class to create and pattern match with syntax Template(parents, self, body).
class TermName extends Name

The abstract type of names representing types
trait TermNamesBase extends Universe.NamesBase

Definition Classes
StandardNames
class TermSymbol extends Symbol with TermSymbolBase

The abstract type of term symbols representing val, var, def, and object declarations as well as packages and value parameters.
trait TermSymbolBase extends Universe.SymbolBase

The base API that all term symbols support
trait TermTree extends Tree

A tree for a term.
case class This(qual: TypeName) extends Tree with TermTree with SymTree with Product with Serializable

Self reference
abstract class ThisExtractor extends AnyRef

An extractor class to create and pattern match with syntax This(qual).
case class ThisType(sym: Symbol) extends SingletonType with Product with Serializable

The ThisType type describes types of the form on the left with the correspnding ThisType representations to the right.
abstract class ThisTypeExtractor extends AnyRef

An extractor class to create and pattern match with syntax ThisType(sym) where sym is the class prefix of the this type.
case class Throw(expr: Tree) extends Tree with TermTree with Product with Serializable

Throw expression
abstract class ThrowExtractor extends AnyRef

An extractor class to create and pattern match with syntax Throw(expr).
abstract class Tree extends TreeBase with Product

Tree is the basis for scala's abstract syntax.
abstract class TreeBase extends Product

The base API that all trees support
case class Try(block: Tree, catches: List[CaseDef], finalizer: Tree) extends Tree with TermTree with Product with Serializable

[Eugene++] comment me!
abstract class TryExtractor extends AnyRef

An extractor class to create and pattern match with syntax Try(block, catches, finalizer).
trait TypTree extends Tree

A tree for a type.
class Type extends TypeBase

The type of Scala types, and also Scala type signatures.
case class TypeApply(fun: Tree, args: List[Tree]) extends GenericApply with Product with Serializable

Explicit type application.
abstract class TypeApplyExtractor extends AnyRef

An extractor class to create and pattern match with syntax TypeApply(fun, args).
abstract class TypeBase extends AnyRef

The base API that all types support
case class TypeBounds(lo: Type, hi: Type) extends Type with Product with Serializable

The TypeBounds type signature is used to indicate lower and upper type bounds of type parameters and abstract types.
abstract class TypeBoundsExtractor extends AnyRef

An extractor class to create and pattern match with syntax TypeBound(lower, upper) Here, lower is the lower bound of the TypeBounds pair, and upper is the upper bound.
case class TypeBoundsTree(lo: Tree, hi: Tree) extends Tree with TypTree with Product with Serializable

Document me!
abstract class TypeBoundsTreeExtractor extends AnyRef

An extractor class to create and pattern match with syntax TypeBoundsTree(lo, hi).
case class TypeDef(mods: Modifiers, name: TypeName, tparams: List[TypeDef], rhs: Tree) extends MemberDef with Product with Serializable

An abstract type, a type parameter, or a type alias.
abstract class TypeDefExtractor extends AnyRef

An extractor class to create and pattern match with syntax TypeDef(mods, name, tparams, rhs).
class TypeName extends Name

The abstract type of names representing terms
trait TypeNamesBase extends Universe.NamesBase

Definition Classes
StandardNames
case class TypeRef(pre: Type, sym: Symbol, args: List[Type]) extends Type with Product with Serializable

The TypeRef type describes types of any of the forms on the left, with their TypeRef representations to the right.
abstract class TypeRefExtractor extends AnyRef

An extractor class to create and pattern match with syntax TypeRef(pre, sym, args) Here, pre is the prefix of the type reference, sym is the symbol referred to by the type reference, and args is a possible empty list of type argumenrts.
class TypeSymbol extends Symbol with TypeSymbolBase

The abstract type of type symbols representing type, class, and trait declarations, as well as type parameters
trait TypeSymbolBase extends Universe.SymbolBase

The base API that all type symbols support
trait TypeTag[T] extends Universe.AbsTypeTag[T] with Equals with Serializable

If an implicit value of type u.
case class TypeTree() extends Tree with TypTree with Product with Serializable

A synthetic tree holding an arbitrary type.
abstract class TypeTreeExtractor extends AnyRef

An extractor class to create and pattern match with syntax TypeTree().
case class Typed(expr: Tree, tpt: Tree) extends Tree with TermTree with Product with Serializable

Type annotation, eliminated by cleanup
abstract class TypedExtractor extends AnyRef

An extractor class to create and pattern match with syntax Typed(expr, tpt).
case class UnApply(fun: Tree, args: List[Tree]) extends Tree with TermTree with Product with Serializable

Noone knows what this is.
abstract class UnApplyExtractor extends AnyRef

An extractor class to create and pattern match with syntax UnApply(fun, args).
case class ValDef(mods: Modifiers, name: TermName, tpt: Tree, rhs: Tree) extends ValOrDefDef with Product with Serializable

Broadly speaking, a value definition.
abstract class ValDefExtractor extends AnyRef

An extractor class to create and pattern match with syntax ValDef(mods, name, tpt, rhs).
abstract class ValOrDefDef extends MemberDef

A common base class for ValDefs and DefDefs.

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Test two objects for inequality.
Test two objects for inequality.
returns
true if !(this == that), false otherwise.

Definition Classes
Any
final def ##(): Int

Equivalent to x.hashCode except for boxed numeric types and null.
Equivalent to x.hashCode except for boxed numeric types and null. For numerics, it returns a hash value which is consistent with value equality: if two value type instances compare as true, then ## will produce the same hash value for each of them. For null returns a hashcode where null.hashCode throws a NullPointerException.
returns
a hash value consistent with ==

Definition Classes
AnyRef → Any
def +(other: String): String

Implicit information
This member is added by an implicit conversion from Base to StringAdd performed by method any2stringadd in scala.Predef.
Definition Classes
StringAdd
def ->[B](y: B): (Base, B)

Implicit information
This member is added by an implicit conversion from Base to ArrowAssoc[Base] performed by method any2ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Test two objects for equality.
Test two objects for equality. The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).
returns
true if the receiver object is equivalent to the argument; false otherwise.

Definition Classes
Any
object AbsTypeTag extends Serializable

Definition Classes
TypeTags
object Alternative extends AlternativeExtractor with Serializable

The constructor/deconstructor for Alternative instances.
implicit val AlternativeTag: ClassTag[Alternative]

A tag that preserves the identity of the Alternative abstract type from erasure.
A tag that preserves the identity of the Alternative abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object Annotated extends AnnotatedExtractor with Serializable

The constructor/deconstructor for Annotated instances.
implicit val AnnotatedTag: ClassTag[Annotated]

A tag that preserves the identity of the Annotated abstract type from erasure.
A tag that preserves the identity of the Annotated abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object AnnotatedType extends AnnotatedTypeExtractor with Serializable

The constructor/deconstructor for AnnotatedType instances.
implicit val AnnotatedTypeTag: ClassTag[AnnotatedType]

A tag that preserves the identity of the AnnotatedType abstract type from erasure.
A tag that preserves the identity of the AnnotatedType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Types
object AnnotationInfo extends AnnotationInfoExtractor with Serializable

Definition Classes
Base → AnnotationInfos
implicit val AnnotationInfoTag: ClassTag[AnnotationInfo]

Definition Classes
Base → AnnotationInfos
object AppliedTypeTree extends AppliedTypeTreeExtractor with Serializable

The constructor/deconstructor for AppliedTypeTree instances.
implicit val AppliedTypeTreeTag: ClassTag[AppliedTypeTree]

A tag that preserves the identity of the AppliedTypeTree abstract type from erasure.
A tag that preserves the identity of the AppliedTypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
def Apply(sym: Symbol, args: Tree*): Tree

Definition Classes
Base → Trees
object Apply extends ApplyExtractor with Serializable

The constructor/deconstructor for Apply instances.
def ApplyConstructor(tpt: Tree, args: List[Tree]): Tree

Definition Classes
Base → Trees
object ApplyDynamic extends ApplyDynamicExtractor with Serializable

The constructor/deconstructor for ApplyDynamic instances.
implicit val ApplyDynamicTag: ClassTag[ApplyDynamic]

A tag that preserves the identity of the ApplyDynamic abstract type from erasure.
A tag that preserves the identity of the ApplyDynamic abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
implicit val ApplyTag: ClassTag[Apply]

A tag that preserves the identity of the Apply abstract type from erasure.
A tag that preserves the identity of the Apply abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object ArrayAnnotArg extends ArrayAnnotArgExtractor with Serializable

Definition Classes
Base → AnnotationInfos
implicit val ArrayAnnotArgTag: ClassTag[ArrayAnnotArg]

Definition Classes
Base → AnnotationInfos
object ArrayValue extends ArrayValueExtractor with Serializable

The constructor/deconstructor for ArrayValue instances.
implicit val ArrayValueTag: ClassTag[ArrayValue]

A tag that preserves the identity of the ArrayValue abstract type from erasure.
A tag that preserves the identity of the ArrayValue abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object Assign extends AssignExtractor with Serializable

The constructor/deconstructor for Assign instances.
object AssignOrNamedArg extends AssignOrNamedArgExtractor with Serializable

The constructor/deconstructor for AssignOrNamedArg instances.
implicit val AssignOrNamedArgTag: ClassTag[AssignOrNamedArg]

A tag that preserves the identity of the AssignOrNamedArg abstract type from erasure.
A tag that preserves the identity of the AssignOrNamedArg abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
implicit val AssignTag: ClassTag[Assign]

A tag that preserves the identity of the Assign abstract type from erasure.
A tag that preserves the identity of the Assign abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
def Bind(sym: Symbol, body: Tree): Bind

Definition Classes
Base → Trees
object Bind extends BindExtractor with Serializable

The constructor/deconstructor for Bind instances.
implicit val BindTag: ClassTag[Bind]

A tag that preserves the identity of the Bind abstract type from erasure.
A tag that preserves the identity of the Bind abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
def Block(stats: Tree*): Block

Block factory that flattens directly nested blocks.
Block factory that flattens directly nested blocks.

Definition Classes
Base → Trees
object Block extends BlockExtractor with Serializable

The constructor/deconstructor for Block instances.
implicit val BlockTag: ClassTag[Block]

A tag that preserves the identity of the Block abstract type from erasure.
A tag that preserves the identity of the Block abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object BoundedWildcardType extends BoundedWildcardTypeExtractor with Serializable

Definition Classes
Base → Types
implicit val BoundedWildcardTypeTag: ClassTag[BoundedWildcardType]

A tag that preserves the identity of the BoundedWildcardType abstract type from erasure.
A tag that preserves the identity of the BoundedWildcardType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Types
def CaseDef(pat: Tree, body: Tree): CaseDef

casedef shorthand
casedef shorthand

Definition Classes
Base → Trees
object CaseDef extends CaseDefExtractor with Serializable

The constructor/deconstructor for CaseDef instances.
implicit val CaseDefTag: ClassTag[CaseDef]

A tag that preserves the identity of the CaseDef abstract type from erasure.
A tag that preserves the identity of the CaseDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
def ClassDef(sym: Symbol, impl: Template): ClassDef

sym
the class symbol
impl
the implementation template

Definition Classes
Base → Trees
object ClassDef extends ClassDefExtractor with Serializable

The constructor/deconstructor for ClassDef instances.
implicit val ClassDefTag: ClassTag[ClassDef]

A tag that preserves the identity of the ClassDef abstract type from erasure.
A tag that preserves the identity of the ClassDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object ClassInfoType extends ClassInfoTypeExtractor with Serializable

The constructor/deconstructor for ClassInfoType instances.
implicit val ClassInfoTypeTag: ClassTag[ClassInfoType]

A tag that preserves the identity of the ClassInfoType abstract type from erasure.
A tag that preserves the identity of the ClassInfoType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Types
implicit val ClassSymbolTag: ClassTag[ClassSymbol]

A tag that preserves the identity of the ClassSymbol abstract type from erasure.
A tag that preserves the identity of the ClassSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Symbols
implicit val ClassfileAnnotArgTag: ClassTag[ClassfileAnnotArg]

Definition Classes
Base → AnnotationInfos
implicit val CompoundTypeTag: ClassTag[CompoundType]

A tag that preserves the identity of the CompoundType abstract type from erasure.
A tag that preserves the identity of the CompoundType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Types
object CompoundTypeTree extends CompoundTypeTreeExtractor with Serializable

The constructor/deconstructor for CompoundTypeTree instances.
implicit val CompoundTypeTreeTag: ClassTag[CompoundTypeTree]

A tag that preserves the identity of the CompoundTypeTree abstract type from erasure.
A tag that preserves the identity of the CompoundTypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object Constant extends ConstantExtractor with Serializable

Definition Classes
Base → Constants
implicit val ConstantTag: ClassTag[Constant]

Definition Classes
Base → Constants
object ConstantType extends ConstantTypeExtractor with Serializable

The constructor/deconstructor for ConstantType instances.
implicit val ConstantTypeTag: ClassTag[ConstantType]

A tag that preserves the identity of the ConstantType abstract type from erasure.
A tag that preserves the identity of the ConstantType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Types
def DefDef(sym: Symbol, rhs: (List[List[Symbol]]) ⇒ Tree): DefDef

Definition Classes
Base → Trees
def DefDef(sym: Symbol, rhs: Tree): DefDef

Definition Classes
Base → Trees
def DefDef(sym: Symbol, mods: Modifiers, rhs: Tree): DefDef

Definition Classes
Base → Trees
def DefDef(sym: Symbol, vparamss: List[List[ValDef]], rhs: Tree): DefDef

Definition Classes
Base → Trees
def DefDef(sym: Symbol, mods: Modifiers, vparamss: List[List[ValDef]], rhs: Tree): DefDef

Definition Classes
Base → Trees
object DefDef extends DefDefExtractor with Serializable

The constructor/deconstructor for DefDef instances.
implicit val DefDefTag: ClassTag[DefDef]

A tag that preserves the identity of the DefDef abstract type from erasure.
A tag that preserves the identity of the DefDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
implicit val DefTreeTag: ClassTag[DefTree]

A tag that preserves the identity of the DefTree abstract type from erasure.
A tag that preserves the identity of the DefTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
def EmptyTermName: TermName

Definition Classes
Names
object EmptyTree extends Tree with TermTree with Product with Serializable

The empty tree
def EmptyTypeName: TypeName

Definition Classes
Names
object ExistentialType extends ExistentialTypeExtractor with Serializable

The constructor/deconstructor for ExistentialType instances.
implicit val ExistentialTypeTag: ClassTag[ExistentialType]

A tag that preserves the identity of the ExistentialType abstract type from erasure.
A tag that preserves the identity of the ExistentialType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Types
object ExistentialTypeTree extends ExistentialTypeTreeExtractor with Serializable

The constructor/deconstructor for ExistentialTypeTree instances.
implicit val ExistentialTypeTreeTag: ClassTag[ExistentialTypeTree]

A tag that preserves the identity of the ExistentialTypeTree abstract type from erasure.
A tag that preserves the identity of the ExistentialTypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object Expr extends Serializable

Definition Classes
Exprs
implicit val FlagSetTag: ClassTag[FlagSet]

A tag that preserves the identity of the FlagSet abstract type from erasure.
A tag that preserves the identity of the FlagSet abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → FlagSets
implicit val FreeTermSymbolTag: ClassTag[FreeTermSymbol]

A tag that preserves the identity of the FreeTermSymbol abstract type from erasure.
A tag that preserves the identity of the FreeTermSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Symbols
implicit val FreeTypeSymbolTag: ClassTag[FreeTypeSymbol]

A tag that preserves the identity of the FreeTypeSymbol abstract type from erasure.
A tag that preserves the identity of the FreeTypeSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Symbols
object Function extends FunctionExtractor with Serializable

The constructor/deconstructor for Function instances.
implicit val FunctionTag: ClassTag[Function]

A tag that preserves the identity of the Function abstract type from erasure.
A tag that preserves the identity of the Function abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
implicit val GenericApplyTag: ClassTag[GenericApply]

A tag that preserves the identity of the GenericApply abstract type from erasure.
A tag that preserves the identity of the GenericApply abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
def Ident(sym: Symbol): Ident

Definition Classes
Base → Trees
def Ident(name: String): Ident

Definition Classes
Base → Trees
object Ident extends IdentExtractor with Serializable

The constructor/deconstructor for Ident instances.
implicit val IdentTag: ClassTag[Ident]

A tag that preserves the identity of the Ident abstract type from erasure.
A tag that preserves the identity of the Ident abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object If extends IfExtractor with Serializable

The constructor/deconstructor for If instances.
implicit val IfTag: ClassTag[If]

A tag that preserves the identity of the If abstract type from erasure.
A tag that preserves the identity of the If abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
implicit val ImplDefTag: ClassTag[ImplDef]

A tag that preserves the identity of the ImplDef abstract type from erasure.
A tag that preserves the identity of the ImplDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object Import extends ImportExtractor with Serializable

The constructor/deconstructor for Import instances.
object ImportSelector extends ImportSelectorExtractor with Serializable

The constructor/deconstructor for ImportSelector instances.
implicit val ImportSelectorTag: ClassTag[ImportSelector]

A tag that preserves the identity of the ImportSelector abstract type from erasure.
A tag that preserves the identity of the ImportSelector abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
implicit val ImportTag: ClassTag[Import]

A tag that preserves the identity of the Import abstract type from erasure.
A tag that preserves the identity of the Import abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
def LabelDef(sym: Symbol, params: List[Symbol], rhs: Tree): LabelDef

Definition Classes
Base → Trees
object LabelDef extends LabelDefExtractor with Serializable

The constructor/deconstructor for LabelDef instances.
implicit val LabelDefTag: ClassTag[LabelDef]

A tag that preserves the identity of the LabelDef abstract type from erasure.
A tag that preserves the identity of the LabelDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object Literal extends LiteralExtractor with Serializable

The constructor/deconstructor for Literal instances.
object LiteralAnnotArg extends LiteralAnnotArgExtractor with Serializable

Definition Classes
Base → AnnotationInfos
implicit val LiteralAnnotArgTag: ClassTag[LiteralAnnotArg]

Definition Classes
Base → AnnotationInfos
implicit val LiteralTag: ClassTag[Literal]

A tag that preserves the identity of the Literal abstract type from erasure.
A tag that preserves the identity of the Literal abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object Match extends MatchExtractor with Serializable

The constructor/deconstructor for Match instances.
implicit val MatchTag: ClassTag[Match]

A tag that preserves the identity of the Match abstract type from erasure.
A tag that preserves the identity of the Match abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
implicit val MemberDefTag: ClassTag[MemberDef]

A tag that preserves the identity of the MemberDef abstract type from erasure.
A tag that preserves the identity of the MemberDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
implicit val MemberScopeTag: ClassTag[MemberScope]

A tag that preserves the identity of the MemberScope abstract type from erasure.
A tag that preserves the identity of the MemberScope abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Scopes
implicit val MethodSymbolTag: ClassTag[MethodSymbol]

A tag that preserves the identity of the MethodSymbol abstract type from erasure.
A tag that preserves the identity of the MethodSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Symbols
object MethodType extends MethodTypeExtractor with Serializable

The constructor/deconstructor for MethodType instances.
implicit val MethodTypeTag: ClassTag[MethodType]

A tag that preserves the identity of the MethodType abstract type from erasure.
A tag that preserves the identity of the MethodType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Types
def Modifiers(flags: FlagSet): Modifiers

Definition Classes
Trees
def Modifiers(flags: FlagSet, privateWithin: Name): Modifiers

Definition Classes
Trees
object Modifiers extends ModifiersCreator

Definition Classes
Base → Trees
implicit val ModifiersTag: ClassTag[Modifiers]

A tag that preserves the identity of the Modifiers abstract type from erasure.
A tag that preserves the identity of the Modifiers abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
def ModuleDef(sym: Symbol, impl: Template): ModuleDef

sym
the class symbol
impl
the implementation template

Definition Classes
Base → Trees
object ModuleDef extends ModuleDefExtractor with Serializable

The constructor/deconstructor for ModuleDef instances.
implicit val ModuleDefTag: ClassTag[ModuleDef]

A tag that preserves the identity of the ModuleDef abstract type from erasure.
A tag that preserves the identity of the ModuleDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
implicit val ModuleSymbolTag: ClassTag[ModuleSymbol]

A tag that preserves the identity of the ModuleSymbol abstract type from erasure.
A tag that preserves the identity of the ModuleSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Symbols
implicit val NameTag: ClassTag[Name]

Definition Classes
Base → Names
implicit val NameTreeTag: ClassTag[NameTree]

A tag that preserves the identity of the NameTree abstract type from erasure.
A tag that preserves the identity of the NameTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object NestedAnnotArg extends NestedAnnotArgExtractor with Serializable

Definition Classes
Base → AnnotationInfos
implicit val NestedAnnotArgTag: ClassTag[NestedAnnotArg]

Definition Classes
Base → AnnotationInfos
def New(sym: Symbol, args: Tree*): Tree

Definition Classes
Base → Trees
def New(tpe: Type, args: Tree*): Tree

0-1 argument list new, based on a type.
0-1 argument list new, based on a type.

Definition Classes
Base → Trees
def New(tpt: Tree, argss: List[List[Tree]]): Tree

Factory method for object creation new tpt(args_1)...(args_n) A New(t, as) is expanded to: (new t).<init>(as)
Factory method for object creation new tpt(args_1)...(args_n) A New(t, as) is expanded to: (new t).<init>(as)

Definition Classes
Base → Trees
object New extends NewExtractor with Serializable

The constructor/deconstructor for New instances.
implicit val NewTag: ClassTag[New]

A tag that preserves the identity of the New abstract type from erasure.
A tag that preserves the identity of the New abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
val NoFlags: Long

The empty set of flags
The empty set of flags

Definition Classes
Base → FlagSets
lazy val NoMods: Modifiers

.
...

Definition Classes
Trees
val NoPosition: Position

.
..

Definition Classes
Base → Positions
val NoPrefix: Type

This constant is used as a special value denoting the empty prefix in a path dependent type.
This constant is used as a special value denoting the empty prefix in a path dependent type. For instance x.type is represented as SingleType(NoPrefix, <x>), where <x> stands for the symbol for x.

Definition Classes
Base → Types
object NoSymbol extends Symbol

A special "missing" symbol
val NoType: Type

This constant is used as a special value that indicates that no meaningful type exists.
This constant is used as a special value that indicates that no meaningful type exists.

Definition Classes
Base → Types
object NullaryMethodType extends NullaryMethodTypeExtractor with Serializable

The constructor/deconstructor for NullaryMethodType instances.
implicit val NullaryMethodTypeTag: ClassTag[NullaryMethodType]

A tag that preserves the identity of the NullaryMethodType abstract type from erasure.
A tag that preserves the identity of the NullaryMethodType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Types
object PackageDef extends PackageDefExtractor with Serializable

The constructor/deconstructor for PackageDef instances.
implicit val PackageDefTag: ClassTag[PackageDef]

A tag that preserves the identity of the PackageDef abstract type from erasure.
A tag that preserves the identity of the PackageDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object PolyType extends PolyTypeExtractor with Serializable

The constructor/deconstructor for PolyType instances.
implicit val PolyTypeTag: ClassTag[PolyType]

A tag that preserves the identity of the PolyType abstract type from erasure.
A tag that preserves the identity of the PolyType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Types
implicit val PositionTag: ClassTag[Position]

A tag that preserves the identity of the FlagSet abstract type from erasure.
A tag that preserves the identity of the FlagSet abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Positions
implicit val RefTreeTag: ClassTag[RefTree]

A tag that preserves the identity of the RefTree abstract type from erasure.
A tag that preserves the identity of the RefTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object ReferenceToBoxed extends ReferenceToBoxedExtractor with Serializable

The constructor/deconstructor for ReferenceToBoxed instances.
implicit val ReferenceToBoxedTag: ClassTag[ReferenceToBoxed]

A tag that preserves the identity of the ReferenceToBoxed abstract type from erasure.
A tag that preserves the identity of the ReferenceToBoxed abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object RefinedType extends RefinedTypeExtractor with Serializable

The constructor/deconstructor for RefinedType instances.
implicit val RefinedTypeTag: ClassTag[RefinedType]

A tag that preserves the identity of the RefinedType abstract type from erasure.
A tag that preserves the identity of the RefinedType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Types
object Return extends ReturnExtractor with Serializable

The constructor/deconstructor for Return instances.
implicit val ReturnTag: ClassTag[Return]

A tag that preserves the identity of the Return abstract type from erasure.
A tag that preserves the identity of the Return abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
implicit val ScopeTag: ClassTag[Scope]

A tag that preserves the identity of the Scope abstract type from erasure.
A tag that preserves the identity of the Scope abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Scopes
def Select(qualifier: Tree, sym: Symbol): Select

Definition Classes
Base → Trees
def Select(qualifier: Tree, name: String): Select

Definition Classes
Base → Trees
object Select extends SelectExtractor with Serializable

The constructor/deconstructor for Select instances.
object SelectFromTypeTree extends SelectFromTypeTreeExtractor with Serializable

The constructor/deconstructor for SelectFromTypeTree instances.
implicit val SelectFromTypeTreeTag: ClassTag[SelectFromTypeTree]

A tag that preserves the identity of the SelectFromTypeTree abstract type from erasure.
A tag that preserves the identity of the SelectFromTypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
implicit val SelectTag: ClassTag[Select]

A tag that preserves the identity of the Select abstract type from erasure.
A tag that preserves the identity of the Select abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object SingleType extends SingleTypeExtractor with Serializable

The constructor/deconstructor for SingleType instances.
implicit val SingleTypeTag: ClassTag[SingleType]

A tag that preserves the identity of the SingleType abstract type from erasure.
A tag that preserves the identity of the SingleType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Types
implicit val SingletonTypeTag: ClassTag[SingletonType]

A tag that preserves the identity of the SingletonType abstract type from erasure.
A tag that preserves the identity of the SingletonType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Types
object SingletonTypeTree extends SingletonTypeTreeExtractor with Serializable

The constructor/deconstructor for SingletonTypeTree instances.
implicit val SingletonTypeTreeTag: ClassTag[SingletonTypeTree]

A tag that preserves the identity of the SingletonTypeTree abstract type from erasure.
A tag that preserves the identity of the SingletonTypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object Star extends StarExtractor with Serializable

The constructor/deconstructor for Star instances.
implicit val StarTag: ClassTag[Star]

A tag that preserves the identity of the Star abstract type from erasure.
A tag that preserves the identity of the Star abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
def Super(sym: Symbol, mix: TypeName): Tree

Definition Classes
Base → Trees
object Super extends SuperExtractor with Serializable

The constructor/deconstructor for Super instances.
implicit val SuperTag: ClassTag[Super]

A tag that preserves the identity of the Super abstract type from erasure.
A tag that preserves the identity of the Super abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object SuperType extends SuperTypeExtractor with Serializable

The constructor/deconstructor for SuperType instances.
implicit val SuperTypeTag: ClassTag[SuperType]

A tag that preserves the identity of the SuperType abstract type from erasure.
A tag that preserves the identity of the SuperType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Types
implicit val SymTreeTag: ClassTag[SymTree]

A tag that preserves the identity of the SymTree abstract type from erasure.
A tag that preserves the identity of the SymTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
implicit val SymbolTag: ClassTag[Symbol]

A tag that preserves the identity of the Symbol abstract type from erasure.
A tag that preserves the identity of the Symbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Symbols
object Template extends TemplateExtractor with Serializable

The constructor/deconstructor for Template instances.
implicit val TemplateTag: ClassTag[Template]

A tag that preserves the identity of the Template abstract type from erasure.
A tag that preserves the identity of the Template abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
implicit val TermNameTag: ClassTag[TermName]

Definition Classes
Base → Names
implicit val TermSymbolTag: ClassTag[TermSymbol]

A tag that preserves the identity of the TermSymbol abstract type from erasure.
A tag that preserves the identity of the TermSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Symbols
implicit val TermTreeTag: ClassTag[TermTree]

A tag that preserves the identity of the TermTree abstract type from erasure.
A tag that preserves the identity of the TermTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
def This(sym: Symbol): Tree

Definition Classes
Base → Trees
object This extends ThisExtractor with Serializable

The constructor/deconstructor for This instances.
implicit val ThisTag: ClassTag[This]

A tag that preserves the identity of the This abstract type from erasure.
A tag that preserves the identity of the This abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object ThisType extends ThisTypeExtractor with Serializable

The constructor/deconstructor for ThisType instances.
implicit val ThisTypeTag: ClassTag[ThisType]

A tag that preserves the identity of the ThisType abstract type from erasure.
A tag that preserves the identity of the ThisType abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Types
def Throw(tpe: Type, args: Tree*): Throw

Definition Classes
Base → Trees
object Throw extends ThrowExtractor with Serializable

The constructor/deconstructor for Throw instances.
implicit val ThrowTag: ClassTag[Throw]

A tag that preserves the identity of the Throw abstract type from erasure.
A tag that preserves the identity of the Throw abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
implicit val TreeTag: ClassTag[Tree]

A tag that preserves the identity of the Tree abstract type from erasure.
A tag that preserves the identity of the Tree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
def Try(body: Tree, cases: (Tree, Tree)*): Try

Definition Classes
Base → Trees
object Try extends TryExtractor with Serializable

The constructor/deconstructor for Try instances.
implicit val TryTag: ClassTag[Try]

A tag that preserves the identity of the Try abstract type from erasure.
A tag that preserves the identity of the Try abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
implicit val TypTreeTag: ClassTag[TypTree]

A tag that preserves the identity of the TypTree abstract type from erasure.
A tag that preserves the identity of the TypTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object TypeApply extends TypeApplyExtractor with Serializable

The constructor/deconstructor for TypeApply instances.
implicit val TypeApplyTag: ClassTag[TypeApply]

A tag that preserves the identity of the TypeApply abstract type from erasure.
A tag that preserves the identity of the TypeApply abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object TypeBounds extends TypeBoundsExtractor with Serializable

The constructor/deconstructor for TypeBounds instances.
implicit val TypeBoundsTag: ClassTag[TypeBounds]

A tag that preserves the identity of the TypeBounds abstract type from erasure.
A tag that preserves the identity of the TypeBounds abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Types
object TypeBoundsTree extends TypeBoundsTreeExtractor with Serializable

The constructor/deconstructor for TypeBoundsTree instances.
implicit val TypeBoundsTreeTag: ClassTag[TypeBoundsTree]

A tag that preserves the identity of the TypeBoundsTree abstract type from erasure.
A tag that preserves the identity of the TypeBoundsTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
def TypeDef(sym: Symbol): TypeDef

A TypeDef node which defines abstract type or type parameter for given sym
A TypeDef node which defines abstract type or type parameter for given sym

Definition Classes
Base → Trees
def TypeDef(sym: Symbol, rhs: Tree): TypeDef

A TypeDef node which defines given sym with given tight hand side rhs.
A TypeDef node which defines given sym with given tight hand side rhs.

Definition Classes
Base → Trees
object TypeDef extends TypeDefExtractor with Serializable

The constructor/deconstructor for TypeDef instances.
implicit val TypeDefTag: ClassTag[TypeDef]

A tag that preserves the identity of the TypeDef abstract type from erasure.
A tag that preserves the identity of the TypeDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
implicit val TypeNameTag: ClassTag[TypeName]

Definition Classes
Base → Names
object TypeRef extends TypeRefExtractor with Serializable

The constructor/deconstructor for TypeRef instances.
implicit val TypeRefTag: ClassTag[TypeRef]

A tag that preserves the identity of the TypeRef abstract type from erasure.
A tag that preserves the identity of the TypeRef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Types
implicit val TypeSymbolTag: ClassTag[TypeSymbol]

A tag that preserves the identity of the TypeSymbol abstract type from erasure.
A tag that preserves the identity of the TypeSymbol abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Symbols
object TypeTag extends Serializable

Definition Classes
TypeTags
implicit val TypeTagg: ClassTag[Type]

A tag that preserves the identity of the Type abstract type from erasure.
A tag that preserves the identity of the Type abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Types
def TypeTree(tp: Type): TypeTree

Definition Classes
Base → Trees
object TypeTree extends TypeTreeExtractor with Serializable

The constructor/deconstructor for TypeTree instances.
implicit val TypeTreeTag: ClassTag[TypeTree]

A tag that preserves the identity of the TypeTree abstract type from erasure.
A tag that preserves the identity of the TypeTree abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object Typed extends TypedExtractor with Serializable

The constructor/deconstructor for Typed instances.
implicit val TypedTag: ClassTag[Typed]

A tag that preserves the identity of the Typed abstract type from erasure.
A tag that preserves the identity of the Typed abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
object UnApply extends UnApplyExtractor with Serializable

The constructor/deconstructor for UnApply instances.
implicit val UnApplyTag: ClassTag[UnApply]

A tag that preserves the identity of the UnApply abstract type from erasure.
A tag that preserves the identity of the UnApply abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
def ValDef(sym: Symbol): ValDef

Definition Classes
Base → Trees
def ValDef(sym: Symbol, rhs: Tree): ValDef

Definition Classes
Base → Trees
object ValDef extends ValDefExtractor with Serializable

The constructor/deconstructor for ValDef instances.
implicit val ValDefTag: ClassTag[ValDef]

A tag that preserves the identity of the ValDef abstract type from erasure.
A tag that preserves the identity of the ValDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
implicit val ValOrDefDefTag: ClassTag[ValOrDefDef]

A tag that preserves the identity of the ValOrDefDef abstract type from erasure.
A tag that preserves the identity of the ValOrDefDef abstract type from erasure. Can be used for pattern matching, instance tests, serialization and likes.

Definition Classes
Base → Trees
val WildcardType: Type

An object representing an unknown type, used during type inference.
An object representing an unknown type, used during type inference. If you see WildcardType outside of inference it is almost certainly a bug.

Definition Classes
Base → Types
final def asInstanceOf[T0]: T0

Cast the receiver object to be of type T0.
Cast the receiver object to be of type T0.
Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression 1.asInstanceOf[String] will throw a ClassCastException at runtime, while the expression List(1).asInstanceOf[List[String]] will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested type.
returns
the receiver object.

Definition Classes
Any
Exceptions thrown
ClassCastException
if the receiver object is not an instance of the erasure of type T0.
object build extends BuildBase

Definition Classes
Base → BuildUtils
def clone(): AnyRef

Create a copy of the receiver object.
Create a copy of the receiver object.
The default implementation of the clone method is platform dependent.
returns
a copy of the receiver object.

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
Note
not specified by SLS as a member of AnyRef
object definitions extends DefinitionsBase

Definition Classes
Base → StandardDefinitions
def ensuring(cond: (Base) ⇒ Boolean, msg: ⇒ Any): Base

Implicit information
This member is added by an implicit conversion from Base to Ensuring[Base] performed by method any2Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (Base) ⇒ Boolean): Base

Implicit information
This member is added by an implicit conversion from Base to Ensuring[Base] performed by method any2Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: ⇒ Any): Base

Implicit information
This member is added by an implicit conversion from Base to Ensuring[Base] performed by method any2Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): Base

Implicit information
This member is added by an implicit conversion from Base to Ensuring[Base] performed by method any2Ensuring in scala.Predef.
Definition Classes
Ensuring
final def eq(arg0: AnyRef): Boolean

Tests whether the argument (arg0) is a reference to the receiver object (this).
Tests whether the argument (arg0) is a reference to the receiver object (this).
The eq method implements an equivalence relation on non-null instances of AnyRef, and has three additional properties:
- It is consistent: for any non-null instances x and y of type AnyRef, multiple invocations of x.eq(y) consistently returns true or consistently returns false.
- For any non-null instance x of type AnyRef, x.eq(null) and null.eq(x) returns false.
- null.eq(null) returns true.
When overriding the equals or hashCode methods, it is important to ensure that their behavior is consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2), they should be equal to each other (o1 == o2) and they should hash to the same value (o1.hashCode == o2.hashCode).
returns
true if the argument is a reference to the receiver object; false otherwise.

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

The equality method for reference types.
The equality method for reference types. Default implementation delegates to eq.
See also equals in scala.Any.
returns
true if the receiver object is equivalent to the argument; false otherwise.

Definition Classes
AnyRef → Any
def finalize(): Unit

Called by the garbage collector on the receiver object when there are no more references to the object.
Called by the garbage collector on the receiver object when there are no more references to the object.
The details of when and if the finalize method is invoked, as well as the interaction between finalize and non-local returns and exceptions, are all platform dependent.

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
Note
not specified by SLS as a member of AnyRef
def formatted(fmtstr: String): String

Returns string formatted according to given format string.
Returns string formatted according to given format string. Format strings are as for String.format (@see java.lang.String.format).

Implicit information
This member is added by an implicit conversion from Base to StringFormat performed by method any2stringfmt in scala.Predef.
Definition Classes
StringFormat
Annotations
@inline()
final def getClass(): Class[_]

A representation that corresponds to the dynamic class of the receiver object.
A representation that corresponds to the dynamic class of the receiver object.
The nature of the representation is platform dependent.
returns
a representation that corresponds to the dynamic class of the receiver object.

Definition Classes
AnyRef → Any
Note
not specified by SLS as a member of AnyRef
def hashCode(): Int

The hashCode method for reference types.
The hashCode method for reference types. See hashCode in scala.Any.
returns
the hash code value for this object.

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Test whether the dynamic type of the receiver object is T0.
Test whether the dynamic type of the receiver object is T0.
Note that the result of the test is modulo Scala's erasure semantics. Therefore the expression 1.isInstanceOf[String] will return false, while the expression List(1).isInstanceOf[List[String]] will return true. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the specified type.
returns
true if the receiver object is an instance of erasure of type T0; false otherwise.

Definition Classes
Any
def manifestToTypeTag[T](mirror: Any, manifest: Manifest[T]): Universe.TypeTag[T]

Definition Classes
TagInterop
final def ne(arg0: AnyRef): Boolean

Equivalent to !(this eq that).
Equivalent to !(this eq that).
returns
true if the argument is not a reference to the receiver object; false otherwise.

Definition Classes
AnyRef
def newNestedScope(outer: Scope): Scope

Create a new scope nested in another one with which it shares its elements
Create a new scope nested in another one with which it shares its elements

Definition Classes
Base → Scopes
def newScope: Scope

Create a new scope
Create a new scope

Definition Classes
Base → Scopes
def newScopeWith(elems: Symbol*): Scope

Create a new scope with given initial elements
Create a new scope with given initial elements

Definition Classes
Base → Scopes
def newTermName(str: String): TermName

Create a new term name.
Create a new term name.

Definition Classes
Base → Names
def newTypeName(str: String): TypeName

Creates a new type name.
Creates a new type name.

Definition Classes
Base → Names
object nme extends TermNamesBase

Definition Classes
Base → StandardNames
final def notify(): Unit

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

Definition Classes
AnyRef
Note
not specified by SLS as a member of AnyRef
final def notifyAll(): Unit

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

Definition Classes
AnyRef
Note
not specified by SLS as a member of AnyRef
def reify[T](expr: T): Expr[T]

Given an expression, generate a tree that when compiled and executed produces the original tree.
Given an expression, generate a tree that when compiled and executed produces the original tree. The produced tree will be bound to the Universe it was called from.
For instance, given the abstract syntax tree representation of the <[ x + 1 ]> expression:
```
Apply(Select(Ident("x"), "+"), List(Literal(Constant(1))))
```
The reifier transforms it to the following expression:
```
<[
  val $u: u.type = u // where u is a reference to the Universe that calls the reify
  $u.Expr[Int]($u.Apply($u.Select($u.Ident($u.newFreeVar("x", <Int>, x), "+"), List($u.Literal($u.Constant(1))))))
]>
```
Reification performs expression splicing (when processing Expr.splice) and type splicing (for every type T that has a TypeTag[T] implicit in scope):
```
val two = mirror.reify(2)                         // Literal(Constant(2))
val four = mirror.reify(two.splice + two.splice)  // Apply(Select(two.tree, newTermName("$plus")), List(two.tree))

def macroImpl[T](c: Context) = {
  ...
  // T here is just a type parameter, so the tree produced by reify won't be of much use in a macro expansion
  // however, if T were annotated with c.AbsTypeTag (which would declare an implicit parameter for macroImpl)
  // then reification would substitute T with the TypeTree that was used in a TypeApply of this particular macro invocation
  val factory = c.reify{ new Queryable[T] }
  ...
}
```
The transformation looks mostly straightforward, but it has its tricky parts: * Reifier retains symbols and types defined outside the reified tree, however locally defined entities get erased and replaced with their original trees * Free variables are detected and wrapped in symbols of the type FreeVar * Mutable variables that are accessed from a local function are wrapped in refs * Since reified trees can be compiled outside of the scope they've been created in, special measures are taken to ensure that all members accessed in the reifee remain visible
Definition Classes
Universe
lazy val rootMirror: Mirror

Definition Classes
Base → Mirrors
implicit def stringToTermName(s: String): TermName

Intentionally no implicit from String => Name.
Intentionally no implicit from String => Name.

Definition Classes
Names
implicit def stringToTypeName(s: String): TypeName

Definition Classes
Names
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Creates a String representation of this object.
Creates a String representation of this object. The default representation is platform dependent. On the java platform it is the concatenation of the class name, "@", and the object's hashcode in hexadecimal.
returns
a String representation of the object.

Definition Classes
AnyRef → Any
object tpnme extends TypeNamesBase

Definition Classes
Base → StandardNames
def treeToString(tree: Tree): String

Obtains string representation of a tree
Obtains string representation of a tree

Definition Classes
Base → Trees
def treeType(tree: Tree): Type

Obtains the type of the tree (we intentionally don't expose tree.tpe in base)
Obtains the type of the tree (we intentionally don't expose tree.tpe in base)

Definition Classes
Base → Trees
def typeOf[T](implicit ttag: TypeTag[T]): Type

Definition Classes
TypeTags
def typeTag[T](implicit ttag: TypeTag[T]): TypeTag[T]

Definition Classes
TypeTags
def typeTagToManifest[T](mirror: Any, tag: Universe.TypeTag[T])(implicit arg0: ClassTag[T]): Manifest[T]

Definition Classes
TagInterop
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws()
def →[B](y: B): (Base, B)

Implicit information
This member is added by an implicit conversion from Base to ArrowAssoc[Base] performed by method any2ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc

Shadowed Implict Value Members

val self: Any
Implicit information
This member is added by an implicit conversion from Base to StringAdd performed by method any2stringadd in scala.Predef.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(base: StringAdd).self
Definition Classes
StringAdd
val self: Any
Implicit information
This member is added by an implicit conversion from Base to StringFormat performed by method any2stringfmt in scala.Predef.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(base: StringFormat).self
Definition Classes
StringFormat

Deprecated Value Members

def x: Base
Implicit information
This member is added by an implicit conversion from Base to ArrowAssoc[Base] performed by method any2ArrowAssoc in scala.Predef.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(base: ArrowAssoc[Base]).x
Definition Classes
ArrowAssoc
Annotations
@deprecated
Deprecated
(Since version 2.10.0) Use leftOfArrow instead
def x: Base
Implicit information
This member is added by an implicit conversion from Base to Ensuring[Base] performed by method any2Ensuring in scala.Predef.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(base: Ensuring[Base]).x
Definition Classes
Ensuring
Annotations
@deprecated
Deprecated
(Since version 2.10.0) Use resultOfEnsuring instead

class Base extends Universe

Instance Constructors

new Base()

Type Members

trait AbsTypeTag[T] extends Equals with Serializable

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

abstract class AlternativeExtractor extends AnyRef

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

abstract class AnnotatedExtractor extends AnyRef

case class AnnotatedType(annotations: List[AnnotationInfo], underlying: Type, selfsym: Symbol) extends Type with Product with Serializable

abstract class AnnotatedTypeExtractor extends AnyRef

case class AnnotationInfo(atp: Type, args: List[Tree], assocs: List[(Name, ClassfileAnnotArg)]) extends Product with Serializable

abstract class AnnotationInfoExtractor extends AnyRef

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

abstract class AppliedTypeTreeExtractor extends AnyRef

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

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

abstract class ApplyDynamicExtractor extends AnyRef

abstract class ApplyExtractor extends AnyRef

case class ArrayAnnotArg(args: Array[ClassfileAnnotArg]) extends ClassfileAnnotArg with Product with Serializable

abstract class ArrayAnnotArgExtractor extends AnyRef

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

abstract class ArrayValueExtractor extends AnyRef

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

abstract class AssignExtractor extends AnyRef

case class AssignOrNamedArg(lhs: Tree, rhs: Tree) extends Tree with TermTree with Product with Serializable

abstract class AssignOrNamedArgExtractor extends AnyRef

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

abstract class BindExtractor extends AnyRef

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

abstract class BlockExtractor extends AnyRef

case class BoundedWildcardType(bounds: TypeBounds) extends Type with Product with Serializable

abstract class BoundedWildcardTypeExtractor extends AnyRef

abstract class BuildBase extends AnyRef

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

abstract class CaseDefExtractor extends AnyRef

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

abstract class ClassDefExtractor extends AnyRef

case class ClassInfoType(parents: List[Type], decls: Scope, typeSymbol: Symbol) extends CompoundType with Product with Serializable

abstract class ClassInfoTypeExtractor extends AnyRef

class ClassSymbol extends TypeSymbol with ClassSymbolBase

trait ClassSymbolBase extends Universe.TypeSymbolBase

abstract class ClassfileAnnotArg extends AnyRef

abstract class CompoundType extends Type

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

abstract class CompoundTypeTreeExtractor extends AnyRef

case class Constant(value: Any) extends Product with Serializable

abstract class ConstantExtractor extends AnyRef

case class ConstantType(value: Constant) extends SingletonType with Product with Serializable

abstract class ConstantTypeExtractor extends AnyRef

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

abstract class DefDefExtractor extends AnyRef

abstract class DefTree extends Tree with SymTree with NameTree

trait DefinitionsBase extends Universe.StandardTypes

case class ExistentialType(quantified: List[Symbol], underlying: Type) extends Type with Product with Serializable

abstract class ExistentialTypeExtractor extends AnyRef

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

abstract class ExistentialTypeTreeExtractor extends AnyRef

trait Expr[+T] extends Equals with Serializable

type FlagSet = Long

class FreeTermSymbol extends TermSymbol with FreeTermSymbolBase

trait FreeTermSymbolBase extends Universe.TermSymbolBase

class FreeTypeSymbol extends TypeSymbol with FreeTypeSymbolBase

trait FreeTypeSymbolBase extends Universe.TypeSymbolBase

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

abstract class FunctionExtractor extends AnyRef

abstract class GenericApply extends Tree with TermTree

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

abstract class IdentExtractor extends AnyRef

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

abstract class IfExtractor extends AnyRef

abstract class ImplDef extends MemberDef

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

abstract class ImportExtractor extends AnyRef

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

abstract class ImportSelectorExtractor extends AnyRef

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

abstract class LabelDefExtractor extends AnyRef

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