reflectModule

Low-level Typed AST metaprogramming API.

Provides all functionality related to AST-based metaprogramming.

Each type XYZ in the API is defined as an abstract type type XYZ. Methods on XYZ are provided by a given XYZMethods which implements extension methods on XYZ in the trait XYZMethods. The XYZ module is defined by a val XYZ: XYZModule which contains the methods defined in XYZModule. Type tests (TypeTest) are also given to perform subtype checks on these types.

Type hierarchy


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

+- ParamClause -+- TypeParamClause
                +- TermParamClause

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

+- Selector -+- SimpleSelector
             +- RenameSelector
             +- OmitSelector
             +- GivenSelector

+- Signature

+- Position

+- SourceFile

+- Constant -+- BooleanConstant
             +- ByteConstant
             +- ShortConstant
             +- IntConstant
             +- LongConstant
             +- FloatConstant
             +- DoubleConstant
             +- CharConstant
             +- StringConstant
             +- UnitConstant
             +- NullConstant
             +- ClassOfConstant
+- Symbol

+- Flags

class Object
trait Matchable
class Any

Type members

Classlikes

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

trait BindModule

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

trait IfModule

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

trait NewModule

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

trait Printer[T]

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

trait RefModule

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

trait TermModule

Methods of the module object val Term

Methods of the module object val TermParamClause

Methods of the module object val TermRef

trait ThisModule

Methods of the module object val This

Methods of the module object val ThisType

trait TreeAccumulator[X]

Customizable Tree accumulator.

Usage:

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

Customizable tree mapper.

Usage:

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

Methods of the module object val Tree

Customizable tree traverser.

Usage:

import qctx.relfect._
class MyTraverser extends TreeTraverser {
  override def traverseTree(tree: Tree)(owner: Symbol): Unit = ...
}
trait TryModule

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

trait defnModule

Methods of the module object val defn

Methods of the module object val report

Types

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 anottation T @foo

type Applied <: TypeTree

Type tree representing a type application

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

type Apply <: Term

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

type Assign <: Term

Tree representing an assignment x = y in the source code

type Bind <: Tree

Pattern representing a _ @ _ binding.

type Block <: Term

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

Constant Boolean value

type ByName <: TypeTree

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

type CaseDef <: Tree

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]

type Closure <: Term

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

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

type Constant <: AnyRef

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

type Export <: Statement

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

type Flags

FlagSet of a Symbol

Constant Float value

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

type Ident <: Ref

Tree representing a reference to definition with a given name

type If <: Term

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

type ImplicitSearchResult <: AnyRef

Result of a given instance search

type Import <: Statement

Tree representing an import in the source code.

See also documentation on Selector.

Type tree representing an inferred type

type Inlined <: Term

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

type Literal <: Term

Tree representing a literal value in the source code

Constant Long value

type Match <: Term

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

Case of a MatchType containing pattern case P => R.

Note: cases with type bindings are represented nested in a TypeLambda.

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.

type NamedArg <: Term

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

type New <: Term

Tree representing new in the source code

NoPrefix for a type selection

Constant null value

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

type OrType <: AndOrType

Union type T | U

Tree representing a pacakage clause in the source code

package foo {
   // package stats
}

or

package foo.bar
// package stats
type ParamClause <: AnyRef

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

[X1, ..., Xn] are reresented 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.

type Position <: AnyRef

Position in a source file

A type that is recursively defined this

A type that is recursively defined

type Ref <: Term

Tree representing a reference to definition

type Refined <: TypeTree

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}

type Repeated <: Term

Tree representing a variable argument list in the source code

type Return <: Term

Tree representing a return in the source code

type Select <: Ref

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

type SelectOuter <: Term

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

type Selector <: AnyRef

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

type Signature <: AnyRef

The signature of a method

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

Type tree representing a singleton type

type SourceFile <: AnyRef

Scala source file

type Statement <: Tree

Tree representing a statement in the source code

Constant String value

type SummonFrom <: Term

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

type Super <: Term

Tree representing super in the source code

Type of a super reference

type Symbol <: AnyRef

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

type Term <: Statement

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

type This <: Term

Tree representing this or C.this in the source code

Type of this

type Tree <: AnyRef

Tree representing code written in the source

