T trait

CompilerInterface

extends Object

Tasty reflect abstract types


+- Tree -+- PackageClause
         +- Import
         +- Statement -+- Definition --+- PackageDef
         |             |               +- 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

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

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

+- Id

+- Signature

+- Position

+- Comment

+- Constant

+- Symbol

+- Flags

Supertypes

Object

Members

type 

Alternatives

 = Nothing <: Tree

Tree representing pattern alternatives X | Y | ...

Tree representing pattern alternatives X | Y | ...

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

Tree representing a binding pattern _ @ _

Tree representing a binding pattern _ @ _

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 annonymus class definitions and the class of a module object

Tree representing a class definition. This includes annonymus 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 

Comment

 = Nothing <: AnyRef

Comment

Comment

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 PackageDef, ClassDef, TypeDef, DefDef or ValDef

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

type 

DivergingImplicit

 = Nothing <: ImplicitSearchFailure

type 

Flags

 =

FlagSet of a Symbol

FlagSet of a Symbol

type 

GivenMatch

 = Nothing <: Term

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

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

type 

Id

 = Nothing <: AnyRef

Untyped identifier

Untyped identifier

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

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]

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 <: TypeOrBounds

NoPrefix for a type selection

NoPrefix for a type selection

type 

OmitSelector

 = Nothing <: ImportSelector

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 

PackageDef

 = Nothing <: Definition

Tree representing a package definition. This includes definitions in all source files

Tree representing a package definition. This includes definitions in all source files

type 

ParamRef

 = Nothing <: Type

Type of a parameter reference

Type of a parameter reference

type 

PolyType

 = Nothing <: LambdaType[TypeBounds]

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

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 

Settings

 = Nothing <: AnyRef

Settings

Settings

type 

Signature

 = Nothing <: AnyRef

type 

SimpleSelector

 = Nothing <: ImportSelector

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 tyr catch try x catch { ... } finally { ... } in the source code

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

type 

Type

 = Nothing <: TypeOrBounds

A type

A type

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 <: TypeOrBounds

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[TypeBounds]

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 

TypeOrBounds

 = Nothing <: AnyRef

Type or bounds

Type or bounds

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

Tree representing an unapply pattern Xyz(...)

Tree representing an unapply pattern Xyz(...)

type 

ValDef

 = Nothing <: Definition

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

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

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.

def 

AndType_apply

( lhs: Type ,  rhs: Type ) ( implicit  ctx: Context ) : AndType

def 

AndType_left

( self: AndType ) ( implicit  ctx: Context ) : Type

def 

AndType_right

( self: AndType ) ( implicit  ctx: Context ) : Type

def 

AnnotatedType_annot

( self: AnnotatedType ) ( implicit  ctx: Context ) : Term

def 

AnnotatedType_apply

( underlying: Type ,  annot: Term ) ( implicit  ctx: Context ) : AnnotatedType

def 

AnnotatedType_underlying

( self: AnnotatedType ) ( implicit  ctx: Context ) : Type

def 

Annotated_annotation

( self: Annotated ) ( implicit  ctx: Context ) : Term

def 

Annotated_apply

( arg: TypeTree ,  annotation: Term ) ( implicit  ctx: Context ) : Annotated

def 

Annotated_arg

( self: Annotated ) ( implicit  ctx: Context ) : TypeTree

def 

Annotated_copy

( original: Tree ) ( arg: TypeTree ,  annotation: Term ) ( implicit  ctx: Context ) : Annotated

def 

AppliedType_apply

( tycon: Type ,  args: List[TypeOrBounds] ) ( implicit  ctx: Context ) : AppliedType

def 

AppliedType_args

( self: AppliedType ) ( implicit  ctx: Context ) : List[TypeOrBounds]

def 

AppliedType_tycon

( self: AppliedType ) ( implicit  ctx: Context ) : Type

def 

Applied_apply

( tpt: TypeTree ,  args: List[Tree] ) ( implicit  ctx: Context ) : Applied

def 

Applied_args

( self: Applied ) ( implicit  ctx: Context ) : List[Tree]

def 

Applied_copy

( original: Tree ) ( tpt: TypeTree ,  args: List[Tree] ) ( implicit  ctx: Context ) : Applied

def 

Applied_tpt

( self: Applied ) ( implicit  ctx: Context ) : TypeTree

def 

Apply_apply

( fn: Term ,  args: List[Term] ) ( implicit  ctx: Context ) : Apply

def 

Apply_args

( self: Apply ) ( implicit  ctx: Context ) : List[Term]

def 

Apply_copy

( original: Tree ) ( fun: Term ,  args: List[Term] ) ( implicit  ctx: Context ) : Apply

def 

Apply_fun

( self: Apply ) ( implicit  ctx: Context ) : Term

def 

Assign_apply

( lhs: Term ,  rhs: Term ) ( implicit  ctx: Context ) : Assign

def 

Assign_copy

( original: Tree ) ( lhs: Term ,  rhs: Term ) ( implicit  ctx: Context ) : Assign

def 

Assign_lhs

( self: Assign ) ( implicit  ctx: Context ) : Term

def 

Assign_rhs

( self: Assign ) ( implicit  ctx: Context ) : Term

def 

Block_apply

( stats: List[Statement] ,  expr: Term ) ( implicit  ctx: Context ) : Block

def 

Block_copy

( original: Tree ) ( stats: List[Statement] ,  expr: Term ) ( implicit  ctx: Context ) : Block

def 

Block_expr

( self: Block ) ( implicit  ctx: Context ) : Term

def 

Block_statements

( self: Block ) ( implicit  ctx: Context ) : List[Statement]

def 

ByNameType_apply

( underlying: Type ) ( implicit  ctx: Context ) : Type

def 

ByNameType_underlying

( self: ByNameType ) ( implicit  ctx: Context ) : Type

def 

ByName_apply

( result: TypeTree ) ( implicit  ctx: Context ) : ByName

def 

ByName_copy

( original: Tree ) ( result: TypeTree ) ( implicit  ctx: Context ) : ByName

def 

ByName_result

( self: ByName ) ( implicit  ctx: Context ) : TypeTree

def 

CaseDef_guard

( self: CaseDef ) ( implicit  ctx: Context ) : Option[Term]

def 

CaseDef_module_apply

( pattern: Tree ,  guard: Option[Term] ,  body: Term ) ( implicit  ctx: Context ) : CaseDef

def 

CaseDef_module_copy

( original: Tree ) ( pattern: Tree ,  guard: Option[Term] ,  body: Term ) ( implicit  ctx: Context ) : CaseDef

def 

CaseDef_pattern

( self: CaseDef ) ( implicit  ctx: Context ) : Tree

def 

CaseDef_rhs

( self: CaseDef ) ( implicit  ctx: Context ) : Term

def 

ClassDef_body

( self: ClassDef ) ( implicit  ctx: Context ) : List[Statement]

def 

ClassDef_constructor

( self: ClassDef ) ( implicit  ctx: Context ) : DefDef

def 

ClassDef_copy

( original: Tree ) ( name: String ,  constr: DefDef ,  parents: List[Tree] ,  derived: List[TypeTree] ,  selfOpt: Option[ValDef] ,  body: List[Statement] ) ( implicit  ctx: Context ) : ClassDef

def 

ClassDef_derived

( self: ClassDef ) ( implicit  ctx: Context ) : List[TypeTree]

def 

ClassDef_parents

( self: ClassDef ) ( implicit  ctx: Context ) : List[Tree]

def 

ClassDef_self

( self: ClassDef ) ( implicit  ctx: Context ) : Option[ValDef]

def 

Closure_apply

( meth: Term ,  tpe: Option[Type] ) ( implicit  ctx: Context ) : Closure

def 

Closure_copy

( original: Tree ) ( meth: Tree ,  tpe: Option[Type] ) ( implicit  ctx: Context ) : Closure

def 

Closure_meth

( self: Closure ) ( implicit  ctx: Context ) : Term

def 

Closure_tpeOpt

( self: Closure ) ( implicit  ctx: Context ) : Option[Type]

def 

Comment_expanded

( self: Comment ) : Option[String]

def 

Comment_raw

( self: Comment ) : String

def 

Comment_usecases

( self: Comment ) : List[( String, Option[DefDef] )]

