antlr-ng/dist/src/tree/RewriteRuleElementStream.d.ts

Next generation ANTLR Tool

import type { GrammarAST } from "../tool/ast/GrammarAST.js";
import type { CommonTree } from "./CommonTree.js";
/**
 * A generic list of elements tracked in an alternative to be used in a -> rewrite rule. We need to subclass to fill
 * in the next() method, which returns either an AST node wrapped around a token payload or an existing subtree.
 *
 * Once you start next()ing, do not try to add more elements. It will break the cursor tracking I believe.
 */
export declare abstract class RewriteRuleElementStream {
    /**
     * Cursor 0..n-1.  If singleElement!=null, cursor is 0 until you next(), which bumps it to 1 meaning no more
     * elements.
     */
    protected cursor: number;
    /** The list of tokens or subtrees we are tracking */
    protected elements: GrammarAST[];
    /**
     * Once a node / subtree has been used in a stream, it must be dup'd from then on. Streams are reset after
     * subrules so that the streams can be reused in future subrules.  So, reset must set a dirty bit. If dirty,
     * then next() always returns a dup.
     *
     * I wanted to use "naughty bit" here, but couldn't think of a way to use "naughty".
     */
    protected dirty: boolean;
    /**
     * The element or stream description; usually has name of the token or rule reference that this list tracks. Can
     * include rule name too, but the exception would track that info.
     */
    protected elementDescription: string;
    constructor(elementDescription: string, elements?: GrammarAST[]);
    /**
     * Reset the condition of this stream so that it appears we have not consumed any of its elements. Elements
     * themselves are untouched. Once we reset the stream, any future use will need duplicates. Set the dirty bit.
     */
    reset(): void;
    add(el: GrammarAST | null): void;
    /**
     * Return the next element in the stream. If out of elements, throw an exception unless size() == 1. If size is 1,
     * then return elements[0].
     *
     * @returns a duplicate node/subtree if stream is out of elements and size == 1. If we've already used the element,
     * dup (dirty bit set).
     */
    nextTree(): CommonTree;
    hasNext(): boolean;
    size(): number;
    getDescription(): string;
    /**
     * Does the work of getting the next element, making sure that it's a tree node or subtree. Throws an exception
     * if the stream is empty or we're out of elements and size > 1.
     *
     * @returns the next element in the stream.
     */
    protected getNext(): GrammarAST;
    /**
     * Ensures stream emits trees. Tokens must be converted to AST nodes. AST nodes can be passed through unmolested.
     *
     * @param el The element to convert.
     *
     * @returns the element unaltered.
     */
    protected toTree(el: GrammarAST): GrammarAST;
    /**
     * When constructing trees, sometimes we need to dup a token or AST	subtree. Duplicating a token means just
     * creating another AST node around it. For trees, you must call the dupTree() unless the element is for a tree
     * root. Then it must be a node duplicate.
     */
    protected abstract dup(el: CommonTree): CommonTree;
}