dotty.tools.dotc.ast

tpd

Related Doc: package ast

object tpd extends Instance[Type] with TypedTreeInfo

Some creators for typed trees

Linear Supertypes
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. tpd
  2. TypedTreeInfo
  3. TreeInfo
  4. Instance
  5. DotClass
  6. AnyRef
  7. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. type Alternative = Trees.Alternative[Type]

    Definition Classes
    Instance
  2. type AndTypeTree = Trees.AndTypeTree[Type]

    Definition Classes
    Instance
  3. type Annotated = Trees.Annotated[Type]

    Definition Classes
    Instance
  4. type AppliedTypeTree = Trees.AppliedTypeTree[Type]

    Definition Classes
    Instance
  5. type Apply = Trees.Apply[Type]

    Definition Classes
    Instance
  6. type Assign = Trees.Assign[Type]

    Definition Classes
    Instance
  7. type BackquotedIdent = Trees.BackquotedIdent[Type]

    Definition Classes
    Instance
  8. type Bind = Trees.Bind[Type]

    Definition Classes
    Instance
  9. type Block = Trees.Block[Type]

    Definition Classes
    Instance
  10. type ByNameTypeTree = Trees.ByNameTypeTree[Type]

    Definition Classes
    Instance
  11. type CaseDef = Trees.CaseDef[Type]

    Definition Classes
    Instance
  12. type Closure = Trees.Closure[Type]

    Definition Classes
    Instance
  13. class DeepFolder[X] extends TreeAccumulator[X]

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

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

    Definition Classes
    Instance
  14. type DefDef = Trees.DefDef[Type]

    Definition Classes
    Instance
  15. type DefTree = Trees.DefTree[Type]

    Definition Classes
    Instance
  16. type DenotingTree = Trees.DenotingTree[Type]

    Definition Classes
    Instance
  17. abstract class EnclosingMethodTraverser extends TreeAccumulator[Symbol]

    A traverser that passes the enclosing class or method as an argument to the traverse method.

  18. type Ident = Trees.Ident[Type]

    Definition Classes
    Instance
  19. type If = Trees.If[Type]

    Definition Classes
    Instance
  20. type Import = Trees.Import[Type]

    Definition Classes
    Instance
  21. type Inlined = Trees.Inlined[Type]

    Definition Classes
    Instance
  22. type JavaSeqLiteral = Trees.JavaSeqLiteral[Type]

    Definition Classes
    Instance
  23. implicit final class ListOfTreeDecorator extends AnyVal

  24. type Literal = Trees.Literal[Type]

    Definition Classes
    Instance
  25. type Match = Trees.Match[Type]

    Definition Classes
    Instance
  26. class MatchingArgs extends AnyRef

    Definition Classes
    TreeInfo
  27. type MemberDef = Trees.MemberDef[Type]

    Definition Classes
    Instance
  28. type NameTree = Trees.NameTree[Type]

    Definition Classes
    Instance
  29. type NamedArg = Trees.NamedArg[Type]

    Definition Classes
    Instance
  30. type New = Trees.New[Type]

    Definition Classes
    Instance
  31. type OrTypeTree = Trees.OrTypeTree[Type]

    Definition Classes
    Instance
  32. type PackageDef = Trees.PackageDef[Type]

    Definition Classes
    Instance
  33. type PatternTree = Trees.PatternTree[Type]

    Definition Classes
    Instance
  34. type PolyTypeTree = Trees.PolyTypeTree[Type]

    Definition Classes
    Instance
  35. type ProxyTree = Trees.ProxyTree[Type]

    Definition Classes
    Instance
  36. type RefTree = Trees.RefTree[Type]

    Definition Classes
    Instance
  37. type RefinedTypeTree = Trees.RefinedTypeTree[Type]

    Definition Classes
    Instance
  38. type Return = Trees.Return[Type]

    Definition Classes
    Instance
  39. type Select = Trees.Select[Type]

    Definition Classes
    Instance
  40. type SelectWithSig = Trees.SelectWithSig[Type]

    Definition Classes
    Instance
  41. type SeqLiteral = Trees.SeqLiteral[Type]

    Definition Classes
    Instance
  42. class ShallowFolder[X] extends TreeAccumulator[X]

    Fold f over all tree nodes, in depth-first, prefix order, but don't visit subtrees where f returns a different result for the root, i.e.

    Fold f over all tree nodes, in depth-first, prefix order, but don't visit subtrees where f returns a different result for the root, i.e. f(x, root) ne x.

    Definition Classes
    Instance
  43. type SingletonTypeTree = Trees.SingletonTypeTree[Type]

    Definition Classes
    Instance
  44. type Super = Trees.Super[Type]

    Definition Classes
    Instance
  45. type Template = Trees.Template[Type]

    Definition Classes
    Instance
  46. type TermTree = Trees.TermTree[Type]

    Definition Classes
    Instance
  47. type Thicket = Trees.Thicket[Type]

    Definition Classes
    Instance
  48. type This = Trees.This[Type]

    Definition Classes
    Instance
  49. type Tree = Trees.Tree[Type]

    Definition Classes
    Instance
  50. abstract class TreeAccumulator[X] extends AnyRef

    Definition Classes
    Instance
  51. abstract class TreeCopier extends AnyRef

    A class for copying trees.

    A class for copying trees. The copy methods avoid creating a new tree If all arguments stay the same.

    Note: Some of the copy methods take a context. These are exactly those methods that are overridden in TypedTreeCopier so that they selectively retype themselves. Retyping needs a context.

    Definition Classes
    Instance
  52. abstract class TreeMap extends AnyRef

    Definition Classes
    Instance
  53. implicit final class TreeOps[ThisTree <: Tree] extends AnyVal

  54. abstract class TreeTraverser extends TreeAccumulator[Unit]

    Definition Classes
    Instance
  55. type Try = Trees.Try[Type]

    Definition Classes
    Instance
  56. type TypTree = Trees.TypTree[Type]

    Definition Classes
    Instance
  57. type TypeApply = Trees.TypeApply[Type]

    Definition Classes
    Instance
  58. type TypeBoundsTree = Trees.TypeBoundsTree[Type]

    Definition Classes
    Instance
  59. type TypeDef = Trees.TypeDef[Type]

    Definition Classes
    Instance
  60. type TypeTree = Trees.TypeTree[Type]

    Definition Classes
    Instance
  61. type Typed = Trees.Typed[Type]

    Definition Classes
    Instance
  62. class TypedTreeCopier extends TreeCopier

  63. type UnApply = Trees.UnApply[Type]

    Definition Classes
    Instance
  64. type ValDef = Trees.ValDef[Type]

    Definition Classes
    Instance
  65. type ValOrDefDef = Trees.ValOrDefDef[Type]

    Definition Classes
    Instance

