final object untpd
extends Instance with UntypedTreeInfo

Constructors

Members

case class ContextBounds
final object ContextBounds
abstract class DerivedTypeTree

A type tree that gets its type from some other tree's symbol. Enters the type tree in the References attachment of the from tree as a side effect.

A type tree that gets its type from some other tree's symbol. Enters the type tree in the References attachment of the from tree as a side effect.

case class DoWhile
final object DoWhile
@sharable final object EmptyTypeIdent
case class ForDo
final object ForDo
case class ForYield
final object ForYield
case class Function
final object Function
case class GenAlias
final object GenAlias
case class GenFrom
final object GenFrom
class ImplicitFunction

An implicit function type

An implicit function type

case class InfixOp
final object InfixOp
class InfixOpBlock

A block arising from a right-associative infix operation, where, e.g.

a +: b

is expanded to

{ val x = a; b.+:(x) }

A block arising from a right-associative infix operation, where, e.g.

a +: b

is expanded to

{ val x = a; b.+:(x) }

case class InterpolatedString

An interpolated string

An interpolated string

final object InterpolatedString

An interpolated string

An interpolated string

[+] sealed abstract class Mod

Mod is intended to record syntactic information about modifiers, it's NOT a replacement of FlagSet.

For any query about semantic information, check flag...

Mod is intended to record syntactic information about modifiers, it's NOT a replacement of FlagSet.

For any query about semantic information, check flags instead.

final object Mod
case class Modifiers

Modifiers and annotations for definitions

Modifiers and annotations for definitions

final object Modifiers

Modifiers and annotations for definitions

Modifiers and annotations for definitions

abstract class ModsDecorator
case class ModuleDef

mods object name impl

mods object name impl

final object ModuleDef

mods object name impl

mods object name impl

trait OpTree
case class Parens
final object Parens
case class ParsedTry
final object ParsedTry
case class PatDef
final object PatDef
case class PostfixOp
final object PostfixOp
case class PrefixOp
final object PrefixOp
case class SymbolLit
final object SymbolLit
case class Throw
final object Throw
case class Tuple
final object Tuple
abstract case class TypedSplice

A typed subtree of an untyped tree needs to be wrapped in a TypedSlice

A typed subtree of an untyped tree needs to be wrapped in a TypedSlice

final object TypedSplice
class UntypedDeepFolder

Fold f over all tree nodes, in depth-first, prefix order

Fold f over all tree nodes, in depth-first, prefix order

abstract class UntypedTreeAccumulator
class UntypedTreeCopier
abstract class UntypedTreeMap
final object UntypedTreeMap
case class WhileDo
final object WhileDo
class WildcardFunction

A function created from a wildcard expression

A function created from a wildcard expression

class modsDeco
@sharable val EmptyModifiers : Modifiers
val OriginalSymbol : Key [ Symbol ]

Property key for TypeTrees marked with TypeRefOfSym or InfoOfSym which contains the symbol of the original tree from which this TypeTree is derived.

Property key for TypeTrees marked with TypeRefOfSym or InfoOfSym which contains the symbol of the original tree from which this TypeTree is derived.

[+] val References : Key [ List [ Tree ] ]

Property key containing TypeTrees whose type is computed from the symbol in this type. These type trees have marker trees TypeRefOfSym or InfoOfSym as t...

Property key containing TypeTrees whose type is computed from the symbol in this type. These type trees have marker trees TypeRefOfSym or InfoOfSym as their originals.

override val cpy : UntypedTreeCopier
def Alternative ( trees: List [ Tree ] ) : Alternative
def AndTypeTree ( left: Tree , right: Tree ) : AndTypeTree
def Annotated ( arg: Tree , annot: Tree ) : Annotated
def AppliedTypeTree ( tpt: Tree , args: List [ Tree ] ) : AppliedTypeTree
def AppliedTypeTree ( tpt: Tree , arg: Tree ) : AppliedTypeTree
def Apply ( fun: Tree , args: List [ Tree ] ) : Apply
def Apply ( fn: Tree , arg: Tree ) : Apply
def Assign ( lhs: Tree , rhs: Tree ) : Assign
def BackquotedIdent ( name: Name ) : BackquotedIdent
def Bind ( name: Name , body: Tree ) : Bind
def Block ( stats: List [ Tree ] , expr: Tree ) : Block
def Block ( stat: Tree , expr: Tree ) : Block
def ByNameTypeTree ( result: Tree ) : ByNameTypeTree
def CaseDef ( pat: Tree , guard: Tree , body: Tree ) : CaseDef
def Closure ( env: List [ Tree ] , meth: Tree , tpt: Tree ) : Closure
def DefDef ( name: TermName , tparams: List [ TypeDef ] , vparamss: List [ List [ ValDef ] ] , tpt: Tree , rhs: LazyTree ) : DefDef
def Ident ( name: Name ) : Ident
def If ( cond: Tree , thenp: Tree , elsep: Tree ) : If
def Import ( expr: Tree , selectors: List [ Tree ] ) : Import
def Inlined ( call: Tree , bindings: List [ MemberDef ] , expansion: Tree ) : Inlined
def JavaSeqLiteral ( elems: List [ Tree ] , elemtpt: Tree ) : JavaSeqLiteral
def LambdaTypeTree ( tparams: List [ TypeDef ] , body: Tree ) : LambdaTypeTree
def Literal ( const: Constant ) : Literal
def Match ( selector: Tree , cases: List [ CaseDef ] ) : Match
def NamedArg ( name: Name , arg: Tree ) : NamedArg
def New ( tpt: Tree ) : New
def New ( tpt: Tree , argss: List [ List [ Tree ] ] ) ( implicit ctx: Context ) : Tree

