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 (paramter or member) definition in the source code

Tree representing a type (paramter 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_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_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_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_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_owner

( self: Context ) : Symbol

Returns the owner of the context

Returns the owner of the context

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 

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