Dotty Documentation

0.17.0-bin-SNAPSHOT

trait Core
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
         |                             +- ImpliedMatch
         |                             +- Try
         |                             +- Return
         |                             +- Repeated
         |                             +- Inlined
         |                             +- SelectOuter
         |                             +- While
         |
         |
         +- TypeTree ----+- Inferred
         |               +- TypeIdent
         |               +- TypeSelect
         |               +- Projection
         |               +- Singleton
         |               +- Refined
         |               +- Applied
         |               +- Annotated
         |               +- MatchTypeTree
         |               +- ByName
         |               +- LambdaTypeTree
         |               +- TypeBind
         |               +- TypeBlock
         |
         +- TypeBoundsTree
         +- WildcardTypeTree
         +- CaseDef
         +- TypeCaseDef

+- Pattern --+- Value
             +- Bind
             +- Unapply
             +- Alternatives
             +- TypeTest
             +- WildcardPattern


                 +- NoPrefix
+- TypeOrBounds -+- TypeBounds
                 |
                 +- Type -------+- ConstantType
                                +- SymRef
                                +- 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 --+- PackageDefSymbol
            |
            +- TypeSymbol -+- ClassDefSymbol
            |              +- TypeDefSymbol
            |              +- TypeBindSymbol
            |
            +- TermSymbol -+- DefDefSymbol
            |              +- ValDefSymbol
            |              +- BindSymbol
            |
            +- NoSymbol

+- Flags

[-] Constructors

[-] Members

[+] type Alternatives = Alternatives

Pattern representing X | Y | ... alternatives.

[+] type AmbiguousImplicits = AmbiguousImplicits
[+] type AndType = AndType

Intersection type T & U

[+] type Annotated = Annotated

Type tree representing an annotated type

[+] type AnnotatedType = AnnotatedType

A type with an anottation T @foo

[+] type Applied = Applied

Type tree representing a type application

[+] type AppliedType = AppliedType

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

[+] type Apply = Apply

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

[+] type Assign = Assign

Tree representing an assignment x = y in the source code

[+] type Bind = Bind

Pattern representing a _ @ _ binding.

[+] type BindSymbol = BindSymbol

Symbol representing a bind definition.

[+] type Block = Block

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

[+] type ByName = ByName

Type tree representing a by name parameter

[+] type ByNameType = ByNameType

Type of a by by name parameter

[+] type CaseDef = CaseDef

Branch of a pattern match or catch clause

[+] type ClassDef = ClassDef

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

[+] type ClassDefSymbol = ClassDefSymbol

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

[+] type Closure = Closure

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

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

[+] type Comment = Comment

Comment

[+] type Constant = Constant

Constant value represented as the constant itself

[+] type ConstantType = ConstantType

A singleton type representing a known constant value

[+] type Context = Context

Compilation context

[+] type DefDef = DefDef

Tree representing a method definition in the source code

[+] type DefDefSymbol = DefDefSymbol

Symbol representing a method definition.

[+] type Definition = Definition

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

[+] type DivergingImplicit = DivergingImplicit
[+] type Flags = Flags

FlagSet of a Symbol

[+] type Id = Id

Untyped identifier

[+] type Ident = Ident

Tree representing a reference to definition with a given name

[+] type If = If

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

[+] type ImplicitSearchFailure = ImplicitSearchFailure
[+] type ImplicitSearchResult = ImplicitSearchResult
[+] type ImplicitSearchSuccess = ImplicitSearchSuccess
[+] type ImpliedMatch = ImpliedMatch

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

[+] type Import = Import

Tree representing an import in the source code

[+] type ImportSelector = ImportSelector

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

[+] type Inferred = Inferred

Type tree representing an inferred type

[+] type Inlined = Inlined

Tree representing the scope of an inlined tree

[+] type LambdaType = LambdaType [ ParamInfo ]

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

[+] type LambdaTypeTree = LambdaTypeTree

Type tree representing a lambda abstraction type

[+] type Literal = Literal

Tree representing a literal value in the source code

[+] type Match = Match

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

[+] type MatchType = MatchType

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

[+] type MatchTypeTree = MatchTypeTree

Type tree representing a type match

[+] type MethodType = MethodType

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