def 

ConstantType_apply

( const: Constant ) ( implicit  ctx: Context ) : ConstantType

def 

ConstantType_constant

( self: ConstantType ) ( implicit  ctx: Context ) : Constant

def 

Constant_ClassTag_apply

( x: Type ) : Constant

def 

Constant_apply

( x: Unit | Null | Int | Boolean | Byte | Short | Int | Long | Float | Double | Char | String | Type ) : Constant

def 

Constant_value

( const: Constant ) : Any

def 

Context_GADT_addToConstraint

( self: Context ) ( syms: List[Symbol] ) : Boolean

def 

Context_GADT_approximation

( self: Context ) ( sym: Symbol ,  fromBelow: Boolean ) : Type

def 

Context_GADT_setFreshGADTBounds

( self: Context ) : Context

def 

Context_compilationUnitClassname

( self: Context ) : String

Class name of the current CompilationUnit

Class name of the current CompilationUnit

def 

Context_isJavaCompilationUnit

( self: Context ) : Boolean

Returns true if we've tried to reflect on a Java class.

Returns true if we've tried to reflect on a Java class.

def 

Context_isScala2CompilationUnit

( self: Context ) : Boolean

Returns true if we've tried to reflect on a Scala2 (non-Tasty) class.

Returns true if we've tried to reflect on a Scala2 (non-Tasty) class.

def 

Context_owner

( self: Context ) : Symbol

Returns the owner of the context

Returns the owner of the context

def 

Context_requiredClass

( self: Context ) ( path: String ) : Symbol

Get class symbol if class is either defined in current compilation run or present on classpath.

Get class symbol if class is either defined in current compilation run or present on classpath.

def 

Context_requiredMethod

( self: Context ) ( path: String ) : Symbol

Get method symbol if method is either defined in current compilation run or present on classpath. Throws if the method has an overload.

Get method symbol if method is either defined in current compilation run or present on classpath. Throws if the method has an overload.

def 

Context_requiredModule

( self: Context ) ( path: String ) : Symbol

Get module symbol if module is either defined in current compilation run or present on classpath.

Get module symbol if module is either defined in current compilation run or present on classpath.

def 

Context_requiredPackage

( self: Context ) ( path: String ) : Symbol

Get package symbol if package is either defined in current compilation run or present on classpath.

Get package symbol if package is either defined in current compilation run or present on classpath.

def 

Context_source

( self: Context ) : Path

Returns the source file being compiled. The path is relative to the current working directory.

Returns the source file being compiled. The path is relative to the current working directory.

def 

DefDef_apply

( symbol: Symbol ,  rhsFn: List[Type] => List[List[Term]] => Option[Term] ) ( implicit  ctx: Context ) : DefDef

def 

DefDef_copy

( original: Tree ) ( name: String ,  typeParams: List[TypeDef] ,  paramss: List[List[ValDef]] ,  tpt: TypeTree ,  rhs: Option[Term] ) ( implicit  ctx: Context ) : DefDef

def 

DefDef_paramss

( self: DefDef ) ( implicit  ctx: Context ) : List[List[ValDef]]

def 

DefDef_returnTpt

( self: DefDef ) ( implicit  ctx: Context ) : TypeTree

def 

DefDef_rhs

( self: DefDef ) ( implicit  ctx: Context ) : Option[Term]

def 

DefDef_typeParams

( self: DefDef ) ( implicit  ctx: Context ) : List[TypeDef]

def 

Definition_name

( self: Definition ) ( implicit  ctx: Context ) : String

def 

Definitions_AnyClass

: Symbol

def 

Definitions_AnyRefClass

: Symbol

def 

Definitions_AnyRefType

: Type

def 

Definitions_AnyType

: Type

def 

Definitions_AnyValClass

: Symbol

def 

Definitions_AnyValType

: Type

def 

Definitions_ArrayClass

: Symbol

def 

Definitions_ArrayModule

: Symbol

def 

Definitions_Array_apply

: Symbol

def 

Definitions_Array_clone

: Symbol

def 

Definitions_Array_length

: Symbol

def 

Definitions_Array_update

: Symbol

def 

Definitions_BooleanClass

: Symbol

def 

Definitions_BooleanType

: Type

def 

Definitions_ByteClass

: Symbol

def 

Definitions_ByteType

: Type

def 

Definitions_CharClass

: Symbol

def 

Definitions_CharType

: Type

def 

Definitions_ClassClass

: Symbol

def 

Definitions_DoubleClass

: Symbol

def 

Definitions_DoubleType

: Type

def 

Definitions_EmptyPackageClass

: Symbol

def 

Definitions_FloatClass

: Symbol

def 

Definitions_FloatType

: Type

def 

Definitions_FunctionClass

( arity: Int ,  isImplicit: Boolean ,  isErased: Boolean ) : Symbol

def 

Definitions_FunctionClass$default$2

: Boolean

def 

Definitions_FunctionClass$default$3

: Boolean

def 

Definitions_IntClass

: Symbol

def 

Definitions_IntType

: Type

def 

Definitions_InternalQuoted_fromAboveAnnot

: Symbol

Symbol of scala.internal.Quoted.fromAbove

Symbol of scala.internal.Quoted.fromAbove

def 

Definitions_InternalQuoted_patternBindHoleAnnot

: Symbol

Symbol of scala.internal.Quoted.patternBindHole

Symbol of scala.internal.Quoted.patternBindHole

def 

Definitions_InternalQuoted_patternHole

: Symbol

Symbol of scala.internal.Quoted.patternHole

Symbol of scala.internal.Quoted.patternHole

def 

Definitions_JavaLangPackage

: Symbol

def 

Definitions_LongClass

: Symbol

def 

Definitions_LongType

: Type

def 

Definitions_NoneModule

: Symbol

def 

Definitions_NothingClass

: Symbol

def 

Definitions_NothingType

: Type

def 

Definitions_NullClass

: Symbol

def 

Definitions_NullType

: Type

def 

Definitions_ObjectClass

: Symbol

def 

Definitions_ObjectType

: Type

def 

Definitions_OptionClass

: Symbol

def 

Definitions_PredefModule

: Symbol

def 

Definitions_Predef_classOf

: Symbol

def 

Definitions_ProductClass

: Symbol

def 

Definitions_RepeatedParamClass

: Symbol

def 

Definitions_RootClass

: Symbol

def 

Definitions_RootPackage

: Symbol

def 

Definitions_ScalaPackage

: Symbol

def 

Definitions_ScalaPackageClass

: Symbol

def 

Definitions_ShortClass

: Symbol

def 

Definitions_ShortType

: Type

def 

Definitions_SomeModule

: Symbol

def 

Definitions_StringClass

: Symbol

def 

Definitions_StringType

: Type

def 

Definitions_TupleClass

( arity: Int ) : Symbol

def 

Definitions_UnitClass

: Symbol

def 

Definitions_UnitType

: Type

def 

Definitions_isTupleClass

( sym: Symbol ) : Boolean

def 

Flags_Abstract

: Flags

def 

Flags_Artifact

: Flags

def 

Flags_Case

: Flags

def 

Flags_CaseAcessor

: Flags

def 

Flags_Contravariant

: Flags

def 

Flags_Covariant

: Flags

def 

Flags_DefaultParameterized

: Flags

def 

Flags_EmptyFlags

: Flags

def 

Flags_Enum

: Flags

def 

Flags_Erased

: Flags

def 

Flags_FieldAccessor

: Flags

def 

Flags_Final

: Flags

def 

Flags_Given

: Flags

def 

Flags_Implicit

: Flags

def 

Flags_Inline

: Flags

def 

Flags_JavaDefined

: Flags

def 

Flags_Lazy

: Flags

def 

Flags_Local

: Flags

def 

Flags_Macro

: Flags

def 

Flags_ModuleClass

: Flags

def 

Flags_Mutable

: Flags

def 

Flags_Object

: Flags

def 

Flags_Override

: Flags

def 

Flags_Package

: Flags

def 

Flags_Param

: Flags

def 

Flags_ParamAccessor

: Flags

def 

Flags_Private

: Flags

def 

Flags_PrivateLocal

: Flags

def 

Flags_Protected

: Flags

def 

Flags_Scala2X

: Flags

def 

Flags_Sealed

