@rsconcept/domain 1.0.0

package/src/rslang/ast-annotations.ts

@@ -0,0 +1,70 @@
+/** Module: AST annotations. */
+
+import { type AstNode } from '../parsing';
+
+import { type ExpressionType } from './semantic/typification';
+import { type RSErrorCode, type RSErrorInfo } from './error';
+
+const AST_ERRORS_KEY = 'rsErrors' as const;
+const AST_TYPE_KEY = 'rsType' as const;
+
+/** Appends {@link ExpressionType} onto the node's `annotation.rsType`. */
+export function annotateType(node: AstNode, type: ExpressionType): void {
+  node.annotation = {
+    ...(typeof node.annotation === 'object' && node.annotation !== null ? node.annotation : {}),
+    [AST_TYPE_KEY]: type
+  };
+}
+
+/** Reads {@link ExpressionType} from node's `annotation`. */
+export function readTypeAnnotation(node: AstNode): ExpressionType | null {
+  if (node.annotation && AST_TYPE_KEY in node.annotation) {
+    return node.annotation[AST_TYPE_KEY] as ExpressionType;
+  }
+  return null;
+}
+
+/** Appends {@link RSErrorInfo} onto the node's `annotation.rsErrors` if not already set. */
+export function annotateError(node: AstNode, code: RSErrorCode, params?: readonly string[]): void {
+  if (
+    typeof node.annotation === 'object' &&
+    node.annotation !== null &&
+    AST_ERRORS_KEY in node.annotation &&
+    isAstNodeErrorRef(node.annotation[AST_ERRORS_KEY])
+  ) {
+    return;
+  }
+  const entry: RSErrorInfo = params !== undefined && params.length > 0 ? { code, params: [...params] } : { code };
+  node.annotation = {
+    ...(typeof node.annotation === 'object' && node.annotation !== null ? node.annotation : {}),
+    [AST_ERRORS_KEY]: entry
+  };
+}
+
+/** Reads validated {@link RSErrorInfo} entry from node's `annotation`. */
+export function readErrorAnnotation(node: AstNode): RSErrorInfo | null {
+  const raw = node.annotation?.[AST_ERRORS_KEY];
+  if (isAstNodeErrorRef(raw)) {
+    return raw;
+  }
+  return null;
+}
+
+// ====== Internal ======
+function isAstNodeErrorRef(x: unknown): x is RSErrorInfo {
+  if (typeof x !== 'object' || x === null || !('code' in x)) {
+    return false;
+  }
+  const code = x.code;
+  if (typeof code !== 'number') {
+    return false;
+  }
+  if (!('params' in x)) {
+    return true;
+  }
+  const p = (x as { params: unknown }).params;
+  if (p === undefined) {
+    return true;
+  }
+  return Array.isArray(p) && p.every(item => typeof item === 'string');
+}

package/src/rslang/error.ts