Value Members

  1. final def !=(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  2. final def ##(): Int

    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  4. def Alternative(trees: List[Tree])(implicit ctx: Context): Alternative

  5. def AndTypeTree(left: Tree, right: Tree)(implicit ctx: Context): AndTypeTree

  6. def Annotated(arg: Tree, annot: Tree)(implicit ctx: Context): Annotated

  7. def AnonClass(parents: List[Type], fns: List[TermSymbol], methNames: List[TermName])(implicit ctx: Context): Block

    An anonymous class

    An anonymous class

    new parents { forwarders }

    where forwarders contains forwarders for all functions in fns.

    parents

    a non-empty list of class types

    fns

    a non-empty of functions for which forwarders should be defined in the class. The class has the same owner as the first function in fns. Its position is the union of all functions in fns.

  8. def AppliedTypeTree(tycon: Tree, args: List[Tree])(implicit ctx: Context): AppliedTypeTree

  9. def Apply(fn: Tree, args: List[Tree])(implicit ctx: Context): Apply

  10. def Assign(lhs: Tree, rhs: Tree)(implicit ctx: Context): Assign

  11. def Bind(sym: TermSymbol, body: Tree)(implicit ctx: Context): Bind

  12. def BindTyped(sym: TermSymbol, tpe: Type)(implicit ctx: Context): Bind

    A pattern corresponding to sym: tpe

  13. def Block(stats: List[Tree], expr: Tree)(implicit ctx: Context): Block

  14. def ByNameTypeTree(result: Tree)(implicit ctx: Context): ByNameTypeTree

  15. def CaseDef(pat: Tree, guard: Tree, body: Tree)(implicit ctx: Context): CaseDef

  16. def ClassDef(cls: ClassSymbol, constr: DefDef, body: List[Tree], superArgs: List[Tree] = Nil)(implicit ctx: Context): TypeDef

  17. def Closure(meth: TermSymbol, rhsFn: (List[List[Tree]]) ⇒ Tree, targs: List[Tree] = Nil, targetType: Type = NoType)(implicit ctx: Context): Block

    A function def

    A function def

    vparams => expr

    gets expanded to

    { def $anonfun(vparams) = expr; Closure($anonfun) }

    where the closure's type is the target type of the expression (FunctionN, unless otherwise specified).

  18. def Closure(env: List[Tree], meth: Tree, tpt: Tree)(implicit ctx: Context): Closure

  19. def DefDef(sym: TermSymbol, rhsFn: (List[List[Tree]]) ⇒ Tree)(implicit ctx: Context): DefDef

  20. def DefDef(sym: TermSymbol, rhs: Tree = EmptyTree)(implicit ctx: Context): DefDef

  21. val EmptyTree: Thicket

    Definition Classes
    Instance
  22. val EmptyValDef: ValDef

    Definition Classes
    Instance
  23. def Ident(tp: NamedType)(implicit ctx: Context): Ident

  24. def If(cond: Tree, thenp: Tree, elsep: Tree)(implicit ctx: Context): If

  25. def Import(expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import

  26. def Inlined(call: Tree, bindings: List[MemberDef], expansion: Tree)(implicit ctx: Context): Inlined

  27. def JavaSeqLiteral(elems: List[Tree], elemtpt: Tree)(implicit ctx: Context): JavaSeqLiteral

  28. def Literal(const: Constant)(implicit ctx: Context): Literal

  29. def Match(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match

  30. object MaybePoly

    An extractor that pulls out type arguments

  31. def ModuleDef(sym: TermSymbol, body: List[Tree])(implicit ctx: Context): Thicket

    An object def

    An object def

    object obs extends parents { decls }

    gets expanded to

    <module> val obj = new obj$ <module> class obj$ extends parents { this: obj.type => decls }

    (The following no longer applies: What's interesting here is that the block is well typed (because class obj$ is hoistable), but the type of the obj val is not expressible. What needs to happen in general when inferring the type of a val from its RHS, is: if the type contains a class that has the val itself as owner, then that class is remapped to have the val's owner as owner. Remapping could be done by cloning the class with the new owner and substituting everywhere in the tree. We know that remapping is safe because the only way a local class can appear in the RHS of a val is by being hoisted outside of a block, and the necessary checks are done at this point already.

    On the other hand, for method result type inference, if the type of the RHS of a method contains a class owned by the method, this would be an error.)

  32. def NamedArg(name: Name, arg: Tree)(implicit ctx: Context): NamedArg

  33. def New(tp: Type, constr: TermSymbol, args: List[Tree])(implicit ctx: Context): Apply

    new C(args), calling given constructor constr of C

  34. def New(tp: Type, args: List[Tree])(implicit ctx: Context): Apply

    new C(args), calling the primary constructor of C

  35. def New(tp: Type)(implicit ctx: Context): New

  36. def New(tpt: Tree)(implicit ctx: Context): New

  37. def OrTypeTree(left: Tree, right: Tree)(implicit ctx: Context): OrTypeTree

  38. def PackageDef(pid: RefTree, stats: List[Tree])(implicit ctx: Context): PackageDef

  39. def Return(expr: Tree, from: Tree)(implicit ctx: Context): Return

  40. def Select(qualifier: Tree, tp: NamedType)(implicit ctx: Context): Select

  41. def Select(qualifier: Tree, name: Name)(implicit ctx: Context): Select

  42. def SeqLiteral(elems: List[Tree], elemtpt: Tree)(implicit ctx: Context): SeqLiteral

  43. def SingletonTypeTree(ref: Tree)(implicit ctx: Context): SingletonTypeTree

  44. def Super(qual: Tree, mix: TypeName, inConstrCall: Boolean, mixinClass: Symbol = NoSymbol)(implicit ctx: Context): Super

  45. def SyntheticValDef(name: TermName, rhs: Tree)(implicit ctx: Context): ValDef

  46. def Thicket(x1: Tree, x2: Tree, x3: Tree): Thicket

    Definition Classes
    Instance
  47. def Thicket(x1: Tree, x2: Tree): Thicket

    Definition Classes
    Instance
  48. def Thicket(): Thicket

    Definition Classes
    Instance
  49. def Thicket(trees: List[Tree]): Thicket

    Definition Classes
    Instance
  50. def This(cls: ClassSymbol)(implicit ctx: Context): This

  51. def Throw(expr: Tree)(implicit ctx: Context): Tree

  52. def Try(block: Tree, cases: List[CaseDef], finalizer: Tree)(implicit ctx: Context): Try

  53. def TypeApply(fn: Tree, args: List[Tree])(implicit ctx: Context): TypeApply

  54. def TypeBoundsTree(lo: Tree, hi: Tree)(implicit ctx: Context): TypeBoundsTree

  55. def TypeDef(sym: TypeSymbol)(implicit ctx: Context): TypeDef

  56. def TypeTree(tp: Type)(implicit ctx: Context): TypeTree

  57. def Typed(expr: Tree, tpt: Tree)(implicit ctx: Context): Typed

  58. def UnApply(fun: Tree, implicits: List[Tree], patterns: List[Tree], proto: Type)(implicit ctx: Context): UnApply

  59. def Underscore(tp: Type)(implicit ctx: Context): Trees.Ident[Type]

    A _' with given type

  60. def ValDef(sym: TermSymbol, rhs: LazyTree = EmptyTree)(implicit ctx: Context): ValDef

  61. def WhileDo(owner: Symbol, cond: Tree, body: List[Tree])(implicit ctx: Context): Tree

  62. def applyOverloaded(receiver: Tree, method: TermName, args: List[Tree], targs: List[Type], expectedType: Type, isAnnotConstructor: Boolean = false)(implicit ctx: Context): Tree

  63. def arguments(tree: Tree): List[Tree]

    The (last) list of arguments of an application

    The (last) list of arguments of an application

    Definition Classes
    TreeInfo
  64. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  65. def catchesAllOf(cdef: CaseDef, threshold: Type)(implicit ctx: Context): Boolean

    Does this CaseDef catch everything of a certain Type?

    Does this CaseDef catch everything of a certain Type?

    Definition Classes
    TreeInfo
  66. def catchesThrowable(cdef: CaseDef)(implicit ctx: Context): Boolean

    Does this CaseDef catch Throwable?

    Does this CaseDef catch Throwable?

    Definition Classes
    TreeInfo
  67. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  68. object closure

    An extractor for closures, either contained in a block or standalone.

    An extractor for closures, either contained in a block or standalone.

    Definition Classes
    TypedTreeInfo
  69. def closureBody(tree: Tree)(implicit ctx: Context): Tree

    If tree is a closure, its body, otherwise tree itself

    If tree is a closure, its body, otherwise tree itself

    Definition Classes
    TypedTreeInfo
  70. def clsOf(tp: Type)(implicit ctx: Context): Tree

    A tree that represents the class of the erasure of type tp.

  71. def constToLiteral(tree: Tree)(implicit ctx: Context): Tree

    If tree is a constant expression, its value as a Literal, or tree itself otherwise.

    If tree is a constant expression, its value as a Literal, or tree itself otherwise.

    Note: Demanding idempotency instead of purity in literalize is strictly speaking too loose. Example

    object O { final val x = 42; println("43") } O.x

    Strictly speaking we can't replace O.x with 42. But this would make most expressions non-constant. Maybe we can change the spec to accept this kind of eliding behavior. Or else enforce true purity in the compiler. The choice will be affected by what we will do with inline and with Singleton type bounds (see SIP 23). Presumably

    object O1 { val x: Singleton = 42; println("43") } object O2 { inline val x = 42; println("43") }

    should behave differently.

    O1.x should have the same effect as { println("43"); 42 }

    whereas

    O2.x = 42

    Revisit this issue once we have implemented inline. Then we can demand purity of the prefix unless the selection goes to an inline val.

    Note: This method should be applied to all term tree nodes that are not literals, that can be idempotent, and that can have constant types. So far, only nodes of the following classes qualify:

    Ident Select TypeApply

    Definition Classes
    TypedTreeInfo
  72. val cpy: TypedTreeCopier

    Definition Classes
    tpdInstance
  73. def decomposeCall(tree: Tree): (Tree, List[Tree], List[List[Tree]])

    Decompose a call fn[targs](vargs_1)...(vargs_n) into its constituents (where targs, vargss may be empty)

    Decompose a call fn[targs](vargs_1)...(vargs_n) into its constituents (where targs, vargss may be empty)

    Definition Classes
    TypedTreeInfo
  74. def defKind(tree: Tree): FlagSet

    The largest subset of {NoInits, PureInterface} that a trait enclosing this statement can have as flags.

    The largest subset of {NoInits, PureInterface} that a trait enclosing this statement can have as flags. Does tree contain an initialization part when seen as a member of a class or trait?

    Definition Classes
    TreeInfo
  75. def defPath(sym: Symbol, root: Tree)(implicit ctx: Context): List[Tree]

    Going from child to parent, the path of tree nodes that starts with a definition of symbol sym and ends with root, or Nil if no such path exists.

    Going from child to parent, the path of tree nodes that starts with a definition of symbol sym and ends with root, or Nil if no such path exists. Pre: sym must have a position.

    Definition Classes
    TypedTreeInfo
  76. def defaultValue(tpe: Type)(implicit ctx: Context): Tree

  77. def definedSym(tree: Tree)(implicit ctx: Context): Symbol

    If tree is a DefTree, the symbol defined by it, otherwise NoSymbol

    If tree is a DefTree, the symbol defined by it, otherwise NoSymbol

    Definition Classes
    TypedTreeInfo
  78. def definingStats(sym: Symbol)(implicit ctx: Context): List[Tree]

    The statement sequence that contains a definition of sym, or Nil if none was found.

    The statement sequence that contains a definition of sym, or Nil if none was found. For a tree to be found, The symbol must have a position and its definition tree must be reachable from come tree stored in an enclosing context.

    Definition Classes
    TypedTreeInfo
  79. def enclosingInlineds(implicit ctx: Context): List[Tree]

    All enclosing calls that are currently inlined, from innermost to outermost

  80. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  81. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  82. def evalOnce(tree: Tree)(within: (Tree) ⇒ Tree)(implicit ctx: Context): Tree

  83. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  84. def firstConstructor(stats: List[Tree]): Tree

    The first constructor definition in stats

    The first constructor definition in stats

    Definition Classes
    TreeInfo
  85. def firstConstructorArgs(stats: List[Tree]): List[Tree]

    The arguments to the first constructor in stats.

    The arguments to the first constructor in stats.

    Definition Classes
    TreeInfo
  86. def flatTree(xs: List[Tree]): Tree

    Definition Classes
    Instance
  87. def forallResults(tree: Tree, p: (Tree) ⇒ Boolean): Boolean

    Checks whether predicate p is true for all result parts of this expression, where we zoom into Ifs, Matches, and Blocks.

    Checks whether predicate p is true for all result parts of this expression, where we zoom into Ifs, Matches, and Blocks.

    Definition Classes
    TreeInfo
  88. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any
  89. def hasNamedArg(args: List[Any]): Boolean

    Does this list contain a named argument tree?

    Does this list contain a named argument tree?

    Definition Classes
    TreeInfo
  90. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  91. def inlineContext(call: Tree)(implicit ctx: Context): Context

    A context derived form ctx that records call as innermost enclosing call for which the inlined version is currently processed.

  92. def isCatchCase(cdef: CaseDef)(implicit ctx: Context): Boolean

    Is this pattern node a catch-all or type-test pattern?

    Is this pattern node a catch-all or type-test pattern?

    Definition Classes
    TypedTreeInfo
  93. def isDeclarationOrTypeDef(tree: Tree): Boolean

    Definition Classes
    TreeInfo
  94. def isDefaultCase(cdef: CaseDef): Boolean

    Is this pattern node a catch-all (wildcard or variable) pattern?

    Is this pattern node a catch-all (wildcard or variable) pattern?

    Definition Classes
    TreeInfo
  95. def isGuardedCase(cdef: CaseDef): Boolean

    Is this case guarded?

    Is this case guarded?

    Definition Classes
    TreeInfo
  96. def isIdempotentExpr(tree: Tree)(implicit ctx: Context): Boolean

    Definition Classes
    TypedTreeInfo
  97. def isIdempotentRef(tree: Tree)(implicit ctx: Context): Boolean

    Definition Classes
    TypedTreeInfo
  98. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  99. def isLeftAssoc(operator: Name): Boolean

    Is name a left-associative operator?

    Is name a left-associative operator?

    Definition Classes
    TreeInfo
  100. val isNamedArg: (Any) ⇒ Boolean

    Definition Classes
    TreeInfo
  101. def isOpAssign(tree: Tree): Boolean

    Definition Classes
    TreeInfo
  102. def isPureExpr(tree: Tree)(implicit ctx: Context): Boolean

    Definition Classes
    TypedTreeInfo
  103. def isPureRef(tree: Tree)(implicit ctx: Context): Boolean

    Definition Classes
    TypedTreeInfo
  104. def isRepeatedParamType(tpt: Tree)(implicit ctx: Context): Boolean

    Is tpt a vararg type of the form T* or => T*?

    Is tpt a vararg type of the form T* or => T*?

    Definition Classes
    TreeInfo
  105. def isSelf(tree: Tree, enclClass: Symbol)(implicit ctx: Context): Boolean

    Is tree a this node which belongs to enclClass?

    Is tree a this node which belongs to enclClass?

    Definition Classes
    TypedTreeInfo
  106. def isSelfConstrCall(tree: Tree): Boolean

    Is tree a self constructor call this(...)? I.e.

    Is tree a self constructor call this(...)? I.e. a call to a constructor of the same object?

    Definition Classes
    TreeInfo
  107. def isSelfOrSuperConstrCall(tree: Tree): Boolean

    Definition Classes
    TreeInfo
  108. def isSuperConstrCall(tree: Tree): Boolean

    Is tree a super constructor call?

    Is tree a super constructor call?

    Definition Classes
    TreeInfo
  109. def isSuperSelection(tree: untpd.Tree): Boolean

    Definition Classes
    TreeInfo
  110. def isSyntheticDefaultCase(cdef: CaseDef): Boolean

    Is this pattern node a synthetic catch-all case, added during PartialFuction synthesis before we know whether the user provided cases are exhaustive.

    Is this pattern node a synthetic catch-all case, added during PartialFuction synthesis before we know whether the user provided cases are exhaustive.

    Definition Classes
    TreeInfo
  111. def isVarPattern(pat: untpd.Tree): Boolean

    Is tree a variable pattern?

    Is tree a variable pattern?

    Definition Classes
    TreeInfo
  112. def isVariableOrGetter(tree: Tree)(implicit ctx: Context): Boolean

    Is tree a reference to a mutable variable, or to a potential getter that has a setter in the same class?

    Is tree a reference to a mutable variable, or to a potential getter that has a setter in the same class?

    Definition Classes
    TypedTreeInfo
  113. def isWildcardArg(tree: Tree): Boolean

    Is the argument a wildcard argument of the form _ or x @ _?

    Is the argument a wildcard argument of the form _ or x @ _?

    Definition Classes
    TreeInfo
  114. def isWildcardStarArg(tree: Tree)(implicit ctx: Context): Boolean

    Is this argument node of the form <expr> : _* ?

    Is this argument node of the form <expr> : _* ?

    Definition Classes
    TreeInfo
  115. def isWildcardStarArgList(trees: List[Tree])(implicit ctx: Context): Boolean

    Does this argument list end with an argument of the form <expr> : _* ?

    Does this argument list end with an argument of the form <expr> : _* ?

    Definition Classes
    TreeInfo
  116. def localSyms(stats: List[Tree])(implicit ctx: Context): List[Symbol]

    The symbols defined locally in a statement list

    The symbols defined locally in a statement list

    Definition Classes
    TypedTreeInfo
  117. def mayBeTypePat(tree: untpd.Tree): Boolean

    can this type be a type pattern?

    can this type be a type pattern?

    Definition Classes
    TreeInfo
  118. def mayBeVarGetter(sym: Symbol)(implicit ctx: Context): Boolean

    Is symbol potentially a getter of a mutable variable?

    Is symbol potentially a getter of a mutable variable?

    Definition Classes
    TypedTreeInfo
  119. def methPart(tree: Tree): Tree

    The method part of an application node, possibly enclosed in a block with only valdefs as statements.

    The method part of an application node, possibly enclosed in a block with only valdefs as statements. the reason for also considering blocks is that named arguments can transform a call into a block, e.g. <init>(b = foo, a = bar) is transformed to { val x$1 = foo val x$2 = bar <init>(x$2, x$1) }

    Definition Classes
    TreeInfo
  120. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  121. def needsSelect(tp: Type)(implicit ctx: Context): Boolean

  122. def newArray(elemTpe: Type, returnTpe: Type, pos: Position, dims: JavaSeqLiteral)(implicit ctx: Context): Tree

    A tree representing a newXYZArray operation of the right kind for the given element type in typeArg.

    A tree representing a newXYZArray operation of the right kind for the given element type in typeArg. No type arguments or length arguments are given.

  123. final def notify(): Unit

    Definition Classes
    AnyRef
  124. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  125. def numArgs(tree: Tree): Int

    The number of arguments in an application

    The number of arguments in an application

    Definition Classes
    TreeInfo
  126. def patVars(tree: Tree)(implicit ctx: Context): List[Symbol]

    The variables defined by a pattern, in reverse order of their appearance.

    The variables defined by a pattern, in reverse order of their appearance.

    Definition Classes
    TypedTreeInfo
  127. def polyDefDef(sym: TermSymbol, rhsFn: (List[Type]) ⇒ (List[List[Tree]]) ⇒ Tree)(implicit ctx: Context): DefDef

  128. def prefixIsElidable(tp: NamedType)(implicit ctx: Context): Boolean

  129. def primitiveConversion(tree: Tree, numericCls: Symbol)(implicit ctx: Context): Tree

  130. def ref(sym: Symbol)(implicit ctx: Context): Tree

  131. def ref(tp: NamedType)(implicit ctx: Context): Tree

    A tree representing the same reference as the given type

  132. def rename(tree: NameTree, newName: Name)(implicit ctx: Context): ThisTree[Type]

    Definition Classes
    Instance
  133. def runtimeCall(name: TermName, args: List[Tree])(implicit ctx: Context): Tree

  134. def sameTypes(trees: List[Tree], trees1: List[Tree]): Boolean

    Annotations
    @tailrec()
  135. def seq(stats: List[Tree], expr: Tree)(implicit ctx: Context): Tree

    Join stats in front of expr creating a new block if necessary

  136. def singleton(tp: Type)(implicit ctx: Context): Tree

  137. def sliceTopLevel(tree: Tree, cls: ClassSymbol)(implicit ctx: Context): List[Tree]

    The tree containing only the top-level classes and objects matching either cls or its companion object

    The tree containing only the top-level classes and objects matching either cls or its companion object

    Definition Classes
    TypedTreeInfo
  138. def sourceFile(call: Tree)(implicit ctx: Context): SourceFile

    The source file where the symbol of the @inline method referred to by call is defined

  139. def stripApply(tree: Tree): Tree

    If this is an application, its function part, stripping all Apply nodes (but leaving TypeApply nodes in).

    If this is an application, its function part, stripping all Apply nodes (but leaving TypeApply nodes in). Otherwise the tree itself.

    Definition Classes
    TreeInfo
  140. def stripCast(tree: Tree)(implicit ctx: Context): Tree

    Strips layers of .asInstanceOf[T] / _.$asInstanceOf[T]() from an expression

    Strips layers of .asInstanceOf[T] / _.$asInstanceOf[T]() from an expression

    Definition Classes
    TypedTreeInfo
  141. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  142. def toString(): String

    Definition Classes
    AnyRef → Any
  143. def topLevelClasses(tree: Tree)(implicit ctx: Context): List[ClassSymbol]

    The top level classes in this tree, including only those module classes that are not a linked class of some other class in the result.

    The top level classes in this tree, including only those module classes that are not a linked class of some other class in the result.

    Definition Classes
    TypedTreeInfo
  144. def unbind(x: Tree): Tree

    The underlying pattern ignoring any bindings

    The underlying pattern ignoring any bindings

    Definition Classes
    TreeInfo
  145. def unitLiteral(implicit ctx: Context): Literal

  146. def unsplice[T >: Untyped](tree: Trees.Tree[T]): Trees.Tree[T]

    Definition Classes
    TreeInfo
  147. def unsupported(methodName: String): Nothing

    Throws an UnsupportedOperationException with the given method name.

    Throws an UnsupportedOperationException with the given method name.

    Definition Classes
    DotClass
  148. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  149. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  150. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from TypedTreeInfo

Inherited from TreeInfo[Type]

Inherited from Instance[Type]

Inherited from DotClass

Inherited from AnyRef

Inherited from Any

Ungrouped