: Flags

def 

Flags_StableRealizable

: Flags

def 

Flags_Static

: Flags

def 

Flags_Synthetic

: Flags

def 

Flags_Trait

: Flags

def 

Flags_and

( self: Flags ) ( that: Flags ) : Flags

Intersection of the two flag sets

Intersection of the two flag sets

def 

Flags_is

( self: Flags ) ( that: Flags ) : Boolean

Is the given flag set a subset of this flag sets

Is the given flag set a subset of this flag sets

def 

Flags_or

( self: Flags ) ( that: Flags ) : Flags

Union of the two flag sets

Union of the two flag sets

def 

GivenMatch_apply

( cases: List[CaseDef] ) ( implicit  ctx: Context ) : GivenMatch

def 

GivenMatch_cases

( self: GivenMatch ) ( implicit  ctx: Context ) : List[CaseDef]

def 

GivenMatch_copy

( original: Tree ) ( cases: List[CaseDef] ) ( implicit  ctx: Context ) : GivenMatch

def 

Id_name

( self: Id ) ( implicit  ctx: Context ) : String

Name of the identifier

Name of the identifier

def 

Id_pos

( self: Id ) ( implicit  ctx: Context ) : Position

Position in the source code

Position in the source code

def 

Ident_apply

( tmref: TermRef ) ( implicit  ctx: Context ) : Term

def 

Ident_copy

( original: Tree ) ( name: String ) ( implicit  ctx: Context ) : Ident

def 

Ident_name

( self: Ident ) ( implicit  ctx: Context ) : String

def 

If_apply

( cond: Term ,  thenp: Term ,  elsep: Term ) ( implicit  ctx: Context ) : If

def 

If_cond

( self: If ) ( implicit  ctx: Context ) : Term

def 

If_copy

( original: Tree ) ( cond: Term ,  thenp: Term ,  elsep: Term ) ( implicit  ctx: Context ) : If

def 

If_elsep

( self: If ) ( implicit  ctx: Context ) : Term

def 

If_thenp

( self: If ) ( implicit  ctx: Context ) : Term

def 

ImplicitSearchFailure_explanation

( self: ImplicitSearchFailure ) ( implicit  ctx: Context ) : String

def 

ImplicitSearchSuccess_tree

( self: ImplicitSearchSuccess ) ( implicit  ctx: Context ) : Term

def 

Import_apply

( iexpr: Term ,  selectors: List[ImportSelector] ) ( implicit  ctx: Context ) : Import

def 

Import_copy

( original: Tree ) ( expr: Term ,  selectors: List[ImportSelector] ) ( implicit  ctx: Context ) : Import

def 

Import_expr

( self: Import ) ( implicit  ctx: Context ) : Term

def 

Import_implied

( self: Import ) : Boolean

def 

Import_selectors

( self: Import ) ( implicit  ctx: Context ) : List[ImportSelector]

def 

Inferred_apply

( tpe: Type ) ( implicit  ctx: Context ) : Inferred

def 

Inlined_apply

( call: Option[Tree] ,  bindings: List[Definition] ,  expansion: Term ) ( implicit  ctx: Context ) : Inlined

def 

Inlined_bindings

( self: Inlined ) ( implicit  ctx: Context ) : List[Definition]

def 

Inlined_body

( self: Inlined ) ( implicit  ctx: Context ) : Term

def 

Inlined_call

( self: Inlined ) ( implicit  ctx: Context ) : Option[Tree]

def 

Inlined_copy

( original: Tree ) ( call: Option[Tree] ,  bindings: List[Definition] ,  expansion: Term ) ( implicit  ctx: Context ) : Inlined

def 

Lambda_apply

( tpe: MethodType ,  rhsFn: List[Tree] => Tree ) ( implicit  ctx: Context ) : Block

def 

Lambdaapply

( tparams: List[TypeDef] ,  body: Tree ) ( implicit  ctx: Context ) : LambdaTypeTree

def 

Lambdabody

( self: LambdaTypeTree ) ( implicit  ctx: Context ) : Tree

def 

Lambdacopy

( original: Tree ) ( tparams: List[TypeDef] ,  body: Tree ) ( implicit  ctx: Context ) : LambdaTypeTree

def 

Lambdatparams

( self: LambdaTypeTree ) ( implicit  ctx: Context ) : List[TypeDef]

def 

Literal_apply

( constant: Constant ) ( implicit  ctx: Context ) : Literal

def 

Literal_constant

( self: Literal ) ( implicit  ctx: Context ) : Constant

def 

Literal_copy

( original: Tree ) ( constant: Constant ) ( implicit  ctx: Context ) : Literal

def 

MatchTypeTree_apply

( bound: Option[TypeTree] ,  selector: TypeTree ,  cases: List[TypeCaseDef] ) ( implicit  ctx: Context ) : MatchTypeTree

def 

MatchTypeTree_bound

( self: MatchTypeTree ) ( implicit  ctx: Context ) : Option[TypeTree]

def 

MatchTypeTree_cases

( self: MatchTypeTree ) ( implicit  ctx: Context ) : List[TypeCaseDef]

def 

MatchTypeTree_copy

( original: Tree ) ( bound: Option[TypeTree] ,  selector: TypeTree ,  cases: List[TypeCaseDef] ) ( implicit  ctx: Context ) : MatchTypeTree

def 

MatchTypeTree_selector

( self: MatchTypeTree ) ( implicit  ctx: Context ) : TypeTree

def 

MatchType_apply

( bound: Type ,  scrutinee: Type ,  cases: List[Type] ) ( implicit  ctx: Context ) : MatchType

def 

MatchType_bound

( self: MatchType ) ( implicit  ctx: Context ) : Type

def 

MatchType_cases

( self: MatchType ) ( implicit  ctx: Context ) : List[Type]

def 

MatchType_scrutinee

( self: MatchType ) ( implicit  ctx: Context ) : Type

def 

Match_apply

( selector: Term ,  cases: List[CaseDef] ) ( implicit  ctx: Context ) : Match

def 

Match_cases

( self: Match ) ( implicit  ctx: Context ) : List[CaseDef]

def 

Match_copy

( original: Tree ) ( selector: Term ,  cases: List[CaseDef] ) ( implicit  ctx: Context ) : Match

def 

Match_scrutinee

( self: Match ) ( implicit  ctx: Context ) : Term

def 

MethodType_apply

( paramNames: List[String] ) ( paramInfosExp: MethodType => List[Type] ,  resultTypeExp: MethodType => Type ) : MethodType

def 

MethodType_isErased

( self: MethodType ) : Boolean

def 

MethodType_isImplicit

( self: MethodType ) : Boolean

def 

MethodType_param

( self: MethodType ,  ids: Int ) ( implicit  ctx: Context ) : Type

def 

MethodType_paramNames

( self: MethodType ) ( implicit  ctx: Context ) : List[String]

def 

MethodType_paramTypes

( self: MethodType ) ( implicit  ctx: Context ) : List[Type]

def 

MethodType_resType

( self: MethodType ) ( implicit  ctx: Context ) : Type

def 

NamedArg_apply

( name: String ,  arg: Term ) ( implicit  ctx: Context ) : NamedArg

def 

NamedArg_copy

( original: Tree ) ( name: String ,  arg: Term ) ( implicit  ctx: Context ) : NamedArg

def 

NamedArg_name

( self: NamedArg ) ( implicit  ctx: Context ) : String

def 

NamedArg_value

( self: NamedArg ) ( implicit  ctx: Context ) : Term

def 

New_apply

( tpt: TypeTree ) ( implicit  ctx: Context ) : New

def 

New_copy

( original: Tree ) ( tpt: TypeTree ) ( implicit  ctx: Context ) : New

def 

New_tpt

( self: New ) ( implicit  ctx: Context ) : TypeTree

def 

OrType_apply

( lhs: Type ,  rhs: Type ) ( implicit  ctx: Context ) : OrType

def 

OrType_left

( self: OrType ) ( implicit  ctx: Context ) : Type

def 

OrType_right

( self: OrType ) ( implicit  ctx: Context ) : Type

def 

PackageClause_apply

( pid: Ref ,  stats: List[Tree] ) ( implicit  ctx: Context ) : PackageClause

def 

PackageClause_copy

