antlr-ng/dist/src/semantics/UseDefAnalyzer.js

Next generation ANTLR Tool

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
import { CharStream } from "antlr4ng";
import { ActionSplitter } from "../generated/ActionSplitter.js";
import { ANTLRv4Parser } from "../generated/ANTLRv4Parser.js";
import { LexerGrammar } from "../tool/LexerGrammar.js";
import { ActionSniffer } from "./ActionSniffer.js";
class UseDefAnalyzer {
  static {
    __name(this, "UseDefAnalyzer");
  }
  // side-effect: updates Alternative with refs in actions
  static trackTokenRuleRefsInActions(g) {
    for (const r of g.rules.values()) {
      for (let i = 1; i <= r.numberOfAlts; i++) {
        const alt = r.alt[i];
        for (const a of alt.actions) {
          const sniffer = new ActionSniffer(g, r, alt, a, a.token);
          sniffer.examineAction();
        }
      }
    }
  }
  static actionIsContextDependent(actionAST) {
    const input = CharStream.fromString(actionAST.token.text);
    const dependent = [false];
    const listener = new class {
      nonLocalAttr(expr, x, y) {
        dependent[0] = true;
      }
      qualifiedAttr(expr, x, y) {
        dependent[0] = true;
      }
      setAttr(expr, x, rhs) {
        dependent[0] = true;
      }
      setExprAttribute(expr) {
        dependent[0] = true;
      }
      setNonLocalAttr(expr, x, y, rhs) {
        dependent[0] = true;
      }
      attr(expr, x) {
        dependent[0] = true;
      }
      text(text) {
      }
    }();
    const splitter = new ActionSplitter(input);
    splitter.getActionTokens(listener);
    return dependent[0];
  }
  static getRuleDependencies(...args) {
    if (args.length === 1) {
      const g = args[0];
      return UseDefAnalyzer.getRuleDependencies(g, Array.from(g.rules.values()));
    }
    if (args[0] instanceof LexerGrammar) {
      const [g, modeName] = args;
      return UseDefAnalyzer.getRuleDependencies(g, g.modes.get(modeName));
    } else {
      const [g, rules] = args;
      const dependencies = /* @__PURE__ */ new Map();
      for (const r of rules) {
        const tokenRefs = r.ast.getNodesWithType(ANTLRv4Parser.TOKEN_REF);
        for (const tref of tokenRefs) {
          let calls = dependencies.get(r);
          if (!calls) {
            calls = /* @__PURE__ */ new Set();
            dependencies.set(r, calls);
          }
          calls.add(g.getRule(tref.getText()));
        }
      }
      return dependencies;
    }
  }
}
export {
  UseDefAnalyzer
};