type Try <: Term

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

type TypeApply <: Term

Tree 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

type TypeCaseDef <: Tree

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

type TypeRepr

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 TypeTree <: Tree

Type tree representing a type written in the source

type Typed <: Term

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

type Unapply <: Tree

Pattern representing a Xyz(...) unapply.

Constant Unit value

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

type While <: Term

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

Value members

Abstract fields

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

val If: IfModule

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)
}
Note

Due to the encoding, in pattern matches the case for Lambda should come before the case for Block to avoid mishandling of Lambda.

Module object of type LambdaTypeTree

Module object of type Literal

Module object of type LongConstant

Module object of type Match

Module object of type MatchCase

Module object of type MatchType

Module object of type MatchTypeTree

Module object of type MethodType

Module object of type NamedArg

Module object of type New

Module object of type NoPrefix

Module object of type NullConstant

Module object of type OmitSelector

Module object of type OrType

Module object of type PackageClause

Module object of type ParamClause

Module object of type ParamRef

Module object of type PolyType

Module object of type Position

Module object of type Printer. Contains custom printers such as TreeCode, TreeAnsiCode, TreeCases, TypeReprCode, ..., SymbolFullName and FlagsCombination.

Module object of type RecursiveThis

Module object of type RecursiveType

Module object of type Ref

Module object of type Refined

Module object of type Refinement

Module object of type RenameSelector

Module object of type Repeated

Module object of type Return

Module object of type Select

Module object of type SelectOuter

Module object of type Selector

Module object of type ShortConstant

Module object of type Signature

Module object of type SimpleSelector

Module object of type Singleton

Module object of type SourceFile

Module object of type StringConstant

Module object of type SummonFrom

Module object of type Super

Module object of type SuperType

Module object of type Symbol

Module object of type Term

Module object of type TermParamClause

Module object of type TermRef

Module object of type This

Module object of type ThisType

Module object of type Tree

Module object of type Try

Module object of type TypeApply

Module object of type TypeBind

Module object of type TypeBlock

Module object of type TypeBounds

Module object of type TypeBoundsTree

Module object of type TypeCaseDef

Module object of type TypeDef

Module object of type TypeIdent

Module object of type TypeLambda

Module object of type TypeParamClause

Module object of type TypeProjection

Module object of type TypeRef

Module object of type TypeRepr

Module object of type TypeSelect

Module object of type TypeTree

Module object of type Typed

Module object of type Unapply

Module object of type UnitConstant

Module object of type ValDef

Module object of type While

Module object of type WildcardTypeTree

A value containing all standard definitions

Module containg error and waring reporiting.

Concrete fields

Default pinter for Constant used when calling const.show

final lazy val TreePrinter: Printer[Tree]

Default pinter for Tree used when calling tree.show

Default pinter for TypeRepr used when calling tpe.show

Givens

Givens

Extension methods of Alternatives

TypeTest that allows testing at runtime in a pattern match if a Tree is an Alternatives

TypeTest that allows testing at runtime in a pattern match if an ImplicitSearchResult is an AmbiguousImplicits

Extension methods of AndOrType

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is an AndOrType

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is an AndType

Extension methods of Annotated

Extension methods of AnnotatedType

TypeTest that allows testing at runtime in a pattern match if a Tree is an Annotated

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is an AnnotatedType

Extension methods of Applied

Extension methods of AppliedType

TypeTest that allows testing at runtime in a pattern match if a Tree is an Applied

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is an AppliedType

Extension methods of Apply

TypeTest that allows testing at runtime in a pattern match if a Tree is an Apply

Extension methods of Assign

TypeTest that allows testing at runtime in a pattern match if a Tree is an Assign

Extension methods of Bind

TypeTest that allows testing at runtime in a pattern match if a Tree is a Bind

Extension methods of Block

TypeTest that allows testing at runtime in a pattern match if a Tree is a Block

TypeTest that allows testing at runtime in a pattern match if a Constant is a BooleanConstant

Extension methods of ByName

Extension methods of ByNameType

TypeTest that allows testing at runtime in a pattern match if a Tree is a ByName

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a ByNameType

TypeTest that allows testing at runtime in a pattern match if a Constant is a ByteConstant

