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

package/src/languages/shared/fingerprint.ts

@@ -0,0 +1,99 @@
+/**
+ * Symbol fingerprints for change matching (spec.md §17.3).
+ *
+ * `astHash` — a structural fingerprint: the SHA-256 of a parenthesized
+ * `kind(child,child,...)` shape string built from node TYPES only (never
+ * identifier/literal text, never whitespace/positions). Two symbols with the
+ * same shape but renamed identifiers or reformatted whitespace hash
+ * identically — this is `spec.md §17.3` step 3 ("identischer
+ * AST-Fingerprint").
+ *
+ * `tokenFingerprint` — a lexical fingerprint: the SHA-256 of every leaf
+ * token's literal TEXT, in source order, joined by U+001F. Unlike
+ * `astHash`, a rename DOES change this fingerprint, but formatting
+ * (whitespace-only changes) does not, matching `spec.md §17.3` step 4's
+ * "Token-/MinHash-Ähnlichkeit" input.
+ *
+ * Both exclude comments (a doc-comment edit must not look like a structural
+ * or lexical change to the symbol it documents).
+ *
+ * TRAVERSIERUNG (WP-95): beide Funktionen bekommen den CURSOR des laufenden
+ * Walks und laufen den Teilbaum ab der aktuellen Position ab; sie geben ihn
+ * an genau dieser Position zurueck. Zwei Gruende, keiner davon Geschmack:
+ *
+ *  1) Tempo. Sie laufen nicht einmal je Datei, sondern einmal je Scope UND
+ *     einmal je Wurzel — der Teilbaum eines verschachtelten Symbols wird also
+ *     so oft durchlaufen, wie er Scopes ueber sich hat. Ueber `.children`
+ *     hiesse das ein Wrapper-Array je Knoten und Durchlauf.
+ *
+ *  2) RICHTIGKEIT, und das wiegt schwerer. `tree-sitter@0.21.1` meldet den
+ *     Typ eines Knotens NUR dann verlaesslich, wenn der Cursor von der Wurzel
+ *     her abgestiegen ist. Weder `node.children` noch ein auf einen Teilbaum
+ *     zurueckgesetzter Cursor (`node.walk()`) haben den Alias-Zusammenhang
+ *     des Elternknotens; in diesem Repository meldeten beide 1.411
+ *     Kommentarknoten in 207 Dateien als `interface_body`. Genau diese
+ *     Knoten hat der frueher hier stehende `.children`-Lauf NICHT als
+ *     Kommentar erkannt und ihren Text in beide Fingerabdruecke geschrieben —
+ *     entgegen der Zusage zwei Absaetze weiter oben. Wer diese Funktionen
+ *     wieder auf `node.walk()` umstellt, baut den Defekt neu ein.
+ */
+import { sha256Hex } from "@untangle-code/domain";
+
+import type { LanguageProfile } from "./profile.js";
+import type { SyntaxCursor } from "./syntax.js";
+
+/**
+ * Baut die Formzeichenkette fuer den Knoten, auf dem der Cursor steht, und
+ * laesst den Cursor GENAU DORT zurueck: jede `gotoFirstChild`-Bewegung wird
+ * von einem `gotoParent` aufgewogen. Wer das verletzt, verschiebt die
+ * Traversierung des Aufrufers.
+ */
+function structuralShapeAt(cursor: SyntaxCursor, profile: LanguageProfile): string {
+  const type = cursor.nodeType;
+  if (profile.commentKinds.has(type)) return "";
+  if (profile.literalContainerKinds.has(type)) return type;
+  if (!cursor.gotoFirstChild()) return type; // entspricht node.childCount === 0
+
+  const childShapes: string[] = [];
+  do {
+    // Kommentarkinder werden AUSGELASSEN, nicht als "" aufgenommen — genau
+    // das tat das frueher vorgeschaltete
+    // `.filter((child) => child.type !== "comment")`.
+    if (!profile.commentKinds.has(cursor.nodeType)) {
+      childShapes.push(structuralShapeAt(cursor, profile));
+    }
+  } while (cursor.gotoNextSibling());
+  cursor.gotoParent();
+
+  return `${type}(${childShapes.join(",")})`;
+}
+
+/** Cursor MUSS auf dem Knoten stehen; er steht danach wieder dort. */
+export function computeAstHash(cursor: SyntaxCursor, profile: LanguageProfile): string {
+  return sha256Hex(structuralShapeAt(cursor, profile));
+}
+
+/** Sammelt die Blatttexte; laesst den Cursor auf dem Ausgangsknoten zurueck. */
+function collectLeafTextsAt(cursor: SyntaxCursor, profile: LanguageProfile, out: string[]): void {
+  const type = cursor.nodeType;
+  if (profile.commentKinds.has(type)) return;
+  if (profile.literalContainerKinds.has(type)) {
+    out.push(cursor.nodeText);
+    return;
+  }
+  if (!cursor.gotoFirstChild()) {
+    out.push(cursor.nodeText); // entspricht node.childCount === 0
+    return;
+  }
+  do {
+    collectLeafTextsAt(cursor, profile, out);
+  } while (cursor.gotoNextSibling());
+  cursor.gotoParent();
+}
+
+/** Cursor MUSS auf dem Knoten stehen; er steht danach wieder dort. */
+export function computeTokenFingerprint(cursor: SyntaxCursor, profile: LanguageProfile): string {
+  const tokens: string[] = [];
+  collectLeafTextsAt(cursor, profile, tokens);
+  return sha256Hex(tokens.join("\u001f"));
+}