@@ -0,0 +1,129 @@
+/** Module: Error types and functions. */
+
+/** Represents error class. */
+export const RSErrorClass = {
+  LEXER: 0,
+  PARSER: 1,
+  SEMANTIC: 2,
+  EVALUATION: 3,
+  UNKNOWN: 4
+} as const;
+export type RSErrorClass = (typeof RSErrorClass)[keyof typeof RSErrorClass];
+
+/** Represents RSLang expression error information. */
+export interface RSErrorInfo {
+  code: RSErrorCode;
+  params?: readonly string[];
+}
+
+/** Represents RSLang expression error description. */
+export interface RSErrorDescription extends RSErrorInfo {
+  from: number;
+  to: number;
+}
+
+/** Error reporter function type. */
+export type ErrorReporter = (error: RSErrorDescription) => void;
+
+/** Represents RSLang expression error types. */
+export const RSErrorCode = {
+  unknownSyntax: 0x8400, // 33792
+  missingParenthesis: 0x8406, // 33798
+  missingCurlyBrace: 0x8407, // 33799
+  missingSquareBracket: 0x8408, // 33800
+  bracketMismatch: 0x8409, // 33801
+  doubleParenthesis: 0x840a, // 33802
+  missingOpenBracket: 0x840b, // 33803
+  expectedLocal: 0x8415, // 33813
+  expectedType: 0x8416, // 33814
+
+  localDoubleDeclare: 0x2801, // 10241
+  localNotUsed: 0x2802, // 10242
+
+  localUndeclared: 0x8801, // 34817
+  localShadowing: 0x8802, // 34818
+
+  typesNotEqual: 0x8803, // 34819
+  globalNotTyped: 0x8804, // 34820
+  invalidDecart: 0x8805, // 34821
+  invalidBoolean: 0x8806, // 34822
+  invalidTypeOperation: 0x8807, // 34823
+  invalidCard: 0x8808, // 34824
+  invalidDebool: 0x8809, // 34825
+  globalFuncWithoutArgs: 0x880b, // 34827
+  invalidReduce: 0x8810, // 34832
+  invalidProjectionTuple: 0x8811, // 34833
+  invalidProjectionSet: 0x8812, // 34834
+  invalidEnumeration: 0x8813, // 34835
+  invalidCortegeDeclare: 0x8814, // 34836
+  localOutOfScope: 0x8815, // 34837
+  invalidElementPredicate: 0x8816, // 34838
+  invalidEmptySetUsage: 0x8817, // 34839
+  invalidArgsArity: 0x8818, // 34840
+  invalidArgumentType: 0x8819, // 34841
+  globalStructure: 0x881c, // 34844
+  radicalUsage: 0x8821, // 34849
+  invalidFilterArgumentType: 0x8822, // 34850
+  invalidFilterArity: 0x8823, // 34851
+  arithmeticNotSupported: 0x8824, // 34852
+  typesNotCompatible: 0x8825, // 34853
+  orderingNotSupported: 0x8826, // 34854
+  expectedLogic: 0x8827, // 34855
+  expectedSetexpr: 0x8828, // 34856
+  invalidArgumentCortegeDeclare: 0x8829, // 34857
+
+  globalNoValue: 0x8840, // 34880
+  invalidPropertyUsage: 0x8841, // 34881
+
+  // Value evaluation (runtime)
+  calcUnknownError: 0x8100, // 35328
+  setOverflow: 0x8101, // 35329
+  booleanBaseLimit: 0x8102, // 35330
+  calcGlobalMissing: 0x8103, // 35331
+  iterationsLimit: 0x8104, // 35332
+  calcInvalidDebool: 0x8105, // 35333
+  iterateInfinity: 0x8106, // 35334
+  calculationNotSupported: 0x8107, // 35335
+
+  cstEmptyDerived: 0x8861, // 34913
+  definitionNotAllowed: 0x8862 // 34914
+} as const;
+export type RSErrorCode = (typeof RSErrorCode)[keyof typeof RSErrorCode];
+
+const ERROR_EVALUATION_MASK = 0x0100;
+const ERROR_LEXER_MASK = 0x0200;
+const ERROR_PARSER_MASK = 0x0400;
+const ERROR_SEMANTIC_MASK = 0x0800;
+
+/** Infers error class from error type (code). */
+function inferErrorClass(error: RSErrorCode): RSErrorClass {
+  if ((error & ERROR_EVALUATION_MASK) !== 0) {
+    return RSErrorClass.EVALUATION;
+  } else if ((error & ERROR_LEXER_MASK) !== 0) {
+    return RSErrorClass.LEXER;
+  } else if ((error & ERROR_PARSER_MASK) !== 0) {
+    return RSErrorClass.PARSER;
+  } else if ((error & ERROR_SEMANTIC_MASK) !== 0) {
+    return RSErrorClass.SEMANTIC;
+  } else {
+    return RSErrorClass.UNKNOWN;
+  }
+}
+
+/** Generate ErrorID label. */
+export function getRSErrorPrefix(code: RSErrorCode): string {
+  const id = code.toString(16).toUpperCase();
+  // prettier-ignore
+  switch (inferErrorClass(code)) {
+    case RSErrorClass.LEXER: return 'L' + id;
+    case RSErrorClass.PARSER: return 'P' + id;
+    case RSErrorClass.SEMANTIC: return 'S' + id;
+    case RSErrorClass.EVALUATION: return 'E' + id;
+    case RSErrorClass.UNKNOWN: return 'U' + id;
+  }
+}
+
+/** Checks if error is critical. */
+export function isCritical(code: RSErrorCode): boolean {
+  return code !== RSErrorCode.localDoubleDeclare && code !== RSErrorCode.localNotUsed;
+}

package/src/rslang/eval/calculator.test.ts

