T trait

Reflection

extends Object

TASTy Reflect Interface.

Provides all functionality related with AST based metaprogramming.

Type hierarchy


+- Tree -+- PackageClause
         +- Import
         +- Statement -+- Definition --+- ClassDef
         |             |               +- TypeDef
         |             |               +- DefDef
         |             |               +- ValDef
         |             |
         |             +- Term --------+- Ref -+- Ident
         |                             |       +- Select
         |                             |
         |                             +- Literal
         |                             +- This
         |                             +- New
         |                             +- NamedArg
         |                             +- Apply
         |                             +- TypeApply
         |                             +- Super
         |                             +- Typed
         |                             +- Assign
         |                             +- Block
         |                             +- Closure
         |                             +- If
         |                             +- Match
         |                             +- GivenMatch
         |                             +- Try
         |                             +- Return
         |                             +- Repeated
         |                             +- Inlined
         |                             +- SelectOuter
         |                             +- While
         |
         |
         +- TypeTree ----+- Inferred
         |               +- TypeIdent
         |               +- TypeSelect
         |               +- Projection
         |               +- Singleton
         |               +- Refined
         |               +- Applied
         |               +- Annotated
         |               +- MatchTypeTree
         |               +- ByName
         |               +- LambdaTypeTree
         |               +- TypeBind
         |               +- TypeBlock
         |
         +- TypeBoundsTree
         +- WildcardTypeTree
         |
         +- CaseDef
         |
         +- TypeCaseDef
         +- Bind
         +- Unapply
         +- Alternatives


+- Type -+- ConstantType
         +- TermRef
         +- TypeRef
         +- SuperType
         +- Refinement
         +- AppliedType
         +- AnnotatedType
         +- AndType
         +- OrType
         +- MatchType
         +- ByNameType
         +- ParamRef
         +- ThisType
         +- RecursiveThis
         +- RecursiveType
         +- LambdaType -+- MethodType
         |              +- PolyType
         |              +- TypeLambda
         +- TypeBounds
         +- NoPrefix

+- ImportSelector -+- SimpleSelector
                   +- RenameSelector
                   +- OmitSelector

+- Signature

+- Position

+- Documentation

+- Constant

+- Symbol

+- Flags

Supertypes

Object

Members

trait 

AndTypeMethods

trait 

AndTypeModule

trait 

AnnotatedModule

trait 

AppliedMethods

trait 

AppliedModule

trait 

ApplyMethods

trait 

ApplyModule

trait 

AssignMethods

trait 

AssignModule

trait 

BindMethods

trait 

BindModule

trait 

BlockMethods

trait 

BlockModule

trait 

ByNameMethods

trait 

ByNameModule

trait 

CaseDefMethods

trait 

CaseDefModule

trait 

ClassDefMethods

trait 

ClassDefModule

trait 

ClosureMethods

trait 

ClosureModule

trait 

ConstantMethods

trait 

ConstantModule

Constant value represented as the constant itself

Constant value represented as the constant itself

trait 

DefDefMethods

trait 

DefDefModule

trait 

DefnModule

Defines standard symbols (and types via its base trait).

Defines standard symbols (and types via its base trait).

trait 

FlagsMethods

trait 

FlagsModule

trait 

IdentMethods

trait 

IdentModule

trait 

IfMethods

trait 

IfModule

trait 

ImplicitsModule

trait 

ImportMethods

trait 

ImportModule

trait 

InferredModule

trait 

InlinedMethods

trait 

InlinedModule

trait 

LambdaModule

trait 

LiteralMethods

trait 

LiteralModule

trait 

MatchMethods

trait 

MatchModule

trait 

MatchTypeModule

trait 

NamedArgMethods

trait 

NamedArgModule

trait 

NewMethods

trait 

NewModule

trait 

NoPrefixModule

trait 

OrTypeMethods

trait 

OrTypeModule

trait 

ParamRefMethods

trait 