Extension methods of CaseDef

TypeTest that allows testing at runtime in a pattern match if a Tree is a CaseDef

TypeTest that allows testing at runtime in a pattern match if a Constant is a CharConstant

Extension methods of ClassDef

TypeTest that allows testing at runtime in a pattern match if a Tree is a ClassDef

TypeTest that allows testing at runtime in a pattern match if a Constant is a ClassOfConstant

Extension methods of Closure

TypeTest that allows testing at runtime in a pattern match if a Tree is a Closure

Extension methods of Constant

Extension methods of ConstantType

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a ConstantType

Extension methods of DefDef

TypeTest that allows testing at runtime in a pattern match if a Tree is a DefDef

Extension methods of Definition

TypeTest that allows testing at runtime in a pattern match if a Tree is a Definition

TypeTest that allows testing at runtime in a pattern match if an ImplicitSearchResult is a DivergingImplicit

TypeTest that allows testing at runtime in a pattern match if a Constant is a DoubleConstant

Extension methods of Export

TypeTest that allows testing at runtime in a pattern match if a Tree is an Export

Extension methods of Flags

TypeTest that allows testing at runtime in a pattern match if a Constant is a FloatConstant

Extension methods of GivenSelector

TypeTest that allows testing at runtime in a pattern match if an Selector is a GivenSelector

Extension methods of Ident

TypeTest that allows testing at runtime in a pattern match if a Tree is an Ident

given IfMethods

Extension methods of If

TypeTest that allows testing at runtime in a pattern match if a Tree is an If

Extension methods of ImplicitSearchFailure

TypeTest that allows testing at runtime in a pattern match if an ImplicitSearchResult is an ImplicitSearchFailure

Extension methods of ImplicitSearchSuccess

TypeTest that allows testing at runtime in a pattern match if an ImplicitSearchResult is an ImplicitSearchSuccess

Extension methods of Import

TypeTest that allows testing at runtime in a pattern match if a Tree is an Import

TypeTest that allows testing at runtime in a pattern match if a Tree is an Inferred

Extension methods of Inlined

TypeTest that allows testing at runtime in a pattern match if a Tree is an Inlined

TypeTest that allows testing at runtime in a pattern match if a Constant is a IntConstant

Extension methods of LambdaType

Extension methods of LambdaTypeTree

TypeTest that allows testing at runtime in a pattern match if a Tree is a LambdaTypeTree

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a LambdaType

Extension methods of Literal

TypeTest that allows testing at runtime in a pattern match if a Tree is a Literal

TypeTest that allows testing at runtime in a pattern match if a Constant is a LongConstant

Extension methods of MatchCase

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a MatchCase

Extension methods of Match

Extension methods of MatchType

TypeTest that allows testing at runtime in a pattern match if a Tree is a Match

Extension methods of MatchTypeTree

TypeTest that allows testing at runtime in a pattern match if a Tree is a MatchTypeTree

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a MatchType

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a MethodOrPoly

Extension methods of MethodType

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a MethodType

Extension methods of NamedArg

TypeTest that allows testing at runtime in a pattern match if a Tree is a NamedArg

Extension methods of NamedType

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a NamedType

given NewMethods

Extension methods of New

TypeTest that allows testing at runtime in a pattern match if a Tree is a New

TypeTest that allows testing at runtime in a pattern match if an ImplicitSearchResult is a NoMatchingImplicits

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a NoPrefix

TypeTest that allows testing at runtime in a pattern match if a Constant is a NullConstant

Extension methods of OmitSelector

TypeTest that allows testing at runtime in a pattern match if a Selector is an OmitSelector

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is an OrType

Extension methods of PackageClause

TypeTest that allows testing at runtime in a pattern match if a Tree is a PackageClause

Extension methods of ParamClause

Extension methods of ParamRef

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a ParamRef

Extension methods of PolyType

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a PolyType

Extension methods of Position

Extension methods of RecursiveThis

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a RecursiveThis

Extension methods of RecursiveType

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a RecursiveType

TypeTest that allows testing at runtime in a pattern match if a Tree is a Ref

Extension methods of Refined

TypeTest that allows testing at runtime in a pattern match if a Tree is a Refined

Extension methods of Refinement

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a Refinement