@@ -0,0 +1,124 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import { type AstNode, buildTree } from '../../parsing';
+import { RSErrorCode } from '../error';
+import { normalizeAST } from '../parser/normalize';
+import { parser as rslangParser } from '../parser/parser';
+
+import { type CalculatorResult, RSCalculator } from './calculator';
+import { printValue } from './value-api';
+
+function buildAST(expression: string): AstNode {
+  const tree = rslangParser.parse(expression);
+  const ast = buildTree(tree.cursor());
+  normalizeAST(ast, expression);
+  return ast;
+}
+
+describe('RSCalculator', () => {
+  let calculator: RSCalculator;
+
+  beforeEach(() => {
+    calculator = new RSCalculator();
+    calculator.setValue('X1', [1, 2, 3]);
+    calculator.setValue('C1', [10, 20, 30]);
+    calculator.setAST('S1', buildAST('ℬ(X1)'));
+    calculator.setAST('D1', buildAST('X1'));
+  });
+
+  function expectCalcValue(expr: string, expected: string) {
+    const ast = buildAST(expr);
+    expect(ast.hasError).toBe(false);
+    const value = calculator.evaluateFast(ast);
+    expect(printValue(value)).toBe(expected);
+  }
+
+  function expectCalcFull(expr: string, options?: { expectValue?: string; expectErrorCode?: RSErrorCode }) {
+    const ast = buildAST(expr);
+    expect(ast.hasError).toBe(false);
+    const result: CalculatorResult = calculator.evaluateFull(ast);
+    if (options?.expectValue !== undefined) {
+      expect(printValue(result.value)).toBe(options.expectValue);
+      expect(result.errors.length).toBe(0);
+    }
+    if (options?.expectErrorCode !== undefined) {
+      expect(result.value).toBe(null);
+      expect(result.errors.length).toBeGreaterThan(0);
+      expect(result.errors[0].code).toBe(options.expectErrorCode);
+    }
+  }
+
+  it('returns null value on syntax error', () => {
+    // Introduce an invalid expression: should set hasError and return null value
+    const ast = buildAST('a ==='); // Invalid
+    // Manually setting hasError for testing, because buildAST may not do this
+    ast.hasError = true;
+    expect(calculator.evaluateFast(ast)).toBe(null);
+    expect(calculator.evaluateFull(ast).value).toBe(null);
+  });
+
+  it('evaluates a simple constant', () => {
+    expectCalcValue('1', '1');
+  });
+
+  it('evaluates a variable from context', () => {
+    expectCalcValue('X1', '{1, 2, 3}');
+  });
+
+  it('evaluates a basic set operation', () => {
+    expectCalcValue('{2,3,4}∩{2,3,5}', '{2, 3}');
+  });
+
+  it('returns error for unknown variable', () => {
+    expectCalcFull('X11', { expectErrorCode: RSErrorCode.calcGlobalMissing });
+  });
+
+  it('returns error for infinite quantifier', () => {
+    expectCalcFull('∀a∈Z a=a', { expectErrorCode: RSErrorCode.iterateInfinity });
+  });
+
+  it('setValue, getValue, and resetValue behave as expected', () => {
+    calculator.setValue('X42', 123);
+    expect(calculator.getValue('X42')).toBe(123);
+    calculator.resetValue('X42');
+    expect(calculator.getValue('X42')).toBe(null);
+  });
+
+  it('setAST registers the AST for future re-evaluation', () => {
+    const ast = buildAST('1+2');
+    calculator.setAST('myAdd', ast);
+    expect(() => calculator.setAST('myAdd', ast)).not.toThrow();
+  });
+
+  it('subscribes to and notifies listeners on setValue/resetValue', () => {
+    let called = false;
+    const unsubscribe = calculator.subscribe('X1', () => (called = true));
+    calculator.setValue('X1', [10, 20]);
+    expect(called).toBe(true);
+    called = false;
+    calculator.resetValue('X1');
+    expect(called).toBe(true);
+    unsubscribe();
+    called = false;
+    calculator.setValue('X1', [3, 4]);
+    expect(called).toBe(false);
+  });
+
+  it('listeners removed when no more subscribers', () => {
+    let calls = 0;
+    const unsubscribe = calculator.subscribe('X1', () => {
+      calls++;
+    });
+    calculator.setValue('X1', [8, 9]);
+    expect(calls).toBe(1);
+    unsubscribe();
+    calculator.setValue('X1', [2, 3]);
+    expect(calls).toBe(1); // not incremented
+  });
+
+  // Additional case for real RS logic
+  it('evaluates logical expressions', () => {
+    expectCalcValue('1=1', '1');
+    expectCalcValue('1=0', '0');
+  });
+});

