AnnotatedAst (P2J - Progress 4GL to Java Conversion and Runtime)

java.lang.Object
- antlr.BaseAST
- - antlr.CommonAST
  - - com.goldencode.ast.AnnotatedAst

All Implemented Interfaces:

antlr.collections.AST, Aast, java.io.Serializable

Direct Known Subclasses:

DataModelAst, FQLAst, HQLAst, JavaAst, ProgressAst, XmlAst
```
public abstract class AnnotatedAst
extends antlr.CommonAST
implements Aast
```
A modified abstract syntax tree node which provides additional services. Each instance of this class provides:
- A persistent, unique identifier. This is implemented as a 64-bit value where the high-order double word represents a unique source file with which this AST is associated, and the low order double word represents a unique identifier within the AST hierarchy associated with that file.
- A link to a parent node. This permits leaf-to-root path traversal, which is necessary to support the pattern recognition engine. This engine uses this information both to walk the tree of ASTs during ruleset processing, and to provide certain user function and action features.
- An API to manage annotations used in post-processing. Annotations are used to attach arbitrary string, numeric, and boolean data to an AST for various reasons. These annotations are exposed by name as user expression variables during ruleset processing, and are available to user functions and actions.
- Access to source file name, line number and column, and nesting level information. This information is exposed via user expression variables during ruleset processing. It is made available to user functions and actions.
- Iterator processing to provide a powerful walking mechanism. This walk can be limited to a specific depth (or it can be unlimited). In addition, certain "non-visiting" events can be hooked during the walk, including descents to lower nesting levels, moves between children (next-child events) and ascents back up to higher nesting levels. Finally, the setHidden(boolean) flag can optionally be honored during the walk, to bypass child nodes marked as hidden. See iterator(int,AstWalkListener,boolean).
See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`private static java.util.Map<java.lang.String,java.lang.String>`	`ANNO_LOWER`
`private java.util.IdentityHashMap<java.lang.String,java.lang.Object>`	`annotations` Map of annotation objects, indexed by name
`private int`	`column` Source file column number associated with this AST
`private boolean`	`hidden` Hidden mode which can be used to modify iterator based walking.
`private java.lang.Long`	`id` Unique, persistent identifier
`private int`	`line` Source file line number associated with this AST
`private TreeLocal`	`local` Tree-specific data (data that is shared by all nodes of a tree.
`private static ConversionStatus`	`LOG` Logger
`private Aast`	`parent` Parent node to this node
`private java.lang.Object[]`	`runtimeAnnotations` Storage for runtime annotation - an array of length `Aast.RUNTIME_ANNOTATION_COUNT`.
`private AnnotatedAst`	`tail` Right-most child node, if any

Fields inherited from class antlr.BaseAST
down, right

Fields inherited from interface com.goldencode.ast.Aast
RUNTIME_ANNOTATION_COUNT, RUNTIME_CLASS, RUNTIME_CONSTRUCTOR, RUNTIME_METHOD, RUNTIME_VALUE

Constructor Summary

Constructors
Constructor and Description

AnnotatedAst()
Default constructor.

AnnotatedAst(antlr.Token token)
Constructor which accepts and wrappers token.

Constructors
Constructor and Description
`AnnotatedAst()` Default constructor.
`AnnotatedAst(antlr.Token token)` Constructor which accepts and wrappers token.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`boolean`	`absolutePath(java.lang.Object[] path)` Compares this node's complete path from the root node (down to and including the current node) with the specified path.
`boolean`	`absolutePath(java.lang.String path)` Deprecated.
`void`	`addChild(antlr.collections.AST node)` Add a child to the list of this node's children.
`boolean`	`ancestor(int level, int type)` Searches the AST's ancestors for an exact token type match.
`boolean`	`ancestor(int level, int[] types)` Searches the AST's ancestors for a token type that matches any of a given list of token types.
`boolean`	`ancestor(int level, int lower, int upper)` Searches the AST's ancestors for a token type that matches a given range of token types (inclusively).
`int`	`annotationCount(java.lang.String key, java.lang.Object value)` Returns the number of annotation objects of an array annotation that are equal to the specified `Object`.
`java.util.Iterator<java.lang.String>`	`annotationKeys()` Get an iterator on the keys for all annotations (if any) stored in this AST.
`int`	`annotationSize(java.lang.String key)` Returns the size of an array annotation as indexed by an arbitrary key.
`void`	`brainwash(java.lang.String filename)` Clear all IDs of an AST and register it under a new filename.
`void`	`brainwash(java.lang.String filename, boolean shadow)` Clear all IDs of an AST and register it under a new filename.
`void`	`clearAnnotations()` Removes ALL annotations from this AST.
`void`	`clearIds()` Clears (sets to `null`) the unique ID of this node and all descendant nodes using recursion.
`boolean`	`compareWith(Aast other)` Compare subtree starting from `this` node as a root and compare it with given subtree.
`boolean`	`compareWith(Aast other, boolean ignoreCase)` Compare subtree starting from `this` node as a root and compare it with given subtree.
`private AnnotatedAst`	`createNode(antlr.Token token, Aast parent)` Create a new AST node of the same sub-class as the current node and initialize it using the given token.
`private void`	`createShadowNodes(java.lang.Long fileId)` Read the original token out of the `original-token` annotation and create shadow nodes from the hidden before and after tokens if they exist.
`boolean`	`descendant(int level, int type)` Searches the AST's descendants for an exact token type match.
`boolean`	`descendant(int level, int[] types)` Searches the AST's descendants for a token type that matches any of a given list of token types.
`boolean`	`descendant(int level, int[] types, java.lang.String key, java.lang.Object match, java.lang.Integer index)` Searches the AST's descendants for a token type that matches any of a given list of token types and for each found, matches the given value for an annotation.
`boolean`	`descendant(int level, int lower, int upper)` Searches the AST's descendants for a token type that matches a given range of token types (inclusively).
`boolean`	`descendant(int level, int lower, int upper, java.lang.String key, java.lang.Object match, java.lang.Integer index)` Searches the AST's descendants for a token type that matches a given range of token types (inclusively), and for each found, matches the given value for an annotation.
`boolean`	`downPath(int tok1)` Determines if this node's path downward matches the specified path.
`boolean`	`downPath(int tok1, int tok2)` Determines if this node's path downward matches the specified path.
`boolean`	`downPath(int tok1, int tok2, int tok3)` Determines if this node's path downward matches the specified path.
`boolean`	`downPath(int tok1, int tok2, int tok3, int tok4)` Determines if this node's path downward matches the specified path.
`boolean`	`downPath(java.lang.Object... path)` Determines if this node's path downward matches the specified path.
`boolean`	`downPath(java.lang.String path)` Deprecated. Use downPath(Integer... path) instead.
`private void`	`driveFixups(Aast child)` Kickoff the fixup process on a specific child to set IDs and ensure that all parent linkages are correct.
`java.lang.String`	`dumpSimpleTree()` Create a human readable text concise representation of the tree rooted at this AST.
`java.lang.String`	`dumpTree()` Create a human readable text representation of the tree rooted at this AST.
`java.lang.String`	`dumpTree(boolean annotations)` Create a human readable text representation of the tree rooted at this AST.
`Aast`	`duplicate()` Creates a deep copy of the original, including all descendant ASTs.
`Aast`	`duplicate(java.util.Map<java.lang.Long,Aast> idMap)` Creates a deep copy of the original, including all descendant ASTs.
`Aast`	`duplicateFresh()` Creates a deep copy of the original, including all descendant ASTs.
`Aast`	`duplicateFresh(java.util.Map<java.lang.Long,Aast> idMap)` Creates a deep copy of the original, including all descendant ASTs.
`private void`	`extractTokenData(antlr.Token token)` Extract line number, column number from the input token and store this information as member data.
`private Aast`	`farthest(boolean right)` Search the sub-tree rooted at this node to return the AST node that exists farthest to the left or right (in line/column).
`void`	`fixupParent(Aast parent)` Fixup the parent references for this tree.
`void`	`fixups(Aast parent, java.lang.Long fileId)` Assigns parent nodes throughout the AST hierarchy of which this AST is the root.
`void`	`fixups(Aast parent, java.lang.Long fileId, boolean shadow)` Assigns parent nodes throughout the AST hierarchy of which this AST is the root.
`Aast`	`getAncestor(int level)` Get the ancestor node at the specified number of levels of ancestry, if it exists.
`Aast`	`getAncestor(int level, int type)` Get the first ancestor node of a specified type found in a walk up to the maximum specified number of levels of ancestry, if such a node exists.
`Aast`	`getAncestor(int level, int type, java.lang.String key, java.lang.Object value)` Get the first ancestor node of the specified type which also has a particular annotation with the specified value.
`Aast`	`getAncestor(int level, java.util.List<java.lang.Integer> types)` Get the first ancestor node of the specified types found in a walk up to the maximum specified number of levels of ancestry, if such a node exists.
`java.lang.Object`	`getAnnotation(java.lang.String key)` Retrieve an annotation.
`java.lang.Object`	`getAnnotation(java.lang.String key, int index)` Retrieve an element in an array annotation using the specified key as a unique identifier and an index to specify the location in the array from which to read the element.
`private static java.lang.String`	`getAnnotationKey(java.lang.String anno)` Get the lowercase annotation key from the `ANNO_LOWER` cache.
`java.util.List<java.lang.Object>`	`getAnnotationList(java.lang.String key)` Retrieve an unmodifiable list view of an array annotation.
`Aast`	`getChildAt(int index)` Search the immediate children for the one at the specified index.
`int`	`getColumn()` Get the source code column number which designates where in the source code file the token wrappered by this node was found.
`int`	`getDepth()` Get the level of nesting of this AST from the root AST, where `0` indicates the root, and a positive number indicates generations from the root.
`java.lang.String`	`getDescriptiveTokenText()` Returns a descriptive string for the current node.
`java.lang.String`	`getFilename()` Get source code filename associated with the current node.
`private Aast`	`getFirstChild(boolean honorHidden)` Returns the first child (hidden or not) if the `honorHidden` flag is `false`, or the first non-hidden child if the `honorHidden` flag is `true`.
`java.lang.Long`	`getId()` Retrieve this AST's unique, persistent identifier.
`Aast`	`getImmediateChild(java.util.Collection<java.lang.Integer> types, Aast start)` Search the immediate children for one that matches any token type in the specified Collection of types.
`Aast`	`getImmediateChild(int type, Aast start)` Search the immediate children for one that matches a specific token type.
`java.util.List<Aast>`	`getImmediateChildren(int type)` Get immediate child nodes of this AST that match a specific token type.
`int`	`getIndexPos()` Returns the index position of this instance in the array of children of its parent.
`Aast`	`getLastImmediateChild(int type)` Search the immediate children for last child that matches a specific token type.
`Aast`	`getLeftAdjacent()` Search the tree to return the AST node that exists nearest on the left (in line/column).
`Aast`	`getLeftmost()` Search the sub-tree rooted at this node to return the AST node that exists farthest to the left (in line/column).
`ShadowNode`	`getLeftmostShadow()` Access a shadow node that exists farthest to the left of the current node.
`ShadowNode`	`getLeftShadow()` Access a shadow node that exists to the left of the current node.
`Aast`	`getLeftShadowNode()` Access the AST of a shadow node that exists to the left of the current node.
`int`	`getLine()` Get the source code line number which designates where in the source code file the token wrappered by this node was found.
`TreeLocal`	`getLocal()` Access the tree-local data directly.
`private Aast`	`getNextSibling(boolean honorHidden)` Returns the next sibling (hidden or not) if the `honorHidden` flag is `false`, or the next non-hidden sibling if the `honorHidden` flag is `true`.
`int`	`getNumChildren()` Get the total number of all descendants of this AST.
`int`	`getNumImmediateChildren()` Get the number of immediate child nodes of this AST.
`int`	`getNumImmediateChildren(int type)` Get the number of immediate child nodes of this AST that match a specific token type.
`int`	`getNumLeftSiblings()` Returns the number of siblings to this node's left (before this node in a tree walk).
`int`	`getNumRightSiblings()` Returns the number of siblings to this node's right (after this node in a tree walk).
`Aast`	`getParent()` Get this Aast's parent node, if any.
`private Aast[]`	`getParentChain(Aast node)` Get chain of parent nodes starting from root to this node.
`java.lang.String`	`getPath()` Return a string representing the path of this AST from the root AST, in terms of the token type of each element from the root to this AST.
`private java.lang.String`	`getPath(int max)` Return a string representing the path of this AST from an ancestor (possibly the root) AST, in terms of the token type of each element from the ancestor to this AST.
`Aast`	`getPrevSibling()` Returns the sibling to the left of this node in the tree or `null` if this instance is the first child of its parent.
`Aast`	`getRightAdjacent()` Search the tree to return the AST node that exists nearest on the right (in line/column).
`Aast`	`getRightmost()` Search the sub-tree rooted at this node to return the AST node that exists farthest to the right (in line/column).
`ShadowNode`	`getRightmostShadow()` Access a shadow node that exists farthest to the right of the current node.
`ShadowNode`	`getRightShadow()` Access a shadow node that exists to the right of the current node.
`Aast`	`getRightShadowNode()` Access the AST of a shadow node that exists to the right of the current node.
`java.lang.Object`	`getRuntimeAnnotation(int key)` Get the runtime annotation with the specified key.
`java.util.Iterator<ShadowNode>`	`getShadowNodeList()` Access the list of all shadow nodes.
`abstract java.lang.String`	`getSymbolicTokenType()` Returns the symbolic representation of this AST's token type.
`void`	`graft(Aast child)` Grafts a new child subtree onto this AST.
`void`	`graftAt(Aast child, int index)` Grafts a new child subtree onto this AST at a specific 0-based child index.
`Aast`	`graftCopyTo(Aast parent, int[] validTokens)` Grafts a copy of this AST node onto the specified parent AST.
`Aast`	`graftCopyTo(Aast parent, int[] validTokens, boolean preserve)` Grafts a copy of this AST node onto the specified parent AST.
`void`	`initialize(antlr.collections.AST ast)` Initialize this node with the specified AST.
`void`	`initialize(antlr.Token token)` Initialize this node with the specified token.
`void`	`intern()` Walk the tree formed by this node and all of its descendants, interning all strings stored in the AST's text and annotation values which are `String` objects.
`boolean`	`isAncestorOf(int level, Aast other)` Report whether this node is an ancestor of the given node.
`boolean`	`isAnnotation(java.lang.String key)` Determines if an annotation exists of any `String`, `Double`, `Long`, `Boolean` or `List` value, indexed by an arbitrary key.
`boolean`	`isArtificial()` Reports on a node that was not generated by parsing text, but was created for some structural purpose by the parser or by post-processing code.
`boolean`	`isHidden()` Get this AST's hidden status.
`boolean`	`isLeaf()` Indicate whether this AST node represents a leaf node in the tree (a node with no children).
`boolean`	`isRoot()` Indicate whether this AST node represents the root of its hierarchy.
`boolean`	`isRuntimeAnnotation(int key)` Check if the runtime annotation with the specified key is set.
`java.util.Iterator<Aast>`	`iterator()` Return an iterator to walk this AST recursively in a depth-first traversal.
`java.util.Iterator<Aast>`	`iterator(int maxLevels, AstWalkListener listener)` Return an iterator to walk this AST recursively in a depth-first traversal.
`java.util.Iterator<Aast>`	`iterator(int maxLevels, AstWalkListener listener, boolean honorHidden)` Return an iterator to walk this AST recursively in a depth-first traversal.
`abstract java.lang.String`	`lookupTokenName(int type)` Translates an integer value of a token type into the associated human readable text representation.
`abstract int`	`lookupTokenType(java.lang.String tokenName)` Translates a text representation of a token type into the actual integer value.
`boolean`	`matchAnnotation(java.lang.String key, java.lang.Object match, java.lang.Integer index)` Indicate whether this AST has an annotation which matches the specified conditions.
`void`	`move(Aast parent, int index)` Move the node from one location to another.
`private Aast`	`nearest(boolean right)` Search the tree to return the AST node that exists nearest to the left or right (in line/column).
`Aast`	`nearestEnclosing(Aast other)` Find and return the nearest ancestor of the current instance which also encloses the node passed as a parameter.
`protected abstract AnnotatedAst`	`newInstance()` Create a new instance of this AST implementation.
`void`	`putAnnotation(java.lang.String key, java.lang.Boolean annotation)` Store a boolean annotation using the specified key as a unique identifier.
`void`	`putAnnotation(java.lang.String key, java.lang.Boolean annotation, int index)` Store a boolean element in an array annotation using the specified key as a unique identifier and an index to specify the location in which to insert.
`void`	`putAnnotation(java.lang.String key, java.lang.Double annotation)` Store a floating point numeric annotation using the specified key as a unique identifier.
`void`	`putAnnotation(java.lang.String key, java.lang.Double annotation, int index)` Store a floating point numeric element in an array annotation using the specified key as a unique identifier and an index to specify the location in which to insert.
`void`	`putAnnotation(java.lang.String key, java.util.List<java.lang.Object> annotation)` Store a list of annotations at once using the specified key as a unique identifier.
`void`	`putAnnotation(java.lang.String key, java.lang.Long annotation)` Store an integral numeric annotation using the specified key as a unique identifier.
`void`	`putAnnotation(java.lang.String key, java.lang.Long annotation, int index)` Store an integral numeric element in an array annotation using the specified key as a unique identifier and an index to specify the location in which to insert.
`void`	`putAnnotation(java.lang.String key, java.lang.String annotation)` Store a text annotation using the specified key as a unique identifier.
`void`	`putAnnotation(java.lang.String key, java.lang.String annotation, int index)` Store a text element in an array annotation using the specified key as a unique identifier and an index to specify the location in which to insert.
`private void`	`putAnnotationImpl(java.lang.String key, java.lang.Object annotation)` Stores an annotation object under a unique key, creating the map of annotations first, if necessary.
`private boolean`	`putAnnotationImpl(java.lang.String key, java.lang.Object annotation, int index)` Stores an annotation object in an array annotation under a unique key, creating both the array itself and the map of annotations first, if necessary.
`void`	`putAnnotationObject(java.lang.String key, java.lang.Object annotation)` Store any object as annotation for this node.
`boolean`	`relativePath(int tok1)` Determines if this node's path from the root ends with the specified path.
`boolean`	`relativePath(int tok1, int tok2)` Determines if this node's path from the root ends with the specified path.
`boolean`	`relativePath(int tok1, int tok2, int tok3)` Determines if this node's path from the root ends with the specified path.
`boolean`	`relativePath(int tok1, int tok2, int tok3, int tok4)` Determines if this node's path from the root ends with the specified path.
`boolean`	`relativePath(java.lang.Object... path)` Determines if this node's path from the root ends with the specified path.
`boolean`	`relativePath(java.lang.String path)` Deprecated. Use relativePath(Integer... path) instead.
`void`	`remove()` Remove this AST (and the entire sub-tree rooted at this node) from its parent's collection of children.
`java.lang.Object`	`removeAnnotation(java.lang.String key)` Remove a specific annotation from this AST.
`java.lang.Object`	`removeAnnotation(java.lang.String key, int index)` Remove a specific element from the array annotation in this AST.
`void`	`removeChildren()` Remove all child nodes.
`private boolean`	`searchDown(java.lang.Object[] list, int index)` Worker to recursively search down the descendant tree to match the passed-in list of token types.
`private boolean`	`searchDown(java.lang.String[] list, int index)` Worker to recursively search down the descendant tree to match the passed-in list of token names.
`private static boolean`	`searchUp(AnnotatedAst node, java.lang.Object[] path, int k, boolean absolute)` Worker to compare the given source path (from root to a given node) to the expected path to the target and return the comparison results.
`private boolean`	`searchUp(java.lang.String source, java.lang.String target)` Worker to compare the given source path (from root to a given node) to the expected path to the target and return the comparison results.
`void`	`setColumn(int column)` Set the source file column number for this node.
`void`	`setFirstChild(antlr.collections.AST node)` Set the first child node of this AST.
`void`	`setHidden(boolean hide)` Set this AST's hidden status.
`boolean`	`setId(java.lang.Long id)` Set this AST's unique, persistent identifier.
`void`	`setLine(int line)` Set the source file line number for this node.
`void`	`setLocal(TreeLocal local)` Set the tree-local data directly.
`void`	`setNextSibling(antlr.collections.AST node)` Set the next sibling to the right of this AST, replacing any such node already present though fixups are not performed.
`void`	`setParent(Aast parent)` Set this Aast's parent node.
`void`	`setRuntimeAnnotation(int key, java.lang.Object value)` Set the runtime annotation with the specified key.
`boolean`	`sibling(long type)` Test whether any of this node's siblings has the given token type.
`java.lang.String`	`toString()` Create a string representation of this AST.
`java.lang.String`	`toStringVerbose()` Create a verbose string representation of this AST.
`boolean`	`upPath(int tok1)` Determines if this node's path upward matches the specified path.
`boolean`	`upPath(int tok1, int tok2)` Determines if this node's path upward matches the specified path.
`boolean`	`upPath(int tok1, int tok2, int tok3)` Determines if this node's path upward matches the specified path.
`boolean`	`upPath(int tok1, int tok2, int tok3, int tok4)` Determines if this node's path upward matches the specified path.
`boolean`	`upPath(java.lang.Object... path)` Determines if this node's path upward matches the specified path.
`boolean`	`upPath(java.lang.String path)` Deprecated. Use upPath(Integer... path) instead.

Methods inherited from class antlr.CommonAST
getText, getType, initialize, setText, setType

Methods inherited from class antlr.BaseAST
decode, encode, equals, equalsList, equalsListPartial, equalsTree, equalsTreePartial, findAll, findAllPartial, getFirstChild, getNextSibling, getNumberOfChildren, getTokenNames, setVerboseStringConversion, toStringList, toStringTree, xmlSerialize, xmlSerializeNode, xmlSerializeRootClose, xmlSerializeRootOpen

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.goldencode.ast.Aast
getImmediateChild

Methods inherited from interface antlr.collections.AST
equals, equalsList, equalsListPartial, equalsTree, equalsTreePartial, findAll, findAllPartial, getFirstChild, getNextSibling, getNumberOfChildren, getText, getType, initialize, setText, setType, toStringList, toStringTree

- Field Detail
  - LOG
```
private static final ConversionStatus LOG
```
    Logger
  - id
```
private java.lang.Long id
```
    Unique, persistent identifier
  - line
```
private int line
```
    Source file line number associated with this AST
  - column
```
private int column
```
    Source file column number associated with this AST
  - parent
```
private Aast parent
```
    Parent node to this node
  - tail
```
private AnnotatedAst tail
```
    Right-most child node, if any
  - hidden
```
private boolean hidden
```
    Hidden mode which can be used to modify iterator based walking.
  - annotations
```
private java.util.IdentityHashMap<java.lang.String,java.lang.Object> annotations
```
    Map of annotation objects, indexed by name
  - local
```
private TreeLocal local
```
    Tree-specific data (data that is shared by all nodes of a tree.
  - runtimeAnnotations
```
private java.lang.Object[] runtimeAnnotations
```
    Storage for runtime annotation - an array of length Aast.RUNTIME_ANNOTATION_COUNT.
  - ANNO_LOWER
```
private static java.util.Map<java.lang.String,java.lang.String> ANNO_LOWER
```
- Constructor Detail
  - AnnotatedAst
```
public AnnotatedAst()
```
    Default constructor.
  - AnnotatedAst
```
public AnnotatedAst(antlr.Token token)
```
    Constructor which accepts and wrappers token.
    
    Parameters:
    
    token - Token upon which this node is based.
- Method Detail
  - getAnnotationKey
```
private static java.lang.String getAnnotationKey(java.lang.String anno)
```
    Get the lowercase annotation key from the ANNO_LOWER cache.
    
    Returns:
    
    See above.
  - lookupTokenType
```
public abstract int lookupTokenType(java.lang.String tokenName)
```
    Translates a text representation of a token type into the actual integer value.
    
    Specified by:
    
    lookupTokenType in interface Aast
    
    Parameters:
    
    tokenName - The text representation of the token type.
    
    Returns:
    
    A valid integer token type value or -1 if no match was found.
  - lookupTokenName
```
public abstract java.lang.String lookupTokenName(int type)
```
    Translates an integer value of a token type into the associated human readable text representation.
    
    Specified by:
    
    lookupTokenName in interface Aast
    
    Parameters:
    
    type - The integer token type.
    
    Returns:
    
    A valid symbolic token type name or null if no match was found.
  - newInstance
```
protected abstract AnnotatedAst newInstance()
```
    Create a new instance of this AST implementation.
    
    Returns:
    
    A new instance.
  - removeChildren
```
public void removeChildren()
```
    Remove all child nodes. This method overrides the base implementation to improve the performance of adding a child node.
    
    Overrides:
    
    removeChildren in class antlr.BaseAST
  - addChild
```
public void addChild(antlr.collections.AST node)
```
    Add a child to the list of this node's children. This method overrides the base implementation to improve performance.
    
    Specified by:
    
    addChild in interface antlr.collections.AST
    
    Overrides:
    
    addChild in class antlr.BaseAST
    
    Parameters:
    
    node - Child node to add to the end of the list of child nodes. If null, the method does nothing. If not null, this object must be of type AnnotatedAst.
  - setFirstChild
```
public void setFirstChild(antlr.collections.AST node)
```
    Set the first child node of this AST. If the AST already has child nodes, they effectively are removed by this method, though fixups are not performed. This method overrides the base implementation to improve performance of adding new child nodes.
    
    Specified by:
    
    setFirstChild in interface antlr.collections.AST
    
    Overrides:
    
    setFirstChild in class antlr.BaseAST
    
    Parameters:
    
    node - Child node to set as the first child of this AST. If null, any existing list of child nodes is removed. If not null, this object must be of type AnnotatedAst.
  - setNextSibling
```
public void setNextSibling(antlr.collections.AST node)
```
    Set the next sibling to the right of this AST, replacing any such node already present though fixups are not performed. This method overrides the base implementation to improve performance of adding new child nodes.
    
    Specified by:
    
    setNextSibling in interface antlr.collections.AST
    
    Overrides:
    
    setNextSibling in class antlr.BaseAST
    
    Parameters:
    
    node - Child node to set as the next sibling. If null, any existing sibling nodes to the right of this node are removed. If not null, this object must be of type AnnotatedAst.
  - setLine
```
public void setLine(int line)
```
    Set the source file line number for this node.
    
    Specified by:
    
    setLine in interface Aast
    
    Parameters:
    
    line - New line number to associate with this node.
  - setColumn
```
public void setColumn(int column)
```
    Set the source file column number for this node.
    
    Specified by:
    
    setColumn in interface Aast
    
    Parameters:
    
    column - New column number to associate with this node.
  - graftCopyTo
```
public Aast graftCopyTo(Aast parent,
                        int[] validTokens)
                 throws AstException
```
    Grafts a copy of this AST node onto the specified parent AST. If a list of valid token types is provided (i.e. validTokens), all child nodes of the copy which do not match a valid token type are removed from the copy node, before it is grafted onto the parent. All necessary parent and ID fixups are performed on the copy to integrate it with its new parent tree.
    The line and column numbers will be preserved in the duplicated tree.
    
    Specified by:
    
    graftCopyTo in interface Aast
    
    Parameters:
    
    parent - AST node which will become the direct parent of the grafted copy of this node.
    
    validTokens - Optional array of valid token types. If not null, only those children of the copy node which match a valid token type are allowed to remain. All other child nodes are removed from the copy.
    
    Returns:
    
    The new AST node grafted into the tree.
    
    Throws:
    
    AstException - if any error occurs registering the grafted node with the AST registry.
  - graftCopyTo
```
public Aast graftCopyTo(Aast parent,
                        int[] validTokens,
                        boolean preserve)
                 throws AstException
```
    Grafts a copy of this AST node onto the specified parent AST. If a list of valid token types is provided (i.e. validTokens), all child nodes of the copy which do not match a valid token type are removed from the copy node, before it is grafted onto the parent. All necessary parent and ID fixups are performed on the copy to integrate it with its new parent tree.
    
    Specified by:
    
    graftCopyTo in interface Aast
    
    Parameters:
    
    parent - AST node which will become the direct parent of the grafted copy of this node.
    
    validTokens - Optional array of valid token types. If not null, only those children of the copy node which match a valid token type are allowed to remain. All other child nodes are removed from the copy.
    
    preserve - true to preserve line and column information in the duplicated tree.
    
    Returns:
    
    The new AST node grafted into the tree.
    
    Throws:
    
    AstException - if any error occurs registering the grafted node with the AST registry.
  - graft
```
public void graft(Aast child)
           throws AstException
```
    Grafts a new child subtree onto this AST. All necessary parent and ID fixups are performed to integrate the child tree with its new parent tree.
    
    Specified by:
    
    graft in interface Aast
    
    Parameters:
    
    child - AST subtree to add as a child of this node.
    
    Throws:
    
    AstException - if any error occurs registering the grafted node with the AST registry.
  - graftAt
```
public void graftAt(Aast child,
                    int index)
             throws AstException
```
    Grafts a new child subtree onto this AST at a specific 0-based child index. All necessary parent and ID fixups are performed to integrate the child tree with its new parent tree.
    
    Specified by:
    
    graftAt in interface Aast
    
    Parameters:
    
    child - AST subtree to add as a child of this node.
    
    index - 0 to insert as the first child, -1 to insert as the last child or a 0-based index to specify an exact child index at which to insert the new child. All current children at that index or at a greater index, are moved right. If the index is greater than the current number of children, the new child will be added at the end.
    
    Throws:
    
    AstException - if any error occurs registering the grafted node with the AST registry.
  - duplicate
```
public Aast duplicate()
```
    Creates a deep copy of the original, including all descendant ASTs. The copy contains no cross-linked object references back to the original AST. This method essentially results in recursive calls when making copies of the AST's children.
    
    Specified by:
    
    duplicate in interface Aast
    
    Returns:
    
    The duplicated AST or null if there is any exception during the copy.
  - duplicate
```
public Aast duplicate(java.util.Map<java.lang.Long,Aast> idMap)
```
    Creates a deep copy of the original, including all descendant ASTs. The copy contains no cross-linked object references back to the original AST. This method essentially results in recursive calls when making copies of the AST's children. If an ID map is provided, map this new node to its ID.
    
    Specified by:
    
    duplicate in interface Aast
    
    Parameters:
    
    idMap - Map of IDs to ASTs. May be null.
    
    Returns:
    
    The duplicated AST or null if there is any exception during the copy.
  - duplicateFresh
```
public Aast duplicateFresh()
```
    Creates a deep copy of the original, including all descendant ASTs. The copy contains no cross-linked object references back to the original AST. This method essentially results in recursive calls when making copies of the AST's children.
    All unique IDs of this new sub-tree are cleared before this method returns (see clearIds()).
    
    Specified by:
    
    duplicateFresh in interface Aast
    
    Returns:
    
    The duplicated AST or null if there is any exception during the copy.
  - duplicateFresh
```
public Aast duplicateFresh(java.util.Map<java.lang.Long,Aast> idMap)
```
    Creates a deep copy of the original, including all descendant ASTs. The copy contains no cross-linked object references back to the original AST. This method essentially results in recursive calls when making copies of the AST's children. If an ID map is provided, map this new node to its ID.
    All unique IDs of this new sub-tree are cleared before this method returns (see clearIds()).
    
    Specified by:
    
    duplicateFresh in interface Aast
    
    Parameters:
    
    idMap - Map of IDs to ASTs. May be null.
    
    Returns:
    
    The duplicated AST or null if there is any exception during the copy.
  - clearIds
```
public void clearIds()
```
    Clears (sets to null) the unique ID of this node and all descendant nodes using recursion. Warning: this is very dangerous so you have better know what you are doing!
    
    Specified by:
    
    clearIds in interface Aast
  - brainwash
```
public void brainwash(java.lang.String filename)
               throws AstException
```
    Clear all IDs of an AST and register it under a new filename. The AST is walked to fix-up all parent-child relationships as part of the re-initialization.
    This would be done in order to safely save a copy AST under a different filename than the source AST. It is necessary in order to avoid having two ASTs registered to the same filename and ID in the AST registry.
    No shadow nodes will be created using this version of the method. All hidden tokens will be dropped.
    
    Specified by:
    
    brainwash in interface Aast
    
    Parameters:
    
    filename - New filename under which the AST is registered.
    
    Throws:
    
    AstException - if any error occurs registering AST or applying fixups.
  - brainwash
```
public void brainwash(java.lang.String filename,
                      boolean shadow)
               throws AstException
```
    Clear all IDs of an AST and register it under a new filename. The AST is walked to fix-up all parent-child relationships as part of the re-initialization.
    This would be done in order to safely save a copy AST under a different filename than the source AST. It is necessary in order to avoid having two ASTs registered to the same filename and ID in the AST registry.
    
    Parameters:
    
    filename - New filename under which the AST is registered.
    
    shadow - true to create shadow nodes from hidden tokens. false to drop hidden tokens without creating any shadow nodes.
    
    Throws:
    
    AstException - if any error occurs registering AST or applying fixups.
  - getId
```
public java.lang.Long getId()
```
    Retrieve this AST's unique, persistent identifier. An ID should be assigned after AST creation but before external post-processing. Thus, a null return from this method generally indicates an invalid AST.
    
    Specified by:
    
    getId in interface Aast
    
    Returns:
    
    A persistent value that uniquely identifies this AST node, or null if no ID has been assigned.
  - isRoot
```
public boolean isRoot()
```
    Indicate whether this AST node represents the root of its hierarchy. This implementation defines "root-hood" as having a null parent. Note that this will create false positives for an AST which has not yet had its initial "fix-up" performed.
    
    Specified by:
    
    isRoot in interface Aast
    
    Returns:
    
    true if this node is the tree root, else false.
  - isLeaf
```
public boolean isLeaf()
```
    Indicate whether this AST node represents a leaf node in the tree (a node with no children).
    
    Specified by:
    
    isLeaf in interface Aast
    
    Returns:
    
    true if this node has no children, else false.
  - setId
```
public boolean setId(java.lang.Long id)
```
    Set this AST's unique, persistent identifier. Once this value is set, it is set "for life" and may not be changed. An ID should be assigned after AST creation but before external post-processing begins.
    Normally, it would be better to set this value during construction. However, we do not have control over the construction process when this AST is instantiated by ANTLR during parsing, so it is done early in post-processing instead.
    
    Specified by:
    
    setId in interface Aast
    
    Parameters:
    
    id - This AST's assigned ID.
    
    Returns:
    
    true if the ID was set; false if it could not be set because it had previously been set.
  - getPath
```
public java.lang.String getPath()
```
    Return a string representing the path of this AST from the root AST, in terms of the token type of each element from the root to this AST. The token types are separated by a forward slash and a trailing slash ends the path. For example:
```
    BLOCK/STATEMENT/KW_IF/
 
```
    represents the following path:
```
    ROOT [type=BLOCK]
     |
    NODE A [type=STATEMENT]
     |
    NODE B [type=KW_IF]
 
```
    The string uniquely identifies the path from this node back to the root, but is not necessarily unique when traversed from the root to this node.
    Specified by:
    
    getPath in interface Aast
    
    Returns:
    
    A string which, when read from right to left, indicates the token type of each node from this AST to the root AST.
  - getDepth
```
public int getDepth()
```
    Get the level of nesting of this AST from the root AST, where 0 indicates the root, and a positive number indicates generations from the root.
    
    Specified by:
    
    getDepth in interface Aast
    
    Returns:
    
    Nesting level.
  - getNumImmediateChildren
```
public int getNumImmediateChildren()
```
    Get the number of immediate child nodes of this AST.
    
    Specified by:
    
    getNumImmediateChildren in interface Aast
    
    Returns:
    
    Number of immediate child nodes.
  - getImmediateChildren
```
public java.util.List<Aast> getImmediateChildren(int type)
```
    Get immediate child nodes of this AST that match a specific token type.
    
    Parameters:
    
    type - The token type of the child nodes to search for.
    
    Returns:
    
    List of immediate child nodes which have the specified token type.
  - getNumImmediateChildren
```
public int getNumImmediateChildren(int type)
```
    Get the number of immediate child nodes of this AST that match a specific token type.
    
    Specified by:
    
    getNumImmediateChildren in interface Aast
    
    Parameters:
    
    type - The token type of the child nodes to search for.
    
    Returns:
    
    Number of immediate child nodes which have the specified token type.
  - getNumChildren
```
public int getNumChildren()
```
    Get the total number of all descendants of this AST.
    
    Specified by:
    
    getNumChildren in interface Aast
    
    Returns:
    
    Total number of descendants.
  - initialize
```
public void initialize(antlr.collections.AST ast)
```
    Initialize this node with the specified AST. Delegates to the superclass and copies data from ast.
    
    Specified by:
    
    initialize in interface antlr.collections.AST
    
    Overrides:
    
    initialize in class antlr.CommonAST
    
    Parameters:
    
    ast - AST upon which this node is based. Expected to be an instance of Aast.
  - initialize
```
public void initialize(antlr.Token token)
```
    Initialize this node with the specified token. Delegates to the superclass and extracts data from token for later use in line number and column queries.
    
    Specified by:
    
    initialize in interface antlr.collections.AST
    
    Overrides:
    
    initialize in class antlr.CommonAST
    
    Parameters:
    
    token - Token upon which this node is based.
  - getParent
```
public Aast getParent()
```
    Get this Aast's parent node, if any.
    
    Specified by:
    
    getParent in interface Aast
    
    Returns:
    
    Parent Aast node, or null if this node represents the root of a hierarchy.
  - setParent
```
public void setParent(Aast parent)
```
    Set this Aast's parent node.
    
    Specified by:
    
    setParent in interface Aast
    
    Parameters:
    
    parent - Parent Aast node.
  - isHidden
```
public boolean isHidden()
```
    Get this AST's hidden status.
    
    Specified by:
    
    isHidden in interface Aast
    
    Returns:
    
    true if this node should be hidden during iterator based walks (in which the iterator is specified to honor the hidden mode).
  - setHidden
```
public void setHidden(boolean hide)
```
    Set this AST's hidden status.
    
    Specified by:
    
    setHidden in interface Aast
    
    Parameters:
    
    hide - true if this node should be hidden during iterator based walks (in which the iterator is specified to honor the hidden mode).
  - getIndexPos
```
public int getIndexPos()
```
    Returns the index position of this instance in the array of children of its parent. For example, if this instance is the first child of its parent, then this method will return 0. If this child is the second child of its parent, this method will return 1, as so on.
    
    Specified by:
    
    getIndexPos in interface Aast
    
    Returns:
    
    The 0-based index position of this node OR 0 if this node has no parent (i.e. it is the tree root).
  - getPrevSibling
```
public Aast getPrevSibling()
```
    Returns the sibling to the left of this node in the tree or null if this instance is the first child of its parent.
    This method is much slower than its counterpart getNextSibling since each node does not maintain a reference back to the previous node. Thus, the parent node must be involved and this extra processing slows the resulting implementation.
    
    Specified by:
    
    getPrevSibling in interface Aast
    
    Returns:
    
    The previous sibling or null if this node is the first child (or has no parent).
  - getAncestor
```
public Aast getAncestor(int level)
```
    Get the ancestor node at the specified number of levels of ancestry, if it exists.
    
    Specified by:
    
    getAncestor in interface Aast
    
    Parameters:
    
    level - Number of generations up the tree to walk to obtain the ancestor. Set to -1 to obtain the tree root, 0 is the current node, 1 is the parent, 2 is the 'grandparent' and so forth.
    
    Returns:
    
    The specified ancestor AST node if found or null if no such node exists (if level specified is greater than depth of the tree).
  - getAncestor
```
public Aast getAncestor(int level,
                        int type)
```
    Get the first ancestor node of a specified type found in a walk up to the maximum specified number of levels of ancestry, if such a node exists.
    
    Specified by:
    
    getAncestor in interface Aast
    
    Parameters:
    
    level - Maximum number of generations up the tree to search for an ancestor. Set to -1 to search up to the tree root, 0 for the current node, 1 for the parent, 2 for the 'grandparent' and so forth.
    
    type - The token type of the ancestor to find.
    
    Returns:
    
    The specified ancestor AST node if found or null if no such node exists (if level specified is greater than depth of the tree).
  - getAncestor
```
public Aast getAncestor(int level,
                        java.util.List<java.lang.Integer> types)
```
    Get the first ancestor node of the specified types found in a walk up to the maximum specified number of levels of ancestry, if such a node exists.
    
    Specified by:
    
    getAncestor in interface Aast
    
    Parameters:
    
    level - Maximum number of generations up the tree to search for an ancestor. Set to -1 to search up to the tree root, 0 for the current node, 1 for the parent, 2 for the 'grandparent' and so forth.
    
    types - The token types of the ancestor to find.
    
    Returns:
    
    The specified ancestor AST node if found or null if no such node exists (if level specified is greater than depth of the tree).
  - getAncestor
```
public Aast getAncestor(int level,
                        int type,
                        java.lang.String key,
                        java.lang.Object value)
```
    Get the first ancestor node of the specified type which also has a particular annotation with the specified value. If a null value is provided, then the existence alone of an annotation with the specified key is considered a match. The search walks up the tree from this node to the maximum specified number of levels of ancestry.
    
    Specified by:
    
    getAncestor in interface Aast
    
    Parameters:
    
    level - Number of generations up the tree to walk to obtain the ancestor. Set to -1 to go up to the tree root, 0 only the current node, 1 is the parent, 2 is the 'grandparent' and so forth.
    
    type - The token type of the ancestor to find. Use 0 as wildcard to match all nodes. In this case the key/value combination will be used for filtering.
    
    key - Annotation key to match.
    
    value - Annotation value to match. null to match any node which has an annotation with the specified key, regardless of its value.
    
    Returns:
    
    The specified ancestor AST node if found or null if no such node exists (if level specified is greater than depth of the tree).
  - ancestor
```
public boolean ancestor(int level,
                        int type)
```
    Searches the AST's ancestors for an exact token type match. The first match ends the search but in the case of no matches, all ancestor nodes (up to the given maximum level) will have been searched.
    
    Specified by:
    
    ancestor in interface Aast
    
    Parameters:
    
    level - Maximum number of generations up the tree to search for an ancestor. Set to -1 to search up to the tree root, 0 for the current node, 1 for the parent, 2 for the 'grandparent' and so forth.
    
    type - Token type to be matched.
    
    Returns:
    
    true if type was found as a ancestor's token type within level generations, else false.
  - ancestor
```
public boolean ancestor(int level,
                        int lower,
                        int upper)
```
    Searches the AST's ancestors for a token type that matches a given range of token types (inclusively). The first match ends the search but in the case of no matches, all ancestor nodes (up to the given maximum level) will have been searched.
    
    Specified by:
    
    ancestor in interface Aast
    
    Parameters:
    
    level - Maximum number of generations up the tree to search for an ancestor. Set to -1 to search up to the tree root, 0 for the current node, 1 for the parent, 2 for the 'grandparent' and so forth.
    
    lower - Lower boundary of the token type range.
    
    upper - Upper boundary of the token type range.
    
    Returns:
    
    true if a ancestor's token type was found to match a range of types within level generations, else false.
  - ancestor
```
public boolean ancestor(int level,
                        int[] types)
```
    Searches the AST's ancestors for a token type that matches any of a given list of token types. The first match ends the search but in the case of no matches, all ancestor nodes (up to the given maximum level) will have been searched. The current node (this) is omitted from the search.
    
    Specified by:
    
    ancestor in interface Aast
    
    Parameters:
    
    level - Maximum number of generations up the tree to search for an ancestor. Set to -1 to search up to the tree root, 1 to search up to the parent, 2 2 to search up to the 'grandparent', and so forth.
    
    types - The list of token types for which to search.
    
    Returns:
    
    true if a ancestor's token type was found to match any of the given list of types within level generations, else false.
  - descendant
```
public boolean descendant(int level,
                          int type)
```
    Searches the AST's descendants for an exact token type match. The first match ends the search but in the case of no matches, all child nodes (up to the given maximum level) will have been searched.
    
    Specified by:
    
    descendant in interface Aast
    
    Parameters:
    
    level - Number of generations to search before abandoning the test. Set to 0 to search exhaustively.
    
    type - Token type to be matched.
    
    Returns:
    
    true if type was found as a descendant's token type within level generations, else false.
  - descendant
```
public boolean descendant(int level,
                          int lower,
                          int upper)
```
    Searches the AST's descendants for a token type that matches a given range of token types (inclusively). The first match ends the search but in the case of no matches, all child nodes (up to the given maximum level) will have been searched.
    
    Specified by:
    
    descendant in interface Aast
    
    Parameters:
    
    level - Number of generations to search before abandoning the test. Set to 0 to search exhaustively.
    
    lower - Lower boundary of the token type range.
    
    upper - Upper boundary of the token type range.
    
    Returns:
    
    true if a descendant's token type was found to match a range of types within level generations, else false.
  - descendant
```
public boolean descendant(int level,
                          int lower,
                          int upper,
                          java.lang.String key,
                          java.lang.Object match,
                          java.lang.Integer index)
```
    Searches the AST's descendants for a token type that matches a given range of token types (inclusively), and for each found, matches the given value for an annotation. The first match ends the search but in the case of no matches, all child nodes (up to the given maximum level) will have been searched.
    
    Specified by:
    
    descendant in interface Aast
    
    Parameters:
    
    level - Number of generations to search before abandoning the test. Set to 0 to search exhaustively.
    
    lower - Lower boundary of the token type range.
    
    upper - Upper boundary of the token type range.
    
    key - Key of the annotation to match. If null, only the token types are used as match criteria.
    
    match - Value of the annotation to match. Ignored if key is null. Must be the same data type as the annotation being searched.
    
    index - Zero-based index of the annotation, if the annotation is part of a list. Set to -1 to test all elements of an annotation list. Set to null for a scalar annotation.
    
    Returns:
    
    true if a descendant's token type was found to match a range of types and an optional annotation was found to match within level generations, else false.
  - descendant
```
public boolean descendant(int level,
                          int[] types)
```
    Searches the AST's descendants for a token type that matches any of a given list of token types. The first match ends the search but in the case of no matches, all child nodes (up to the given maximum level) will have been searched.
    
    Specified by:
    
    descendant in interface Aast
    
    Parameters:
    
    level - Number of generations to search before abandoning the test. Set to 0 to search exhaustively.
    
    types - The list of token types for which to search.
    
    Returns:
    
    true if a descendant's token type was found to match any of the given list of types within level generations, else false.
  - descendant
```
public boolean descendant(int level,
                          int[] types,
                          java.lang.String key,
                          java.lang.Object match,
                          java.lang.Integer index)
```
    Searches the AST's descendants for a token type that matches any of a given list of token types and for each found, matches the given value for an annotation. The first match ends the search but in the case of no matches, all child nodes (up to the given maximum level) will have been searched.
    
    Specified by:
    
    descendant in interface Aast
    
    Parameters:
    
    level - Number of generations to search before abandoning the test. Set to 0 to search exhaustively.
    
    types - The list of token types for which to search.
    
    key - Key of the annotation to match. If null, only the token types are used as match criteria.
    
    match - Value of the annotation to match. Ignored if key is null. Must be the same data type as the annotation being searched.
    
    index - Zero-based index of the annotation, if the annotation is part of a list. Set to -1 to test all elements of an annotation list. Set to null for a scalar annotation.
    
    Returns:
    
    true if a descendant's token type was found to match any of the given list of types and an optional annotation was matched within level generations, else false.
  - matchAnnotation
```
public boolean matchAnnotation(java.lang.String key,
                               java.lang.Object match,
                               java.lang.Integer index)
```
    Indicate whether this AST has an annotation which matches the specified conditions.
    The match succeeds if an annotation exists with the given key and match value. If index is not null, the annotation must exist in an annotation list and the annotation element at the given index must match the given match value.
    The match fails under the following conditions without raising an error:
    - No annotation is found with the given key;
    - An annotation is found with the given key, but it does not match the given value;
    - index is a positive value that is out-of-bounds for the annotation list;
    - index is not null and the annotation is scalar.
    Specified by:
    
    matchAnnotation in interface Aast
    
    Parameters:
    
    key - The key under which to check for an annotation. May not be null.
    
    match - An object to match as the annotation's value. Must be the same data type as the annotation, such that a comparison using equals will determine whether the annotation matches. May not be null.
    
    index - Non-negative, zero-based index of the annotation, if it is part of a list. Set to null for a scalar annotation. Set to -1 to check all elements of a list for a match.
    
    Returns:
    
    true if a matching annotation exists, else false.
  - sibling
```
public boolean sibling(long type)
```
    Test whether any of this node's siblings has the given token type.
    
    Specified by:
    
    sibling in interface Aast
    
    Parameters:
    
    type - Token type to match.
    
    Returns:
    
    true if any of this node's siblings match, else false.
  - getNumLeftSiblings
```
public int getNumLeftSiblings()
```
    Returns the number of siblings to this node's left (before this node in a tree walk). This is a synonym for getIndexPos().
    
    Specified by:
    
    getNumLeftSiblings in interface Aast
    
    Returns:
    
    The number of left siblings or 0 if this node is the first child or has no parent (i.e. it is the tree root).
  - getNumRightSiblings
```
public int getNumRightSiblings()
```
    Returns the number of siblings to this node's right (after this node in a tree walk).
    
    Specified by:
    
    getNumRightSiblings in interface Aast
    
    Returns:
    
    The number of right siblings or 0 if this node is the last child or has no parent (i.e. it is the tree root).
  - isAncestorOf
```
public boolean isAncestorOf(int level,
                            Aast other)
```
    Report whether this node is an ancestor of the given node.
    
    Specified by:
    
    isAncestorOf in interface Aast
    
    Parameters:
    
    level - The number of generations to search before abandoning the test. Set to 0 to search exhaustively.
    
    other - The node whose ancestry will be tested.
    
    Returns:
    
    true if this node is an ancestor of other, else false. Returns false if this == other .
  - absolutePath
```
@Deprecated
public boolean absolutePath(java.lang.String path)
```
    Deprecated.
    
    Compares this node's complete path from the root node (down to and including the current node) with the specified path.
    
    Specified by:
    
    absolutePath in interface Aast
    
    Parameters:
    
    path - Root-to-current path, formatted as described in getPath().
    
    Returns:
    
    true if specified path matches this node's path exactly, else false.
  - absolutePath
```
public boolean absolutePath(java.lang.Object[] path)
```
    Compares this node's complete path from the root node (down to and including the current node) with the specified path.
    
    Specified by:
    
    absolutePath in interface Aast
    
    Parameters:
    
    path - Root-to-current path, as an array of integers representing the types of the ancestor's nodes.
    
    Returns:
    
    true if specified path matches this node's path exactly, else false.
  - relativePath
```
@Deprecated
public boolean relativePath(java.lang.String path)
```
    Deprecated. Use relativePath(Integer... path) instead.
    
    Determines if this node's path from the root ends with the specified path, on a case-insensitive basis.
    This node's type IS included in this path, which is different from the upPath(java.lang.String) which compares paths upward starting at the parent node.
    
    Specified by:
    
    relativePath in interface Aast
    
    Parameters:
    
    path - Partial path from this node up to an arbitrary number of parent nodes, formatted as described in getPath().
    
    Returns:
    
    true if specified path matches the end of this node's path exactly, else false.
  - relativePath
```
public boolean relativePath(java.lang.Object... path)
```
    Determines if this node's path from the root ends with the specified path.
    This node's type IS included in this path, which is different from the upPath(java.lang.String) which compares paths upward starting at the parent node.
    
    Specified by:
    
    relativePath in interface Aast
    
    Parameters:
    
    path - Partial path from this node up to an arbitrary number of parent nodes.
    
    Returns:
    
    true if specified path matches the end of this node's path exactly.
  - relativePath
```
public boolean relativePath(int tok1)
```
    Determines if this node's path from the root ends with the specified path.
    This node's type IS included in this path, which is different from the upPath(java.lang.String) which compares paths upward starting at the parent node.
    
    Specified by:
    
    relativePath in interface Aast
    
    Parameters:
    
    tok1 - The first token for this path match.
    
    Returns:
    
    true if specified path matches the end of this node's path exactly.
  - relativePath
```
public boolean relativePath(int tok1,
                            int tok2)
```
    Determines if this node's path from the root ends with the specified path.
    This node's type IS included in this path, which is different from the upPath(java.lang.String) which compares paths upward starting at the parent node.
    
    Specified by:
    
    relativePath in interface Aast
    
    Parameters:
    
    tok1 - The first token for this path match.
    
    tok2 - The second token for this path match.
    
    Returns:
    
    true if specified path matches the end of this node's path exactly.
  - relativePath
```
public boolean relativePath(int tok1,
                            int tok2,
                            int tok3)
```
    Determines if this node's path from the root ends with the specified path.
    This node's type IS included in this path, which is different from the upPath(java.lang.String) which compares paths upward starting at the parent node.
    
    Specified by:
    
    relativePath in interface Aast
    
    Parameters:
    
    tok1 - The first token for this path match.
    
    tok2 - The second token for this path match.
    
    tok3 - The third token for this path match.
    
    Returns:
    
    true if specified path matches the end of this node's path exactly.
  - relativePath
```
public boolean relativePath(int tok1,
                            int tok2,
                            int tok3,
                            int tok4)
```
    Determines if this node's path from the root ends with the specified path.
    This node's type IS included in this path, which is different from the upPath(java.lang.String) which compares paths upward starting at the parent node.
    
    Specified by:
    
    relativePath in interface Aast
    
    Parameters:
    
    tok1 - The first token for this path match.
    
    tok2 - The second token for this path match.
    
    tok3 - The third token for this path match.
    
    tok4 - The fourth token for this path match.
    
    Returns:
    
    true if specified path matches the end of this node's path exactly.
  - upPath
```
@Deprecated
public boolean upPath(java.lang.String path)
```
    Deprecated. Use upPath(Integer... path) instead.
    
    Determines if this node's path upward matches the specified path, on a case-insensitive basis. The format of the 'segments' of the up path starts with the parent's type and each subsequent segment must be the type of the next parent up in the hierarchy.
    The type of the current node is NOT included in the up path. This is the only difference between this method and relativePath(java.lang.String).
    
    Specified by:
    
    upPath in interface Aast
    
    Parameters:
    
    path - Partial path from this node's parent upward to an arbitrary number of ancestor nodes, formatted as described in getPath().
    
    Returns:
    
    true if specified path exactly matches the upward path from this node's parent, else false.
  - upPath
```
public boolean upPath(java.lang.Object... path)
```
    Determines if this node's path upward matches the specified path. The value of the 'segments' of the up path starts with the parent's type and each subsequent segment must be the type of the next parent up in the hierarchy.
    The type of the current node is NOT included in the up path. This is the only difference between this method and relativePath(java.lang.String).
    
    Specified by:
    
    upPath in interface Aast
    
    Parameters:
    
    path - Partial path from this node's parent upward to an arbitrary number of ancestor nodes.
    
    Returns:
    
    true if specified path exactly matches the upward path from this node's parent.
  - upPath
```
public boolean upPath(int tok1)
```
    Determines if this node's path upward matches the specified path. The value of the 'segments' of the up path starts with the parent's type and each subsequent segment must be the type of the next parent up in the hierarchy.
    The type of the current node is NOT included in the up path. This is the only difference between this method and relativePath(java.lang.String).
    
    Specified by:
    
    upPath in interface Aast
    
    Parameters:
    
    tok1 - The first token for this path match.
    
    Returns:
    
    true if specified path exactly matches the upward path from this node's parent.
  - upPath
```
public boolean upPath(int tok1,
                      int tok2)
```
    Determines if this node's path upward matches the specified path. The value of the 'segments' of the up path starts with the parent's type and each subsequent segment must be the type of the next parent up in the hierarchy.
    The type of the current node is NOT included in the up path. This is the only difference between this method and relativePath(java.lang.String).
    
    Specified by:
    
    upPath in interface Aast
    
    Parameters:
    
    tok1 - The first token for this path match.
    
    tok2 - The second token for this path match.
    
    Returns:
    
    true if specified path exactly matches the upward path from this node's parent.
  - upPath
```
public boolean upPath(int tok1,
                      int tok2,
                      int tok3)
```
    Determines if this node's path upward matches the specified path. The value of the 'segments' of the up path starts with the parent's type and each subsequent segment must be the type of the next parent up in the hierarchy.
    The type of the current node is NOT included in the up path. This is the only difference between this method and relativePath(java.lang.String).
    
    Specified by:
    
    upPath in interface Aast
    
    Parameters:
    
    tok1 - The first token for this path match.
    
    tok2 - The second token for this path match.
    
    tok3 - The third token for this path match.
    
    Returns:
    
    true if specified path exactly matches the upward path from this node's parent.
  - upPath
```
public boolean upPath(int tok1,
                      int tok2,
                      int tok3,
                      int tok4)
```
    Determines if this node's path upward matches the specified path. The value of the 'segments' of the up path starts with the parent's type and each subsequent segment must be the type of the next parent up in the hierarchy.
    The type of the current node is NOT included in the up path. This is the only difference between this method and relativePath(java.lang.String).
    
    Specified by:
    
    upPath in interface Aast
    
    Parameters:
    
    tok1 - The first token for this path match.
    
    tok2 - The second token for this path match.
    
    tok3 - The third token for this path match.
    
    tok4 - The fourth token for this path match.
    
    Returns:
    
    true if specified path exactly matches the upward path from this node's parent.
  - downPath
```
@Deprecated
public boolean downPath(java.lang.String path)
```
    Deprecated. Use downPath(Integer... path) instead.
    
    Determines if this node's path downward matches the specified path, on a case-insensitive basis. More than 1 down path may match this specification since sibling nodes can have the same token type. If any such match exists then this function will return true.
    The format of the 'segments' of the down path starts with the immediate child's type and each subsequent segment must be the type of the next child down in the hierarchy. The type of the current node is NOT included in the down path.
    
    Specified by:
    
    downPath in interface Aast
    
    Parameters:
    
    path - Partial path from this node down to an arbitrary number of descendant nodes, formatted as described in getPath().
    
    Returns:
    
    true if specified path exactly matches the downward path from this node, else false.
  - downPath
```
public boolean downPath(java.lang.Object... path)
```
    Determines if this node's path downward matches the specified path. More than 1 down path may match this specification since sibling nodes can have the same token type. If any such match exists then this function will return true.
    The list of the 'segments' of the down path starts with the immediate child's type and each subsequent segment must be the type of the next child down in the hierarchy. The type of the current node is NOT included in the down path.
    
    Specified by:
    
    downPath in interface Aast
    
    Parameters:
    
    path - Partial path from this node down to an arbitrary number of descendant nodes.
    
    Returns:
    
    true if specified path exactly matches the downward path from this node.
  - downPath
```
public boolean downPath(int tok1)
```
    Determines if this node's path downward matches the specified path. More than 1 down path may match this specification since sibling nodes can have the same token type. If any such match exists then this function will return true.
    The list of the 'segments' of the down path starts with the immediate child's type and each subsequent segment must be the type of the next child down in the hierarchy. The type of the current node is NOT included in the down path.
    
    Specified by:
    
    downPath in interface Aast
    
    Parameters:
    
    tok1 - The first token for this path match.
    
    Returns:
    
    true if specified path exactly matches the downward path from this node.
  - downPath
```
public boolean downPath(int tok1,
                        int tok2)
```
    Determines if this node's path downward matches the specified path. More than 1 down path may match this specification since sibling nodes can have the same token type. If any such match exists then this function will return true.
    The list of the 'segments' of the down path starts with the immediate child's type and each subsequent segment must be the type of the next child down in the hierarchy. The type of the current node is NOT included in the down path.
    
    Specified by:
    
    downPath in interface Aast
    
    Parameters:
    
    tok1 - The first token for this path match.
    
    tok2 - The second token for this path match.
    
    Returns:
    
    true if specified path exactly matches the downward path from this node.
  - downPath
```
public boolean downPath(int tok1,
                        int tok2,
                        int tok3)
```
    Determines if this node's path downward matches the specified path. More than 1 down path may match this specification since sibling nodes can have the same token type. If any such match exists then this function will return true.
    The list of the 'segments' of the down path starts with the immediate child's type and each subsequent segment must be the type of the next child down in the hierarchy. The type of the current node is NOT included in the down path.
    
    Specified by:
    
    downPath in interface Aast
    
    Parameters:
    
    tok1 - The first token for this path match.
    
    tok2 - The second token for this path match.
    
    tok3 - The third token for this path match.
    
    Returns:
    
    true if specified path exactly matches the downward path from this node.
  - downPath
```
public boolean downPath(int tok1,
                        int tok2,
                        int tok3,
                        int tok4)
```
    Determines if this node's path downward matches the specified path. More than 1 down path may match this specification since sibling nodes can have the same token type. If any such match exists then this function will return true.
    The list of the 'segments' of the down path starts with the immediate child's type and each subsequent segment must be the type of the next child down in the hierarchy. The type of the current node is NOT included in the down path.
    
    Specified by:
    
    downPath in interface Aast
    
    Parameters:
    
    tok1 - The first token for this path match.
    
    tok2 - The second token for this path match.
    
    tok3 - The third token for this path match.
    
    tok4 - The fourth token for this path match.
    
    Returns:
    
    true if specified path exactly matches the downward path from this node.
  - nearestEnclosing
```
public Aast nearestEnclosing(Aast other)
```
    Find and return the nearest ancestor of the current instance which also encloses the node passed as a parameter. By definition, if both nodes exist in the same tree, there must be a common ancestor. The only exception to this rule is if one of the two nodes encloses the other (e.g. it is the tree root or is itself the ancestor of the other node). In this case, the enclosing node itself will be returned. If both references are to the same node, then the parent node will be returned.
    
    Specified by:
    
    nearestEnclosing in interface Aast
    
    Parameters:
    
    other - Another reference node in the same tree.
    
    Returns:
    
    The nearest enclosing ancestor or null if the two AST nodes are not in the same tree. If the two references are identical (they are the same node), the parent node will be returned (even if this is null due to the given node being the tree root). Finally, if one node encloses the other, the enclosing node will be returned.
  - getChildAt
```
public Aast getChildAt(int index)
```
    Search the immediate children for the one at the specified index. If no such child exists, return null.
    
    Specified by:
    
    getChildAt in interface Aast
    
    Parameters:
    
    index - The 0-based index at which to search.
    
    Returns:
    
    The child at the specified index or null if no such index exists.
  - getImmediateChild
```
public Aast getImmediateChild(int type,
                              Aast start)
```
    Search the immediate children for one that matches a specific token type. An optional starting child AST can be provided which allows a search to be made for matches subsequent to the first, if the start AST is null, then the search will start with the first child.
    
    Specified by:
    
    getImmediateChild in interface Aast
    
    Parameters:
    
    type - The token type of the child for which to search.
    
    start - The child from which to start the search or null if the search is to start with the first child.
    
    Returns:
    
    The first child (to the right of the starting point) that matches or null if no match was found.
  - getImmediateChild
```
public Aast getImmediateChild(java.util.Collection<java.lang.Integer> types,
                              Aast start)
```
    Search the immediate children for one that matches any token type in the specified Collection of types. The first match is returned, as determined by the iteration order of the types collection. An optional starting child AST can be provided which allows a search to be made for matches subsequent to the first, if the start AST is null, then the search will start with the first child.
    
    Specified by:
    
    getImmediateChild in interface Aast
    
    Parameters:
    
    types - Collection of token types of the child for which to search.
    
    start - The child from which to start the search or null if the search is to start with the first child.
    
    Returns:
    
    The first child (to the right of the starting point) that matches or null if no match was found.
  - getLastImmediateChild
```
public Aast getLastImmediateChild(int type)
```
    Search the immediate children for last child that matches a specific token type.
    
    Specified by:
    
    getLastImmediateChild in interface Aast
    
    Parameters:
    
    type - The token type of the child for which to search.
    
    Returns:
    
    The last child (rightmost) that matches or null if no match was found.
  - remove
```
public void remove()
```
    Remove this AST (and the entire sub-tree rooted at this node) from its parent's collection of children. Note that the implication of such removal is that all descendants of this node remain parented by this sub-tree but are removed from the original parent tree along with this node.
    This method has no effect if invoked on the root node of an AST.
    
    Specified by:
    
    remove in interface Aast
  - move
```
public void move(Aast parent,
                 int index)
          throws AstException
```
    Move the node from one location to another. The move can occur between index positions under a single parent, between 2 different parent nodes in the same tree or between 2 different parent nodes in different trees. The type of the Aast nodes must be the same between the current node and the parent node, otherwise the results will be undefined.
    If the given parent node is null and the current parent node of this instance is null, this method returns immediately since there is nothing to do.
    
    Specified by:
    
    move in interface Aast
    
    Parameters:
    
    parent - The parent node which is the target of the move operation or null if the move is only affecting the index position of this node (a move of the child to a different index in the same parent).
    
    index - 0 to insert as the first child, -1 to insert as the last child or a 0-based index to specify an exact child index at which to insert the new child. All current nodes at that index or at a greater index, are moved right. If the index is greater than the current number of nodes, the node will be added at the end.
    
    Throws:
    
    AstException - if any error occurs registering the grafted node with the AST registry.
  - getFilename
```
public java.lang.String getFilename()
```
    Get source code filename associated with the current node. This information is retrieved from the AstManager by this AST's ID.
    
    Specified by:
    
    getFilename in interface Aast
    
    Returns:
    
    Source code filename associated with this AST or null if the ID is null or invalid.
  - isArtificial
```
public boolean isArtificial()
```
    Reports on a node that was not generated by parsing text, but was created for some structural purpose by the parser or by post-processing code.
    
    Specified by:
    
    isArtificial in interface Aast
    
    Returns:
    
    true if this is an artificial node.
  - getLine
```
public int getLine()
```
    Get the source code line number which designates where in the source code file the token wrappered by this node was found. This will always return 0 for an artificially manufactured AST (i.e., one not generated by a parser).
    
    Specified by:
    
    getLine in interface antlr.collections.AST
    
    Overrides:
    
    getLine in class antlr.BaseAST
    
    Returns:
    
    Source file line number where the token underlying this AST was found, or 0 for an artificial AST.
    
    See Also:
    
    getColumn()
  - getColumn
```
public int getColumn()
```
    Get the source code column number which designates where in the source code file the token wrappered by this node was found. This will always return 0 for an artificially manufactured AST (i.e., one not generated by a parser).
    
    Specified by:
    
    getColumn in interface antlr.collections.AST
    
    Overrides:
    
    getColumn in class antlr.BaseAST
    
    Returns:
    
    Column number within a specific source code line, indicating where the token underlying this AST was found, or 0 for an artificial AST.
    
    See Also:
    
    getLine()
  - getSymbolicTokenType
```
public abstract java.lang.String getSymbolicTokenType()
```
    Returns the symbolic representation of this AST's token type.
    
    Specified by:
    
    getSymbolicTokenType in interface Aast
    
    Returns:
    
    Symbolic token name for this AST's token type.
  - getDescriptiveTokenText
```
public java.lang.String getDescriptiveTokenText()
```
    Returns a descriptive string for the current node. This string will normally contain both the text and the symbolic representation of this AST's token type.
    
    Specified by:
    
    getDescriptiveTokenText in interface Aast
    
    Returns:
    
    A descriptive string for the token type of this node.
  - iterator
```
public java.util.Iterator<Aast> iterator()
```
    Return an iterator to walk this AST recursively in a depth-first traversal. 'Depth-first' means that the iteration will traverse the children of any given node before traversing that node's siblings.
    This iterator will not support any "non-visiting" events (descent, ascent and next-child). In addition, all nodes will be returned, regardless of hidden status. EXCEPTION: shadow nodes are NOT included in any tree walks and will NOT be returned by this iterator.
    
    Specified by:
    
    iterator in interface Aast
    
    Returns:
    
    An iterator which will walk this node and all of its descendants.
  - iterator
```
public java.util.Iterator<Aast> iterator(int maxLevels,
                                         AstWalkListener listener)
```
    Return an iterator to walk this AST recursively in a depth-first traversal. 'Depth-first' means that the iteration will traverse the children of any given node before traversing that node's siblings.
    The iterator will walk at most to a node depth of maxLevels relative to this node. A maxLevels value of 0 indicates that the full tree beneath this node should be walked, down to every leaf, regardless of its depth.
    If a listener is specified, it will be notified when the tree walk transitions between nesting levels. The notifications occur during processing of the iterator's next method. In each case (whether the transition represents a descent to a lower tree level or an ascent to a higher tree level), the parent of the parent/child link being traversed will be sent with the notification. No more than a single descent notification will ever be sent during a single invocation of the iterator's next method. However, multiple ascent notifications may be sent, since the tree walk may proceed directly from a deeply nested node to the next sibling of a distant ancestor node. In such a case, one call to the listener's AstWalkListener.ascent(com.goldencode.ast.Aast) method will be made for each upward step from child to parent, until an ancestor with an unvisited sibling is found, or the walk ends.
    This iterator will return all nodes in the tree, regardless of hidden status. EXCEPTION: shadow nodes are NOT included in any tree walks and will NOT be returned by this iterator.
    
    Specified by:
    
    iterator in interface Aast
    
    Parameters:
    
    maxLevels - Maximum number of levels or generations to visit relative to the root defined by ast. If the tree contains more levels than maxLevels, the levels beyond a relative depth of maxLevels will be ignored. Set to 0 to disable this restriction. Set to 1 for immediate children only, etc.
    
    listener - An optional listener which is notified of significant events during the tree walk, such as descents to lower nesting levels, moves between children (next-child events) and ascents back up to higher nesting levels. This may be null if these "non-visiting" events are not needed.
    
    Returns:
    
    An iterator which will behave as described above.
  - iterator
```
public java.util.Iterator<Aast> iterator(int maxLevels,
                                         AstWalkListener listener,
                                         boolean honorHidden)
```
    Return an iterator to walk this AST recursively in a depth-first traversal. "Depth-first" means that the iteration will traverse the children of any given node before traversing that node's siblings.
    The iterator will walk at most to a node depth of maxLevels relative to this node. A maxLevels value of 0 indicates that the full tree beneath this node should be walked, down to every leaf, regardless of its depth.
    If a listener is specified, it will be notified when the tree walk transitions between nesting levels. The notifications occur during processing of the iterator's next method. In each case (whether the transition represents a descent to a lower tree level or an ascent to a higher tree level), the parent of the parent/child link being traversed will be sent with the notification. No more than a single descent notification will ever be sent during a single invocation of the iterator's next method. However, multiple ascent notifications may be sent, since the tree walk may proceed directly from a deeply nested node to the next sibling of a distant ancestor node. In such a case, one call to the listener's AstWalkListener.ascent(com.goldencode.ast.Aast) method will be made for each upward step from child to parent, until an ancestor with an unvisited sibling is found, or the walk ends.
    Optionally, the returned iterator can omit nodes in which the hidden status is enabled (see isHidden() and setHidden(boolean)). Please note that if the root node (the instance upon which this method is called) is set as hidden, this setting will not be honored. The hidden mode is only honored on child nodes that have this mode set.
    EXCEPTION: shadow nodes are NOT included in any tree walks and will NOT be returned by this iterator.
    
    Specified by:
    
    iterator in interface Aast
    
    Parameters:
    
    maxLevels - Maximum number of levels or generations to visit relative to the root defined by ast. If the tree contains more levels than maxLevels, the levels beyond a relative depth of maxLevels will be ignored. Set to 0 to disable this restriction. Set to 1 for immediate children only, etc.
    
    listener - An optional listener which is notified of significant events during the tree walk, such as descents to lower nesting levels, moves between children (next-child events) and ascents back up to higher nesting levels. This may be null if these "non-visiting" events are not needed.
    
    honorHidden - If true, the hidden attribute of the node will be honored. This means that the node will not appear in the iterator nor will any "non-visiting" events be triggered for such nodes.
    
    Returns:
    
    An iterator which will behave as described above.
  - isAnnotation
```
public boolean isAnnotation(java.lang.String key)
```
    Determines if an annotation exists of any String, Double, Long, Boolean or List value, indexed by an arbitrary key.
    
    Specified by:
    
    isAnnotation in interface Aast
    
    Parameters:
    
    key - Key under which the annotation is stored.
    
    Returns:
    
    true if an annotation exists mapped by that key.
  - annotationSize
```
public int annotationSize(java.lang.String key)
```
    Returns the size of an array annotation as indexed by an arbitrary key.
    
    Specified by:
    
    annotationSize in interface Aast
    
    Parameters:
    
    key - Key under which the annotation is stored.
    
    Returns:
    
    The number of elements in an array annotation that exists mapped by that key or 0 if no such named array annotation exists. A scalar annotation using that same name will also result in a return of 0.
  - annotationCount
```
public int annotationCount(java.lang.String key,
                           java.lang.Object value)
```
    Returns the number of annotation objects of an array annotation that are equal to the specified Object.
    
    Specified by:
    
    annotationCount in interface Aast
    
    Parameters:
    
    key - Key under which the annotation is stored.
    
    value - Object to compare with.
    
    Returns:
    
    The number of elements in an array annotation that equals the specified value or 0 if no such named array annotation exists. A scalar annotation using that same name will also result in a return of 0.
  - getAnnotation
```
public java.lang.Object getAnnotation(java.lang.String key)
```
    Retrieve an annotation. This may be any String, Double, Long, or Boolean value, indexed by an arbitrary key. Note that it is possible to obtain the entire array if the annotation is an array type. This would be a List of objects of the above mentioned types.
    
    Specified by:
    
    getAnnotation in interface Aast
    
    Parameters:
    
    key - Key under which the annotation is stored.
    
    Returns:
    
    The annotation object stored under the specified key, or null if none exists.
  - getAnnotation
```
public java.lang.Object getAnnotation(java.lang.String key,
                                      int index)
```
    Retrieve an element in an array annotation using the specified key as a unique identifier and an index to specify the location in the array from which to read the element. The special index of -1 indicates the last element in the array. The resulting data may be any String, Double, Long, or Boolean value.
    
    Specified by:
    
    getAnnotation in interface Aast
    
    Parameters:
    
    key - Key under which the annotation is stored.
    
    index - The index of -1 indicates the last element of the array. Otherwise this is the explicit zero-based index at which to find the annotation.
    
    Returns:
    
    The annotation object stored under the specified key and at the specified index, or null if the annotation doesn't exist, if the annotation is not an array or if no element exists at the given index.
  - getAnnotationList
```
public java.util.List<java.lang.Object> getAnnotationList(java.lang.String key)
```
    Retrieve an unmodifiable list view of an array annotation.
    
    Specified by:
    
    getAnnotationList in interface Aast
    
    Parameters:
    
    key - Key under which the annotation is stored.
    
    Returns:
    
    Unmodifiable list view of the array annotation, or null if no such annotation exists.
  - putAnnotation
```
public void putAnnotation(java.lang.String key,
                          java.lang.String annotation)
```
    Store a text annotation using the specified key as a unique identifier.
    This is just a thin wrapper to ensure annotation type safety, since annotations are stored in a Map as Objects.
    
    Specified by:
    
    putAnnotation in interface Aast
    
    Parameters:
    
    key - Key under which to store the annotation.
    
    annotation - Arbitrary text.
  - putAnnotation
```
public void putAnnotation(java.lang.String key,
                          java.lang.String annotation,
                          int index)
```
    Store a text element in an array annotation using the specified key as a unique identifier and an index to specify the location in which to insert. If an element already exists at that index, it and all following elements will be located at indices that are 1 greater than before. The special index of -1 indicates an addition to the end of the array.
    
    Specified by:
    
    putAnnotation in interface Aast
    
    Parameters:
    
    key - Key under which to store the annotation.
    
    annotation - Arbitrary text.
    
    index - The index of -1 indicates an addition to the end of the array. Otherwise this is the explicit zero-based index at which to add the annotation.
  - putAnnotation
```
public void putAnnotation(java.lang.String key,
                          java.lang.Double annotation)
```
    Store a floating point numeric annotation using the specified key as a unique identifier.
    This is just a thin wrapper to ensure annotation type safety, since annotations are stored in a Map as Objects.
    
    Specified by:
    
    putAnnotation in interface Aast
    
    Parameters:
    
    key - Key under which to store the annotation.
    
    annotation - Arbitrary floating point numeric value.
  - putAnnotation
```
public void putAnnotation(java.lang.String key,
                          java.lang.Double annotation,
                          int index)
```
    Store a floating point numeric element in an array annotation using the specified key as a unique identifier and an index to specify the location in which to insert. If an element already exists at that index, it and all following elements will be located at indices that are 1 greater than before. The special index of -1 indicates an addition to the end of the array.
    
    Specified by:
    
    putAnnotation in interface Aast
    
    Parameters:
    
    key - Key under which to store the annotation.
    
    annotation - Arbitrary floating point numeric value.
    
    index - The index of -1 indicates an addition to the end of the array. Otherwise this is the explicit zero-based index at which to add the annotation.
  - putAnnotation
```
public void putAnnotation(java.lang.String key,
                          java.lang.Long annotation)
```
    Store an integral numeric annotation using the specified key as a unique identifier.
    This is just a thin wrapper to ensure annotation type safety, since annotations are stored in a Map as Objects.
    
    Specified by:
    
    putAnnotation in interface Aast
    
    Parameters:
    
    key - Key under which to store the annotation.
    
    annotation - Arbitrary integral numeric value.
  - putAnnotation
```
public void putAnnotation(java.lang.String key,
                          java.lang.Long annotation,
                          int index)
```
    Store an integral numeric element in an array annotation using the specified key as a unique identifier and an index to specify the location in which to insert. If an element already exists at that index, it and all following elements will be located at indices that are 1 greater than before. The special index of -1 indicates an addition to the end of the array.
    
    Specified by:
    
    putAnnotation in interface Aast
    
    Parameters:
    
    key - Key under which to store the annotation.
    
    annotation - Arbitrary integral numeric value.
    
    index - The index of -1 indicates an addition to the end of the array. Otherwise this is the explicit zero-based index at which to add the annotation.
  - putAnnotation
```
public void putAnnotation(java.lang.String key,
                          java.lang.Boolean annotation)
```
    Store a boolean annotation using the specified key as a unique identifier.
    This is just a thin wrapper to ensure annotation type safety, since annotations are stored in a Map as Objects.
    
    Specified by:
    
    putAnnotation in interface Aast
    
    Parameters:
    
    key - Key under which to store the annotation.
    
    annotation - Arbitrary boolean value.
  - putAnnotation
```
public void putAnnotation(java.lang.String key,
                          java.lang.Boolean annotation,
                          int index)
```
    Store a boolean element in an array annotation using the specified key as a unique identifier and an index to specify the location in which to insert. If an element already exists at that index, it and all following elements will be located at indices that are 1 greater than before. The special index of -1 indicates an addition to the end of the array.
    
    Specified by:
    
    putAnnotation in interface Aast
    
    Parameters:
    
    key - Key under which to store the annotation.
    
    annotation - Arbitrary boolean value.
    
    index - The index of -1 indicates an addition to the end of the array. Otherwise this is the explicit zero-based index at which to add the annotation.
  - putAnnotation
```
public void putAnnotation(java.lang.String key,
                          java.util.List<java.lang.Object> annotation)
```
    Store a list of annotations at once using the specified key as a unique identifier. The list should be made of objects of the same type, which, in turn, should be one of the supported annotation types:
    - String
    - Double
    - Long
    - Boolean
    Specified by:
    
    putAnnotation in interface Aast
    
    Parameters:
    
    key - Key under which to store the annotation.
    
    annotation - list of annotations of the same, supported type.
  - putAnnotationObject
```
public void putAnnotationObject(java.lang.String key,
                                java.lang.Object annotation)
```
    Store any object as annotation for this node. It will work only with InMemoryRegistryPlugin since this is the only plugin that does not truly serialize the nodes. The other plugins require the the annotation objects to be serializable so only a small set of objects are supported.
    
    Specified by:
    
    putAnnotationObject in interface Aast
    
    Parameters:
    
    key - The name of the annotation.
    
    annotation - The value for the annotation. Any type of object can be stored as long it is not required to be saved.
  - removeAnnotation
```
public java.lang.Object removeAnnotation(java.lang.String key)
```
    Remove a specific annotation from this AST. Note that this annotation may be an entire array (of type List) or it may be a scalar value.
    
    Specified by:
    
    removeAnnotation in interface Aast
    
    Parameters:
    
    key - Key under which the annotation is stored.
    
    Returns:
    
    The annotation which was removed, or null if none was found.
  - removeAnnotation
```
public java.lang.Object removeAnnotation(java.lang.String key,
                                         int index)
```
    Remove a specific element from the array annotation in this AST. The special index of -1 indicates the removal of the last element of the array.
    
    Specified by:
    
    removeAnnotation in interface Aast
    
    Parameters:
    
    key - Key under which the annotation is stored.
    
    index - The index of -1 indicates an addition to the end of the array. Otherwise this is the explicit zero-based index at which to add the annotation.
    
    Returns:
    
    The element which was removed, or null if the annotation doesn't exist, if the annotation is not an array or if no element exists at the given index.
  - clearAnnotations
```
public void clearAnnotations()
```
    Removes ALL annotations from this AST. BE VERY CAREFUL WITH THIS! There is no recovery once this is called.
    
    Specified by:
    
    clearAnnotations in interface Aast
  - annotationKeys
```
public java.util.Iterator<java.lang.String> annotationKeys()
```
    Get an iterator on the keys for all annotations (if any) stored in this AST.
    
    Specified by:
    
    annotationKeys in interface Aast
    
    Returns:
    
    An iterator on all annotation keys. May be empty, but will not be null.
  - fixups
```
public void fixups(Aast parent,
                   java.lang.Long fileId)
            throws AstException
```
    Assigns parent nodes throughout the AST hierarchy of which this AST is the root. This method should be called directly after creation of an AST hierarchy, but before that hierarchy is post-processed. It recursively walks downward through the tree, assigning itself as the parent to each of its children.
    If the current node's ID is null, then this method will use the AstManager.getNextNodeId(long) to obtain a valid ID that will uniquely identify this node. This can only be done if the passed in file ID is valid and not null.
    No shadow nodes will be created using this version of the method. All hidden tokens will be dropped.
    
    Parameters:
    
    parent - Parent AST node to be assigned to the current node.
    
    fileId - The file ID of the source file.
    
    Throws:
    
    AstException
  - fixups
```
public void fixups(Aast parent,
                   java.lang.Long fileId,
                   boolean shadow)
            throws AstException
```
    Assigns parent nodes throughout the AST hierarchy of which this AST is the root. This method should be called directly after creation of an AST hierarchy, but before that hierarchy is post-processed. It recursively walks downward through the tree, assigning itself as the parent to each of its children.
    If the current node's ID is null, then this method will use the AstManager.getNextNodeId(long) to obtain a valid ID that will uniquely identify this node. This can only be done if the passed in file ID is valid and not null.
    
    Parameters:
    
    parent - Parent AST node to be assigned to the current node.
    
    fileId - The file ID of the source file.
    
    shadow - true to create shadow nodes from hidden tokens. false to drop hidden tokens without creating any shadow nodes.
    
    Throws:
    
    AstException
  - fixupParent
```
public void fixupParent(Aast parent)
```
    Fixup the parent references for this tree.
    
    Parameters:
    
    parent - The parent for this node.
  - intern
```
public void intern()
```
    Walk the tree formed by this node and all of its descendants, interning all strings stored in the AST's text and annotation values which are String objects.
    Since all these objects must be retrieved and re-stored, this method will be expensive for a large tree. It should only be invoked on trees which will remain in long term memory.
    
    Specified by:
    
    intern in interface Aast
  - toString
```
public java.lang.String toString()
```
    Create a string representation of this AST. This implementation simply uses the token name associated with this AST's token type.
    
    Specified by:
    
    toString in interface antlr.collections.AST
    
    Overrides:
    
    toString in class antlr.BaseAST
    
    Returns:
    
    Token name for this AST's token type.
  - toStringVerbose
```
public java.lang.String toStringVerbose()
```
    Create a verbose string representation of this AST. This includes the the token name associated with this AST's token type, its text, its line and column number, and its ID if non-null.
    
    Specified by:
    
    toStringVerbose in interface Aast
    
    Returns:
    
    Verbose description of this node.
  - dumpSimpleTree
```
public java.lang.String dumpSimpleTree()
```
    Create a human readable text concise representation of the tree rooted at this AST. This implementation walks the subtree and dumps the text, token type, line and column of each node, with indents to show the nesting and each node on its own line.
    
    Returns:
    
    The tree's text representation.
  - dumpTree
```
public java.lang.String dumpTree()
```
    Create a human readable text representation of the tree rooted at this AST. This implementation walks the subtree and dumps the text, token type, line and column of each node, with indents to show the nesting and each node on its own line.
    
    Specified by:
    
    dumpTree in interface Aast
    
    Returns:
    
    The tree's text representation.
  - dumpTree
```
public java.lang.String dumpTree(boolean annotations)
```
    Create a human readable text representation of the tree rooted at this AST. This implementation walks the subtree and dumps the text, token type, line and column of each node, with indents to show the nesting and each node on its own line.
    
    Specified by:
    
    dumpTree in interface Aast
    
    Parameters:
    
    annotations - Verbose mode. If true dump the annotations along with node name and type.
    
    Returns:
    
    The tree's text representation.
  - getLeftShadowNode
```
public Aast getLeftShadowNode()
```
    Access the AST of a shadow node that exists to the left of the current node.
    
    Specified by:
    
    getLeftShadowNode in interface Aast
    
    Returns:
    
    The AST of the shadow node that is left of the current node or null if no such node exists.
  - getRightShadowNode
```
public Aast getRightShadowNode()
```
    Access the AST of a shadow node that exists to the right of the current node.
    
    Specified by:
    
    getRightShadowNode in interface Aast
    
    Returns:
    
    The AST of the shadow node that is right of the current node or null if no such node exists.
  - getLeftmost
```
public Aast getLeftmost()
```
    Search the sub-tree rooted at this node to return the AST node that exists farthest to the left (in line/column).
    
    Specified by:
    
    getLeftmost in interface Aast
    
    Returns:
    
    The AST node that is leftmost of the sub-tree or this if there are no children.
  - getRightmost
```
public Aast getRightmost()
```
    Search the sub-tree rooted at this node to return the AST node that exists farthest to the right (in line/column).
    
    Specified by:
    
    getRightmost in interface Aast
    
    Returns:
    
    The AST node that is rightmost of the sub-tree or this if there are no children.
  - getLeftAdjacent
```
public Aast getLeftAdjacent()
```
    Search the tree to return the AST node that exists nearest on the left (in line/column).
    
    Specified by:
    
    getLeftAdjacent in interface Aast
    
    Returns:
    
    The AST node that is nearest on the left or null if there are no nodes on the left.
  - getRightAdjacent
```
public Aast getRightAdjacent()
```
    Search the tree to return the AST node that exists nearest on the right (in line/column).
    
    Specified by:
    
    getRightAdjacent in interface Aast
    
    Returns:
    
    The AST node that is nearest on the right or null if there are no nodes on the right.
  - getLeftShadow
```
public ShadowNode getLeftShadow()
```
    Access a shadow node that exists to the left of the current node.
    
    Specified by:
    
    getLeftShadow in interface Aast
    
    Returns:
    
    The shadow node that is left of the current node or null if no such node exists.
  - getRightShadow
```
public ShadowNode getRightShadow()
```
    Access a shadow node that exists to the right of the current node.
    
    Specified by:
    
    getRightShadow in interface Aast
    
    Returns:
    
    The shadow node that is right of the current node or null if no such node exists.
  - getLeftmostShadow
```
public ShadowNode getLeftmostShadow()
```
    Access a shadow node that exists farthest to the left of the current node.
    
    Specified by:
    
    getLeftmostShadow in interface Aast
    
    Returns:
    
    The shadow node that is leftmost of the current node or null if no such node exists.
  - getRightmostShadow
```
public ShadowNode getRightmostShadow()
```
    Access a shadow node that exists farthest to the right of the current node.
    
    Specified by:
    
    getRightmostShadow in interface Aast
    
    Returns:
    
    The shadow node that is rightmost of the current node or null if no such node exists.
  - getShadowNodeList
```
public java.util.Iterator<ShadowNode> getShadowNodeList()
```
    Access the list of all shadow nodes.
    
    Specified by:
    
    getShadowNodeList in interface Aast
    
    Returns:
    
    All shadow nodes or null if none exist.
  - getLocal
```
public TreeLocal getLocal()
```
    Access the tree-local data directly. WARNING: this data is mutable so make sure you really want to change it. If the tree is subsequently persisted, any changes will be saved.
    
    Specified by:
    
    getLocal in interface Aast
    
    Returns:
    
    The tree-local data or null if there is no tree-local data.
  - setLocal
```
public void setLocal(TreeLocal local)
```
    Set the tree-local data directly. WARNING: this data is mutable so make sure you really want to change it. If the tree is subsequently persisted, any changes will be saved.
    
    Specified by:
    
    setLocal in interface Aast
    
    Parameters:
    
    local - The tree-local data or null if there is no tree-local data.
  - compareWith
```
public boolean compareWith(Aast other)
```
    Compare subtree starting from this node as a root and compare it with given subtree. Subtrees considered identical if both contain identical nodes organized in the same order. Two nodes are considered identical if their type and text are identical. The order of subtrees is defined by iterator provided by iterator() method.
    The comparison of token text is case sensitive. For a case insensitive comparison, use the compareWith(Aast,boolean) method variant.
    
    Specified by:
    
    compareWith in interface Aast
    
    Parameters:
    
    other - The subtree to compare with.
    
    Returns:
    
    true if subtrees are identical and false otherwise.
  - compareWith
```
public boolean compareWith(Aast other,
                           boolean ignoreCase)
```
    Compare subtree starting from this node as a root and compare it with given subtree. Subtrees considered identical if both contain identical nodes organized in the same order. Two nodes are considered identical if their type and text are identical. The order of subtrees is defined by iterator provided by iterator() method.
    
    Specified by:
    
    compareWith in interface Aast
    
    Parameters:
    
    other - The subtree to compare with.
    
    ignoreCase - true to ignore case in the token text comparison; false for a case sensitive comparison.
    
    Returns:
    
    true if subtrees are identical and false otherwise.
  - setRuntimeAnnotation
```
public void setRuntimeAnnotation(int key,
                                 java.lang.Object value)
```
    Set the runtime annotation with the specified key.
    
    Specified by:
    
    setRuntimeAnnotation in interface Aast
    
    Parameters:
    
    key - The annotation key.
    
    value - The annotation value.
  - getRuntimeAnnotation
```
public java.lang.Object getRuntimeAnnotation(int key)
```
    Get the runtime annotation with the specified key.
    
    Specified by:
    
    getRuntimeAnnotation in interface Aast
    
    Parameters:
    
    key - The annotation key.
    
    Returns:
    
    See above.
  - isRuntimeAnnotation
```
public boolean isRuntimeAnnotation(int key)
```
    Check if the runtime annotation with the specified key is set.
    
    Specified by:
    
    isRuntimeAnnotation in interface Aast
    
    Parameters:
    
    key - The annotation key.
    
    Returns:
    
    See above.
  - farthest
```
private Aast farthest(boolean right)
```
    Search the sub-tree rooted at this node to return the AST node that exists farthest to the left or right (in line/column).
    
    Parameters:
    
    right - true to search rightwards, false to search leftwards.
    
    Returns:
    
    The AST node that is farthest of the sub-tree in the given direction or this if there are no children.
  - nearest
```
private Aast nearest(boolean right)
```
    Search the tree to return the AST node that exists nearest to the left or right (in line/column).
    This is an expensive operation as we cannot look down to find the answer, the answer may be enclosed within an arbitrary number of parents above (possibly all the way to the root). For this reason, we iterate through all nodes in the tree to find the answer.
    
    Parameters:
    
    right - true to search rightwards, false to search leftwards.
    
    Returns:
    
    The AST node that is nearest in the tree in the given direction or null if there is no node in that direction.
  - createNode
```
private AnnotatedAst createNode(antlr.Token token,
                                Aast parent)
```
    Create a new AST node of the same sub-class as the current node and initialize it using the given token.
    
    Parameters:
    
    token - The data with which to populate the node.
    
    parent - The parent for the newly created node.
    
    Returns:
    
    The newly created node or null if there is an error.
  - getParentChain
```
private Aast[] getParentChain(Aast node)
```
    Get chain of parent nodes starting from root to this node.
    
    Parameters:
    
    node - The root node to get parent chain.
    
    Returns:
    
    array of parent nodes.
  - createShadowNodes
```
private void createShadowNodes(java.lang.Long fileId)
```
    Read the original token out of the original-token annotation and create shadow nodes from the hidden before and after tokens if they exist. The entire chain of hidden tokens will be walked and created. Each shadow node will have a valid ID and will have the left and right IDs set as appropriate. Then the temporary original token annotation will be removed so that there is never an attempt to persist it to file.
    Both the parent and the ID must be assigned before this method is called.
    
    Parameters:
    
    fileId - The file ID of the source file.
  - getPath
```
private java.lang.String getPath(int max)
```
    Return a string representing the path of this AST from an ancestor (possibly the root) AST, in terms of the token type of each element from the ancestor to this AST. The token types are separated by a forward slash and a trailing slash ends the path. For example:
```
    BLOCK/STATEMENT/KW_IF/
 
```
    represents the following path:
```
    ROOT [type=BLOCK]
     |
    NODE A [type=STATEMENT]
     |
    NODE B [type=KW_IF]
 
```
    The string uniquely identifies the path from this node back to the ancestor node, but is not necessarily unique when traversed from the ancestor to this node. How far up the tree we travel is determined by the max parameter.
    Parameters:
    
    max - The maximum number of characters to be included in the returned path, or a non-positive integer to indicate that all nodes up to and including the root should be included in the path.
    
    Returns:
    
    A string which, when read from right to left, indicates the token type of each node from this AST to the ancestor AST, or if max > 0, as much of that path that can fit within max characters.
  - getFirstChild
```
private Aast getFirstChild(boolean honorHidden)
```
    Returns the first child (hidden or not) if the honorHidden flag is false, or the first non-hidden child if the honorHidden flag is true.
    
    Parameters:
    
    honorHidden - If true, the hidden attribute of the node will be honored. This means that the node will not be returned and instead the first non-hidden sibling will be returned.
    
    Returns:
    
    The first non-hidden child (in honorHidden mode), or otherwise the first child. Returns null if no non-hidden children exist (in honorHidden mode) or whenever no children of any kind exist.
  - getNextSibling
```
private Aast getNextSibling(boolean honorHidden)
```
    Returns the next sibling (hidden or not) if the honorHidden flag is false, or the next non-hidden sibling if the honorHidden flag is true.
    
    Parameters:
    
    honorHidden - If true, the hidden attribute of the node will be honored. This means that the node will not be returned and instead the next non-hidden sibling will be returned.
    
    Returns:
    
    The next non-hidden sibling (in honorHidden mode), or otherwise the next child. Returns null if no non-hidden siblings exist (in honorHidden mode) or whenever no siblings of any kind exist.
  - searchDown
```
private boolean searchDown(java.lang.String[] list,
                           int index)
```
    Worker to recursively search down the descendant tree to match the passed-in list of token names.
    
    Parameters:
    
    list - The list of token names in order from ancestor (leftmost) to descendant (rightmost).
    
    index - The current segment of the path which must be tested.
    
    Returns:
    
    If the path matches completely true.
  - searchDown
```
private boolean searchDown(java.lang.Object[] list,
                           int index)
```
    Worker to recursively search down the descendant tree to match the passed-in list of token types.
    
    Parameters:
    
    list - The list of token types in order from ancestor (list[0]) to descendant (list[N]).
    
    index - The current segment of the path which must be tested.
    
    Returns:
    
    If the path matches completely true.
  - searchUp
```
private static boolean searchUp(AnnotatedAst node,
                                java.lang.Object[] path,
                                int k,
                                boolean absolute)
```
    Worker to compare the given source path (from root to a given node) to the expected path to the target and return the comparison results.
    
    Parameters:
    
    node - The node to start the search.
    
    path - The comparison path.
    
    k - The index in the path to search.
    
    absolute - Flag indicating that this path must match to the root node.
    
    Returns:
    
    true if the source path starts with the root node and ends with the target path.
  - searchUp
```
private boolean searchUp(java.lang.String source,
                         java.lang.String target)
```
    Worker to compare the given source path (from root to a given node) to the expected path to the target and return the comparison results. Please note that a match exists if the source string ends with the target string on a case-insensitive basis. Some simple normalization of path strings is done before comparison to ensure that the format is consistent.
    
    Parameters:
    
    source - The actual path upward.
    
    target - The comparison path.
    
    Returns:
    
    true if the source path ends with the target path.
  - driveFixups
```
private void driveFixups(Aast child)
                  throws AstException
```
    Kickoff the fixup process on a specific child to set IDs and ensure that all parent linkages are correct.
    
    Parameters:
    
    child - The child node to fixup.
    
    Throws:
    
    AstException
  - putAnnotationImpl
```
private void putAnnotationImpl(java.lang.String key,
                               java.lang.Object annotation)
```
    Stores an annotation object under a unique key, creating the map of annotations first, if necessary.
    
    Parameters:
    
    key - Key under which to store the annotation.
    
    annotation - Arbitrary annotation value.
  - putAnnotationImpl
```
private boolean putAnnotationImpl(java.lang.String key,
                                  java.lang.Object annotation,
                                  int index)
```
    Stores an annotation object in an array annotation under a unique key, creating both the array itself and the map of annotations first, if necessary.
    
    Parameters:
    
    key - Key under which to store the annotation.
    
    annotation - Arbitrary annotation value.
    
    index - The index of -1 indicates an addition to the end of the array. Otherwise this is the explicit zero-based index at which to add the annotation. Any element at that location will be replaced.
    
    Returns:
    
    true if the element was added.
  - extractTokenData
```
private void extractTokenData(antlr.Token token)
```
    Extract line number, column number from the input token and store this information as member data. If the input token class is ManagedHiddenStreamToken, then also store the input token as an "original-token" annotation. Otherwise, that token will not be stored.
    The original token will be temporarily stored before being used to create the shadow nodes by the fixup process. This is a hack but it is the simplest and cleanest approach available until better hooks exist for processing IDs and parent linkages during node creation. Since the shadow nodes cannot be fully processed until the node IDs are assigned, the input token instance must be retained with the node until that time. Rather than make a new data member, a temporary annotation is used and will be removed when the shadow nodes are created and stored in the tree-local data store. These temporary annotations will never be persisted to disk.
    It is important to leave behind the actual token for each node because AST nodes are created as the lexer stream is processed but subsequent token processing can modify the hidden token state of the orignial token for prior nodes. This is done to patch dropped tokens back into the hidden token streams (we are putting "Humpty Dumpty" back together again). Thus, we cannot extract the hidden token linkages during this method call, but only when fixups are being processed since everything will be patched by that time.
    
    Parameters:
    
    token - Token from which information is to be extracted.

Class AnnotatedAst

Field Summary

Fields inherited from class antlr.BaseAST

Fields inherited from interface com.goldencode.ast.Aast

Constructor Summary

Method Summary

Methods inherited from class antlr.CommonAST

Methods inherited from class antlr.BaseAST

Methods inherited from class java.lang.Object

Methods inherited from interface com.goldencode.ast.Aast

Methods inherited from interface antlr.collections.AST

Field Detail

LOG

id

line

column

parent

tail

hidden

annotations

local

runtimeAnnotations

ANNO_LOWER

Constructor Detail

AnnotatedAst

AnnotatedAst

Method Detail

getAnnotationKey

lookupTokenType

lookupTokenName

newInstance

removeChildren

addChild

setFirstChild

setNextSibling

setLine

setColumn

graftCopyTo

graftCopyTo

graft

graftAt

duplicate

duplicate

duplicateFresh

duplicateFresh

clearIds

brainwash

brainwash

getId

isRoot

isLeaf

setId

getPath

getDepth

getNumImmediateChildren

getImmediateChildren

getNumImmediateChildren

getNumChildren

initialize

initialize

getParent

setParent

isHidden

setHidden

getIndexPos

getPrevSibling

getAncestor

getAncestor

getAncestor

getAncestor

ancestor

ancestor

ancestor

descendant

descendant

descendant

descendant

descendant

matchAnnotation

sibling