Extension methods of RenameSelector

TypeTest that allows testing at runtime in a pattern match if a Selector is a RenameSelector

Extension methods of Repeated

TypeTest that allows testing at runtime in a pattern match if a Tree is a Repeated

Extension methods of Return

TypeTest that allows testing at runtime in a pattern match if a Tree is a Return

Extension methods of Select

Extension methods of SelectOuter

TypeTest that allows testing at runtime in a pattern match if a Tree is a SelectOuter

TypeTest that allows testing at runtime in a pattern match if a Tree is a Select

TypeTest that allows testing at runtime in a pattern match if a Constant is a ShortConstant

Extension methods of Signature

Extension methods of SimpleSelector

TypeTest that allows testing at runtime in a pattern match if a Selector is a SimpleSelector

Extension methods of Singleton

TypeTest that allows testing at runtime in a pattern match if a Tree is a Singleton

Extension methods of SourceFile

TypeTest that allows testing at runtime in a pattern match if a Tree is a Statement

TypeTest that allows testing at runtime in a pattern match if a Constant is a StringConstant

Extension methods of SummonFrom

TypeTest that allows testing at runtime in a pattern match if a Tree is a SummonFrom

Extension methods of Super

Extension methods of SuperType

TypeTest that allows testing at runtime in a pattern match if a Tree is a Super

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a SuperType

Extension methods of Symbol

Extension methods of Term

Extension methods of TermParamClause

TypeTest that allows testing at runtime in a pattern match if a ParamClause is a TermParamClause

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a TermRef

TypeTest that allows testing at runtime in a pattern match if a Tree is a Term

Extension methods of This

Extension methods of ThisType

TypeTest that allows testing at runtime in a pattern match if a Tree is a This

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a ThisType

Extension methods of Tree

given TryMethods

Extension methods of Try

TypeTest that allows testing at runtime in a pattern match if a Tree is a Try

Extension methods of TypeApply

TypeTest that allows testing at runtime in a pattern match if a Tree is a TypeApply

Extension methods of TypeBind

TypeTest that allows testing at runtime in a pattern match if a Tree is a TypeBind

Extension methods of TypeBlock

TypeTest that allows testing at runtime in a pattern match if a Tree is a TypeBlock

Extension methods of TypeBounds

Extension methods of TypeBoundsTree

TypeTest that allows testing at runtime in a pattern match if a Tree is a TypeBoundsTree

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a TypeBounds

Extension methods of TypeCaseDef

TypeTest that allows testing at runtime in a pattern match if a Tree is a TypeCaseDef

Extension methods of TypeDef

TypeTest that allows testing at runtime in a pattern match if a Tree is a TypeDef

Extension methods of TypeIdent

TypeTest that allows testing at runtime in a pattern match if a Tree is a TypeIdent

Extension methods of TypeLambda

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a TypeLambda

Extension methods of TypeParamClause

TypeTest that allows testing at runtime in a pattern match if a ParamClause is a TypeParamClause

Extension methods of TypeProjection

TypeTest that allows testing at runtime in a pattern match if a Tree is a TypeProjection

Extension methods of TypeRef

TypeTest that allows testing at runtime in a pattern match if a TypeRepr is a TypeRef

Extension methods of TypeRepr

Extension methods of TypeSelect

TypeTest that allows testing at runtime in a pattern match if a Tree is a TypeSelect

Extension methods of TypeTree

TypeTest that allows testing at runtime in a pattern match if a Tree is a TypeTree

Extension methods of Typed

TypeTest that allows testing at runtime in a pattern match if a Tree is a Typed

Extension methods of Unapply

TypeTest that allows testing at runtime in a pattern match if a Tree is an Unapply

TypeTest that allows testing at runtime in a pattern match if a Constant is a UnitConstant

Extension methods of ValDef

TypeTest that allows testing at runtime in a pattern match if a Tree is a ValDef

Extension methods of While

TypeTest that allows testing at runtime in a pattern match if a Tree is a While

Extension methods of WildcardTypeTree

TypeTest that allows testing at runtime in a pattern match if a Tree is a WildcardTypeTree

Extensions

Extensions

extension (expr: Expr[Any])
def asTerm: Term

Returns the Term representation this expression