reflectModule

Methods of the module object val Alternatives

Methods of the module object val AndType

Methods of the module object val Annotated

Methods of the module object val AnnotatedType

Methods of the module object val Applied

Methods of the module object val AppliedType

Methods of the module object val Apply

Methods of the module object val Assign

Methods of the module object val Bind

Methods of the module object val Block

Methods of the module object val BooleanConstant

Methods of the module object val ByName

Methods of the module object val ByNameType

Methods of the module object val ByteConstant

Methods of the module object val CaseDef

Methods of the module object val CharConstant

Methods of the module object val ClassDef

Methods of the module object val ClassOf

Methods of the module object val Closure

Methods of the module object val CompilationInfo

Constant value represented as the constant itself

Methods of the module object val Type

Methods of the module object val DefDef

Methods of the module object val Definition

Methods of the module object val DoubleConstant

Methods of the module object val Export

Methods of the module object val Flags

Methods of the module object val FloatConstant

Methods of the module object val GivenSelector

Methods of the module object val Ident

Methods of the module object val If

Methods of the module object val Implicits

Methods of the module object val Import

Methods of the module object val Inferred

Methods of the module object val Inlined

Methods of the module object val IntConstant

Methods of the module object val Lambda

Methods of the module object val LambdaTypeTree

Methods of the module object val Literal

Methods of the module object val LongConstant

Methods of the module object val MatchCase

Methods of the module object val Match

Methods of the module object val MatchType

Methods of the module object val MatchTypeTree

Methods of the module object val MethodType

Methods of the module object val NamedArg

Methods of the module object val New

Methods of the module object val NoPrefix

Methods of the module object val NullConstant

Methods of the module object val OmitSelector

Methods of the module object val OrType

Methods of the module object val PackageClause

Methods of the module object val ParamClause

Methods of the module object val ParamRef

Methods of the module object val PolyType

Methods of the module object val Position

Type class used in show methods to provide customizable String representations

Methods of the module object val Printer

Methods of the module object val RecursiveThis

Methods of the module object val RecursiveType

Methods of the module object val Ref

Methods of the module object val Refined

Methods of the module object val Refinement

Methods of the module object val RenameSelector

Methods of the module object val Repeated

Methods of the module object val Return

Methods of the module object val Select

Methods of the module object val SelectOuter

Methods of the module object val Selector

Methods of the module object val Short

Methods of the module object val Signature

Methods of the module object val SimpleSelector

Methods of the module object val Singleton

Methods of the module object val SourceFile

Methods of the module object val StringConstant

Methods of the module object val SummonFrom

Methods of the module object val Super

Methods of the module object val SuperType

Methods of the module object val Symbol

Methods of the module object val Term

Methods of the module object val TermParamClause

Methods of the module object val TermRef

Methods of the module object val This

Methods of the module object val ThisType

Customizable Tree accumulator.

Usage:

import quotes.reflect._
class MyTreeAccumulator extends TreeAccumulator[X] {
  def foldTree(x: X, tree: Tree)(owner: Symbol): X = ...
}

Customizable tree mapper.

Usage:

import quotes.reflect._
class MyTreeMap extends TreeMap {
  override def transformTree(tree: Tree)(owner: Symbol): Tree = ...
}

Methods of the module object val Tree

Customizable tree traverser.

Usage:

import quotes.reflect._
class MyTraverser extends TreeTraverser {
  override def traverseTree(tree: Tree)(owner: Symbol): Unit = ...
}

Methods of the module object val Try

Methods of the module object val TypeApply

Methods of the module object val TypeBind

Methods of the module object val TypeBlock

Methods of the module object val TypeBounds

Methods of the module object val TypeBoundsTree

Methods of the module object val TypeCaseDef

Methods of the module object val TypeDef

Methods of the module object val TypeIdent

Methods of the module object val TypeLambda

Methods of the module object val TypeParamClause

Methods of the module object val TypeProjection

Methods of the module object val TypeRef

Methods of the module object val TypeRepr

Methods of the module object val TypeSelect

Methods of the module object val TypeTree

Methods of the module object val Typed

Methods of the module object val Unapply

Methods of the module object val UnitConstant

Methods of the module object val ValDef

Methods of the module object val While

Methods of the module object val WildcardTypeTree

Methods of the module object val defn

Methods of the module object val report

Pattern representing X | Y | ... alternatives.

Intersection type T & U or an union type T | U

Intersection type T & U

Type tree representing an annotated type

A type with an annotation T @foo

Type tree representing a type application

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

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

Tree representing an assignment x = y in the source code

