@untangle-code/parser-registry 0.0.0-stage → 0.1.0

package/src/languages/shared/syntax.ts

@@ -0,0 +1,116 @@
+/**
+ * Der backend-neutrale Baumvertrag dieses Pakets.
+ *
+ * WARUM ES IHN GIBT: seit WP-220 laufen ZWEI Parser-Backends unter demselben
+ * `LanguageAdapter` (domain `analysis.ts`) — `tree-sitter` fuer die
+ * JS/TS-Familie und `@ast-grep/napi` fuer die Sprachen, fuer die wir keine
+ * eigene Grammatik pflegen wollen. Der vereinheitlichte Walk (`engine.ts`),
+ * die Parse-Diagnosen (`parse-diagnostics.ts`), die Fingerabdruecke
+ * (`fingerprint.ts`) und der Regionenbaum (`chunks.ts`) sind fuer BEIDE
+ * dieselben Zeilen. Sie sprechen deshalb nicht mehr ueber
+ * `Parser.SyntaxNode`/`Parser.TreeCursor`, sondern ueber die zwei Formen hier.
+ *
+ * DIE FORMEN SIND ABSICHTLICH DIE VON TREE-SITTER. `Parser.SyntaxNode` und
+ * `Parser.TreeCursor` erfuellen sie STRUKTURELL, ohne einen einzigen Wrapper:
+ * der tree-sitter-Weg zahlt fuer diese Abstraktion nichts, kein Objekt, kein
+ * Aufruf mehr als vorher (`languages/shared/tree-sitter-types.ts` haelt die
+ * Zusage mit einer Zuweisungspruefung fest). Die Kosten traegt der neue Weg:
+ * `languages/astgrep-backend/syntax.ts` baut die Form ueber `SgNode` nach, weil
+ * ast-grep KEINE Cursor-API hat (gemessen: Faktor 3,74 auf dem Walk). Diese
+ * Richtung ist gewollt — der gemessen schnellere Weg bleibt der billige.
+ *
+ * ZWEI EIGENSCHAFTEN, DIE JEDES BACKEND EINHALTEN MUSS:
+ *
+ *  1. `startIndex`/`endIndex` und `startPosition.column` sind UTF-16-Offsets,
+ *     NICHT Bytes — bei tree-sitter ebenso wie bei ast-grep, dessen
+ *     Typdefinition `Pos.index` faelschlich als "byte offset" beschreibt
+ *     (nachgemessen an Umlauten und Emoji). Bytes entstehen ausschliesslich
+ *     in `node-utils.ts#rangeOf`/`rangeOfCursor` ueber die `ByteOffsetTable`.
+ *
+ *  2. Ein Cursor wird IMMER an der Ausgangsposition zurueckgegeben. Jede
+ *     Hilfsfunktion, die ihn bewegt, bewegt ihn zurueck.
+ */
+/** Zeile/Spalte eines Knotens; `row` und `column` sind 0-basiert. */
+export interface SyntaxPoint {
+  readonly row: number;
+  readonly column: number;
+}
+
+/**
+ * Ein Knoten des Syntaxbaums — die Teilmenge der tree-sitter-Knotenform, die
+ * dieses Paket wirklich benutzt. Wer hier etwas hinzufuegt, verpflichtet
+ * BEIDE Backends dazu; `languages/astgrep-backend/syntax.ts` muss es dann nachbauen.
+ */
+export interface SyntaxNode {
+  readonly type: string;
+  readonly text: string;
+  /**
+   * Benannter Knoten der Grammatik (kein reines Satzzeichen-/Schluesselwort-
+   * Token). Beide Backends liefern das ohne Umweg (tree-sitter `isNamed`,
+   * ast-grep `isNamed()`); gebraucht wird es dort, wo ein Operator KEIN
+   * eigenes Feld hat und nur ueber "das anonyme Kind" zu finden ist.
+   */
+  readonly isNamed: boolean;
+  /** UTF-16-Offset des ersten Zeichens (siehe Modulkopf, Punkt 1). */
+  readonly startIndex: number;
+  /** UTF-16-Offset hinter dem letzten Zeichen. */
+  readonly endIndex: number;
+  readonly startPosition: SyntaxPoint;
+  readonly endPosition: SyntaxPoint;
+  readonly parent: SyntaxNode | null;
+  /**
+   * Vorheriges Geschwister — auch ein anonymes. `doc-binding.ts` laeuft
+   * darueber rueckwaerts zu Dekoratoren und Doc-Kommentaren; wuerde ein
+   * Backend hier nur BENANNTE Geschwister liefern, veraenderte das die
+   * Doc-Bindung stillschweigend (ast-grep `prev()` ist deshalb geprueft).
+   */
+  readonly previousSibling: SyntaxNode | null;
+  readonly children: readonly SyntaxNode[];
+  readonly namedChildCount: number;
+  namedChild(index: number): SyntaxNode | null;
+  childForFieldName(fieldName: string): SyntaxNode | null;
+  /** Ein Cursor, der auf DIESEM Knoten steht. */
+  walk(): SyntaxCursor;
+}
+
+/**
+ * Der Traversierungszeiger. Bei tree-sitter haelt er die Position nativ und
+ * baut je Knoten KEINEN Wrapper (WP-95); bei ast-grep bildet ihn ein
+ * expliziter Stapel nach. Der Vertrag ist in beiden Faellen derselbe, und die
+ * Besuchsreihenfolge ebenfalls: Vorordnung ueber `gotoFirstChild` /
+ * `gotoNextSibling` / `gotoParent`, Rueckordnung ueber `gotoLastChild` /
+ * `gotoPreviousSibling` (die Parse-Diagnosen laufen rueckwaerts, siehe
+ * `parse-diagnostics.ts`).
+ */
+export interface SyntaxCursor {
+  readonly nodeType: string;
+  readonly nodeText: string;
+  /**
+   * Fehlender Knoten der Fehlerkorrektur (tree-sitter `ts_node_is_missing`).
+   *
+   * ast-grep hat dazu KEIN Gegenstueck. Sein Cursor liefert an dieser Stelle
+   * eine HEURISTIK (Knoten der Breite null), und der Adapter sagt das in der
+   * Diagnose auch — `languages/astgrep-backend/syntax.ts` und
+   * `languages/astgrep-backend/create-adapter.ts`. Wer den Wert liest, muss wissen,
+   * dass er je nach Backend gemessen oder geschaetzt ist.
+   */
+  readonly nodeIsMissing: boolean;
+  /**
+   * Feldname, unter dem der aktuelle Knoten in seinem Elternknoten steht,
+   * oder `undefined`. tree-sitter liefert ihn ohne Zusatzkosten; der
+   * ast-grep-Cursor muss ihn ueber die Felder des Elternknotens suchen und
+   * kennt deshalb nur die Feldnamen, die das Sprachprofil nennt
+   * (`profile.ts#LanguageProfile.fieldNames`).
+   */
+  readonly currentFieldName: string | undefined;
+  readonly currentNode: SyntaxNode;
+  readonly startPosition: SyntaxPoint;
+  readonly endPosition: SyntaxPoint;
+  readonly startIndex: number;
+  readonly endIndex: number;
+  gotoParent(): boolean;
+  gotoFirstChild(): boolean;
+  gotoLastChild(): boolean;
+  gotoNextSibling(): boolean;
+  gotoPreviousSibling(): boolean;
+}