package/src/rslang/eval/calculator.ts

@@ -0,0 +1,121 @@
+/**
+ * Module: API for calculations.
+ */
+
+import { type AstNode } from '../../parsing';
+import { annotateError } from '../ast-annotations';
+import { RSErrorCode, type RSErrorDescription } from '../error';
+import { type ExpressionType } from '../semantic/typification';
+
+import { type ASTContext, Evaluator } from './evaluator';
+import { type Value, type ValueContext } from './value';
+import { validateValue } from './value-api';
+
+/** Result of calculator evaluation. */
+export interface CalculatorResult {
+  value: Value | null;
+  iterations: number;
+  cacheHits: number;
+  errors: RSErrorDescription[];
+}
+
+/** Options for {@link RSCalculator.evaluateFull}. */
+export interface CalculatorEvaluateOptions {
+  annotateErrors?: boolean;
+  disableCache?: boolean;
+}
+
+type Listener = () => void;
+
+/** AST calculator - evaluates RS expressions via visitor pattern and provides updates via listeners. */
+export class RSCalculator {
+  private context: ValueContext = new Map();
+  private treeContext: ASTContext = new Map();
+  private evaluator: Evaluator = new Evaluator(this.context, this.treeContext);
+
+  private listeners = new Map<string, Set<Listener>>();
+
+  public subscribe = (alias: string, listener: Listener) => {
+    let notifyList = this.listeners.get(alias);
+
+    if (!notifyList) {
+      notifyList = new Set();
+      this.listeners.set(alias, notifyList);
+    }
+
+    notifyList.add(listener);
+    return () => {
+      notifyList.delete(listener);
+      if (notifyList.size === 0) {
+        this.listeners.delete(alias);
+      }
+    };
+  };
+
+  public setValue(alias: string, value: Value): void {
+    this.context.set(alias, value);
+    this.notify(alias);
+  }
+
+  public resetValue(alias: string): void {
+    this.context.delete(alias);
+    this.notify(alias);
+  }
+
+  public clearAllAst(): void {
+    this.treeContext.clear();
+  }
+
+  public getValue(alias: string): Value | null {
+    return this.context.get(alias) ?? null;
+  }
+
+  public setAST(alias: string, ast: AstNode): void {
+    this.treeContext.set(alias, ast);
+  }
+
+  public validate(value: Value, type: ExpressionType): boolean {
+    return validateValue(value, type, this.context);
+  }
+
+  public evaluateFast(ast: AstNode): Value | null {
+    if (ast.hasError) {
+      return null;
+    }
+    return this.evaluator.run(ast);
+  }
+
+  public evaluateFull(ast: AstNode, options?: CalculatorEvaluateOptions): CalculatorResult {
+    const errors: RSErrorDescription[] = [];
+    const reporter = (error: RSErrorDescription) => {
+      errors.push(error);
+    };
+
+    if (ast.hasError) {
+      return { value: null, iterations: 0, cacheHits: 0, errors };
+    }
+
+    const value = this.evaluator.run(ast, reporter, options?.annotateErrors ?? false, options?.disableCache ?? false);
+    if (value === null && errors.length === 0) {
+      errors.push({ code: RSErrorCode.calcUnknownError, from: 0, to: 0 });
+      if (options?.annotateErrors) {
+        annotateError(ast, RSErrorCode.calcUnknownError);
+      }
+    }
+    return {
+      value,
+      iterations: this.evaluator.iterationCounter,
+      cacheHits: this.evaluator.cacheHits,
+      errors
+    };
+  }
+
+  private notify(alias: string) {
+    const set = this.listeners.get(alias);
+    if (!set) return;
+
+    for (const l of set) {
+      l();
+    }
+  }
+}

package/src/rslang/eval/evaluation-cache.ts