[+] type NamedArg = NamedArg

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

[+] type New = New

Tree representing new in the source code

[+] type NoMatchingImplicits = NoMatchingImplicits
[+] type NoPrefix = NoPrefix

NoPrefix for a type selection

[+] type NoSymbol = NoSymbol

No symbol available.

[+] type OmitSelector = OmitSelector
[+] type OrType = OrType

Union type T | U

[+] type PackageClause = PackageClause

Tree representing a pacakage clause in the source code

[+] type PackageDef = PackageDef

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

[+] type PackageDefSymbol = PackageDefSymbol

Symbol of a package definition

[+] type ParamRef = ParamRef

Type of a parameter reference

[+] type Pattern = Pattern

Pattern tree of the pattern part of a CaseDef

[+] type PolyType = PolyType

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

[+] type Position = Position

Position in a source file

[+] type Projection = Projection

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

[+] type RecursiveThis = RecursiveThis

A type that is recursively defined this

[+] type RecursiveType = RecursiveType

A type that is recursively defined

[+] type Ref = Ref

Tree representing a reference to definition

[+] type Refined = Refined

Type tree representing a type refinement

[+] type Refinement = Refinement

A type with a type refinement T { type U }

[+] type RenameSelector = RenameSelector
[+] type Repeated = Repeated

Tree representing a variable argument list in the source code

[+] type Return = Return

Tree representing a return in the source code

[+] type Select = Select

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

[+] type SelectOuter = SelectOuter

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

[+] type Settings = Settings

Settings

[+] type Signature = Signature

JVM signature of a method

[+] type SimpleSelector = SimpleSelector
[+] type Singleton = Singleton

Type tree representing a singleton type

[+] type SourceFile = SourceFile

Scala source file

[+] type Statement = Statement

Tree representing a statement in the source code

[+] type Super = Super

Tree representing super in the source code

[+] type SuperType = SuperType

Type of a super refernce

[+] type SymRef = SymRef

Type of a reference to a symbol

[+] type Symbol = Symbol

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

[+] type Term = Term

Tree representing an expression in the source code

[+] type TermRef = TermRef

Type of a reference to a term

[+] type TermSymbol = TermSymbol

Symbol representing a term definition.

[+] type This = This

Tree representing this in the source code

[+] type ThisType = ThisType

Type of this

[+] type Tree = Tree

Tree representing code written in the source

[+] type Try = Try

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

[+] type Type = Type

A type

[+] type TypeApply = TypeApply

Tree an application of type arguments

[+] type TypeBind = TypeBind

Type tree representing a type binding

[+] type TypeBindSymbol = TypeBindSymbol

Symbol representing a type bind definition.

[+] type TypeBlock = TypeBlock

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

[+] type TypeBounds = TypeBounds

Type bounds

[+] type TypeBoundsTree = TypeBoundsTree

Type tree representing a type bound written in the source

[+] type TypeCaseDef = TypeCaseDef

Branch of a type pattern match

[+] type TypeDef = TypeDef

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

[+] type TypeDefSymbol = TypeDefSymbol

Symbol of a type (parameter or member) definition.

[+] type TypeIdent = TypeIdent

Type tree representing a reference to definition with a given name

[+] type TypeLambda = 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 = TypeOrBounds

Type or bounds

[+] type TypeRef = TypeRef

Type of a reference to a type

[+] type TypeSelect = TypeSelect

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

[+] type TypeSymbol = TypeSymbol

Symbol representing a type definition.

[+] type TypeTest = TypeTest

Pattern representing a x: Y type test.

[+] type TypeTree = TypeTree

Type tree representing a type written in the source

[+] type Typed = Typed

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

[+] type Unapply = Unapply

Pattern representing a Xyz(...) unapply.

[+] type ValDef = ValDef

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

[+] type ValDefSymbol = ValDefSymbol

Symbol representing a value definition. This includes val, lazy val, var, object and parameter definitions.

[+] type Value = Value

Pattern representing a value. This includes 1, x and _

[+] type While = While

Tree representing a while loop

[+] type WildcardPattern = WildcardPattern

Pattern representing a _ pattern

[+] type WildcardTypeTree = WildcardTypeTree

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

[+] val kernel : Kernel