package/src/languages/shared/grammar-loader.ts

@@ -0,0 +1,67 @@
+/**
+ * Lazy loader for the native `tree-sitter` runtime and its grammars.
+ *
+ * architecture.md §6.5 / the WP-06 mandate require that the CLI NOT load
+ * every grammar at startup. We satisfy that with plain lazy `require`
+ * (via `node:module#createRequire`, since this package is ESM and the
+ * native bindings are CommonJS) cached in module-level maps: nothing here
+ * runs until `getParser()`/`loadGrammar()` is first called for a given
+ * language, and each grammar is required at most once per process.
+ *
+ * `require` (not dynamic `import()`) is deliberate: `LanguageAdapter.parse`
+ * (domain `analysis.ts`) is a SYNCHRONOUS method, so grammar acquisition on
+ * first use must be synchronous too. `createRequire` gives us a synchronous
+ * CJS `require` from inside an ESM module without violating
+ * `verbatimModuleSyntax`.
+ */
+import { createRequire } from "node:module";
+
+import type { TsLanguage, TsParserCtor } from "./tree-sitter-types.js";
+
+const require = createRequire(import.meta.url);
+
+let cachedParserCtor: TsParserCtor | undefined;
+
+/** Lazily requires the native `tree-sitter` Parser constructor (once per process). */
+export function loadParserCtor(): TsParserCtor {
+  if (cachedParserCtor === undefined) {
+    cachedParserCtor = require("tree-sitter") as TsParserCtor;
+  }
+  return cachedParserCtor;
+}
+
+/** Which grammar module a dialect is loaded from, and how to reach the language export. */
+export interface GrammarSource {
+  /** npm module to `require` lazily. */
+  moduleName: "tree-sitter-typescript" | "tree-sitter-javascript";
+  /** Property on the required module holding the `Language`, or `undefined` for the module's default export itself. */
+  exportName?: "typescript" | "tsx";
+}
+
+const grammarCache = new Map<string, TsLanguage>();
+
+function grammarCacheKey(source: GrammarSource): string {
+  return `${source.moduleName}::${source.exportName ?? "default"}`;
+}
+
+/** Lazily requires and caches a single grammar `Language` handle. */
+export function loadGrammar(source: GrammarSource): TsLanguage {
+  const key = grammarCacheKey(source);
+  const cached = grammarCache.get(key);
+  if (cached !== undefined) {
+    return cached;
+  }
+
+  const loadedModule = require(source.moduleName) as Record<string, unknown>;
+  const language = (
+    source.exportName === undefined ? loadedModule : loadedModule[source.exportName]
+  ) as TsLanguage;
+  grammarCache.set(key, language);
+  return language;
+}
+
+/** Test-only: clears caches so grammar-loading behavior can be re-exercised. */
+export function resetGrammarCachesForTests(): void {
+  cachedParserCtor = undefined;
+  grammarCache.clear();
+}

package/src/languages/shared/import-detection.ts