@@ -0,0 +1,257 @@
+/**
+ * Module: Dependency metadata and per-run memoization for RSLang evaluation.
+ */
+
+import { type AstNode, getNodeIndices, getNodeText } from '../../parsing';
+import { TokenID } from '../parser/token';
+
+import { type Value } from './value';
+
+/** Static metadata for one AST node. */
+export interface EvalNodeInfo {
+  /** Local aliases this expression reads (for dependency stamping). */
+  reads: ReadonlySet<string>;
+  /** Stable key shared by structurally equivalent expressions. */
+  structuralKey: string;
+  /** Whether the node may be memoized for the current evaluation run. */
+  cacheable: boolean;
+}
+
+/** Per-evaluator cache of immutable AST dependency metadata (no runtime values). */
+export class EvaluationMetadata {
+  private readonly byNode = new WeakMap<AstNode, EvalNodeInfo>();
+
+  get(node: AstNode): EvalNodeInfo {
+    let info = this.byNode.get(node);
+    if (!info) {
+      info = analyzeNode(node, new Set());
+      this.byNode.set(node, info);
+    }
+    return info;
+  }
+}
+
+/** Per-run memo of computed values (cleared on each {@link Evaluator.run}). */
+export class EvaluationCache {
+  private entries = new Map<string, CacheEntry>();
+
+  /** Cache hits in the current evaluation run (for tests/diagnostics). */
+  hits = 0;
+
+  /** Returns cached value, or `undefined` on miss or stamp mismatch. */
+  lookup(structuralKey: string, stamp: string): Value | undefined {
+    const entry = this.entries.get(structuralKey);
+    if (entry?.stamp !== stamp) {
+      return undefined;
+    }
+    this.hits++;
+    return entry.value;
+  }
+
+  /** Stores one value per structural key (replaces previous stamp). */
+  store(structuralKey: string, stamp: string, value: Value): void {
+    this.entries.set(structuralKey, { stamp, value });
+  }
+
+  clear(): void {
+    this.entries.clear();
+    this.hits = 0;
+  }
+}
+
+interface CacheEntry {
+  stamp: string;
+  value: Value;
+}
+
+function analyzeNode(node: AstNode, bound: Set<string>): EvalNodeInfo {
+  const reads = collectReads(node, bound);
+  const structuralKey = buildStructuralKey(node);
+  const cacheable = isCacheableNode(node);
+  return { reads, structuralKey, cacheable };
+}
+
+function isCacheableNode(node: AstNode): boolean {
+  switch (node.typeID) {
+    case TokenID.ASSIGN:
+    case TokenID.ITERATE:
+    case TokenID.NT_IMPERATIVE_EXPR:
+    case TokenID.NT_DECLARATIVE_EXPR:
+    case TokenID.NT_RECURSIVE_FULL:
+    case TokenID.NT_RECURSIVE_SHORT:
+    case TokenID.QUANTOR_UNIVERSAL:
+    case TokenID.QUANTOR_EXISTS:
+    case TokenID.LOGIC_AND:
+    case TokenID.LOGIC_OR:
+    case TokenID.LOGIC_IMPLICATION:
+    case TokenID.NT_FUNC_DEFINITION:
+    case TokenID.LIT_INTEGER:
+    case TokenID.LIT_EMPTYSET:
+    case TokenID.LIT_WHOLE_NUMBERS:
+    case TokenID.ID_LOCAL:
+    case TokenID.ID_RADICAL:
+    case TokenID.ID_GLOBAL:
+      return false;
+    default:
+      return !node.hasError;
+  }
+}
+
+function buildStructuralKey(node: AstNode): string {
+  switch (node.typeID) {
+    case TokenID.ID_GLOBAL:
+    case TokenID.ID_LOCAL:
+    case TokenID.ID_RADICAL:
+    case TokenID.LIT_INTEGER:
+    case TokenID.LIT_EMPTYSET:
+    case TokenID.LIT_WHOLE_NUMBERS:
+      return `${node.typeID}:${nodeTextKey(node)}`;
+
+    case TokenID.NT_FUNC_CALL:
+      return `${node.typeID}:${nodeTextKey(node.children[0])}(${node.children
+        .slice(1)
+        .map(buildStructuralKey)
+        .join(',')})`;
+
+    case TokenID.BIGPR:
+    case TokenID.SMALLPR:
+    case TokenID.FILTER:
+      return `${node.typeID}:${indicesKey(node)}(${node.children.map(buildStructuralKey).join(',')})`;
+
+    default:
+      return `${node.typeID}(${node.children.map(buildStructuralKey).join(',')})`;
+  }
+}
+
+function nodeTextKey(node: AstNode): string {
+  if (node.data.dataType === 'number') {
+    return String(node.data.value);
+  }
+  return getNodeText(node);
+}
+
+function indicesKey(node: AstNode): string {
+  return getNodeIndices(node).join('.');
+}
+
+function collectReads(node: AstNode, bound: Set<string>): Set<string> {
+  const reads = new Set<string>();
+  collectReadsImpl(node, bound, reads);
+  return reads;
+}
+
+function collectReadsImpl(node: AstNode, bound: Set<string>, reads: Set<string>): void {
+  switch (node.typeID) {
+    case TokenID.ID_LOCAL:
+    case TokenID.ID_RADICAL: {
+      reads.add(getNodeText(node));
+      return;
+    }
+
+    case TokenID.QUANTOR_UNIVERSAL:
+    case TokenID.QUANTOR_EXISTS: {
+      collectReadsImpl(node.children[1], bound, reads);
+      const innerBound = extendBound(bound, node.children[0]);
+      collectReadsImpl(node.children[2], innerBound, reads);
+      return;
+    }
+
+    case TokenID.NT_DECLARATIVE_EXPR: {
+      collectReadsImpl(node.children[1], bound, reads);
+      const innerBound = extendBound(bound, node.children[0]);
+      collectReadsImpl(node.children[2], innerBound, reads);
+      return;
+    }
+
+    case TokenID.ITERATE: {
+      collectReadsImpl(node.children[1], bound, reads);
+      return;
+    }
+
+    case TokenID.ASSIGN: {
+      collectReadsImpl(node.children[1], bound, reads);
+      return;
+    }
+
+    case TokenID.NT_IMPERATIVE_EXPR: {
+      const innerBound = new Set(bound);
+      collectReadsImpl(node.children[0], innerBound, reads);
+      for (let i = 1; i < node.children.length; i++) {
+        const child = node.children[i];
+        if (child.typeID === TokenID.ITERATE) {
+          extendBoundInPlace(innerBound, child.children[0]);
+          collectReadsImpl(child.children[1], innerBound, reads);
+        } else if (child.typeID === TokenID.ASSIGN) {
+          collectReadsImpl(child.children[1], innerBound, reads);
+          extendBoundInPlace(innerBound, child.children[0]);
+        } else {
+          collectReadsImpl(child, innerBound, reads);
+        }
+      }
+      return;
+    }
+
+    case TokenID.NT_RECURSIVE_FULL:
+    case TokenID.NT_RECURSIVE_SHORT: {
+      collectReadsImpl(node.children[1], bound, reads);
+      const innerBound = extendBound(bound, node.children[0]);
+      if (node.typeID === TokenID.NT_RECURSIVE_FULL) {
+        collectReadsImpl(node.children[2], innerBound, reads);
+        collectReadsImpl(node.children[3], innerBound, reads);
+      } else {
+        collectReadsImpl(node.children[2], innerBound, reads);
+      }
+      return;
+    }
+
+    case TokenID.NT_FUNC_DEFINITION: {
+      const innerBound = extendBound(bound, node.children[0]);
+      collectReadsImpl(node.children[1], innerBound, reads);
+      return;
+    }
+
+    case TokenID.NT_FUNC_CALL: {
+      for (let i = 1; i < node.children.length; i++) {
+        collectReadsImpl(node.children[i], bound, reads);
+      }
+      return;
+    }
+
+    case TokenID.LOGIC_AND:
+    case TokenID.LOGIC_OR:
+    case TokenID.LOGIC_IMPLICATION: {
+      collectReadsImpl(node.children[0], bound, reads);
+      collectReadsImpl(node.children[1], bound, reads);
+      return;
+    }
+
+    default:
+      for (const child of node.children) {
+        collectReadsImpl(child, bound, reads);
+      }
+  }
+}
+
+function extendBound(bound: Set<string>, declNode: AstNode): Set<string> {
+  const next = new Set(bound);
+  extendBoundInPlace(next, declNode);
+  return next;
+}
+
+function extendBoundInPlace(bound: Set<string>, declNode: AstNode): void {
+  switch (declNode.typeID) {
+    case TokenID.ID_LOCAL:
+    case TokenID.ID_RADICAL:
+      bound.add(getNodeText(declNode));
+      break;
+    case TokenID.NT_TUPLE_DECL:
+    case TokenID.NT_ENUM_DECL:
+      for (const child of declNode.children) {
+        extendBoundInPlace(bound, child);
+      }
+      break;
+    case TokenID.NT_ARG_DECL:
+      extendBoundInPlace(bound, declNode.children[0]);
+      break;
+  }
+}