index.d.ts.template

{{doNotEditBanner}}
export = ohm;

declare namespace ohm {
  const ohmGrammar: Grammar;

  /**
   * Instantiate the Grammar defined by source. If specified, namespace is
   * the Namespace to use when resolving external references in the grammar.
   */
  function grammar(source: string, namespace?: Namespace): Grammar;

  /**
   * grammarFromScriptElement was removed in Ohm v16.0. See
   * https://ohmjs.org/d/gfs for more info.
   * @deprecated
   */
  function grammarFromScriptElement(node?: unknown, namespace?: Namespace): Grammar;

  /**
   * Create a new Namespace containing Grammar instances for all of the
   * grammars defined in source.
   * If namespace is specified, it will be the prototype of the new
   * Namespace.
   */
  function grammars(source: string, namespace?: Namespace): Namespace;

  /**
   * grammarsFromScriptElements was removed in Ohm v16.0. See
   * https://ohmjs.org/d/gfs for more info.
   * @deprecated
   */
  function grammarsFromScriptElements(nodeList?: unknown, namespace?: Namespace): Namespace;

  /**
   * Create a new namespace. If props is specified, all of its properties
   * will be copied to the new namespace.
   */
  function namespace(props?: Object): Namespace;

  /**
   * Create a new namespace which inherits from namespace. If props is
   * specified, all of its properties will be copied to the new namespace.
   */
  function extendNamespace(namespace: Namespace, props?: Object): Namespace;

  /**
   * A Namespace is a dictionary of Grammars
   */
  interface Namespace {
    [index: string]: Grammar;
  }

  /**
   * An Ohm Grammar.
   */
  interface Grammar {
    name: string;
    superGrammar: Grammar;
    rules: {[ruleName: string]: RuleInfo};

    /** Return true if the grammar is a built-in grammar, otherwise false. */
    isBuiltIn(): boolean;

    /**
     * Try to match input with this grammar, returning a MatchResult. If
     * startRule is given, it specifies the rule on which to start
     * matching. By default, the start rule is inherited from the
     * supergrammar, or if there is no supergrammar specified, it is the
     * first rule in this grammar.
     */
    match(input: string, startRule?: string): MatchResult;

    /**
     * Create a new Matcher object which supports incrementally matching
     * this grammar against a changing input string.
     */
    matcher(): Matcher;

    /**
     * Like match() except returns a trace object whose toString() returns
     * a summary of each parsing step useful for debugging.
     */
    trace(input: string, startRule?: string): Object;

    /**
     * Create a new Semantics object for this Grammar.
     */
    createSemantics(): Semantics;

    /**
     * Create a new Semantics object for this Grammar that inherits all
     * of the operations and attributes in superSemantics.
     * This Grammar must be a descendant of the grammar associated with
     * superSemantics.
     */
    extendSemantics(superSemantics: Semantics): Semantics;
  }

  interface PExpr {}

  /**
   * Matcher objects are used to incrementally match a changing input
   * against a Grammar, e.g. in an editor or IDE.
   */
  interface Matcher {
    /**
     * Return the current input string.
     */
    getInput(): string;

    /**
     * Set the input string to `str`.
     */
    setInput(str: string): void;

    /**
     * Edit the current input string, replacing the characters between
     * `startIdx` and `endIdx` with `str`.
     */
    replaceInputRange(startIdx: number, endIdx: number, str: string): Matcher;

    /**
     * Like Grammar#match, but operates incrementally.
     */
    match(optStartRule?: string): MatchResult;

    /**
     * Like Grammar#trace, but operates incrementally.
     */
    trace(optStartRule?: string): Object;
  }

  /**
   * Result of Grammar#match
   */
  interface MatchResult {
    /**
     * True iff match succeeded
     */
    succeeded(): boolean;

    /**
     * True iff match did not succeed
     */
    failed(): boolean;

    /**
     * If match failed contains an error message indicating where and
     * why the match failed. This message is suitable for end users of a
     * language (i.e., people who do not have access to the grammar source).
     */
    message?: string;

    /**
     * If match failed contains an abbreviated version of this.message that
     * does not include an excerpt from the invalid input.
     */
    shortMessage?: string;
  }

  /**
   * A Semantics is a family of operations and/or attributes for a given
   * grammar. Each operation/attribute has a unique name within the
   * Semantics. A grammar may have any number of Semantics instances
   * associated with it -- this means that the clients of a grammar
   * (even in the same program) never have to worry about
   * operation/attribute name clashes.
   */
  interface Semantics {
    /**
     * Returns a dictionary containing operations and attributes defined by
     * this Semantics on the result of a matched grammar. Operations are
     * no-arg functions and attributes are properties.
     */
    (match: MatchResult): Dict;