( original: Tree ) ( pid: Ref ,  stats: List[Tree] ) ( implicit  ctx: Context ) : PackageClause

def 

PackageClause_pid

( self: PackageClause ) ( implicit  ctx: Context ) : Ref

def 

PackageClause_stats

( self: PackageClause ) ( implicit  ctx: Context ) : List[Tree]

def 

PackageDef_members

( self: PackageDef ) ( implicit  ctx: Context ) : List[Statement]

def 

PackageDef_owner

( self: PackageDef ) ( implicit  ctx: Context ) : PackageDef

def 

ParamRef_binder

( self: ParamRef ) ( implicit  ctx: Context ) : LambdaType[TypeOrBounds]

def 

ParamRef_paramNum

( self: ParamRef ) ( implicit  ctx: Context ) : Int

def 

PolyType_apply

( paramNames: List[String] ) ( paramBoundsExp: PolyType => List[TypeBounds] ,  resultTypeExp: PolyType => Type ) ( implicit  ctx: Context ) : PolyType

def 

PolyType_param

( self: PolyType ,  idx: Int ) ( implicit  ctx: Context ) : Type

def 

PolyType_paramBounds

( self: PolyType ) ( implicit  ctx: Context ) : List[TypeBounds]

def 

PolyType_paramNames

( self: PolyType ) ( implicit  ctx: Context ) : List[String]

def 

PolyType_resType

( self: PolyType ) ( implicit  ctx: Context ) : Type

def 

Position_end

( self: Position ) : Int

The end offset in the source file

The end offset in the source file

def 

Position_endColumn

( self: Position ) : Int

The end column in the source file

The end column in the source file

def 

Position_endLine

( self: Position ) : Int

The end line in the source file

The end line in the source file

def 

Position_exists

( self: Position ) : Boolean

Does this position exist

Does this position exist

def 

Position_sourceCode

( self: Position ) : String

Source code within the position

Source code within the position

def 

Position_sourceFile

( self: Position ) : SourceFile

Source file in which this position is located

Source file in which this position is located

def 

Position_start

( self: Position ) : Int

The start offset in the source file

The start offset in the source file

def 

Position_startColumn

( self: Position ) : Int

The start column in the source file

The start column in the source file

def 

Position_startLine

( self: Position ) : Int

The start line in the source file

The start line in the source file

def 

Projection_copy

( original: Tree ) ( qualifier: TypeTree ,  name: String ) ( implicit  ctx: Context ) : Projection

def 

Projection_name

( self: Projection ) ( implicit  ctx: Context ) : String

def 

Projection_qualifier

( self: Projection ) ( implicit  ctx: Context ) : TypeTree

def 

QuotedExpr_cast

[U] ( self: Expr[Nothing <: Any] ) ( implicit  tp: Type[U] ,  ctx: Context ) : Expr[U]

Checked cast to a quoted.Expr[U]

Checked cast to a quoted.Expr[U]

def 

QuotedExpr_seal

( self: Term ) ( implicit  ctx: Context ) : Expr[Any]

Convert Term to an quoted.Expr[Any]

Convert Term to an quoted.Expr[Any]

def 

QuotedExpr_unseal

( self: Expr[Nothing <: Any] ) ( implicit  ctx: Context ) : Term

View this expression quoted.Expr[_] as a Term

View this expression quoted.Expr[_] as a Term

def 

QuotedType_seal

( self: Type ) ( implicit  ctx: Context ) : Type[Nothing <: AnyKind]

Convert Type to an quoted.Type[_]

Convert Type to an quoted.Type[_]

def 

QuotedType_unseal

( self: Type[Nothing <: AnyKind] ) ( implicit  ctx: Context ) : TypeTree

View this expression quoted.Type[T] as a TypeTree

View this expression quoted.Type[T] as a TypeTree

def 

RecursiveThis_binder

( self: RecursiveThis ) ( implicit  ctx: Context ) : RecursiveType

def 

RecursiveThis_recThis

( self: RecursiveType ) ( implicit  ctx: Context ) : RecursiveThis

def 

RecursiveType_apply

( parentExp: RecursiveType => Type ) ( implicit  ctx: Context ) : RecursiveType

Create a RecType, normalizing its contents. This means:

  1. Nested Rec types on the type's spine are merged with the outer one.
  2. Any refinement of the form type T = z.T on the spine of the type where z refers to the created rec-type is replaced by type T. This avoids infinite recursions later when we try to follow these references.

Create a RecType, normalizing its contents. This means:

  1. Nested Rec types on the type's spine are merged with the outer one.
  2. Any refinement of the form type T = z.T on the spine of the type where z refers to the created rec-type is replaced by type T. This avoids infinite recursions later when we try to follow these references.
def 

RecursiveType_underlying

( self: RecursiveType ) ( implicit  ctx: Context ) : Type

def 

Ref_apply

( sym: Symbol ) ( implicit  ctx: Context ) : Ref

def 

Refined_copy

( original: Tree ) ( tpt: TypeTree ,  refinements: List[Definition] ) ( implicit  ctx: Context ) : Refined

def 

Refined_refinements

( self: Refined ) ( implicit  ctx: Context ) : List[Definition]

def 

Refined_tpt

( self: Refined ) ( implicit  ctx: Context ) : TypeTree

def 

Refinement_apply

( parent: Type ,  name: String ,  info: TypeOrBounds ) ( implicit  ctx: Context ) : Refinement

def 

Refinement_info

( self: Refinement ) ( implicit  ctx: Context ) : TypeOrBounds

def 

Refinement_name

( self: Refinement ) ( implicit  ctx: Context ) : String

def 

Refinement_parent

( self: Refinement ) ( implicit  ctx: Context ) : Type

def 

RenameSelector_from

( self: RenameSelector ) ( implicit  ctx: Context ) : Id

def 

RenameSelector_to

( self: RenameSelector ) ( implicit  ctx: Context ) : Id

def 

Repeated_apply

( elems: List[Term] ,  elemtpt: TypeTree ) ( implicit  ctx: Context ) : Repeated

def 

Repeated_copy

( original: Tree ) ( elems: List[Term] ,  elemtpt: TypeTree ) ( implicit  ctx: Context ) : Repeated

def 

Repeated_elems

( self: Repeated ) ( implicit  ctx: Context ) : List[Term]

def 

Repeated_elemtpt

( self: Repeated ) ( implicit  ctx: Context ) : TypeTree

def 

Return_apply

( expr: Term ) ( implicit  ctx: Context ) : Return

def 

Return_copy

( original: Tree ) ( expr: Term ) ( implicit  ctx: Context ) : Return

def 

Return_expr

( self: Return ) ( implicit  ctx: Context ) : Term

def 

SelectOuter_apply

( qualifier: Term ,  name: String ,  levels: Int ) ( implicit  ctx: Context ) : SelectOuter

def 

SelectOuter_copy

( original: Tree ) ( qualifier: Term ,  name: String ,  levels: Int ) ( implicit  ctx: Context ) : SelectOuter

def 

SelectOuter_level

( self: SelectOuter ) ( implicit  ctx: Context ) : Int

def 

SelectOuter_qualifier

( self: SelectOuter ) ( implicit  ctx: Context ) : Term

def 

Select_apply

( qualifier: Term ,  symbol: Symbol ) ( implicit  ctx: Context ) : Select

def 

Select_copy

( original: Tree ) ( qualifier: Term ,  name: String ) ( implicit  ctx: Context ) : Select

def 

Select_name

( self: Select ) ( implicit  ctx: Context ) : String

def 

Select_overloaded

( qualifier: Term ,  name: String ,  targs: List[Type] ,  args: List[Term] ) ( implicit  ctx: Context ) : Apply

def 

Select_qualifier

( self: Select ) ( implicit  ctx: Context ) : Term

def 

Select_signature

( self: Select ) ( implicit  ctx: Context ) : Option[Signature]

def 

Select_unique

( qualifier: Term ,  name: String ) ( implicit  ctx: Context ) : Select

def 

Settings_color

( self: Settings ) : Boolean

def 

Signature_paramSigs

( self: Signature ) : List[String | Int]

def 

Signature_resultSig

( self: Signature ) : String

def 

SimpleSelector_omitted

( self: OmitSelector ) ( implicit  ctx: Context ) : Id

