NameTree

abstract def canEqual(that: Any): Boolean

abstract def name: Name

abstract def productArity: Int

abstract def productElement(n: Int): Any

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def addPos(pos: Position): NameTree.this.type

This item with a position that's the union of the given pos and the current position.

final def allAttachments: List[(Key[_], Any)]

The list of all keys and values attached to this container.

final def asInstanceOf[T0]: T0

final def attachment[V](key: Key[V]): V

The attachment corresponding to key.

final def attachmentOrElse[V](key: Key[V], default: V): V

The attachment corresponding to key, or default if no attachment with key exists.

def checkPos(nonOverlapping: Boolean)(implicit ctx: Context): Unit

Check that all positioned items in this tree satisfy the following conditions:

def clone(): Tree[T]

def contains(that: Positioned): Boolean

def denot(implicit ctx: Context): Denotation

The denotation referred tno by this tree.

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def fallbackToText(printer: Printer): Text

A fallback text representation, if the pattern matching in Printers does not have a case for this showable element

def finalize(): Unit

def foreachInThicket(op: (Tree[T]) ⇒ Unit): Unit

If this is a thicket, perform op on each of its trees otherwise, perform op ion tree itself.

final def getAttachment[V](key: Key[V]): Option[V]

Optionally get attachment corresponding to key

final def getClass(): Class[_]

final def hasType: Boolean

Does the tree have its type field set? Note: this operation is not referentially transparent, because it can observe the withType modifications.

def hashCode(): Int

def initialPos: Position

The initial, synthetic position.

def isDef: Boolean

Does this tree define a new symbol that is not defined elsewhere?

def isEmpty: Boolean

Is this tree either the empty tree or the empty ValDef?

final def isInstanceOf[T0]: Boolean

def isPattern: Boolean

Is this a legal part of a pattern which is not at the same time a term?

def isTerm: Boolean

Does this tree represent a term?

def isType: Boolean

Does this tree represent a type?

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def orElse[U >: Untyped <: T](that: ⇒ Tree[U]): Tree[U]

if this tree is the empty tree, the alternative, else this tree

def pos: Position

The item's position.

def productIterator: Iterator[Any]

def productPrefix: String

final def pushAttachment[V](key: Key[V], value: V): Unit

final def putAttachment[V](key: Key[V], value: V): Option[V]

Add attachment with given key and value.

final def removeAttachment[V](key: Key[V]): Option[V]

Remove attachment with given key, if it exists.

def setPos(pos: Position): Unit

Destructively update curPos to given position.

def show(implicit ctx: Context): String

The string representation of this showable element.

def showSummary(implicit ctx: Context): String

def showSummary(depth: Int)(implicit ctx: Context): String

The summarized string representation of this showable element.

final def symbol(implicit ctx: Context): Symbol

Shorthand for denot.symbol.

final def synchronized[T0](arg0: ⇒ T0): T0

def toList: List[Tree[T]]

Convert tree to a list.

def toString(): String

def toText(printer: Printer): Text

The text representation of this showable element.

def tpe: T

The type of the tree.

def treeSize: Int

The number of nodes in this tree

final def typeOpt: Type

def uniqueId: Int

def unsupported(methodName: String): Nothing

Throws an UnsupportedOperationException with the given method name.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withPos(posd: Positioned): NameTree.this.type

def withPos(pos: Position): NameTree.this.type

A positioned item like this one with the position set to pos.

def withType(tpe: Type)(implicit ctx: Context): ThisTree[Type]

Return a typed tree that's isomorphic to this tree, but has given type.

def withTypeUnchecked(tpe: Type): ThisTree[Type]