ParamRefModule

trait 

PolyTypeMethods

trait 

PolyTypeModule

trait 

PositionMethods

trait 

PositionModule

trait 

RefModule

trait 

RefinedMethods

trait 

RefinedModule

trait 

RepeatedMethods

trait 

RepeatedModule

trait 

ReportingModule

Module containg error and waring reporiting.

Also see scala.quoted.report

Module containg error and waring reporiting.

Also see scala.quoted.report

trait 

ReturnMethods

trait 

ReturnModule

trait 

SelectMethods

trait 

SelectModule

trait 

SignatureModule

trait 

SingletonModule

trait 

SourceModule

trait 

SuperMethods

trait 

SuperModule

trait 

SuperTypeModule

trait 

SymbolMethods

trait 

SymbolModule

trait 

TermMethods

trait 

TermModule

trait 

TermRefMethods

trait 

TermRefModule

trait 

ThisMethods

trait 

ThisModule

trait 

ThisTypeMethods

trait 

ThisTypeModule

trait 

TreeAccumulator

[X]

TASTy Reflect tree accumulator

TASTy Reflect tree accumulator

trait 

TreeMap

TASTy Reflect tree map

TASTy Reflect tree map

trait 

TreeMethods

trait 

TreeModule

trait 

TreeTraverser

TASTy Reflect tree traverser

TASTy Reflect tree traverser

trait 

TryMethods

trait 

TryModule

trait 

TypeApplyModule

trait 

TypeBindMethods

trait 

TypeBindModule

trait 

TypeBlockModule

trait 

TypeDefMethods

trait 

TypeDefModule

trait 

TypeIdentModule

trait 

TypeMethods

trait 

TypeModule

trait 

TypeRefMethods

trait 

TypeRefModule

trait 

TypeTreeMethods

trait 

TypeTreeModule

trait 

TypedMethods

trait 

TypedModule

trait 

UnapplyMethods

trait 

UnapplyModule

trait 

ValDefMethods

trait 

ValDefModule

trait 

WhileMethods

trait 

WhileModule

type 

Alternatives

 = Nothing <: Tree

Pattern representing X | Y | ... alternatives.

Pattern representing X | Y | ... alternatives.

type 

AmbiguousImplicits

 = Nothing <: ImplicitSearchFailure

type 

AndType

 = Nothing <: Type

Intersection type T & U

Intersection type T & U

type 

Annotated

 = Nothing <: TypeTree

Type tree representing an annotated type

Type tree representing an annotated type

type 

AnnotatedType

 = Nothing <: Type

A type with an anottation T @foo

A type with an anottation T @foo

type 

Applied

 = Nothing <: TypeTree

Type tree representing a type application

Type tree representing a type application

type 

AppliedType

 = Nothing <: Type

A higher kinded type applied to some types T[U]

A higher kinded type applied to some types T[U]

type 

Apply

 = Nothing <: Term

Tree an application of arguments. It represents a single list of arguments, multiple argument lists will have nested Applys

Tree an application of arguments. It represents a single list of arguments, multiple argument lists will have nested Applys

type 

Assign

 = Nothing <: Term

Tree representing an assignment x = y in the source code

Tree representing an assignment x = y in the source code

type 

Bind

 = Nothing <: Tree

Pattern representing a _ @ _ binding.

Pattern representing a _ @ _ binding.

type 

Block

 = Nothing <: Term

Tree representing a block { ... } in the source code

Tree representing a block { ... } in the source code

type 

ByName

 = Nothing <: TypeTree

Type tree representing a by name parameter

Type tree representing a by name parameter

type 

ByNameType

 = Nothing <: Type

Type of a by by name parameter

Type of a by by name parameter

type 

CaseDef

 = Nothing <: Tree

Branch of a pattern match or catch clause

Branch of a pattern match or catch clause

type 

ClassDef

 = Nothing <: Definition

Tree representing a class definition. This includes anonymous class definitions and the class of a module object