def 

SimpleSelector_selection

( self: SimpleSelector ) ( implicit  ctx: Context ) : Id

def 

Singleton_apply

( ref: Term ) ( implicit  ctx: Context ) : Singleton

def 

Singleton_copy

( original: Tree ) ( ref: Term ) ( implicit  ctx: Context ) : Singleton

def 

Singleton_ref

( self: Singleton ) ( implicit  ctx: Context ) : Term

def 

SourceFile_content

( self: SourceFile ) : String

Content of a source file

Content of a source file

def 

SourceFile_jpath

( self: SourceFile ) : Path

Path to a source file

Path to a source file

def 

SuperType_apply

( thistpe: Type ,  supertpe: Type ) ( implicit  ctx: Context ) : SuperType

def 

SuperType_supertpe

( self: SuperType ) ( implicit  ctx: Context ) : Type

def 

SuperType_thistpe

( self: SuperType ) ( implicit  ctx: Context ) : Type

def 

Super_apply

( qual: Term ,  mix: Option[Id] ) ( implicit  ctx: Context ) : Super

def 

Super_copy

( original: Tree ) ( qual: Term ,  mix: Option[Id] ) ( implicit  ctx: Context ) : Super

def 

Super_id

( self: Super ) ( implicit  ctx: Context ) : Option[Id]

def 

Super_qualifier

( self: Super ) ( implicit  ctx: Context ) : Term

def 

Symbol_annots

( self: Symbol ) ( implicit  ctx: Context ) : List[Term]

Annotations attached to this symbol

Annotations attached to this symbol

def 

Symbol_caseFields

( self: Symbol ) ( implicit  ctx: Context ) : List[Symbol]

Fields of a case class type -- only the ones declared in primary constructor

Fields of a case class type -- only the ones declared in primary constructor

def 

Symbol_children

( self: Symbol ) ( implicit  ctx: Context ) : List[Symbol]

Case class or case object children of a sealed trait

Case class or case object children of a sealed trait

def 

Symbol_classMethod

( self: Symbol ) ( name: String ) ( implicit  ctx: Context ) : List[Symbol]

Get non-private named methods defined directly inside the class

Get non-private named methods defined directly inside the class

def 

Symbol_classMethods

( self: Symbol ) ( implicit  ctx: Context ) : List[Symbol]

Get all non-private methods defined directly inside the class, excluding constructors

Get all non-private methods defined directly inside the class, excluding constructors

def 

Symbol_comment

( self: Symbol ) ( implicit  ctx: Context ) : Option[Comment]

The comment of the symbol

The comment of the symbol

def 

Symbol_companionClass

( self: Symbol ) ( implicit  ctx: Context ) : Symbol

The symbol of the companion class

The symbol of the companion class

def 

Symbol_companionModule

( self: Symbol ) ( implicit  ctx: Context ) : Symbol

The symbol of the companion module

The symbol of the companion module

def 

Symbol_field

( self: Symbol ) ( name: String ) ( implicit  ctx: Context ) : Symbol

Field with the given name directly declared in the class

Field with the given name directly declared in the class

def 

Symbol_fields

( self: Symbol ) ( implicit  ctx: Context ) : List[Symbol]

Fields directly declared in the class

Fields directly declared in the class

def 

Symbol_flags

( self: Symbol ) ( implicit  ctx: Context ) : Flags

Flags of this symbol

Flags of this symbol

def 

Symbol_fullName

( self: Symbol ) ( implicit  ctx: Context ) : String

The full name of this symbol up to the root package.

The full name of this symbol up to the root package.

def 

Symbol_isAbstractType

( self: Symbol ) ( implicit  ctx: Context ) : Boolean

def 

Symbol_isAliasType

( self: Symbol ) ( implicit  ctx: Context ) : Boolean

def 

Symbol_isAnonymousClass

( self: Symbol ) ( implicit  ctx: Context ) : Boolean

def 

Symbol_isAnonymousFunction

( self: Symbol ) ( implicit  ctx: Context ) : Boolean

def 

Symbol_isBind

( symbol: Symbol ) ( implicit  ctx: Context ) : Boolean

Is this the definition of a Bind pattern?

Is this the definition of a Bind pattern?

def 

Symbol_isClassConstructor

( self: Symbol ) ( implicit  ctx: Context ) : Boolean

def 

Symbol_isClassDef

( symbol: Symbol ) ( implicit  ctx: Context ) : Boolean

Is this the definition of a ClassDef tree?

Is this the definition of a ClassDef tree?

def 

Symbol_isDefDef

( symbol: Symbol ) ( implicit  ctx: Context ) : Boolean

Is this the definition of a DefDef tree?

Is this the definition of a DefDef tree?

def 

Symbol_isDefinedInCurrentRun

( self: Symbol ) ( implicit  ctx: Context ) : Boolean

def 

Symbol_isLocalDummy

( self: Symbol ) ( implicit  ctx: Context ) : Boolean

def 

Symbol_isPackageDef

( symbol: Symbol ) ( implicit  ctx: Context ) : Boolean

def 

Symbol_isRefinementClass

( self: Symbol ) ( implicit  ctx: Context ) : Boolean

def 

Symbol_isTerm

( symbol: Symbol ) ( implicit  ctx: Context ) : Boolean

Is this the definition of a term?

Is this the definition of a term?

def 

Symbol_isType

( symbol: Symbol ) ( implicit  ctx: Context ) : Boolean

Is this the definition of a type?

Is this the definition of a type?

def 

Symbol_isTypeDef

( symbol: Symbol ) ( implicit  ctx: Context ) : Boolean

Is this the definition of a TypeDef tree?

Is this the definition of a TypeDef tree?

def 

Symbol_isTypeParam

( self: Symbol ) ( implicit  ctx: Context ) : Boolean

def 

Symbol_isValDef

( symbol: Symbol ) ( implicit  ctx: Context ) : Boolean

Is this the definition of a ValDef tree?

Is this the definition of a ValDef tree?

def 

Symbol_localContext

( self: Symbol ) ( implicit  ctx: Context ) : Context

def 

Symbol_maybeOwner

( self: Symbol ) ( implicit  ctx: Context ) : Symbol

Owner of this symbol. The owner is the symbol in which this symbol is defined. Returns NoSymbol if this symbol does not have an owner.

Owner of this symbol. The owner is the symbol in which this symbol is defined. Returns NoSymbol if this symbol does not have an owner.

def 

Symbol_method

( self: Symbol ) ( name: String ) ( implicit  ctx: Context ) : List[Symbol]

Get named non-private methods declared or inherited

Get named non-private methods declared or inherited

def 

Symbol_methods

( self: Symbol ) ( implicit  ctx: Context ) : List[Symbol]

Get all non-private methods declared or inherited

Get all non-private methods declared or inherited

def 

Symbol_moduleClass

( self: Symbol ) ( implicit  ctx: Context ) : Symbol

The class symbol of the companion module class

The class symbol of the companion module class

def 

Symbol_name

( self: Symbol ) ( implicit  ctx: Context ) : String

The name of this symbol.

The name of this symbol.

def 

Symbol_newMethod

( parent: Symbol ,  name: String ,  flags: Flags ,  tpe: Type ,  privateWithin: Symbol ) ( implicit  ctx: Context ) : Symbol

def 

Symbol_newVal

( parent: Symbol ,  name: String ,  flags: Flags ,  tpe: Type ,  privateWithin: Symbol ) ( implicit  ctx: Context ) : Symbol

def 

Symbol_noSymbol

( implicit  ctx: Context ) : Symbol

def 

Symbol_of

( fullName: String ) ( implicit  ctx: Context ) : Symbol

def 

Symbol_owner

( self: Symbol ) ( implicit  ctx: Context ) : Symbol

Owner of this symbol. The owner is the symbol in which this symbol is defined. Throws if this symbol does not have an owner.

Owner of this symbol. The owner is the symbol in which this symbol is defined. Throws if this symbol does not have an owner.

def 

Symbol_pos

( self: Symbol ) ( implicit  ctx: Context ) : Position

The position of this symbol

The position of this symbol

def 

Symbol_privateWithin

( self: Symbol ) ( implicit  ctx: Context ) : Option[Type]

This symbol is private within the resulting type.