package/src/languages/shared/table-profile-decisions.ts

@@ -0,0 +1,251 @@
+/** Entscheidungs- und Nestingauflösung des Tabellenprofils. */
+import type { DecisionKind } from "@untangle-code/domain";
+
+import type { DecisionDetectionResult, DetectedDecision } from "./decisions.js";
+import type { SyntaxNode } from "./syntax.js";
+import { firstChildOfKinds, setOf } from "./table-profile-queries.js";
+import type { DecisionRules } from "./table-profile.js";
+
+function branching(
+  kind: DecisionKind,
+  construct: string,
+  continuation: boolean,
+): DecisionDetectionResult {
+  return {
+    decision: { kind, countsForClassic: true, countsForExtended: true },
+    nesting: { construct, continuation },
+  };
+}
+
+function extendedOnly(kind: DecisionKind, logicalGroupId?: string): DecisionDetectionResult {
+  const decision: DetectedDecision = {
+    kind,
+    countsForClassic: false,
+    countsForExtended: true,
+    ...(logicalGroupId === undefined ? {} : { logicalGroupId }),
+  };
+  return { decision };
+}
+
+/** Kompiliert ausschliesslich Kontrollflussregeln einer Sprachtabelle. */
+export class TableDecisionDetector {
+  readonly nodeKinds: ReadonlySet<string>;
+
+  private readonly ifKinds: ReadonlySet<string>;
+  private readonly elseIfParentKinds: ReadonlySet<string>;
+  private readonly elseIfWrapperKinds: ReadonlySet<string>;
+  private readonly elseIfKinds: ReadonlySet<string>;
+  private readonly loopKinds: ReadonlySet<string>;
+  private readonly catchKinds: ReadonlySet<string>;
+  private readonly ternaryKinds: ReadonlySet<string>;
+  private readonly switchKinds: ReadonlySet<string>;
+  private readonly caseKinds: ReadonlySet<string>;
+  private readonly caseExcludeChildKinds: ReadonlySet<string>;
+  private readonly guardKinds: ReadonlySet<string>;
+  private readonly patternAlternativeKinds: ReadonlySet<string>;
+  private readonly shortCircuitKinds: ReadonlySet<string>;
+  private readonly anonymousOperatorKinds: ReadonlySet<string>;
+  private readonly binaryKinds: ReadonlySet<string>;
+  private readonly jumpKinds: ReadonlySet<string>;
+  private readonly blockKinds: ReadonlySet<string>;
+  private readonly logicalKinds = new Map<string, DecisionKind>();
+  private readonly operatorField: string;
+
+  constructor(
+    private readonly rules: DecisionRules,
+    private readonly triviaKinds: ReadonlySet<string>,
+  ) {
+    this.ifKinds = setOf(rules.ifKinds);
+    this.elseIfParentKinds = setOf(rules.elseIfParentKinds);
+    this.elseIfWrapperKinds = setOf(rules.elseIfWrapperKinds);
+    this.elseIfKinds = setOf(rules.elseIfKinds);
+    this.loopKinds = setOf(rules.loopKinds);
+    this.catchKinds = setOf(rules.catchKinds);
+    this.ternaryKinds = setOf(rules.ternaryKinds);
+    this.switchKinds = setOf(rules.switchKinds);
+    this.caseKinds = setOf(rules.caseKinds);
+    this.caseExcludeChildKinds = setOf(rules.caseExcludeChildKinds);
+    this.guardKinds = setOf(rules.guardKinds);
+    this.patternAlternativeKinds = setOf(rules.patternAlternativeKinds);
+    this.shortCircuitKinds = setOf(rules.shortCircuitKinds);
+    this.anonymousOperatorKinds = setOf(rules.anonymousOperatorKinds);
+    this.binaryKinds = setOf(rules.binaryKinds);
+    this.jumpKinds = setOf(rules.jumpKinds);
+    this.blockKinds = setOf(rules.blockKinds);
+    this.operatorField = rules.operatorField ?? "operator";
+    this.registerLogicalKinds(rules.logicalAndOperators, "logical_and");
+    this.registerLogicalKinds(rules.logicalOrOperators, "logical_or");
+    this.registerLogicalKinds(rules.shortCircuitOperators, "short_circuit");
+    this.nodeKinds = new Set([
+      ...this.ifKinds,
+      ...this.loopKinds,
+      ...this.catchKinds,
+      ...this.ternaryKinds,
+      ...this.switchKinds,
+      ...this.caseKinds,
+      ...this.elseIfKinds,
+      ...this.guardKinds,
+      ...this.patternAlternativeKinds,
+      ...this.shortCircuitKinds,
+      ...this.anonymousOperatorKinds,
+      ...this.binaryKinds,
+    ]);
+  }
+
+  private registerLogicalKinds(operators: readonly string[] | undefined, kind: DecisionKind): void {
+    for (const operator of operators ?? []) this.logicalKinds.set(operator, kind);
+  }
+
+  detect(node: SyntaxNode): DecisionDetectionResult {
+    const kind = node.type;
+    if (this.elseIfKinds.has(kind)) return branching("else_if", "if", true);
+    if (this.guardKinds.has(kind)) return branching("guard", "if", false);
+    if (this.patternAlternativeKinds.has(kind)) return extendedOnly("pattern_alternative");
+    if (this.shortCircuitKinds.has(kind)) {
+      return extendedOnly("short_circuit", `short-circuit-${String(node.startIndex)}`);
+    }
+    if (this.ifKinds.has(kind)) return this.detectIf(node);
+    if (this.loopKinds.has(kind)) return branching("loop", "loop", false);
+    if (this.catchKinds.has(kind)) return branching("catch", "catch", false);
+    if (this.ternaryKinds.has(kind)) return branching("ternary", "ternary", false);
+    if (this.switchKinds.has(kind))
+      return { nesting: { construct: "switch", continuation: false } };
+    if (this.caseKinds.has(kind)) return this.detectCase(node);
+    if (this.binaryKinds.has(kind) || this.anonymousOperatorKinds.has(kind)) {
+      return this.detectLogical(node);
+    }
+    return {};
+  }
+
+  private detectIf(node: SyntaxNode): DecisionDetectionResult {
+    if (this.isElseIf(node)) return branching("else_if", "if", true);
+    return branching(this.isGuardClause(node) ? "guard" : "if", "if", false);
+  }
+
+  private isElseIf(node: SyntaxNode): boolean {
+    const parent = node.parent;
+    if (parent === null) return false;
+    if (this.elseIfParentKinds.has(parent.type)) return true;
+    if (this.elseIfWrapperKinds.has(parent.type)) {
+      let previous = parent.previousSibling;
+      while (previous !== null && this.triviaKinds.has(previous.type)) {
+        previous = previous.previousSibling;
+      }
+      if (previous?.type === "else") return true;
+    }
+    return this.isDetachedElseIfAfterComments(node, parent);
+  }
+
+  /**
+   * Kotlin 0.0.7 verliert in `else /* ... *\/ if` das `else` als Baumknoten
+   * und beendet das erste `if_expression` vor dem Blockkommentar. Die
+   * Korrektur bleibt an AST-Grenzen gebunden: links muss ein mit `if` endender
+   * Geschwisterteilbaum stehen, dazwischen mindestens ein echter
+   * Kommentarknoten, und nur der exakte Keyword-Spalt `else` darf fehlen.
+   */
+  private isDetachedElseIfAfterComments(node: SyntaxNode, parent: SyntaxNode): boolean {
+    if (this.rules.recoverDetachedElseIfAfterComments !== true) return false;
+
+    let right = node;
+    let left = node.previousSibling;
+    let sawComment = false;
+    while (left !== null && this.triviaKinds.has(left.type)) {
+      if (!this.isWhitespaceGap(parent, left.endIndex, right.startIndex)) return false;
+      sawComment = true;
+      right = left;
+      left = left.previousSibling;
+    }
+    if (!sawComment || left === null || !this.endsWithIf(left)) return false;
+
+    const keywordGap = this.textBetween(parent, left.endIndex, right.startIndex);
+    return keywordGap !== null && keywordGap.trim() === "else";
+  }
+
+  private isWhitespaceGap(parent: SyntaxNode, startIndex: number, endIndex: number): boolean {
+    const gap = this.textBetween(parent, startIndex, endIndex);
+    return gap !== null && gap.trim().length === 0;
+  }
+
+  private textBetween(parent: SyntaxNode, startIndex: number, endIndex: number): string | null {
+    const start = startIndex - parent.startIndex;
+    const end = endIndex - parent.startIndex;
+    if (start < 0 || end < start || end > parent.text.length) return null;
+    return parent.text.slice(start, end);
+  }
+
+  /** Ob `node` an seiner rechten AST-Grenze in einem `if` endet. */
+  private endsWithIf(node: SyntaxNode): boolean {
+    const endIndex = node.endIndex;
+    const stack: SyntaxNode[] = [node];
+    while (stack.length > 0) {
+      const current = stack.pop() as SyntaxNode;
+      if (current.endIndex !== endIndex) continue;
+      if (this.ifKinds.has(current.type)) return true;
+      for (const child of current.children) {
+        if (child.endIndex === endIndex) stack.push(child);
+      }
+    }
+    return false;
+  }
+
+  private isGuardClause(node: SyntaxNode): boolean {
+    if (this.rules.consequenceField === undefined || this.jumpKinds.size === 0) return false;
+    if (
+      this.rules.alternativeField !== undefined &&
+      node.childForFieldName(this.rules.alternativeField) !== null
+    ) {
+      return false;
+    }
+    const consequence = node.childForFieldName(this.rules.consequenceField);
+    const sole = consequence === null ? null : this.soleStatementOf(consequence);
+    return sole !== null && this.jumpKinds.has(sole.type);
+  }
+
+  private soleStatementOf(node: SyntaxNode): SyntaxNode | null {
+    let current: SyntaxNode | null = node;
+    while (current !== null && this.blockKinds.has(current.type)) {
+      current = current.namedChildCount === 1 ? current.namedChild(0) : null;
+    }
+    return current;
+  }
+
+  private detectCase(node: SyntaxNode): DecisionDetectionResult {
+    if (firstChildOfKinds(node, this.caseExcludeChildKinds) !== null) return {};
+    const firstText = node.children[0]?.text.trim();
+    if (firstText !== undefined && firstText === this.rules.caseExcludeFirstChildText) return {};
+    return { decision: { kind: "case", countsForClassic: true, countsForExtended: true } };
+  }
+
+  private detectLogical(node: SyntaxNode): DecisionDetectionResult {
+    const operator = this.operatorOf(node);
+    if (operator === undefined) return {};
+    const kind = this.logicalKinds.get(operator);
+    return kind === undefined ? {} : extendedOnly(kind, this.logicalGroupIdFor(node, operator));
+  }
+
+  private operatorOf(node: SyntaxNode): string | undefined {
+    if (!this.anonymousOperatorKinds.has(node.type)) {
+      return node.childForFieldName(this.operatorField)?.text;
+    }
+    for (const child of node.children) {
+      const text = child.text.trim();
+      if (this.logicalKinds.has(text)) return text;
+    }
+    return undefined;
+  }
+
+  /** Stabile, positionsbasierte Kennung einer maximalen Operatorkette. */
+  private logicalGroupIdFor(node: SyntaxNode, operator: string): string {
+    let top = node;
+    while (top.parent !== null && this.isLogicalExpression(top.parent)) {
+      const parent = top.parent;
+      if (this.operatorOf(parent) !== operator) break;
+      top = parent;
+    }
+    return `logical-${String(top.startIndex)}`;
+  }
+
+  private isLogicalExpression(node: SyntaxNode): boolean {
+    return this.binaryKinds.has(node.type) || this.anonymousOperatorKinds.has(node.type);
+  }
+}