Tree representing a class definition. This includes anonymous class definitions and the class of a module object

type 

Closure

 = Nothing <: Term

A lambda (...) => ... in the source code is represented as a local method and a closure:

{ def m(...) = ... closure(m) }

A lambda (...) => ... in the source code is represented as a local method and a closure:

{ def m(...) = ... closure(m) }

type 

Constant

 = Nothing <: AnyRef

Constant value represented as the constant itself

Constant value represented as the constant itself

type 

ConstantType

 = Nothing <: Type

A singleton type representing a known constant value

A singleton type representing a known constant value

type 

Context

 = Nothing <: AnyRef

Compilation context

Compilation context

type 

DefDef

 = Nothing <: Definition

Tree representing a method definition in the source code

Tree representing a method definition in the source code

type 

Definition

 = Nothing <: Statement

Tree representing a definition in the source code. It can be ClassDef, TypeDef, DefDef or ValDef

Tree representing a definition in the source code. It can be ClassDef, TypeDef, DefDef or ValDef

type 

DivergingImplicit

 = Nothing <: ImplicitSearchFailure

type 

Documentation

 = Nothing <: AnyRef

Attachment representing the documentation of a definition

Attachment representing the documentation of a definition

type 

Flags

 =

FlagSet of a Symbol

FlagSet of a Symbol

type 

GivenMatch

 = Nothing <: Term

type 

Ident

 = Nothing <: Ref

Tree representing a reference to definition with a given name

Tree representing a reference to definition with a given name

type 

If

 = Nothing <: Term

Tree representing an if/then/else if (...) ... else ... in the source code

Tree representing an if/then/else if (...) ... else ... in the source code

type 

ImplicitSearchFailure

 = Nothing <: ImplicitSearchResult

type 

ImplicitSearchResult

 = Nothing <: AnyRef

Result of a given instance search

Result of a given instance search

type 

ImplicitSearchSuccess

 = Nothing <: ImplicitSearchResult

type 

Import

 = Nothing <: Statement

Tree representing an import in the source code

Tree representing an import in the source code

type 

ImportSelector

 = Nothing <: AnyRef

Import selectors: * SimpleSelector: .bar in import foo.bar * RenameSelector: .{bar => baz} in import foo.{bar => baz} * OmitSelector: .{bar => _} in impo...

Import selectors: * SimpleSelector: .bar in import foo.bar * RenameSelector: .{bar => baz} in import foo.{bar => baz} * OmitSelector: .{bar => _} in import foo.{bar => _}

type 

Inferred

 = Nothing <: TypeTree

Type tree representing an inferred type

Type tree representing an inferred type

type 

Inlined

 = Nothing <: Term

Tree representing the scope of an inlined tree

Tree representing the scope of an inlined tree

type 

LambdaType

 = Nothing <: Type

Common abstraction for lambda types (MethodType, PolyType and TypeLambda).

Common abstraction for lambda types (MethodType, PolyType and TypeLambda).

type 

LambdaTypeTree

 = Nothing <: TypeTree

Type tree representing a lambda abstraction type

Type tree representing a lambda abstraction type

type 

Literal

 = Nothing <: Term

Tree representing a literal value in the source code

Tree representing a literal value in the source code

type 

Match

 = Nothing <: Term

Tree representing a pattern match x match { ... } in the source code

Tree representing a pattern match x match { ... } in the source code

type 

MatchType

 = Nothing <: Type

Type match T match { case U => ... }

Type match T match { case U => ... }

type 

MatchTypeTree

 = Nothing <: TypeTree

Type tree representing a type match

Type tree representing a type match

type 

MethodType

 = Nothing <: LambdaType

Type of the definition of a method taking a single list of parameters. It's return type may be a MethodType.

Type of the definition of a method taking a single list of parameters. It's return type may be a MethodType.

type 

NamedArg

 = Nothing <: Term