@@ -0,0 +1,154 @@
+/**
+ * Import/re-export/require/dynamic-import detection (spec.md §14.2).
+ *
+ * `RawImportKind` (domain `analysis.ts`) has exactly four members: `import`,
+ * `re_export`, `dynamic_import`, `package_dependency`. CommonJS
+ * `require("x")` has no dedicated member — it is mapped to `"import"`
+ * (documented WP-06 decision, README "Entscheidungen"): a `require` call is
+ * functionally a synchronous import of the same specifier space, and
+ * `"package_dependency"` is reserved for a resolved (not source-level)
+ * cross-package edge produced downstream by the import resolver / file
+ * graph, not by this adapter.
+ */
+import type { RawImport, RawImportBinding } from "@untangle-code/domain";
+
+import type { FileTextContext } from "./node-utils.js";
+import { unquote, rangeOf } from "./node-utils.js";
+import type { SyntaxNode } from "./syntax.js";
+
+/**
+ * Zerlegt eine Importklausel in ihre BINDUNGEN — lokaler Name UND Name im
+ * Zielmodul. Der lokale Name allein genuegt nicht: bei
+ * `import { run as go } from "./lib"` ist `go` lokal und `run` der Export.
+ * Wer die Zuordnung hier wegwirft, kann sie nirgends mehr herstellen
+ * (`RawImportBinding` in domain `analysis.ts`).
+ */
+function extractImportBindings(clauseOrSpecifierHolder: SyntaxNode): RawImportBinding[] {
+  const bindings: RawImportBinding[] = [];
+  for (const child of clauseOrSpecifierHolder.children) {
+    if (child.type === "identifier") {
+      // Direkter Bezeichner der Importklausel: der Vorgabeexport.
+      bindings.push({ localName: child.text, importedName: "default", kind: "default" });
+    } else if (child.type === "namespace_import") {
+      const inner = child.children.find((c) => c.type === "identifier");
+      if (inner !== undefined) bindings.push({ localName: inner.text, kind: "namespace" });
+    } else if (child.type === "named_imports") {
+      for (const specifier of child.children) {
+        if (specifier.type !== "import_specifier") continue;
+        const alias = specifier.childForFieldName("alias");
+        const name = specifier.childForFieldName("name");
+        if (name === null) continue;
+        const importedName = unquote(name.text);
+        bindings.push({
+          localName: alias === null ? importedName : unquote(alias.text),
+          importedName,
+          kind: importedName === "default" ? "default" : "named",
+        });
+      }
+    }
+  }
+  return bindings;
+}
+
+/** Lokale Namen der Bindungen, in Quelltextreihenfolge. */
+function localNamesOf(bindings: readonly RawImportBinding[]): string[] {
+  return bindings.map((binding) => binding.localName);
+}
+
+function hasDirectTypeModifier(node: SyntaxNode): boolean {
+  return node.children.some((child) => child.type === "type");
+}
+
+/** Detects a static `import ...` / TS `import x = require(...)` statement. */
+export function detectStaticImport(node: SyntaxNode, ctx: FileTextContext): RawImport | null {
+  const range = rangeOf(node, ctx);
+  const requireClause = node.children.find((child) => child.type === "import_require_clause");
+  if (requireClause !== undefined) {
+    const source = requireClause.childForFieldName("source");
+    if (source === null) return null;
+    return {
+      specifier: unquote(source.text),
+      importKind: "import",
+      range,
+      typeOnly: hasDirectTypeModifier(node),
+    };
+  }
+
+  const source = node.childForFieldName("source");
+  if (source === null) return null;
+  const importClause = node.children.find((child) => child.type === "import_clause");
+  const bindings = importClause !== undefined ? extractImportBindings(importClause) : [];
+  const importedNames = localNamesOf(bindings);
+
+  return {
+    specifier: unquote(source.text),
+    importKind: "import",
+    range,
+    ...(importedNames.length > 0 ? { importedNames, bindings } : {}),
+    typeOnly: hasDirectTypeModifier(node),
+  };
+}
+
+/** Detects a re-export (`export { x } from "y"`, `export * from "y"`, `export * as ns from "y"`). */
+export function detectReExport(node: SyntaxNode, ctx: FileTextContext): RawImport | null {
+  const source = node.childForFieldName("source");
+  if (source === null) return null;
+  const exportClause = node.children.find((child) => child.type === "export_clause");
+  const bindings: RawImportBinding[] = [];
+  if (exportClause !== undefined) {
+    for (const specifier of exportClause.children) {
+      if (specifier.type !== "export_specifier") continue;
+      const alias = specifier.childForFieldName("alias");
+      const name = specifier.childForFieldName("name");
+      if (name === null) continue;
+      // Bei `export { run as go } from "m"` ist `run` der Name IM Zielmodul
+      // und `go` der hier weitergereichte Name.
+      const importedName = unquote(name.text);
+      bindings.push({
+        localName: alias === null ? importedName : unquote(alias.text),
+        importedName,
+        kind: importedName === "default" ? "default" : "named",
+      });
+    }
+  }
+  const importedNames = localNamesOf(bindings);
+  return {
+    specifier: unquote(source.text),
+    importKind: "re_export",
+    range: rangeOf(node, ctx),
+    ...(importedNames.length > 0 ? { importedNames, bindings } : {}),
+    typeOnly: hasDirectTypeModifier(node),
+  };
+}
+
+/** Detects `import("specifier")` (dynamic import) given its enclosing `call_expression`. */
+export function detectDynamicImport(callNode: SyntaxNode, ctx: FileTextContext): RawImport | null {
+  const args = callNode.childForFieldName("arguments");
+  const firstArg = args?.namedChild(0) ?? null;
+  const specifier =
+    firstArg !== null && firstArg.type === "string"
+      ? unquote(firstArg.text)
+      : (firstArg?.text ?? "");
+  return {
+    specifier,
+    importKind: "dynamic_import",
+    range: rangeOf(callNode, ctx),
+    typeOnly: false,
+  };
+}
+
+/** Detects `require("specifier")` given its enclosing `call_expression`. Mapped to `importKind: "import"` (see file doc). */
+export function detectRequireCall(callNode: SyntaxNode, ctx: FileTextContext): RawImport | null {
+  const args = callNode.childForFieldName("arguments");
+  const firstArg = args?.namedChild(0) ?? null;
+  const specifier =
+    firstArg !== null && firstArg.type === "string"
+      ? unquote(firstArg.text)
+      : (firstArg?.text ?? "");
+  return {
+    specifier,
+    importKind: "import",
+    range: rangeOf(callNode, ctx),
+    typeOnly: false,
+  };
+}