package/src/languages/shared/table-profile-module-facts.ts

@@ -0,0 +1,177 @@
+/** Import- und Aufruffakten des Tabellenprofils. */
+import type { RawCall, RawImport } from "@untangle-code/domain";
+
+import type { FileTextContext } from "./node-utils.js";
+import { rangeOf, unquote } from "./node-utils.js";
+import type { ModuleFactSink } from "./profile.js";
+import type { SyntaxNode } from "./syntax.js";
+import {
+  descendantsOfKinds,
+  firstChildByKindPriority,
+  nameTextsOf,
+  setOf,
+} from "./table-profile-queries.js";
+import type { CallRules, ImportRules } from "./table-profile.js";
+
+interface Callee {
+  calleeName: string;
+  qualifier?: string;
+}
+
+interface ImportParts {
+  pathNode: SyntaxNode | null;
+  names: string[];
+}
+
+/** Kompiliert ausschliesslich Import- und Aufrufregeln einer Sprachtabelle. */
+export class TableModuleFactCollector {
+  readonly nodeKinds: ReadonlySet<string>;
+
+  private readonly importKinds: ReadonlySet<string>;
+  private readonly importSpecKinds: ReadonlySet<string>;
+  private readonly callKinds: ReadonlySet<string>;
+  private readonly constructionKinds: ReadonlySet<string>;
+  private readonly memberKinds: ReadonlySet<string>;
+  private readonly functionField: string;
+  private readonly argumentsField: string;
+
+  constructor(
+    private readonly imports: ImportRules,
+    private readonly calls: CallRules,
+  ) {
+    this.importKinds = setOf(imports.kinds);
+    this.importSpecKinds = setOf(imports.specKinds);
+    this.callKinds = setOf(calls.kinds);
+    this.constructionKinds = setOf(calls.constructionKinds);
+    this.memberKinds = setOf(calls.memberKinds);
+    this.functionField = calls.functionField ?? "function";
+    this.argumentsField = calls.argumentsField ?? "arguments";
+    this.nodeKinds = new Set([...this.importKinds, ...this.callKinds, ...this.constructionKinds]);
+  }
+
+  collect(
+    node: SyntaxNode,
+    kind: string,
+    callerScopeId: string,
+    ctx: FileTextContext,
+    sink: ModuleFactSink,
+  ): void {
+    if (this.importKinds.has(kind)) {
+      this.collectImports(node, ctx, sink);
+    } else if (this.callKinds.has(kind) || this.constructionKinds.has(kind)) {
+      this.collectCall(node, callerScopeId, ctx, sink);
+    }
+  }
+
+  private collectImports(node: SyntaxNode, ctx: FileTextContext, sink: ModuleFactSink): void {
+    const found =
+      this.importSpecKinds.size === 0 ? [] : descendantsOfKinds(node, this.importSpecKinds);
+    const specs = this.importSpecKinds.size > 0 && found.length > 0 ? found : [node];
+    for (const spec of specs) this.collectImportSpec(spec, ctx, sink);
+  }
+
+  private collectImportSpec(spec: SyntaxNode, ctx: FileTextContext, sink: ModuleFactSink): void {
+    const parts = this.importPartsOf(spec);
+    const specifier = unquote((parts.pathNode ?? spec).text.trim());
+    if (specifier.length === 0) return;
+    const rawImport: RawImport = {
+      specifier,
+      importKind: "import",
+      range: rangeOf(spec, ctx),
+      // Ohne echte Namensknoten bleibt die Bindung unbekannt.
+      ...(parts.names.length > 0 ? { importedNames: parts.names } : {}),
+    };
+    sink.imports.push(rawImport);
+  }
+
+  private importPartsOf(spec: SyntaxNode): ImportParts {
+    let pathNode = this.initialImportPathOf(spec);
+    let names =
+      this.imports.aliasField === undefined
+        ? []
+        : nameTextsOf(spec.childForFieldName(this.imports.aliasField));
+    for (const rule of this.imports.unwrap ?? []) {
+      if (pathNode === null || !rule.kinds.includes(pathNode.type)) continue;
+      if (rule.aliasField !== undefined) {
+        names = [...names, ...nameTextsOf(pathNode.childForFieldName(rule.aliasField))];
+      }
+      if (rule.namesField !== undefined) {
+        names = [...names, ...this.namedChildTexts(pathNode.childForFieldName(rule.namesField))];
+      }
+      pathNode = pathNode.childForFieldName(rule.pathField) ?? pathNode;
+    }
+    return { pathNode, names };
+  }
+
+  private initialImportPathOf(spec: SyntaxNode): SyntaxNode | null {
+    if (this.imports.pathField !== undefined) {
+      const byField = spec.childForFieldName(this.imports.pathField);
+      if (byField !== null) return byField;
+    }
+    return this.imports.pathKinds === undefined
+      ? null
+      : firstChildByKindPriority(spec, this.imports.pathKinds);
+  }
+
+  private namedChildTexts(node: SyntaxNode | null): string[] {
+    if (node === null) return [];
+    const names: string[] = [];
+    for (let index = 0; index < node.namedChildCount; index += 1) {
+      const entry = node.namedChild(index);
+      if (entry !== null) names.push(entry.text);
+    }
+    return names;
+  }
+
+  private collectCall(
+    node: SyntaxNode,
+    callerScopeId: string,
+    ctx: FileTextContext,
+    sink: ModuleFactSink,
+  ): void {
+    if (this.calls.acceptCall?.(node) === false) return;
+    const callee = this.calleeOf(node);
+    if (callee === null) return;
+    const args = node.childForFieldName(this.argumentsField);
+    const call: RawCall = {
+      calleeName: callee.calleeName,
+      ...(callee.qualifier === undefined ? {} : { qualifier: callee.qualifier }),
+      callerScopeId,
+      range: rangeOf(node, ctx),
+      ...(args === null ? {} : { argumentCount: args.namedChildCount }),
+    };
+    sink.calls.push(call);
+  }
+
+  private calleeOf(node: SyntaxNode): Callee | null {
+    const target = this.callTargetOf(node);
+    if (target === null) return null;
+    const receiver =
+      this.calls.receiverField === undefined
+        ? null
+        : node.childForFieldName(this.calls.receiverField);
+    if (receiver !== null && !this.memberKinds.has(target.type)) {
+      return { calleeName: target.text, qualifier: receiver.text };
+    }
+    return this.memberKinds.has(target.type)
+      ? this.memberCalleeOf(target)
+      : { calleeName: target.text };
+  }
+
+  private callTargetOf(node: SyntaxNode): SyntaxNode | null {
+    const constructedType =
+      this.calls.constructedTypeField === undefined
+        ? null
+        : node.childForFieldName(this.calls.constructedTypeField);
+    return node.childForFieldName(this.functionField) ?? constructedType ?? node.namedChild(0);
+  }
+
+  private memberCalleeOf(target: SyntaxNode): Callee {
+    const parts = target.children.filter((child) => child.type !== ".");
+    const calleeName = (parts.at(-1)?.text ?? target.text).replace(/^[.:]+/, "");
+    const qualifier = target.text
+      .slice(0, Math.max(0, target.text.length - calleeName.length))
+      .replace(/[.:]+$/, "");
+    return { calleeName, ...(qualifier.length === 0 ? {} : { qualifier }) };
+  }
+}

