sift-light 1.0.0

package/src/syntax-facts.ts

@@ -0,0 +1,464 @@
+import { syntaxField, syntaxFields, syntaxText } from "./syntax-tree.js";
+import type {
+  SyntaxAnalysis,
+  SyntaxLanguage,
+  SyntaxNode,
+  SyntaxRole,
+  SyntaxRoleName,
+  SyntaxSymbol,
+} from "./syntax-types.js";
+
+const IMPLEMENTATIONS = new Set([
+  "function_declaration",
+  "generator_function_declaration",
+  "function_expression",
+  "generator_function",
+  "arrow_function",
+  "method_definition",
+  "method_declaration",
+  "func_literal",
+]);
+const SIGNATURES = new Set([
+  "function_signature",
+  "method_signature",
+  "abstract_method_signature",
+  "construct_signature",
+  "call_signature",
+  "method_elem",
+]);
+const CONTAINERS = new Set([
+  "class_declaration",
+  "abstract_class_declaration",
+  "class",
+  "interface_declaration",
+]);
+const TYPE_SYMBOLS = new Set([
+  "type_alias_declaration",
+  "enum_declaration",
+  "type_spec",
+  "type_alias",
+]);
+const BINDING_IDENTIFIERS = new Set([
+  "identifier",
+  "shorthand_property_identifier_pattern",
+  "private_property_identifier",
+  "property_identifier",
+  "type_identifier",
+  "field_identifier",
+]);
+const STRINGS = new Set([
+  "string",
+  "interpreted_string_literal",
+  "raw_string_literal",
+  "rune_literal",
+]);
+const TYPE_AREAS = new Set([
+  "type_annotation",
+  "type_arguments",
+  "type_parameters",
+  "type_identifier",
+  "predefined_type",
+  "type_alias_declaration",
+  "interface_body",
+  "extends_type_clause",
+  "implements_clause",
+  "array_type",
+  "conditional_type",
+  "constructor_type",
+  "existential_type",
+  "flow_maybe_type",
+  "function_type",
+  "generic_type",
+  "index_type_query",
+  "infer_type",
+  "intersection_type",
+  "literal_type",
+  "lookup_type",
+  "nested_type_identifier",
+  "object_type",
+  "parenthesized_type",
+  "readonly_type",
+  "template_literal_type",
+  "this_type",
+  "tuple_type",
+  "type_query",
+  "union_type",
+]);
+
+interface Interval {
+  start: number;
+  end: number;
+}
+type Tree = Pick<SyntaxAnalysis, "nodes" | "children">;
+
+function mergeIntervals(intervals: Interval[]): Interval[] {
+  const merged: Interval[] = [];
+  intervals.sort((a, b) => a.start - b.start || b.end - a.end);
+  for (const interval of intervals) {
+    const previous = merged.at(-1);
+    if (previous && interval.start <= previous.end)
+      previous.end = Math.max(previous.end, interval.end);
+    else merged.push({ ...interval });
+  }
+  return merged;
+}
+
+function subtract(range: Interval, excluded: readonly Interval[]): Interval[] {
+  const results: Interval[] = [];
+  let low = 0,
+    high = excluded.length;
+  while (low < high) {
+    const middle = (low + high) >>> 1;
+    if ((excluded[middle]?.end ?? Infinity) <= range.start) low = middle + 1;
+    else high = middle;
+  }
+  let start = range.start;
+  for (let i = low; i < excluded.length; i++) {
+    const gap = excluded[i];
+    if (!gap || gap.start >= range.end) break;
+    if (gap.start > start) results.push({ start, end: gap.start });
+    start = Math.max(start, gap.end);
+  }
+  if (start < range.end) results.push({ start, end: range.end });
+  return results;
+}
+
+function containedIntervals(range: Interval, sorted: readonly Interval[]): Interval[] {
+  let low = 0,
+    high = sorted.length;
+  while (low < high) {
+    const middle = (low + high) >>> 1;
+    if ((sorted[middle]?.start ?? Infinity) < range.start) low = middle + 1;
+    else high = middle;
+  }
+  const contained: Interval[] = [];
+  for (let i = low; i < sorted.length; i++) {
+    const item = sorted[i];
+    if (!item || item.start >= range.end) break;
+    if (item.end <= range.end) contained.push(item);
+  }
+  return mergeIntervals(contained);
+}
+
+function bindingNodes(tree: Tree, index: number): number[] {
+  const results: number[] = [];
+  const stack = [index];
+  while (stack.length) {
+    const id = stack.pop();
+    if (id === undefined) break;
+    const node = tree.nodes[id];
+    if (!node) continue;
+    if (BINDING_IDENTIFIERS.has(node.kind)) {
+      results.push(id);
+      continue;
+    }
+    if (node.kind === "pair_pattern") {
+      const value = syntaxField(tree, id, "value");
+      if (value !== undefined) stack.push(value);
+    } else if (node.kind === "assignment_pattern" || node.kind === "object_assignment_pattern") {
+      const left = syntaxField(tree, id, "left");
+      if (left !== undefined) stack.push(left);
+    } else {
+      for (const child of tree.children[id] ?? []) {
+        const value = tree.nodes[child];
+        if (value?.named && value.field !== "type" && value.field !== "value") stack.push(child);
+      }
+    }
+  }
+  return results;
+}
+
+function attachedName(tree: Tree, index: number, text: string): string {
+  const node = tree.nodes[index];
+  if (!node) return "<anonymous>";
+  const ownName = syntaxField(tree, index, "name");
+  const own = ownName === undefined ? undefined : tree.nodes[ownName];
+  if (own) return syntaxText(own, text);
+  const parent = node.parent === null ? undefined : tree.nodes[node.parent];
+  if (parent && node.parent !== null) {
+    const binding =
+      syntaxField(tree, node.parent, parent.kind === "pair" ? "key" : "name") ??
+      (parent.kind === "assignment_expression"
+        ? syntaxField(tree, node.parent, "left")
+        : undefined);
+    const target = binding === undefined ? undefined : tree.nodes[binding];
+    if (target) return syntaxText(target, text);
+    if (parent.kind === "export_statement") return "default";
+  }
+  return `<anonymous@${node.start}>`;
+}
+
+function directlyExported(tree: Tree, index: number): boolean {
+  let current: number | null = tree.nodes[index]?.parent ?? null;
+  while (current !== null) {
+    const node: SyntaxNode | undefined = tree.nodes[current];
+    if (!node) return false;
+    if (node.kind === "export_statement") return true;
+    if (
+      ![
+        "variable_declarator",
+        "lexical_declaration",
+        "variable_declaration",
+        "ambient_declaration",
+      ].includes(node.kind)
+    )
+      return false;
+    current = node.parent;
+  }
+  return false;
+}
+
+function goExported(tree: Tree, index: number, name: string, inFunction: boolean): boolean {
+  if (!/^\p{Lu}/u.test(name)) return false;
+  const kind = tree.nodes[index]?.kind;
+  if (kind === "method_declaration" || kind === "field_declaration" || kind === "method_elem")
+    return true;
+  return (
+    !inFunction &&
+    ["function_declaration", "type_spec", "type_alias", "var_spec", "const_spec"].includes(
+      kind ?? "",
+    )
+  );
+}
+
+/** Derive bounded facts once; no downstream consumer needs another native parse. */
+export function deriveSyntaxFacts(
+  tree: Tree,
+  language: SyntaxLanguage,
+  text: string,
+): { symbols: SyntaxSymbol[]; roles: SyntaxRole[] } {
+  const { nodes, children } = tree;
+  const roles: SyntaxRole[] = [];
+  const symbols: SyntaxSymbol[] = [];
+  const lexical: Interval[] = [];
+  const comments: Interval[] = [];
+  const nestedCallContent: Interval[] = [];
+  const scopes: (string | undefined)[] = [];
+  const functionScopes: boolean[] = [];
+  const semanticCalls: { node: number; range: SyntaxNode; subkind: string; candidate: boolean }[] =
+    [];
+  const semanticImports: { node: number; range: SyntaxNode; role: "import" | "export" }[] = [];
+  const add = (id: number, role: SyntaxRoleName, subkind?: string, candidate = false) => {
+    const node = nodes[id];
+    if (!node || node.start === node.end) return;
+    roles.push({
+      start: node.start,
+      end: node.end,
+      role,
+      certainty: candidate ? "candidate" : "syntax",
+      node: id,
+      ...(subkind ? { subkind } : {}),
+    });
+  };
+
+  for (let index = 0; index < nodes.length; index++) {
+    const node = nodes[index];
+    if (!node) continue;
+    const parent = node.parent === null ? undefined : nodes[node.parent];
+    const outerScope = node.parent === null ? undefined : scopes[node.parent];
+    const inFunction = node.parent === null ? false : (functionScopes[node.parent] ?? false);
+    scopes[index] = outerScope;
+    functionScopes[index] = inFunction || IMPLEMENTATIONS.has(node.kind);
+
+    if (node.kind === "comment") {
+      add(index, "comment");
+      lexical.push(node);
+      comments.push(node);
+    } else if (node.named && STRINGS.has(node.kind)) {
+      add(index, "string", node.kind);
+      lexical.push(node);
+    } else if (node.kind === "template_string") {
+      const substitutions = (children[index] ?? [])
+        .map((child) => nodes[child])
+        .filter((child): child is SyntaxNode => child?.kind === "template_substitution");
+      for (const range of subtract(node, mergeIntervals(substitutions))) {
+        roles.push({
+          ...range,
+          role: "string",
+          certainty: "syntax",
+          subkind: "template-static",
+          node: index,
+        });
+        lexical.push(range);
+      }
+    } else if (node.kind === "jsx_text") {
+      add(index, "jsx-text");
+      lexical.push(node);
+    } else if (node.kind === "regex" || node.kind === "regex_pattern") {
+      add(index, "unknown", "regex-literal");
+      lexical.push(node);
+    } else if (language !== "go" && TYPE_AREAS.has(node.kind)) {
+      add(index, "unknown", "type");
+      lexical.push(node);
+    }
+    if (node.kind === "as_expression" || node.kind === "satisfies_expression") {
+      let afterOperator = false;
+      for (const child of children[index] ?? []) {
+        const target = nodes[child];
+        if (!target) continue;
+        if (target.kind === "as" || target.kind === "satisfies") afterOperator = true;
+        else if (afterOperator) {
+          add(child, "unknown", "type");
+          lexical.push(target);
+        }
+      }
+    }
+
+    if (["arguments", "argument_list", "formal_parameters", "parameter_list"].includes(node.kind)) {
+      nestedCallContent.push(node);
+    }
+    if (IMPLEMENTATIONS.has(node.kind)) {
+      const bodyId = syntaxField(tree, index, "body");
+      const body = bodyId === undefined ? undefined : nodes[bodyId];
+      if (body) nestedCallContent.push(body);
+    }
+
+    const isImplementation = IMPLEMENTATIONS.has(node.kind);
+    const isStructure =
+      node.named &&
+      (isImplementation ||
+        SIGNATURES.has(node.kind) ||
+        CONTAINERS.has(node.kind) ||
+        TYPE_SYMBOLS.has(node.kind));
+    const isVariable =
+      node.named && ["variable_declarator", "var_spec", "const_spec"].includes(node.kind);
+    const isField =
+      node.named &&
+      [
+        "public_field_definition",
+        "field_definition",
+        "field_declaration",
+        "property_signature",
+      ].includes(node.kind);
+    if (isStructure || isVariable || isField) {
+      const nameIds = syntaxFields(tree, index, "name").flatMap((name) => bindingNodes(tree, name));
+      for (const id of nameIds) {
+        if (syntaxText(nodes[id]!, text) !== "_") {
+          add(id, "declaration", node.kind);
+          const name = syntaxText(nodes[id]!, text);
+          if (
+            language === "go"
+              ? goExported(tree, index, name, inFunction)
+              : directlyExported(tree, index)
+          ) {
+            add(id, "export", language === "go" ? "exported-identifier" : "exported-declaration");
+          }
+        }
+      }
+      const valueId = syntaxField(tree, index, "value");
+      const value = valueId === undefined ? undefined : nodes[valueId];
+      const variableHasOwnImplementation = value && IMPLEMENTATIONS.has(value.kind);
+      if (isStructure || (isVariable && !inFunction && !variableHasOwnImplementation) || isField) {
+        const name = attachedName(tree, index, text);
+        const bodyId = syntaxField(tree, index, "body");
+        const body = bodyId === undefined ? undefined : nodes[bodyId];
+        const hasBody = isImplementation && body !== undefined;
+        const symbol: SyntaxSymbol = {
+          name,
+          kind: node.kind,
+          start: node.start,
+          end: node.end,
+          hasBody,
+          exported:
+            language === "go"
+              ? goExported(tree, index, name, inFunction)
+              : directlyExported(tree, index),
+          node: index,
+          ...(outerScope ? { scope: outerScope } : {}),
+          ...(hasBody && body ? { bodyStart: body.start, bodyEnd: body.end } : {}),
+        };
+        symbols.push(symbol);
+        if (isImplementation || CONTAINERS.has(node.kind)) scopes[index] = name;
+      }
+    } else if (node.kind === "object" && parent?.kind === "variable_declarator") {
+      scopes[index] = attachedName(tree, index, text);
+    } else if (language === "go" && node.kind === "short_var_declaration") {
+      const left = syntaxField(tree, index, "left");
+      if (left !== undefined) {
+        for (const id of bindingNodes(tree, left)) {
+          if (syntaxText(nodes[id]!, text) !== "_")
+            add(id, "declaration", "short-variable-candidate", true);
+        }
+      }
+    }
+
+    if (node.kind === "call_expression" || node.kind === "new_expression") {
+      const field = node.kind === "new_expression" ? "constructor" : "function";
+      const calleeId = syntaxField(tree, index, field);
+      const callee = calleeId === undefined ? undefined : nodes[calleeId];
+      if (callee) {
+        const optional = (children[index] ?? []).some(
+          (child) => nodes[child]?.kind === "optional_chain",
+        );
+        semanticCalls.push({
+          node: index,
+          range: callee,
+          subkind:
+            language === "go"
+              ? callee.kind === "func_literal"
+                ? "call"
+                : "call-or-conversion"
+              : node.kind === "new_expression"
+                ? "constructor"
+                : optional
+                  ? "optional-call"
+                  : "call",
+          candidate: language === "go" && callee.kind !== "func_literal",
+        });
+      }
+    }
+    if (["import_statement", "import_spec", "export_statement"].includes(node.kind)) {
+      const role = node.kind === "export_statement" ? "export" : "import";
+      for (const child of children[index] ?? []) {
+        const target = nodes[child];
+        if (
+          target &&
+          (["source", "path", "name"].includes(target.field ?? "") ||
+            ["import_clause", "export_clause", "import", "export", "default"].includes(target.kind))
+        )
+          semanticImports.push({ node: child, range: target, role });
+      }
+    }
+    if (language === "go" && node.kind === "import") add(index, "import", "import-keyword");
+  }
+
+  const excluded = mergeIntervals(lexical);
+  nestedCallContent.sort((a, b) => a.start - b.start);
+  const commentExcluded = mergeIntervals(comments);
+  for (const call of semanticCalls) {
+    const callExcluded = containedIntervals(call.range, nestedCallContent);
+    for (const lexicalRange of subtract(call.range, excluded)) {
+      for (const range of subtract(lexicalRange, callExcluded)) {
+        roles.push({
+          ...range,
+          role: "call",
+          certainty: call.candidate ? "candidate" : "syntax",
+          subkind: call.subkind,
+          node: call.node,
+        });
+      }
+    }
+  }
+  for (const item of semanticImports) {
+    for (const range of subtract(item.range, commentExcluded)) {
+      roles.push({ ...range, role: item.role, certainty: "syntax", node: item.node });
+    }
+  }
+  for (const range of subtract({ start: 0, end: text.length }, excluded)) {
+    roles.push({ ...range, role: "code", certainty: "syntax", node: 0 });
+  }
+  roles.sort((a, b) => a.start - b.start || a.end - b.end || a.role.localeCompare(b.role));
+  return { symbols, roles };
+}
+
+/** Whole-occurrence classification; crossing a role boundary is not a role match. */
+export function classifySyntaxRange(
+  analysis: SyntaxAnalysis,
+  start: number,
+  end: number,
+): SyntaxRole[] {
+  if (analysis.status !== "ok" || start < 0 || end < start) return [];
+  return analysis.roles.filter(
+    (role) => role.start <= start && end <= role.end && start < role.end,
+  );
+}