Tree representing an argument passed with an explicit name. Such as arg1 = x in foo(arg1 = x)

Tree representing an argument passed with an explicit name. Such as arg1 = x in foo(arg1 = x)

type 

New

 = Nothing <: Term

Tree representing new in the source code

Tree representing new in the source code

type 

NoMatchingImplicits

 = Nothing <: ImplicitSearchFailure

type 

NoPrefix

 = Nothing <: Type

NoPrefix for a type selection

NoPrefix for a type selection

type 

OmitSelector

 = Nothing <: ImportSelector

Omit import selector: .{bar => _} in import foo.{bar => _}

Omit import selector: .{bar => _} in import foo.{bar => _}

type 

OrType

 = Nothing <: Type

Union type T | U

Union type T | U

type 

PackageClause

 = Nothing <: Tree

Tree representing a pacakage clause in the source code

Tree representing a pacakage clause in the source code

type 

ParamRef

 = Nothing <: Type

Type of a parameter reference

Type of a parameter reference

type 

PolyType

 = Nothing <: LambdaType

Type of the definition of a method taking a list of type parameters. It's return type may be a MethodType.

Type of the definition of a method taking a list of type parameters. It's return type may be a MethodType.

type 

Position

 = Nothing <: AnyRef

Position in a source file

Position in a source file

type 

Projection

 = Nothing <: TypeTree

Type tree representing a selection of definition with a given name on a given type prefix

Type tree representing a selection of definition with a given name on a given type prefix

type 

RecursiveThis

 = Nothing <: Type

A type that is recursively defined this

A type that is recursively defined this

type 

RecursiveType

 = Nothing <: Type

A type that is recursively defined

A type that is recursively defined

type 

Ref

 = Nothing <: Term

Tree representing a reference to definition

Tree representing a reference to definition

type 

Refined

 = Nothing <: TypeTree

Type tree representing a type refinement

Type tree representing a type refinement

type 

Refinement

 = Nothing <: Type

A type with a type refinement T { type U }

A type with a type refinement T { type U }

type 

RenameSelector

 = Nothing <: ImportSelector

Rename import selector: .{bar => baz} in import foo.{bar => baz}

Rename import selector: .{bar => baz} in import foo.{bar => baz}

type 

Repeated

 = Nothing <: Term

Tree representing a variable argument list in the source code

Tree representing a variable argument list in the source code

type 

Return

 = Nothing <: Term

Tree representing a return in the source code

Tree representing a return in the source code

type 

Select

 = Nothing <: Ref

Tree representing a selection of definition with a given name on a given prefix

Tree representing a selection of definition with a given name on a given prefix

type 

SelectOuter

 = Nothing <: Term

Tree representing a selection of definition with a given name on a given prefix and number of nested scopes of inlined trees

Tree representing a selection of definition with a given name on a given prefix and number of nested scopes of inlined trees

type 

Signature

 = Nothing <: AnyRef

The signature of a method

The signature of a method

type 

SimpleSelector

 = Nothing <: ImportSelector

Simple import selector: .bar in import foo.bar

Simple import selector: .bar in import foo.bar

type 

Singleton

 = Nothing <: TypeTree

Type tree representing a singleton type

Type tree representing a singleton type

type 

SourceFile

 = Nothing <: AnyRef

Scala source file

Scala source file

type 

Statement

 = Nothing <: Tree

Tree representing a statement in the source code

Tree representing a statement in the source code

type 

Super

 = Nothing <: Term

Tree representing super in the source code

Tree representing super in the source code

type 

SuperType

 = Nothing <: Type

Type of a super reference

Type of a super reference

type 

Symbol

 = Nothing <: AnyRef

Symbol of a definition. Then can be compared with == to know if the definition is the same.

Symbol of a definition. Then can be compared with == to know if the definition is the same.

type 

Term

 = Nothing <: Statement

Tree representing an expression in the source code

Tree representing an expression in the source code