package/src/languages/shared/table-profile-queries.ts

@@ -0,0 +1,85 @@
+/**
+ * Kleine, backend-neutrale Baumabfragen fuer das Tabellenprofil.
+ *
+ * Sie stehen getrennt von Scope-, Entscheidungs- und Modulregeln, damit jede
+ * dieser Verantwortungen dieselbe Iterations- und Reihenfolgelogik benutzt.
+ */
+import type { SyntaxNode } from "./syntax.js";
+
+export function setOf(values: readonly string[] | undefined): ReadonlySet<string> {
+  return new Set(values ?? []);
+}
+
+/** Der Text eines Namensknotens, oder nichts — nie ein erfundener Name. */
+export function nameTextsOf(node: SyntaxNode | null): string[] {
+  return node === null ? [] : [node.text];
+}
+
+/** Erster Kindknoten (in Quelltextreihenfolge), dessen Art in `kinds` liegt. */
+export function firstChildOfKinds(node: SyntaxNode, kinds: ReadonlySet<string>): SyntaxNode | null {
+  for (const child of node.children) {
+    if (kinds.has(child.type)) return child;
+  }
+  return null;
+}
+
+/** Erstes direktes Kind genau einer Art. */
+export function firstChildOfKind(node: SyntaxNode, kind: string): SyntaxNode | null {
+  for (const child of node.children) {
+    if (child.type === kind) return child;
+  }
+  return null;
+}
+
+/**
+ * Erstes Kind nach der REIHENFOLGE DER LISTE, nicht nach Quelltextreihenfolge.
+ *
+ * WOFUER: `using Sys = System.Text;` hat als Kinder `identifier` (Alias) UND
+ * `qualified_name` (Pfad), in dieser Reihenfolge. Die Tabelle nennt deshalb
+ * `qualified_name` zuerst und meint damit: erst das Genauere.
+ */
+export function firstChildByKindPriority(
+  node: SyntaxNode,
+  kinds: readonly string[],
+): SyntaxNode | null {
+  for (const kind of kinds) {
+    const child = firstChildOfKind(node, kind);
+    if (child !== null) return child;
+  }
+  return null;
+}
+
+/** Alle Knoten dieser Art im Teilbaum, in Quelltextreihenfolge (iterativ). */
+export function descendantsOfKinds(node: SyntaxNode, kinds: ReadonlySet<string>): SyntaxNode[] {
+  const found: SyntaxNode[] = [];
+  const stack: SyntaxNode[] = [node];
+  while (stack.length > 0) {
+    const current = stack.pop() as SyntaxNode;
+    if (current !== node && kinds.has(current.type)) {
+      found.push(current);
+      continue;
+    }
+    const children = current.children;
+    for (let index = children.length - 1; index >= 0; index -= 1) {
+      stack.push(children[index] as SyntaxNode);
+    }
+  }
+  return found.sort((a, b) => a.startIndex - b.startIndex);
+}
+
+/** Erster passender Nachfahre, ohne den ganzen Teilbaum zu materialisieren. */
+export function firstDescendantOfKinds(
+  node: SyntaxNode,
+  kinds: ReadonlySet<string>,
+): SyntaxNode | null {
+  const stack = [...node.children].reverse();
+  while (stack.length > 0) {
+    const current = stack.pop() as SyntaxNode;
+    if (kinds.has(current.type)) return current;
+    const children = current.children;
+    for (let index = children.length - 1; index >= 0; index -= 1) {
+      stack.push(children[index] as SyntaxNode);
+    }
+  }
+  return null;
+}