package/src/syntax-fields.ts

@@ -0,0 +1,161 @@
+/*
+ * Field-name metadata derived from @ast-grep/napi 0.45.2
+ * (tree-sitter-javascript 0.25.0, tree-sitter-typescript/tsx 0.23.2)
+ * and @ast-grep/lang-go 0.0.6 (tree-sitter-go 0.25.0).
+ *
+ * MIT License
+ * Copyright (c) 2020 N-API for Rust
+ * Copyright (c) 2025 ast-grep
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+export const JAVASCRIPT_FIELDS: Readonly<Record<string, readonly string[]>> = {
+  arrow_function: ["body", "parameter", "parameters", "return_type", "type_parameters"],
+  assignment_expression: ["left", "right"],
+  assignment_pattern: ["left", "right"],
+  augmented_assignment_expression: ["left", "operator", "right"],
+  binary_expression: ["left", "operator", "right"],
+  break_statement: ["label"],
+  call_expression: ["arguments", "function", "optional_chain", "type_arguments"],
+  catch_clause: ["body", "parameter", "type"],
+  class: ["body", "decorator", "name", "type_parameters"],
+  class_body: ["decorator", "member"],
+  class_declaration: ["body", "decorator", "name", "type_parameters"],
+  class_static_block: ["body"],
+  continue_statement: ["label"],
+  do_statement: ["body", "condition"],
+  export_specifier: ["alias", "name"],
+  export_statement: ["declaration", "decorator", "source", "value"],
+  field_definition: ["decorator", "property", "value"],
+  finally_clause: ["body"],
+  for_in_statement: ["body", "kind", "left", "operator", "right", "value"],
+  for_statement: ["body", "condition", "increment", "initializer"],
+  function_declaration: ["body", "name", "parameters", "return_type", "type_parameters"],
+  function_expression: ["body", "name", "parameters", "return_type", "type_parameters"],
+  generator_function: ["body", "name", "parameters", "return_type", "type_parameters"],
+  generator_function_declaration: ["body", "name", "parameters", "return_type", "type_parameters"],
+  if_statement: ["alternative", "condition", "consequence"],
+  import_specifier: ["alias", "name"],
+  import_statement: ["source"],
+  jsx_closing_element: ["name"],
+  jsx_element: ["close_tag", "open_tag"],
+  jsx_opening_element: ["attribute", "name", "type_arguments"],
+  jsx_self_closing_element: ["attribute", "name", "type_arguments"],
+  labeled_statement: ["body", "label"],
+  lexical_declaration: ["kind"],
+  member_expression: ["object", "optional_chain", "property"],
+  method_definition: ["body", "decorator", "name", "parameters", "return_type", "type_parameters"],
+  new_expression: ["arguments", "constructor", "type_arguments"],
+  object_assignment_pattern: ["left", "right"],
+  pair: ["key", "value"],
+  pair_pattern: ["key", "value"],
+  regex: ["flags", "pattern"],
+  subscript_expression: ["index", "object", "optional_chain"],
+  switch_case: ["body", "value"],
+  switch_default: ["body"],
+  switch_statement: ["body", "value"],
+  ternary_expression: ["alternative", "condition", "consequence"],
+  try_statement: ["body", "finalizer", "handler"],
+  unary_expression: ["argument", "operator"],
+  update_expression: ["argument", "operator"],
+  using_declaration: ["kind"],
+  variable_declarator: ["name", "type", "value"],
+  while_statement: ["body", "condition"],
+  with_statement: ["body", "object"],
+  abstract_class_declaration: ["body", "decorator", "name", "type_parameters"],
+  abstract_method_signature: ["name", "parameters", "return_type", "type_parameters"],
+  call_signature: ["parameters", "return_type", "type_parameters"],
+  conditional_type: ["alternative", "consequence", "left", "right"],
+  construct_signature: ["parameters", "type", "type_parameters"],
+  constructor_type: ["parameters", "type", "type_parameters"],
+  enum_assignment: ["name", "value"],
+  enum_body: ["name"],
+  enum_declaration: ["body", "name"],
+  extends_clause: ["type_arguments", "value"],
+  extends_type_clause: ["type"],
+  function_signature: ["name", "parameters", "return_type", "type_parameters"],
+  function_type: ["parameters", "return_type", "type_parameters"],
+  generic_type: ["name", "type_arguments"],
+  import_require_clause: ["source"],
+  index_signature: ["index_type", "name", "sign", "type"],
+  instantiation_expression: ["function", "type_arguments"],
+  interface_declaration: ["body", "name", "type_parameters"],
+  internal_module: ["body", "name"],
+  mapped_type_clause: ["alias", "name", "type"],
+  method_signature: ["name", "parameters", "return_type", "type_parameters"],
+  module: ["body", "name"],
+  nested_identifier: ["object", "property"],
+  nested_type_identifier: ["module", "name"],
+  optional_parameter: ["decorator", "name", "pattern", "type", "value"],
+  parenthesized_expression: ["type"],
+  property_signature: ["name", "type"],
+  public_field_definition: ["decorator", "name", "type", "value"],
+  required_parameter: ["decorator", "name", "pattern", "type", "value"],
+  type_alias_declaration: ["name", "type_parameters", "value"],
+  type_parameter: ["constraint", "name", "value"],
+  type_predicate: ["name", "type"],
+};
+
+export const GO_FIELDS: Readonly<Record<string, readonly string[]>> = {
+  array_type: ["element", "length"],
+  assignment_statement: ["left", "operator", "right"],
+  binary_expression: ["left", "operator", "right"],
+  call_expression: ["arguments", "function", "type_arguments"],
+  channel_type: ["value"],
+  communication_case: ["communication"],
+  composite_literal: ["body", "type"],
+  const_spec: ["name", "type", "value"],
+  expression_case: ["value"],
+  expression_switch_statement: ["initializer", "value"],
+  field_declaration: ["name", "tag", "type"],
+  for_clause: ["condition", "initializer", "update"],
+  for_statement: ["body"],
+  func_literal: ["body", "parameters", "result"],
+  function_declaration: ["body", "name", "parameters", "result", "type_parameters"],
+  function_type: ["parameters", "result"],
+  generic_type: ["type", "type_arguments"],
+  if_statement: ["alternative", "condition", "consequence", "initializer"],
+  implicit_length_array_type: ["element"],
+  import_spec: ["name", "path"],
+  index_expression: ["index", "operand"],
+  keyed_element: ["key", "value"],
+  labeled_statement: ["label"],
+  map_type: ["key", "value"],
+  method_declaration: ["body", "name", "parameters", "receiver", "result"],
+  method_elem: ["name", "parameters", "result"],
+  parameter_declaration: ["name", "type"],
+  qualified_type: ["name", "package"],
+  range_clause: ["left", "right"],
+  receive_statement: ["left", "right"],
+  selector_expression: ["field", "operand"],
+  send_statement: ["channel", "value"],
+  short_var_declaration: ["left", "right"],
+  slice_expression: ["capacity", "end", "operand", "start"],
+  slice_type: ["element"],
+  type_alias: ["name", "type", "type_parameters"],
+  type_assertion_expression: ["operand", "type"],
+  type_case: ["type"],
+  type_conversion_expression: ["operand", "type"],
+  type_instantiation_expression: ["type"],
+  type_parameter_declaration: ["name", "type"],
+  type_spec: ["name", "type", "type_parameters"],
+  type_switch_statement: ["alias", "initializer", "value"],
+  unary_expression: ["operand", "operator"],
+  var_spec: ["name", "type", "value"],
+  variadic_parameter_declaration: ["name", "type"],
+};