type 

TermRef

 = Nothing <: Type

Type of a reference to a term symbol

Type of a reference to a term symbol

type 

This

 = Nothing <: Term

Tree representing this in the source code

Tree representing this in the source code

type 

ThisType

 = Nothing <: Type

Type of this

Type of this

type 

Tree

 = Nothing <: AnyRef

Tree representing code written in the source

Tree representing code written in the source

type 

Try

 = Nothing <: Term

Tree representing a try catch try x catch { ... } finally { ... } in the source code

Tree representing a try catch try x catch { ... } finally { ... } in the source code

type 

Type

 =

A type, type constructors, type bounds or NoPrefix

A type, type constructors, type bounds or NoPrefix

type 

TypeApply

 = Nothing <: Term

Tree an application of type arguments

Tree an application of type arguments

type 

TypeBind

 = Nothing <: TypeTree

Type tree representing a type binding

Type tree representing a type binding

type 

TypeBlock

 = Nothing <: TypeTree

Type tree within a block with aliases { type U1 = ... ; T[U1, U2] }

Type tree within a block with aliases { type U1 = ... ; T[U1, U2] }

type 

TypeBounds

 = Nothing <: Type

Type bounds

Type bounds

type 

TypeBoundsTree

 = Nothing <: Tree

Type tree representing a type bound written in the source

Type tree representing a type bound written in the source

type 

TypeCaseDef

 = Nothing <: Tree

Branch of a type pattern match

Branch of a type pattern match

type 

TypeDef

 = Nothing <: Definition

Tree representing a type (parameter or member) definition in the source code

Tree representing a type (parameter or member) definition in the source code

type 

TypeIdent

 = Nothing <: TypeTree

Type tree representing a reference to definition with a given name

Type tree representing a reference to definition with a given name

type 

TypeLambda

 = Nothing <: LambdaType

Type of the definition of a type lambda taking a list of type parameters. It's return type may be a TypeLambda.

Type of the definition of a type lambda taking a list of type parameters. It's return type may be a TypeLambda.

type 

TypeRef

 = Nothing <: Type

Type of a reference to a type symbol

Type of a reference to a type symbol

type 

TypeSelect

 = Nothing <: TypeTree

Type tree representing a selection of definition with a given name on a given term prefix

Type tree representing a selection of definition with a given name on a given term prefix

type 

TypeTree

 = Nothing <: Tree

Type tree representing a type written in the source

Type tree representing a type written in the source

type 

Typed

 = Nothing <: Term

Tree representing a type ascription x: T in the source code

Tree representing a type ascription x: T in the source code

type 

Unapply

 = Nothing <: Tree

Pattern representing a Xyz(...) unapply.

Pattern representing a Xyz(...) unapply.

type 

ValDef

 = Nothing <: Definition

Tree representing a value definition in the source code This inclues val, lazy val, var, object and parameter defintions.

Tree representing a value definition in the source code This inclues val, lazy val, var, object and parameter defintions.

type 

While

 = Nothing <: Term

Tree representing a while loop

Tree representing a while loop

type 

WildcardTypeTree

 = Nothing <: Tree

Type tree representing wildcard type bounds written in the source. The wildcard type _ (for example in in List[_]) will be a type tree that represents a...

Type tree representing wildcard type bounds written in the source. The wildcard type _ (for example in in List[_]) will be a type tree that represents a type but has TypeBounda inside.

val 

Alternatives

: AlternativesModule

protected val 

AlternativesMethodsImpl

: AlternativesMethods

protected val 

AlternativesTypeTest

: TypeTest[Tree,Alternatives]

protected val 

AmbiguousImplicitsTypeTest

: TypeTest[ImplicitSearchResult,AmbiguousImplicits]

val 

AndType

: AndTypeModule

protected val 

AndTypeMethodsImpl

: AndTypeMethods

protected val 

AndTypeTypeTest

: TypeTest[Type,AndType]