    /**
     * Add a new operation named name to this Semantics, using the
     * semantic actions contained in actionDict. It is an error if there
     * is already an operation or attribute called name in this semantics.
     * Returns this Semantics.
     */
    addOperation<T>(name: string, actionDict: ActionDict<T>): Semantics;

    /**
     * Add a new attribute named name to this Semantics, using the
     * semantic actions contained in actionDict. It is an error if there
     * is already an operation or attribute called name in this semantics.
     * Returns this Semantics.
     */
    addAttribute<T>(name: string, actionDict: ActionDict<T>): Semantics;

    /**
     * Extend the operation named name with the semantic actions contained
     * in actionDict. name must be the name of an operation in the super
     * semantics.
     * Returns this Semantics.
     */
    extendOperation<T>(name: string, actionDict: ActionDict<T>): Semantics;

    /**
     * Extend the attribute named name with the semantic actions contained
     * in actionDict. name must be the name of an attribute in the super
     * semantics.
     * Returns this Semantics.
     */
    extendAttribute<T>(name: string, actionDict: ActionDict<T>): Semantics;
  }

  /**
   * A dictionary is indexed by strings.
   */
  interface Dict {
    [index: string]: any;
  }

  /**
   * An ActionDict is a dictionary of Actions indexed by rule names.
   */
  interface ActionDict<T> {
    [index: string]: Action<T> | undefined;

    _iter?: (this: IterationNode, ...children: Node[]) => T;
    _nonterminal?: (this: NonterminalNode, ...children: Node[]) => T;
    _terminal?: (this: TerminalNode) => T;

    // Built-in rules
    {{builtInRuleActions}}
  }

  /**
   * An Action is a function from ParseNodes, called with the children nodes
   * of the node it is being executed on.
   * The current node is passed as a dynamic this, requiring an ES5
   * anonymous function with this typed as any.
   */
  type Action<T> = (this: Node, ...args: Node[]) => T;

  /**
   * A node in the parse tree, passed to Action functions.
   */
  interface Node {
    /**
     * Returns the child at index idx.
     */
    child(idx: number): Node;

    /**
     * true if the node is a terminal node, otherwise false.
     */
    isTerminal(): boolean;

    /**
     * true if the node is an iteration node, which corresponds to a
     * +, *, or ? expression in the grammar.
     */
    isIteration(): boolean;

    /**
     * An array containing the node's children.
     */
    children: Node[];

    /**
     * The name of grammar rule that created the node.
     */
    ctorName: string;

    /**
     * Captures the portion of the input that was consumed by the node.
     */
    source: Interval;

    /**
     * Returns the contents of the input stream consumed by this node.
     */
    sourceString: string;

    /**
     * The number of child nodes that the node has.
     */
    numChildren: number;

    /**
     * True if Node is ? option
     */
    isOptional: boolean;

    /**
     * In addition to the properties defined above, within a given
     * semantics, every node also has a method/property corresponding to
     * each operation/attribute in the semantics.
     * For example, in a semantics that has an operation named 'prettyPrint'
     * and an attribute named 'freeVars', every node has a prettyPrint()
     * method and a freeVars property.
     * NOTE this means the above node properties can not be used as
     * operation/attribute names.
     */
    [index: string]: any;
  }

  interface IterationNode extends Node {}
  interface NonterminalNode extends Node {}
  interface TerminalNode extends Node {}

  /**
   * Interval in input string
   */
  interface Interval {
    /**
     * Input stream of parse
     */
    inputStream: any;

    /**
     * Starting index in input
     */
    startIdx: number;
    /**
     * Ending index in input
     */
    endIdx: number;
    /**
     * Contents of interval
     */
    contents: string;

    /**
     * Returns a new Interval at the start of this one
     */
    collapsedLeft(): Interval;

    /**
     * Returns a new Interval at the end of this one
     */
    collapsedRight(): Interval;

    /**
     * Returns a new Interval which contains the same contents as this one,
     * but with whitespace trimmed from both ends.
     */
    trimmed(): Interval;

    /**
     * Returns a new Interval that covers this Interval and all the
     * argument Intervals. The new Interval will start at the lowest start
     * index and end at the largest end index.
     */
    coverageWith(...intervals: Interval[]): Interval;

    /**
     * Return a nicely-formatted string describing the start of the Interval
     */
    getLineAndColumnMessage(): string;
  }

  interface RuleInfo {
    body: PExpr;
    formals: string[];
    description: string;
    source: Interval;
  }
}