Pattern representing a _ @ _ binding.

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

Constant Boolean value

Type tree representing a by name parameter

Type of a by-name definition of type =>T.

May represent by-name parameter such as thunk in

def log[T](thunk: =>T): T = ...

May also represent a the return type of a parameterless method definition such as

def foo: Int = ...

Constant Byte value

Branch of a pattern match or catch clause

Constant Char value

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

Constant class value representing a classOf[T]

Constant value represented as the constant itself

A singleton type representing a known constant value

Tree representing a method definition in the source code

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

Constant Double value

Tree representing an export clause in the source code. Export forwarders generated from this clause appear in the same scope.

FlagSet of a Symbol

Constant Float value

given import/export selector: .given/.{given T} in import foo.given/export foo.{given T}

Tree representing a reference to definition with a given name

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

Result of a given instance search

Type tree representing an inferred type

Tree representing the scope of an inlined tree

Constant Int value

Type of the definition of a method taking a single list of type or term parameters

Type tree representing a lambda abstraction type

Tree representing a literal value in the source code

Constant Long value

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

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

Type tree representing a type match

Type of the definition of a method taking a single list of type or term parameters

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

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

Type of a reference to a type or term symbol

Tree representing new in the source code

NoPrefix for a type selection

Constant null value

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

Union type T | U

Tree representing a package clause in the source code

package foo {
   // package stats
}

or

package foo.bar
// package stats

A parameter clause [X1, ..., Xn] or (x1: X1, ..., xn: Xx)

[X1, ..., Xn] are represented with TypeParamClause and (x1: X1, ..., xn: Xx) are represented with TermParamClause

ParamClause encodes the following enumeration

enum ParamClause:
  case TypeParamClause(params: List[TypeDef])
  case TermParamClause(params: List[ValDef])

Type of a parameter reference

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

Position in a source file

A type that is recursively defined this

A type that is recursively defined

Tree representing a reference to definition

Type tree representing a type refinement

A type with a type refinement T { type U }

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

Tree representing a variable argument list in the source code

Tree representing a return in the source code

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 and number of nested scopes of inlined trees

Import/Export selectors: - SimpleSelector: .bar in import foo.bar - RenameSelector: .{bar => baz} in export foo.{bar => baz} - OmitSelector: .{bar => _} in import foo.{bar => _} - GivenSelector: .given/.{given T} in export foo.given/import foo.{given T}

Constant Short value

The signature of a method

Simple import/export selector: .bar in import foo.bar

Type tree representing a singleton type

Scala source file

Tree representing a statement in the source code

Constant String value

Tree representing a summoning match summonFrom { ... } in the source code

Tree representing super in the source code

Type of a super reference

Symbol of a definition. Symbols can be compared with == to know if two definitions are the same.

Tree representing an expression in the source code

A term parameter clause (x1: X1, ..., xn: Xx) Can also be (implicit X1, ..., Xn), (given X1, ..., Xn) or (given x1: X1, ..., xn: Xn)

Type of a reference to a term symbol

Tree representing this or C.this in the source code

Type of this

Tree representing code written in the source

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

Tree representing an application of type arguments

Type tree representing a type binding

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

Type bounds

Type tree representing a type bound written in the source

Branch of a type pattern match

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

Type tree representing a reference to definition with a given name

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

A type parameter clause [X1, ..., Xn]

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

Type of a reference to a type symbol

A type, type constructors, type bounds or NoPrefix

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

Type tree representing a type written in the source

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

Pattern representing a Xyz(...) unapply.

Constant Unit value

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

Tree representing a while loop

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 TypeBounds inside.

Module object of type Alternatives

Module object of type AndType

Module object of type Annotated

Module object of type AnnotatedType

Module object of type Applied

Module object of type AppliedType

Module object of type Apply

Module object of type Assign

Module object of type Bind

Module object of type Block

Module object of type BooleanConstant

Module object of type ByName

Module object of type ByNameType

Module object of type ByteConstant

Module object of type CaseDef

Module object of type CharConstant

Module object of type ClassDef

Module object of type ClassOfConstant

Module object of type Closure

Module object of type CompilationInfo

Constant value represented as the constant itself

Module object of type ConstantType

Module object of type DefDef

Module object of type Definition

Module object of type DoubleConstant

Module object of type Export

Module object of type Flags

Module object of type FloatConstant

Module object of type GivenSelector

Module object of type Ident

Module object of type If

Module object of type Implicits

Module object of type Import

Module object of type Inferred

Module object of type Inlined

Module object of type IntConstant

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

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

Module object of type LambdaTypeTree