new pre.CTs...(args_n) ==> (new pre.C).Ts...(args_n)

new pre.CTs...(args_n) ==> (new pre.C).Ts...(args_n)

def OrTypeTree ( left: Tree , right: Tree ) : OrTypeTree
def PackageDef ( pid: RefTree , stats: List [ Tree ] ) : PackageDef
def RefinedTypeTree ( tpt: Tree , refinements: List [ Tree ] ) : RefinedTypeTree
def Return ( expr: Tree , from: Tree ) : Return
def Select ( qualifier: Tree , name: Name ) : Select
def SelectWithSig ( qualifier: Tree , name: Name , sig: Signature ) : Select
def SeqLiteral ( elems: List [ Tree ] , elemtpt: Tree ) : SeqLiteral
def SingletonTypeTree ( ref: Tree ) : SingletonTypeTree
def Super ( qual: Tree , mix: Ident ) : Super
def Template ( constr: DefDef , parents: List [ Tree ] , self: ValDef , body: LazyTreeList ) : Template
def This ( qual: Ident ) : This
def Try ( expr: Tree , cases: List [ CaseDef ] , finalizer: Tree ) : Try
def TypeApply ( fun: Tree , args: List [ Tree ] ) : TypeApply
def TypeBoundsTree ( lo: Tree , hi: Tree ) : TypeBoundsTree
def TypeDef ( name: TypeName , rhs: Tree ) : TypeDef
def TypeTree ( ) : TypeTree [ T ]
def TypeTree ( tpe: Type ) ( implicit ctx: Context ) : TypedSplice
def Typed ( expr: Tree , tpt: Tree ) : Typed
def UnApply ( fun: Tree , implicits: List [ Tree ] , patterns: List [ Tree ] ) : UnApply
def ValDef ( name: TermName , tpt: Tree , rhs: LazyTree ) : ValDef
def emptyConstructor ( implicit ctx: Context ) : DefDef
def ensureApplied ( tpt: Tree ) : Tree
def lambdaAbstract ( tparams: List [ TypeDef ] , tpt: Tree ) ( implicit ctx: Context ) : Tree
def makeConstructor ( tparams: List [ TypeDef ] , vparamss: List [ List [ ValDef ] ] , rhs: Tree ) ( implicit ctx: Context ) : DefDef
def makeConstructor$default$3 : Thicket
def makeParameter ( pname: TermName , tpe: Tree , mods: Modifiers ) ( implicit ctx: Context ) : ValDef
def makeParameter$default$3 : Modifiers
def makeSelfDef ( name: TermName , tpt: Tree ) ( implicit ctx: Context ) : ValDef [ Untyped ]
def makeSyntheticParameter ( n: Int , tpt: Tree ) ( implicit ctx: Context ) : ValDef
def makeSyntheticParameter$default$1 : Int
def makeSyntheticParameter$default$2 : TypeTree [ T ]
def makeTuple ( ts: List [ Tree ] ) ( implicit ctx: Context ) : Tree [ T ]
def makeTupleOrParens ( ts: List [ Tree ] ) ( implicit ctx: Context ) : R | R
implicit def modsDeco ( mdef: MemberDef ) ( implicit ctx: Context ) : modsDeco
def ref ( tp: NamedType ) ( implicit ctx: Context ) : Tree
def refOfDef ( tree: MemberDef ) ( implicit ctx: Context ) : Typed | Ident
def repeated ( arg: Tree ) ( implicit ctx: Context ) : Typed

A repeated argument such as arg: _*

A repeated argument such as arg: _*

def rootDot ( name: Name ) : Select
def scalaAny : Select
def scalaDot ( name: Name ) : Select
def scalaUnit : Select
def unitLiteral : Literal