This symbol is private within the resulting type.

def 

Symbol_protectedWithin

( self: Symbol ) ( implicit  ctx: Context ) : Option[Type]

This symbol is protected within the resulting type.

This symbol is protected within the resulting type.

def 

Symbol_signature

( self: Symbol ) ( implicit  ctx: Context ) : Signature

Signature of this definition

Signature of this definition

def 

Symbol_tree

( self: Symbol ) ( implicit  ctx: Context ) : Tree

def 

TermRef_apply

( qual: TypeOrBounds ,  name: String ) ( implicit  ctx: Context ) : TermRef

def 

TermRef_name

( self: TermRef ) ( implicit  ctx: Context ) : String

def 

TermRef_qualifier

( self: TermRef ) ( implicit  ctx: Context ) : TypeOrBounds

def 

Term_etaExpand

( term: Term ) ( implicit  ctx: Context ) : Term

def 

Term_tpe

( self: Term ) ( implicit  ctx: Context ) : Type

def 

Term_underlying

( self: Term ) ( implicit  ctx: Context ) : Term

def 

Term_underlyingArgument

( self: Term ) ( implicit  ctx: Context ) : Term

def 

ThisType_tref

( self: ThisType ) ( implicit  ctx: Context ) : Type

def 

This_apply

( cls: Symbol ) ( implicit  ctx: Context ) : This

def 

This_copy

( original: Tree ) ( qual: Option[Id] ) ( implicit  ctx: Context ) : This

def 

This_id

( self: This ) ( implicit  ctx: Context ) : Option[Id]

def 

Tree_Alternatives_module_apply

( patterns: List[Tree] ) ( implicit  ctx: Context ) : Alternatives

def 

Tree_Alternatives_module_copy

( original: Tree ) ( patterns: List[Tree] ) ( implicit  ctx: Context ) : Alternatives

def 

Tree_Alternatives_patterns

( self: Alternatives ) ( implicit  ctx: Context ) : List[Tree]

def 

Tree_Bind_module_copy

( original: Tree ) ( name: String ,  pattern: Tree ) ( implicit  ctx: Context ) : Bind

def 

Tree_Bind_name

( self: Bind ) ( implicit  ctx: Context ) : String

def 

Tree_Bind_pattern

( self: Bind ) ( implicit  ctx: Context ) : Tree

def 

Tree_Unapply_fun

( self: Unapply ) ( implicit  ctx: Context ) : Term

def 

Tree_Unapply_implicits

( self: Unapply ) ( implicit  ctx: Context ) : List[Term]

def 

Tree_Unapply_module_copy

( original: Tree ) ( fun: Term ,  implicits: List[Term] ,  patterns: List[Tree] ) ( implicit  ctx: Context ) : Unapply

def 

Tree_Unapply_patterns

( self: Unapply ) ( implicit  ctx: Context ) : List[Tree]

def 

Tree_pos

( self: Tree ) ( implicit  ctx: Context ) : Position

def 

Tree_symbol

( self: Tree ) ( implicit  ctx: Context ) : Symbol

def 

Try_apply

( expr: Term ,  cases: List[CaseDef] ,  finalizer: Option[Term] ) ( implicit  ctx: Context ) : Try

def 

Try_body

( self: Try ) ( implicit  ctx: Context ) : Term

def 

Try_cases

( self: Try ) ( implicit  ctx: Context ) : List[CaseDef]

def 

Try_copy

( original: Tree ) ( expr: Term ,  cases: List[CaseDef] ,  finalizer: Option[Term] ) ( implicit  ctx: Context ) : Try

def 

Try_finalizer

( self: Try ) ( implicit  ctx: Context ) : Option[Term]

def 

TypeApply_apply

( fn: Term ,  args: List[TypeTree] ) ( implicit  ctx: Context ) : TypeApply

def 

TypeApply_args

( self: TypeApply ) ( implicit  ctx: Context ) : List[TypeTree]

def 

TypeApply_copy

( original: Tree ) ( fun: Term ,  args: List[TypeTree] ) ( implicit  ctx: Context ) : TypeApply

def 

TypeApply_fun

( self: TypeApply ) ( implicit  ctx: Context ) : Term

def 

TypeBind_body

( self: TypeBind ) ( implicit  ctx: Context ) : Tree

def 

TypeBind_copy

( original: Tree ) ( name: String ,  tpt: Tree ) ( implicit  ctx: Context ) : TypeBind

def 

TypeBind_name

( self: TypeBind ) ( implicit  ctx: Context ) : String

def 

TypeBlock_aliases

( self: TypeBlock ) ( implicit  ctx: Context ) : List[TypeDef]

def 

TypeBlock_apply

( aliases: List[TypeDef] ,  tpt: TypeTree ) ( implicit  ctx: Context ) : TypeBlock

def 

TypeBlock_copy

( original: Tree ) ( aliases: List[TypeDef] ,  tpt: TypeTree ) ( implicit  ctx: Context ) : TypeBlock

def 

TypeBlock_tpt

( self: TypeBlock ) ( implicit  ctx: Context ) : TypeTree

def 

TypeBoundsTree_hi

( self: TypeBoundsTree ) ( implicit  ctx: Context ) : TypeTree

def 

TypeBoundsTree_low

( self: TypeBoundsTree ) ( implicit  ctx: Context ) : TypeTree

def 

TypeBoundsTree_tpe

( self: TypeBoundsTree ) ( implicit  ctx: Context ) : TypeBounds

def 

TypeBounds_apply

( low: Type ,  hi: Type ) ( implicit  ctx: Context ) : TypeBounds

def 

TypeBounds_hi

( self: TypeBounds ) ( implicit  ctx: Context ) : Type

def 

TypeBounds_low

( self: TypeBounds ) ( implicit  ctx: Context ) : Type

def 

TypeCaseDef_module_apply

( pattern: TypeTree ,  body: TypeTree ) ( implicit  ctx: Context ) : TypeCaseDef

def 

TypeCaseDef_module_copy

( original: Tree ) ( pattern: TypeTree ,  body: TypeTree ) ( implicit  ctx: Context ) : TypeCaseDef

def 

TypeCaseDef_pattern

( self: TypeCaseDef ) ( implicit  ctx: Context ) : TypeTree

def 

TypeCaseDef_rhs

( self: TypeCaseDef ) ( implicit  ctx: Context ) : TypeTree

def 

TypeDef_apply

( symbol: Symbol ) ( implicit  ctx: Context ) : TypeDef

def 

TypeDef_copy

( original: Tree ) ( name: String ,  rhs: Tree ) ( implicit  ctx: Context ) : TypeDef

def 

TypeDef_rhs

( self: TypeDef ) ( implicit  ctx: Context ) : Tree

def 

TypeIdent_copy

( original: Tree ) ( name: String ) ( implicit  ctx: Context ) : TypeIdent

def 

TypeIdent_name

( self: TypeIdent ) ( implicit  ctx: Context ) : String

def 

TypeLambda_apply

( paramNames: List[String] ,  boundsFn: TypeLambda => List[TypeBounds] ,  bodyFn: TypeLambda => Type ) : TypeLambda

def 

TypeLambda_param

( self: TypeLambda ,  idx: Int ) ( implicit  ctx: Context ) : Type

def 

TypeLambda_paramBounds

( self: TypeLambda ) ( implicit  ctx: Context ) : List[TypeBounds]

def 

TypeLambda_paramNames

( self: TypeLambda ) ( implicit  ctx: Context ) : List[String]

def 

TypeLambda_resType

( self: TypeLambda ) ( implicit  ctx: Context ) : Type

def 

TypeRef_apply

( sym: Symbol ) ( implicit  ctx: Context ) : TypeTree

def 

TypeRef_isOpaqueAlias

( self: TypeRef ) ( implicit  ctx: Context ) : Boolean

def 

TypeRef_name

( self: TypeRef ) ( implicit  ctx: Context ) : String

def 

TypeRef_qualifier

( self: TypeRef ) ( implicit  ctx: Context ) : TypeOrBounds

def 

TypeRef_translucentSuperType

( self: TypeRef ) ( implicit  ctx: Context ) : Type

def 

TypeSelect_apply

( qualifier: Term ,  name: String ) ( implicit  ctx: Context ) : TypeSelect

def 