package/src/languages/shared/js-family-profile.ts

@@ -0,0 +1,246 @@
+/**
+ * Das Sprachprofil der JS/TS-Familie (TypeScript, JavaScript, TSX, JSX).
+ *
+ * Diese Datei fuegt zusammen, was vorher fest in `engine.ts`, `chunks.ts` und
+ * `fingerprint.ts` stand: die Knotenarten aus `node-kinds.ts` und die
+ * handgeschriebenen Detektoren aus `decisions.ts`, `import-detection.ts`,
+ * `call-detection.ts`, `scope-naming.ts`, `scope-signature.ts` und
+ * `doc-binding.ts`. Es ist eine reine UMSTELLUNG, keine Verhaltensaenderung —
+ * jede Verzweigung steht hier in derselben Reihenfolge und mit derselben
+ * Bedingung wie vorher im Motor. Die Golden-Tests (`languages/golden.test.ts`)
+ * und `cursor-walk.test.ts` sind der Beleg, dass sie es geblieben ist.
+ *
+ * WARUM DIE DETEKTOREN NICHT MITGEZOGEN SIND: sie sind nicht generisch, und
+ * das sollen sie auch nicht sein. `detectStaticImport` kennt `import_clause`,
+ * `named_imports`, `namespace_import` — Formen der ECMAScript-Grammatik. Eine
+ * tabellengetriebene Fassung davon waere eine Tabelle mit genau einem Eintrag
+ * und einer Menge Ausreden. Andere Sprachen bekommen ihre eigene, kleine
+ * Fassung ueber `table-profile.ts`.
+ */
+import type { LiteralFact, SupportLevel } from "@untangle-code/domain";
+
+import { detectCallExpression, detectNewExpression } from "./call-detection.js";
+import { detectDecisionAndNesting, mayCarryDecisionOrNesting } from "./decisions.js";
+import type { Dialect } from "./dialect.js";
+import { resolveDocRange } from "./doc-binding.js";
+import {
+  detectDynamicImport,
+  detectReExport,
+  detectRequireCall,
+  detectStaticImport,
+} from "./import-detection.js";
+import {
+  CALL_EXPRESSION,
+  CLASS_STATIC_BLOCK_TYPE,
+  CLASS_TYPES,
+  COMMENT_TYPE,
+  ENUM_TYPE,
+  EXPORT_STATEMENT,
+  FIELD_TYPES,
+  FUNCTION_LIKE_TYPES,
+  IDENTIFIER_LEAF_TYPES,
+  IGNORED_PUNCTUATION_TYPES,
+  IMPORT_STATEMENT,
+  INTERFACE_TYPE,
+  LITERAL_CONTAINER_STOP_TYPES,
+  METHOD_TYPE,
+  NAMESPACE_TYPE,
+  NEW_EXPRESSION,
+  SCOPE_OPENING_TYPES,
+  SIMPLE_LITERAL_LEAF_TYPES,
+  TEMPLATE_TEXT_LEAF_TYPES,
+  TYPE_ALIAS_TYPE,
+} from "./node-kinds.js";
+import { rangeOf } from "./node-utils.js";
+import type { LanguageProfile, MemberRegion, ModuleFactSink, ScopeSignature } from "./profile.js";
+import type { ScopeNode } from "./scope-model.js";
+import {
+  fieldDelegatesToFunctionValue,
+  resolveExportedNames,
+  resolveScopeName,
+  resolveVisibility,
+} from "./scope-naming.js";
+import {
+  buildFunctionSignature,
+  buildHeaderSignature,
+  buildPropertySignature,
+  isFunctionLikeScope,
+} from "./scope-signature.js";
+import type { SyntaxNode } from "./syntax.js";
+
+/** Der TS-Knoten, dessen Blaetter reine Typsyntax sind (`string`, `number`, `void`, ...). */
+const PREDEFINED_TYPE = "predefined_type";
+
+/**
+ * Die Knotenarten, fuer die der Walk einen Knotenwrapper braucht: Scopeoeffner,
+ * Entscheidungstraeger, Import/Export, Aufruf. Fuer alles andere bleibt der
+ * Cursor unter sich (WP-95).
+ */
+function needsNodeFor(kind: string): boolean {
+  return (
+    SCOPE_OPENING_TYPES.has(kind) ||
+    mayCarryDecisionOrNesting(kind) ||
+    kind === IMPORT_STATEMENT ||
+    kind === EXPORT_STATEMENT ||
+    kind === CALL_EXPRESSION ||
+    kind === NEW_EXPRESSION
+  );
+}
+
+function simpleLiteralKind(kind: string): LiteralFact["literalKind"] {
+  switch (kind) {
+    case "number":
+      return "number";
+    case "true":
+    case "false":
+      return "boolean";
+    case "null":
+      return "null";
+    default:
+      return "other";
+  }
+}
+
+/**
+ * Deklaration oder Verweis? Aus `cursor.currentFieldName` und der Elternart —
+ * unveraendert aus `engine.ts` uebernommen.
+ */
+function identifierRole(
+  fieldName: string | undefined,
+  parentKind: string,
+): "declaration" | "reference" {
+  if (fieldName === "name") {
+    if (
+      parentKind === "variable_declarator" ||
+      parentKind === "function_declaration" ||
+      parentKind === "class_declaration" ||
+      parentKind === "abstract_class_declaration" ||
+      parentKind === "interface_declaration" ||
+      parentKind === "type_alias_declaration" ||
+      parentKind === "enum_declaration" ||
+      parentKind === "method_definition" ||
+      parentKind === "required_parameter" ||
+      parentKind === "optional_parameter" ||
+      parentKind === "import_specifier" ||
+      parentKind === "namespace_import"
+    ) {
+      return "declaration";
+    }
+  }
+  if (
+    fieldName === "property" &&
+    (parentKind === "field_definition" || parentKind === "public_field_definition")
+  ) {
+    return "declaration";
+  }
+  return "reference";
+}
+
+/** Baut das Profil einer der vier JS/TS-Dialekte. */
+export function createJsFamilyProfile(dialect: Dialect): LanguageProfile {
+  const supportLevel: SupportLevel = dialect.supportLevel;
+
+  return {
+    languageId: dialect.languageId,
+    extensions: dialect.extensions,
+    supportLevel,
+
+    commentKinds: new Set([COMMENT_TYPE]),
+    literalContainerKinds: LITERAL_CONTAINER_STOP_TYPES,
+    identifierLeafKinds: IDENTIFIER_LEAF_TYPES,
+    simpleLiteralLeafKinds: SIMPLE_LITERAL_LEAF_TYPES,
+    templateTextLeafKinds: TEMPLATE_TEXT_LEAF_TYPES,
+    ignoredPunctuationKinds: IGNORED_PUNCTUATION_TYPES,
+    typeKeywordParentKinds: new Set([PREDEFINED_TYPE]),
+    functionLikeKinds: FUNCTION_LIKE_TYPES,
+    exportWrapperKinds: new Set([EXPORT_STATEMENT]),
+
+    containerLiteralKind: (kind) => (kind === "regex" ? "regex" : "string"),
+    simpleLiteralKind,
+    identifierRole,
+    needsNode: needsNodeFor,
+
+    scopeKindOf(node: SyntaxNode): ScopeNode["kind"] | null {
+      if (FUNCTION_LIKE_TYPES.has(node.type)) return "function";
+      if (node.type === METHOD_TYPE) {
+        return resolveScopeName(node) === "constructor" ? "constructor" : "method";
+      }
+      if (CLASS_TYPES.has(node.type)) return "class";
+      if (node.type === INTERFACE_TYPE) return "interface";
+      if (node.type === TYPE_ALIAS_TYPE) return "type";
+      if (node.type === ENUM_TYPE) return "enum";
+      if (node.type === NAMESPACE_TYPE) return "namespace";
+      if (node.type === dialect.fieldDefinitionKind) return "property";
+      return null;
+    },
+
+    suppressesScope(node: SyntaxNode): boolean {
+      return FIELD_TYPES.has(node.type) && fieldDelegatesToFunctionValue(node);
+    },
+
+    scopeName: resolveScopeName,
+
+    scopeSignature(node: SyntaxNode, kind: ScopeNode["kind"], name: string): ScopeSignature {
+      return isFunctionLikeScope(node.type)
+        ? buildFunctionSignature(node, name)
+        : kind === "property"
+          ? buildPropertySignature(node, name)
+          : buildHeaderSignature(node);
+    },
+
+    docRange: resolveDocRange,
+    visibility: resolveVisibility,
+    exportedNames: resolveExportedNames,
+    detectDecisionAndNesting,
+
+    collectModuleFacts(node, kind, callerScopeId, ctx, sink: ModuleFactSink): void {
+      if (kind === IMPORT_STATEMENT) {
+        const detectedImport = detectStaticImport(node, ctx);
+        if (detectedImport !== null) sink.imports.push(detectedImport);
+        return;
+      }
+      if (kind === EXPORT_STATEMENT) {
+        if (node.childForFieldName("source") !== null) {
+          const reExport = detectReExport(node, ctx);
+          if (reExport !== null) sink.imports.push(reExport);
+        }
+        return;
+      }
+      if (kind === CALL_EXPRESSION) {
+        const functionNode = node.childForFieldName("function");
+        if (functionNode?.type === "import") {
+          const dynamicImport = detectDynamicImport(node, ctx);
+          if (dynamicImport !== null) sink.imports.push(dynamicImport);
+        } else if (functionNode?.type === "identifier" && functionNode.text === "require") {
+          const requireImport = detectRequireCall(node, ctx);
+          if (requireImport !== null) sink.imports.push(requireImport);
+        } else {
+          const call = detectCallExpression(node, callerScopeId, ctx);
+          if (call !== null) sink.calls.push(call);
+        }
+        return;
+      }
+      if (kind === NEW_EXPRESSION) {
+        const call = detectNewExpression(node, callerScopeId, ctx);
+        if (call !== null) sink.calls.push(call);
+      }
+    },
+
+    memberRegions(node: SyntaxNode, parentScopeId, ctx): MemberRegion[] {
+      const body = node.childForFieldName("body");
+      if (body === null) return [];
+      const regions: MemberRegion[] = [];
+      let ordinal = 0;
+      for (const child of body.children) {
+        if (child.type !== CLASS_STATIC_BLOCK_TYPE) continue;
+        regions.push({
+          range: rangeOf(child, ctx),
+          scopeId: `${parentScopeId}#static_block#${String(ordinal)}`,
+          headerText: "static initialization block",
+        });
+        ordinal += 1;
+      }
+      return regions;
+    },
+  };
+}