TypeSelect_copy

( original: Tree ) ( qualifier: Term ,  name: String ) ( implicit  ctx: Context ) : TypeSelect

def 

TypeSelect_name

( self: TypeSelect ) ( implicit  ctx: Context ) : String

def 

TypeSelect_qualifier

( self: TypeSelect ) ( implicit  ctx: Context ) : Term

def 

TypeTree_tpe

( self: TypeTree ) ( implicit  ctx: Context ) : Type

def 

Type_apply

( clazz: Class[Nothing <: Any] ) ( implicit  ctx: Context ) : Type

def 

Type_classSymbol

( self: Type ) ( implicit  ctx: Context ) : Option[Symbol]

def 

Type_dealias

( self: Type ) ( implicit  ctx: Context ) : Type

Follow aliases and dereferences LazyRefs, annotated types and instantiated TypeVars until type is no longer alias type, annotated type, LazyRef, or inst...

Follow aliases and dereferences LazyRefs, annotated types and instantiated TypeVars until type is no longer alias type, annotated type, LazyRef, or instantiated type variable.

def 

Type_derivesFrom

( self: Type ) ( cls: Symbol ) ( implicit  ctx: Context ) : Boolean

Is this type an instance of a non-bottom subclass of the given class cls?

Is this type an instance of a non-bottom subclass of the given class cls?

def 

Type_isContextFunctionType

( self: Type ) ( implicit  ctx: Context ) : Boolean

Is this type an context function type?

Is this type an context function type?

def 

Type_isDependentFunctionType

( self: Type ) ( implicit  ctx: Context ) : Boolean

Is this type a dependent function type?

Is this type a dependent function type?

def 

Type_isErasedFunctionType

( self: Type ) ( implicit  ctx: Context ) : Boolean

Is this type an erased function type?

Is this type an erased function type?

def 

Type_isFunctionType

( self: Type ) ( implicit  ctx: Context ) : Boolean

Is this type a function type?

Is this type a function type?

def 

Type_isSingleton

( self: Type ) ( implicit  ctx: Context ) : Boolean

def 

Type_isSubType

( self: Type ) ( that: Type ) ( implicit  ctx: Context ) : Boolean

Is this type a subtype of that type?

Is this type a subtype of that type?

def 

Type_isTypeEq

( self: Type ) ( that: Type ) ( implicit  ctx: Context ) : Boolean

Is self type the same as that type? This is the case iff Type_isSubType(self, that) and Type_isSubType(that, self).

Is self type the same as that type? This is the case iff Type_isSubType(self, that) and Type_isSubType(that, self).

def 

Type_memberType

( self: Type ) ( member: Symbol ) ( implicit  ctx: Context ) : Type

def 

Type_simplified

( self: Type ) ( implicit  ctx: Context ) : Type

def 

Type_termSymbol

( self: Type ) ( implicit  ctx: Context ) : Symbol

def 

Type_typeSymbol

( self: Type ) ( implicit  ctx: Context ) : Symbol

def 

Type_widen

( self: Type ) ( implicit  ctx: Context ) : Type

Widen from singleton type to its underlying non-singleton base type by applying one or more underlying dereferences, Also go from => T to T. Identity for...

Widen from singleton type to its underlying non-singleton base type by applying one or more underlying dereferences, Also go from => T to T. Identity for all other types. Example:

class Outer { class C ; val x: C } def o: Outer <o.x.type>.widen = o.C

def 

Type_widenTermRefExpr

( self: Type ) ( implicit  ctx: Context ) : Type

Widen from TermRef to its underlying non-termref base type, while also skipping Expr types.

Widen from TermRef to its underlying non-termref base type, while also skipping Expr types.

def 

Typed_apply

( expr: Term ,  tpt: TypeTree ) ( implicit  ctx: Context ) : Typed

def 

Typed_copy

( original: Tree ) ( expr: Term ,  tpt: TypeTree ) ( implicit  ctx: Context ) : Typed

def 

Typed_expr

( self: Typed ) ( implicit  ctx: Context ) : Term

def 

Typed_tpt

( self: Typed ) ( implicit  ctx: Context ) : TypeTree

def 

ValDef_apply

( symbol: Symbol ,  rhs: Option[Term] ) ( implicit  ctx: Context ) : ValDef

def 

ValDef_copy

( original: Tree ) ( name: String ,  tpt: TypeTree ,  rhs: Option[Term] ) ( implicit  ctx: Context ) : ValDef

def 

ValDef_rhs

( self: ValDef ) ( implicit  ctx: Context ) : Option[Term]

def 

ValDef_tpt

( self: ValDef ) ( implicit  ctx: Context ) : TypeTree

def 

While_apply

( cond: Term ,  body: Term ) ( implicit  ctx: Context ) : While

def 

While_body

( self: While ) ( implicit  ctx: Context ) : Term

def 

While_cond

( self: While ) ( implicit  ctx: Context ) : Term

def 

While_copy

( original: Tree ) ( cond: Term ,  body: Term ) ( implicit  ctx: Context ) : While

def 

WildcardTypeTree_tpe

( self: WildcardTypeTree ) ( implicit  ctx: Context ) : TypeOrBounds

def 

betaReduce

( f: Term ,  args: List[Term] ) ( implicit  ctx: Context ) : Term

Inline fn if it is an explicit closure possibly nested inside the expression of a block. Otherwise apply the arguments to the closure.

Inline fn if it is an explicit closure possibly nested inside the expression of a block. Otherwise apply the arguments to the closure.

def 

error

( msg: => String ,  pos: Position ) ( implicit  ctx: Context ) : Unit

Report a compilation error with the given message at the given position

Report a compilation error with the given message at the given position

def 

error

( msg: => String ,  source: SourceFile ,  start: Int ,  end: Int ) ( implicit  ctx: Context ) : Unit

Report a compilation error with the given message at the given position range

Report a compilation error with the given message at the given position range

def 

isInstanceOfAlternatives

( implicit  ctx: Context ) : ClassTag[Alternatives]

def 

isInstanceOfAmbiguousImplicits

( implicit  ctx: Context ) : ClassTag[AmbiguousImplicits]

def 

isInstanceOfAndType

( implicit  ctx: Context ) : ClassTag[AndType]

def 

isInstanceOfAnnotated

( implicit  ctx: Context ) : ClassTag[Annotated]

def 

isInstanceOfAnnotatedType

( implicit  ctx: Context ) : ClassTag[AnnotatedType]

def 

isInstanceOfApplied

( implicit  ctx: Context ) : ClassTag[Applied]

def 

isInstanceOfAppliedType

( implicit  ctx: Context ) : ClassTag[AppliedType]

def 

isInstanceOfApply

( implicit  ctx: Context ) : ClassTag[Apply]

def 

isInstanceOfAssign

( implicit  ctx: Context ) : ClassTag[Assign]

def 

isInstanceOfBind

( implicit  ctx: Context ) : ClassTag[Bind]

def 

isInstanceOfBlock

( implicit  ctx: Context ) : ClassTag[Block]

def 

isInstanceOfByName

( implicit  ctx: Context ) : ClassTag[ByName]

def 

isInstanceOfByNameType

( implicit  ctx: Context ) : ClassTag[ByNameType]

def 

isInstanceOfCaseDef

( implicit  ctx: Context ) : ClassTag[CaseDef]

def 

isInstanceOfClassDef

( implicit  ctx: Context ) : ClassTag[ClassDef]

def 

isInstanceOfClosure

( implicit  ctx: Context ) : ClassTag[Closure]

def 

isInstanceOfConstantType

( implicit  ctx: Context ) : ClassTag[ConstantType]

def 

isInstanceOfDefDef

( implicit  ctx: Context ) : ClassTag[DefDef]

def 

isInstanceOfDefinition

( implicit  ctx: Context ) : ClassTag[Definition]

def 

isInstanceOfDivergingImplicit

( implicit  ctx: Context ) : ClassTag[DivergingImplicit]

def 

isInstanceOfGivenMatch

( implicit  ctx: Context ) : ClassTag[GivenMatch]

def 

isInstanceOfIdent

( implicit  ctx: Context ) : ClassTag[Ident]

def 

isInstanceOfIf

( implicit  ctx: Context ) : ClassTag[If]

def 

isInstanceOfImplicitSearchFailure

( implicit  ctx: Context ) : ClassTag[ImplicitSearchFailure]

def 

isInstanceOfImplicitSearchSuccess

( implicit  ctx: Context ) : ClassTag[ImplicitSearchSuccess]

def 

isInstanceOfImport

( implicit  ctx: Context ) : ClassTag[Import]

def 

isInstanceOfInferred

( implicit  ctx: Context ) : ClassTag[Inferred]

def 

isInstanceOfInlined

( implicit  ctx: Context ) : ClassTag[Inlined]

def 

isInstanceOfLambdaTypeTree

( implicit  ctx: Context ) : ClassTag[LambdaTypeTree]

def 

isInstanceOfLiteral

( implicit  ctx: Context ) : ClassTag[Literal]

def 

isInstanceOfMatch

( implicit  ctx: Context ) : ClassTag[Match]

def 

isInstanceOfMatchType

( implicit  ctx: Context ) : ClassTag[MatchType]

def 

isInstanceOfMatchTypeTree

( implicit  ctx: Context ) : ClassTag[MatchTypeTree]

def 

isInstanceOfMethodType

( implicit  ctx: Context ) : ClassTag[MethodType]

def 

isInstanceOfNamedArg

( implicit  ctx: Context ) : ClassTag[NamedArg]

def 

isInstanceOfNew

( implicit  ctx: Context ) : ClassTag[New]

def 

isInstanceOfNoMatchingImplicits

( implicit  ctx: Context ) : ClassTag[NoMatchingImplicits]

def 

isInstanceOfNoPrefix

( implicit  ctx: Context ) : ClassTag[NoPrefix]

def 

isInstanceOfOmitSelector

( implicit  ctx: Context ) : ClassTag[OmitSelector]

def 

isInstanceOfOrType

( implicit  ctx: Context ) : ClassTag[OrType]

def 

isInstanceOfPackageClause

( implicit  ctx: Context ) : ClassTag[PackageClause]

def 

isInstanceOfPackageDef

( implicit  ctx: Context ) : ClassTag[PackageDef]

def 

isInstanceOfParamRef

( implicit  ctx: Context ) : ClassTag[ParamRef]

def 

isInstanceOfPolyType

( implicit  ctx: Context ) : ClassTag[PolyType]

def 

isInstanceOfProjection

( implicit  ctx: Context ) : ClassTag[Projection]

def 

isInstanceOfRecursiveThis

( implicit  ctx: Context ) : ClassTag[RecursiveThis]

def 

isInstanceOfRecursiveType

( implicit  ctx: Context ) : ClassTag[RecursiveType]

def 

isInstanceOfRef

( implicit  ctx: Context ) : ClassTag[Ref]

def 

isInstanceOfRefined

( implicit  ctx: Context ) : ClassTag[Refined]

def 

isInstanceOfRefinement

( implicit  ctx: Context ) : ClassTag[Refinement]

def 

isInstanceOfRenameSelector

( implicit  ctx: Context ) : ClassTag[RenameSelector]

def 

isInstanceOfRepeated

( implicit  ctx: Context ) : ClassTag[Repeated]

def 

isInstanceOfReturn

( implicit  ctx: Context ) : ClassTag[Return]

def 

isInstanceOfSelect

( implicit  ctx: Context ) : ClassTag[Select]

def 

isInstanceOfSelectOuter

( implicit  ctx: Context ) : ClassTag[SelectOuter]

def 

isInstanceOfSimpleSelector

( implicit  ctx: Context ) : ClassTag[SimpleSelector]

def 

isInstanceOfSingleton

( implicit  ctx: Context ) : ClassTag[Singleton]

def 

isInstanceOfStatement

( implicit  ctx: Context ) : ClassTag[Statement]

def 

isInstanceOfSuper

( implicit  ctx: Context ) : ClassTag[Super]

def 

isInstanceOfSuperType

( implicit  ctx: Context ) : ClassTag[SuperType]

def 

isInstanceOfTerm

( implicit  ctx: Context ) : ClassTag[Term]

def 

isInstanceOfTermRef

( implicit  ctx: Context ) : ClassTag[TermRef]

def 

isInstanceOfThis

( implicit  ctx: Context ) : ClassTag[This]

def 

isInstanceOfThisType

( implicit  ctx: Context ) : ClassTag[ThisType]

def 

isInstanceOfTry

( implicit  ctx: Context ) : ClassTag[Try]

def 

isInstanceOfType

( implicit  ctx: Context ) : ClassTag[Type]

def 

isInstanceOfTypeApply

( implicit  ctx: Context ) : ClassTag[TypeApply]

def 

isInstanceOfTypeBind

( implicit  ctx: Context ) : ClassTag[TypeBind]

def 

isInstanceOfTypeBlock

( implicit  ctx: Context ) : ClassTag[TypeBlock]

def 

isInstanceOfTypeBounds

( implicit  ctx: Context ) : ClassTag[TypeBounds]

def 

isInstanceOfTypeBoundsTree

( implicit  ctx: Context ) : ClassTag[TypeBoundsTree]

def 

isInstanceOfTypeCaseDef

( implicit  ctx: Context ) : ClassTag[TypeCaseDef]

def 

isInstanceOfTypeDef

( implicit  ctx: Context ) : ClassTag[TypeDef]

def 

isInstanceOfTypeIdent

( implicit  ctx: Context ) : ClassTag[TypeIdent]

def 

isInstanceOfTypeLambda

( implicit  ctx: Context ) : ClassTag[TypeLambda]

def 

isInstanceOfTypeRef

( implicit  ctx: Context ) : ClassTag[TypeRef]

def 

isInstanceOfTypeSelect

( implicit  ctx: Context ) : ClassTag[TypeSelect]

def 

isInstanceOfTypeTree

( implicit  ctx: Context ) : ClassTag[TypeTree]

def 

isInstanceOfTyped

( implicit  ctx: Context ) : ClassTag[Typed]

def 

isInstanceOfUnapply

( implicit  ctx: Context ) : ClassTag[Unapply]

def 

isInstanceOfValDef

( implicit  ctx: Context ) : ClassTag[ValDef]

def 

isInstanceOfWhile

( implicit  ctx: Context ) : ClassTag[While]

def 

isInstanceOfWildcardTypeTree

( implicit  ctx: Context ) : ClassTag[WildcardTypeTree]

def 

lambdaExtractor

( term: Term ,  paramTypes: List[Type] ) ( implicit  ctx: Context ) : Option[List[Term] => Term]

def 

matchConstant

( constant: Constant ) : Option[Unit | Null | Int | Boolean | Byte | Short | Int | Long | Float | Double | Char | String | Type]

def 

matchConstant_ClassTag

( constant: Constant ) : Option[Type]

def 

rootContext

: Context

Context of the macro expansion

Context of the macro expansion

def 

rootPosition

: Position

Root position of this tasty context. For macros it corresponds to the expansion site.

Root position of this tasty context. For macros it corresponds to the expansion site.

def 

searchImplicit

( tpe: Type ) ( implicit  ctx: Context ) : ImplicitSearchResult

Find an implicit of type T in the current scope given by ctx. Return an ImplicitSearchResult.

Find an implicit of type T in the current scope given by ctx. Return an ImplicitSearchResult.

def 

settings

: Settings

def 

unpickleExpr

( repr: PickledQuote ,  args: PickledArgs ) : Expr[Nothing <: Any]

Unpickle repr which represents a pickled Expr tree, replacing splice nodes with args

Unpickle repr which represents a pickled Expr tree, replacing splice nodes with args

def 

unpickleType

( repr: PickledQuote ,  args: PickledArgs ) : Type[Nothing <: AnyKind]

Unpickle repr which represents a pickled Type tree, replacing splice nodes with args

Unpickle repr which represents a pickled Type tree, replacing splice nodes with args

def 

warning

( msg: => String ,  pos: Position ) ( implicit  ctx: Context ) : Unit

Report a compilation warning with the given message at the given position

Report a compilation warning with the given message at the given position

def 

warning

( msg: => String ,  source: SourceFile ,  start: Int ,  end: Int ) ( implicit  ctx: Context ) : Unit

Report a compilation warning with the given message at the given position range

Report a compilation warning with the given message at the given position range