dsh-plugin-codegraph-tree-sitter 0.1.4 → 0.1.5

package/lib/extract.js

@@ -7,7 +7,7 @@
  * real workspace are of exactly this shape.
  * @module dsh-plugin-codegraph-tree-sitter/extract
  */
-import { DECLARATOR_NAME_FIELD, FIRST_CHILD_NAME_FIELD, PHP_ELEMENT_NAME_FIELD, SELF_NAME_FIELD } from "./languages.js";
+import { DART_FIELD_NAME_FIELD, DECLARATOR_NAME_FIELD, FIRST_CHILD_NAME_FIELD, KOTLIN_NAME_FIELD, PHP_ELEMENT_NAME_FIELD, SELF_NAME_FIELD, SWIFT_FUNCTION_NAME_FIELD, SWIFT_PROPERTY_NAME_FIELD } from "./languages.js";
 /** A node's named children, with the `null` slots `web-tree-sitter` reserves for missing nodes dropped. */
 function namedChildren(node) {
     return node.namedChildren.filter(child => child !== null);
@@ -227,6 +227,490 @@ function soleNamedField(node, field) {
     const named = node.childrenForFieldName(field).filter((child) => child !== null && child.isNamed);
     return named.length === 1 ? named[0] : undefined;
 }
+/**
+ * A Zig `variable_declaration`'s initializer value — its last named child, when one is present. Neither
+ * the declared name nor its value binds to a field of its own (both are purely positional), but an
+ * explicit type annotation (`var counter: i32 = 0;`) does bind to a `type` field — when present, the
+ * value always follows it, so comparing the last named child against that field tells an initializer
+ * apart from a type-only forward declaration with no value at all (`extern var x: i32;`, which this
+ * package never sees paired with a captured name in practice, but which `matchDefinition`'s general
+ * "don't guess" precedent still guards against misreading as its own type). Verified against a real
+ * parse, not guessed.
+ */
+function zigDeclarationValue(node) {
+    const typeNode = node.childForFieldName('type');
+    const last = namedChildren(node).at(-1);
+    // The grammar's `variable_declaration` always wraps at least its own declared name as a named child;
+    // the undefined case only satisfies `Array.prototype.at`'s general return type.
+    /* v8 ignore next */
+    if (last === undefined)
+        return undefined;
+    if (typeNode !== null && last.equals(typeNode))
+        return undefined;
+    return last;
+}
+/**
+ * The seam kind a Zig `variable_declaration` actually reports — `DefinitionRule.kind` is fixed per rule,
+ * with no way to vary by a value's shape, so this is computed here instead of in `LANGUAGE_TABLE`. A
+ * `struct_declaration`/`union_declaration` value reports `struct` (matching this file's existing
+ * union→`struct` precedent for C/C++/Rust); an `enum_declaration` value reports `enum`; anything else
+ * falls back to `constant`/`variable` by whether the declaration's own keyword is `const` or `var`.
+ * Verified against a real parse, not guessed.
+ */
+function zigDeclarationKind(node) {
+    const value = zigDeclarationValue(node);
+    if (value?.type === 'struct_declaration' || value?.type === 'union_declaration')
+        return 'struct';
+    if (value?.type === 'enum_declaration')
+        return 'enum';
+    return hasKeywordChild(node, 'var') ? 'variable' : 'constant';
+}
+/**
+ * A Zig `const name = @import("...")` recognized as an import binding — the only way Zig brings in
+ * another file or the standard library, spelled as an ordinary builtin-function call bound through the
+ * same `variable_declaration` shape `zigDeclarationKind` already classifies as an unremarkable constant
+ * (both are recorded — the same "also captured as an ordinary variable" precedent CommonJS's
+ * `require()`-bound `const` already sets). Neither `builtin_function` nor its own `arguments` wrapper
+ * binds a field of its own; both are purely positional, verified against a real parse, not guessed.
+ * @param node - the `variable_declaration` node.
+ * @param localName - the declaration's own bound name, already resolved by the caller.
+ * @returns the import binding, or `undefined` when `node`'s value is not an `@import(...)` call.
+ */
+function zigImportBinding(node, localName) {
+    const value = zigDeclarationValue(node);
+    if (value?.type !== 'builtin_function')
+        return undefined;
+    const [builtinIdentifier, argsNode] = namedChildren(value);
+    if (builtinIdentifier?.type !== 'builtin_identifier' || builtinIdentifier.text !== '@import')
+        return undefined;
+    // The grammar's builtin-call syntax always pairs a `builtin_identifier` with an `arguments` node right
+    // after it, even when the call has zero arguments (`@import()`); the undefined-return case only
+    // satisfies `childForFieldName`'s general return type, verified against a real parse, not guessed.
+    /* v8 ignore next */
+    if (argsNode?.type !== 'arguments')
+        return undefined;
+    const args = namedChildren(argsNode);
+    const specifierNode = args.length === 1 ? args[0] : undefined;
+    if (specifierNode?.type !== 'string')
+        return undefined;
+    const specifier = namedChildren(specifierNode)[0]?.text ?? specifierNode.text.slice(1, -1);
+    return { localName, importedName: '*', specifier };
+}
+/**
+ * A Kotlin `class_declaration`/`function_declaration`/`enum_entry`'s declared name — see
+ * {@link KOTLIN_NAME_FIELD}. Found by node type among direct named children rather than by position,
+ * since an optional leading `modifiers` node (`private fun foo()`'s own wrapping `modifiers` node,
+ * itself containing a `visibility_modifier`) would otherwise occupy index 0 ahead of the real name.
+ * Verified against a real parse, not guessed.
+ */
+function kotlinDeclaredName(node) {
+    return namedChildren(node).find(child => child.type === 'simple_identifier' || child.type === 'type_identifier');
+}
+/**
+ * The Kotlin `modifiers` node wrapping a declaration's `private`/`internal`/`protected`/`public`
+ * keyword (and any annotations), if present — unlike a bare keyword token directly on the declaration
+ * itself (see `hasKeywordChild`), Kotlin always wraps its visibility keyword one level down inside a
+ * `visibility_modifier` child of this node. Verified against a real parse, not guessed.
+ */
+function kotlinModifiersNode(node) {
+    return namedChildren(node).find(child => child.type === 'modifiers');
+}
+/** Whether a Kotlin declaration's `modifiers` node (see {@link kotlinModifiersNode}) carries a
+ * `visibility_modifier` with the given keyword text. Verified against a real parse, not guessed. */
+function kotlinHasVisibility(node, keyword) {
+    const modifiers = kotlinModifiersNode(node);
+    if (modifiers === undefined)
+        return false;
+    return namedChildren(modifiers).some(child => child.type === 'visibility_modifier' && hasKeywordChild(child, keyword));
+}
+/**
+ * Whether a Scala declaration's `modifiers` node carries `keyword` (`private`/`protected`) as a bare
+ * anonymous child directly — unlike Kotlin's/Swift's own `modifiers` node, Scala's wraps the keyword
+ * with no further `visibility_modifier` layer in between. Verified against a real parse, not guessed.
+ */
+function scalaHasModifier(node, keyword) {
+    const modifiers = namedChildren(node).find(child => child.type === 'modifiers');
+    return modifiers !== undefined && hasKeywordChild(modifiers, keyword);
+}
+/**
+ * The seam kind a Kotlin `class_declaration` actually reports — `class`, `interface`, and `enum class`
+ * all share this one node type, distinguished only by a bare `interface`/`enum` keyword among the
+ * declaration's own children (never wrapped, unlike a visibility keyword — see
+ * {@link kotlinModifiersNode}); `DefinitionRule.kind` has no way to vary by a keyword the way this
+ * needs, so this is computed here instead of in `LANGUAGE_TABLE`, the same "kind computed per node"
+ * precedent `zigDeclarationKind` already establishes. Verified against a real parse, not guessed.
+ */
+function kotlinClassKind(node) {
+    if (hasKeywordChild(node, 'interface'))
+        return 'interface';
+    if (hasKeywordChild(node, 'enum'))
+        return 'enum';
+    return 'class';
+}
+/**
+ * One Kotlin `delegation_specifier`'s target name, from a `class Foo : Base(), Shape` list — a
+ * superclass with an explicit constructor call wraps a `constructor_invocation` around its `user_type`;
+ * a bare interface (or an abstract base with no call) is a `user_type` directly. Either way, the target
+ * name itself sits one level deeper still, inside the `user_type`'s own `type_identifier`. Kotlin's
+ * grammar draws no distinction here between extending a class and implementing an interface — the same
+ * ambiguity `pythonClassHeritage`/`baseListHeritage` already document for a comparable shape — so every
+ * entry reports `extends`. Verified against a real parse, not guessed.
+ * @param delegationSpecifier - the `delegation_specifier` node.
+ * @returns the target's simple name, or `undefined` when its shape is not one of the two above.
+ */
+function kotlinHeritageTargetName(delegationSpecifier) {
+    const first = namedChildren(delegationSpecifier)[0];
+    const userType = first?.type === 'constructor_invocation' ? namedChildren(first)[0] : first;
+    const typeIdentifier = userType?.type === 'user_type' ? namedChildren(userType)[0] : undefined;
+    return typeIdentifier?.type === 'type_identifier' ? typeIdentifier.text : undefined;
+}
+/**
+ * Kotlin `class_declaration`/interface heritage extraction from every `delegation_specifier` child —
+ * verified against a real parse, not guessed.
+ * @param node - the declaring `class_declaration` node.
+ * @param sourceKey - the declaring definition's own {@link RawDefinition.key}.
+ * @returns every heritage reference the declaration declares.
+ */
+function kotlinHeritage(node, sourceKey) {
+    return namedChildren(node)
+        .filter(child => child.type === 'delegation_specifier')
+        .map(child => kotlinHeritageTargetName(child))
+        .filter((name) => name !== undefined)
+        .map(targetName => ({ sourceKey, targetName, relation: 'extends' }));
+}
+/**
+ * A Kotlin `call_expression`'s callee, resolved down to the trailing simple name — `call_expression`
+ * binds no field of its own for this grammar (see {@link KOTLIN_NAME_FIELD}'s doc comment), so this is
+ * consulted directly by `extractFile` instead of through `LanguageSpec.callFunctionField`, which can
+ * never resolve anything here. A bare call (`add(1, 2)`)'s first child is the callee `simple_identifier`
+ * directly; a member call (`p.greet()`, `kotlin.math.abs(-1)`)'s first child is a `navigation_expression`
+ * instead — its own direct `navigation_suffix` child (never itself nested, even when the receiver chain
+ * is: `a.b.c()`'s outer `navigation_expression` wraps an inner `navigation_expression` as one child and
+ * this same node's own trailing `navigation_suffix` as the other, so reading only the outermost level
+ * always reaches the correct final segment regardless of chain depth) wraps the trailing
+ * `simple_identifier` this resolves to. Verified against a real parse, not guessed.
+ * @param node - the `call_expression` node.
+ * @returns the callee's simple-name node, or `undefined` when its shape is not one of the two above.
+ */
+function kotlinCallee(node) {
+    const first = namedChildren(node)[0];
+    // The grammar's `call_expression` always wraps a callee expression as its first named child; the
+    // undefined case only satisfies `Array.prototype.at`-style general array-access return type.
+    /* v8 ignore next */
+    if (first === undefined)
+        return undefined;
+    if (first.type !== 'navigation_expression')
+        return first;
+    const suffix = namedChildren(first).find(child => child.type === 'navigation_suffix');
+    // A `navigation_expression` always wraps a trailing `navigation_suffix` naming the accessed member
+    // (`.foo`, `?.foo`, even off `super`) — verified against a real parse across a plain member access, a
+    // safe-nav access, and a `super` receiver; the undefined case only satisfies `Array.prototype.find`'s
+    // general return type.
+    /* v8 ignore next */
+    return suffix === undefined ? undefined : namedChildren(suffix).find(child => child.type === 'simple_identifier');
+}
+/**
+ * Kotlin `import_header` extraction — a plain import (`import kotlin.math.abs`) wraps its dotted path
+ * in a bare `identifier`, whose own last `simple_identifier` segment is the imported symbol; a wildcard
+ * import (`import kotlin.collections.*`) pairs that same `identifier` prefix with a sibling
+ * `wildcard_import` marker instead; an aliased import (`import java.util.List as JList`) adds a sibling
+ * `import_alias` wrapping the alias `type_identifier`. Neither `identifier` nor `import_alias` binds a
+ * field of its own. Verified against a real parse, not guessed.
+ * @param node - the `import_header` node.
+ * @returns the single import binding this statement introduces.
+ */
+function kotlinImports(node) {
+    const children = namedChildren(node);
+    const path = children.find(child => child.type === 'identifier');
+    // `import_header` always wraps a dotted path per the grammar (a bare `import;` does not parse); the
+    // empty-array case only satisfies `Array.prototype.find`'s general return type.
+    /* v8 ignore next */
+    if (path === undefined)
+        return [];
+    const specifier = path.text;
+    if (children.some(child => child.type === 'wildcard_import'))
+        return [{ localName: '', importedName: '*', specifier }];
+    const segments = namedChildren(path).filter(child => child.type === 'simple_identifier');
+    const importedName = segments.at(-1)?.text;
+    // The grammar's `identifier` rule always wraps at least one `simple_identifier` segment; the
+    // empty-array case only satisfies `Array.prototype.at`'s general return type.
+    /* v8 ignore next */
+    if (importedName === undefined)
+        return [];
+    const alias = children.find(child => child.type === 'import_alias');
+    // The grammar's `import_alias` rule always wraps exactly one `type_identifier`; the fallback only
+    // satisfies `namedChildren`'s general array-access return type.
+    /* v8 ignore next */
+    const localName = alias === undefined ? importedName : (namedChildren(alias)[0]?.text ?? importedName);
+    return [{ localName, importedName, specifier }];
+}
+/**
+ * A Swift `property_declaration`'s declared name — see {@link SWIFT_PROPERTY_NAME_FIELD}. Its own
+ * `name` field points to a `pattern` node, not the identifier itself; the identifier is one level
+ * deeper, bound to that `pattern`'s own `bound_identifier` field. Verified against a real parse, not
+ * guessed.
+ */
+function swiftPropertyName(node) {
+    const pattern = node.childForFieldName('name');
+    // The grammar's `property_declaration` always binds its `name` field, even for a destructuring pattern
+    // (`let (a, b) = ...`, whose `pattern` still binds the field, just with no `bound_identifier` of its
+    // own — see the fallback below); the undefined case only satisfies `childForFieldName`'s general
+    // return type, verified against a real parse, not guessed.
+    /* v8 ignore next */
+    if (pattern === null)
+        return undefined;
+    const bound = pattern.childForFieldName('bound_identifier');
+    return bound?.type === 'simple_identifier' ? bound : undefined;
+}
+/**
+ * A Swift `function_declaration`/`protocol_function_declaration`'s declared name — see
+ * {@link SWIFT_FUNCTION_NAME_FIELD}. Uses `childForFieldName` (first match, document order) rather than
+ * `soleNamedField` (all matches, requiring exactly one): a return-typed function binds both its name
+ * and its `return_type` node to this same `name` field in this grammar build, and the name always comes
+ * first syntactically (`func f() -> Int` never writes the return type before the identifier), so the
+ * first match is always correct. Verified against a real parse, not guessed.
+ */
+function swiftFunctionName(node) {
+    const name = node.childForFieldName('name');
+    return name?.type === 'simple_identifier' ? name : undefined;
+}
+/** Whether a Swift `property_declaration` was declared with `var` (mutable) rather than `let` —
+ * the keyword sits as a bare anonymous token on the declaration's own `value_binding_pattern` child,
+ * itself one level down from `property_declaration` directly. Verified against a real parse, not
+ * guessed. */
+function swiftIsVar(node) {
+    const binding = namedChildren(node).find(child => child.type === 'value_binding_pattern');
+    return binding !== undefined && hasKeywordChild(binding, 'var');
+}
+/**
+ * The seam kind a Swift `class_declaration`/`property_declaration` actually reports —
+ * `DefinitionRule.kind` has no way to vary by a field's value or a keyword the way either needs, so
+ * this is computed here instead of in `LANGUAGE_TABLE`, the same "kind computed per node" precedent
+ * Zig's `variable_declaration`/Kotlin's `class_declaration` entries already establish. A
+ * `class_declaration`'s own `declaration_kind` field value node's type is directly `struct`/`class`/
+ * `enum` — an unusual shape (most grammars this package extracts from leave a keyword as a bare
+ * anonymous token, but this one promotes it to its own field value) verified against a real parse, not
+ * guessed. A `property_declaration` reports `field` when it is a class/struct member (inspecting the
+ * node's actual parent, not which of the two Swift `property_declaration` rules fired, so this gives
+ * the right answer regardless), or `constant`/`variable` by {@link swiftIsVar} otherwise.
+ */
+function swiftDeclarationKind(node) {
+    if (node.type === 'class_declaration') {
+        const kind = node.childForFieldName('declaration_kind')?.type;
+        return kind === 'struct' || kind === 'class' || kind === 'enum' ? kind : 'class';
+    }
+    if (node.parent?.type === 'class_body')
+        return 'field';
+    return swiftIsVar(node) ? 'variable' : 'constant';
+}
+/**
+ * Swift `class_declaration`/`protocol_declaration` heritage extraction from every `inheritance_specifier`
+ * child's `inherits_from` field — Swift draws no distinction between extending a class and conforming to
+ * a protocol in this same colon-separated list, the same ambiguity `pythonClassHeritage`/
+ * `baseListHeritage`/`kotlinHeritage` already document for a comparable shape, so every entry reports
+ * `extends`. Verified against a real parse, not guessed.
+ * @param node - the declaring `class_declaration`/`protocol_declaration` node.
+ * @param sourceKey - the declaring definition's own {@link RawDefinition.key}.
+ * @returns every heritage reference the declaration declares.
+ */
+function swiftHeritage(node, sourceKey) {
+    return namedChildren(node)
+        .filter(child => child.type === 'inheritance_specifier')
+        .map((child) => {
+        const userType = child.childForFieldName('inherits_from');
+        // `inherits_from` always resolves to a `user_type` whose first child is a `type_identifier` for
+        // every shape this has been checked against — a plain base, a `&`-composed protocol list (each
+        // conjunct its own `inheritance_specifier`), and a module-qualified name (`Swift.Equatable`, whose
+        // `user_type` still starts with a `type_identifier`, just the qualifier segment rather than the
+        // one this package would ideally resolve to — a known, accepted imprecision, not a crash). Neither
+        // fallback is known to be reachable; both exist only to satisfy the general return type of
+        // `childForFieldName`/array access rather than guess a name for a shape not yet seen.
+        /* v8 ignore next */
+        const typeIdentifier = userType?.type === 'user_type' ? namedChildren(userType)[0] : undefined;
+        /* v8 ignore next */
+        return typeIdentifier?.type === 'type_identifier' ? typeIdentifier.text : undefined;
+    })
+        .filter((name) => name !== undefined)
+        .map(targetName => ({ sourceKey, targetName, relation: 'extends' }));
+}
+/**
+ * A Swift `call_expression`'s callee, resolved down to the trailing simple name — `call_expression`
+ * binds no field of its own for its callee (see `LANGUAGE_TABLE`'s `swift` entry), so this is consulted
+ * directly by `extractFile` instead of through `LanguageSpec.callFunctionField`. A bare call
+ * (`add(1, 2)`)'s first child is the callee `simple_identifier` directly; a member call (`p.length()`)'s
+ * first child is a `navigation_expression` instead, whose own `suffix` field gives a `navigation_suffix`
+ * node, itself carrying the trailing identifier through its own `suffix` field in turn — reading only
+ * this outermost level reaches the correct final segment regardless of a longer dotted chain, the same
+ * "outermost level is enough" shape `kotlinCallee` already documents. Verified against a real parse, not
+ * guessed.
+ * @param node - the `call_expression` node.
+ * @returns the callee's simple-name node, or `undefined` when its shape is not one of the two above.
+ */
+function swiftCallee(node) {
+    const first = namedChildren(node)[0];
+    // The grammar's `call_expression` always wraps a callee expression as its first named child; the
+    // undefined case only satisfies `Array.prototype.at`-style general array-access return type.
+    /* v8 ignore next */
+    if (first === undefined)
+        return undefined;
+    if (first.type !== 'navigation_expression')
+        return first;
+    const navigationSuffix = first.childForFieldName('suffix');
+    const trailing = navigationSuffix?.childForFieldName('suffix');
+    // A `navigation_expression`'s own `suffix` field always resolves to a `navigation_suffix` carrying a
+    // trailing `suffix` of its own in turn (`.foo`, `?.foo`, even off `super`) — verified against a real
+    // parse across a plain member access, a safe-nav access, and a `super` receiver; the undefined case
+    // only satisfies `childForFieldName`'s general return type.
+    /* v8 ignore next */
+    return trailing === null ? undefined : trailing;
+}
+/**
+ * Swift `import_declaration` extraction — a whole-module import (`import Foundation`) wraps its dotted
+ * path in a bare `identifier`, whose own last `simple_identifier` segment is the module's own simple
+ * name; like a Go package import, it binds no individual symbol this package tracks by name, so the
+ * local name recorded is that same trailing segment (matching `goImports`'s own convention for a
+ * whole-package binding) rather than the empty-string, side-effect-only marker a `#include`/`require`
+ * binding uses elsewhere in this file. Verified against a real parse, not guessed.
+ * @param node - the `import_declaration` node.
+ * @returns the single import binding this statement introduces.
+ */
+function swiftImports(node) {
+    const path = namedChildren(node).find(child => child.type === 'identifier');
+    // `import_declaration` always wraps a dotted path per the grammar; the empty-array case only
+    // satisfies `Array.prototype.find`'s general return type.
+    /* v8 ignore next */
+    if (path === undefined)
+        return [];
+    const specifier = path.text;
+    const segments = namedChildren(path).filter(child => child.type === 'simple_identifier');
+    const localName = segments.at(-1)?.text;
+    // The grammar's `identifier` rule always wraps at least one `simple_identifier` segment; the
+    // empty-array case only satisfies `Array.prototype.at`'s general return type.
+    /* v8 ignore next */
+    if (localName === undefined)
+        return [];
+    return [{ localName, importedName: '*', specifier }];
+}
+/**
+ * A Dart `declaration`'s field name — see {@link DART_FIELD_NAME_FIELD}. Only the single-identifier
+ * `initialized_identifier_list` shape is named; a constructor-wrapping `declaration` (no
+ * `initialized_identifier_list` child at all) and a multi-declare `int x, y;` (more than one
+ * `initialized_identifier`) both return `undefined` rather than guess a name for a shape this package
+ * does not attempt to resolve. Verified against a real parse, not guessed.
+ */
+function dartFieldName(node) {
+    const list = namedChildren(node).find(child => child.type === 'initialized_identifier_list');
+    if (list === undefined)
+        return undefined;
+    const items = namedChildren(list).filter(child => child.type === 'initialized_identifier');
+    const sole = items.length === 1 ? items[0] : undefined;
+    if (sole === undefined)
+        return undefined;
+    const name = namedChildren(sole)[0];
+    // The grammar's `initialized_identifier` always wraps its own name as an `identifier` first child,
+    // with an optional initializer expression only ever following it (`int x = 5;` still binds `x` first)
+    // — verified against a real parse, not guessed; the undefined case only satisfies
+    // `Array.prototype.at`-style general array-access return type.
+    /* v8 ignore next */
+    return name?.type === 'identifier' ? name : undefined;
+}
+/**
+ * Dart `class_definition` heritage extraction from its `superclass` field (`extends Base`, wrapping the
+ * base type directly) and `interfaces` field (`implements Shape, Other` — a single wrapper node holding
+ * one `type_identifier` per implemented interface as its own direct children, verified against a real
+ * parse). Dart draws no distinction here that this package resolves beyond `extends`/`implements`
+ * themselves, so a `superclass` entry reports `extends` and each `interfaces` entry reports
+ * `implements`.
+ * @param node - the declaring `class_definition` node.
+ * @param sourceKey - the declaring definition's own {@link RawDefinition.key}.
+ * @returns every heritage reference the class declares.
+ */
+function dartHeritage(node, sourceKey) {
+    const refs = [];
+    const superclass = node.childForFieldName('superclass');
+    const base = superclass === null ? undefined : namedChildren(superclass)[0];
+    // Every `superclass` shape checked against a real parse — a plain base, a module-qualified one
+    // (`lib.Base`), and a generic one (`Generic<int>`) — puts a heritage-name-shaped node first; the false
+    // case exists only as this file's usual "don't guess" guard for a shape not yet seen, matching
+    // `isHeritageName`'s other call sites.
+    /* v8 ignore next */
+    if (base !== undefined && isHeritageName(base))
+        refs.push({ sourceKey, targetName: base.text, relation: 'extends' });
+    const interfaces = node.childForFieldName('interfaces');
+    if (interfaces !== null) {
+        // An `implements` clause always lists at least one target per the grammar (`implements` with an
+        // empty list does not parse); the zero-iteration case only satisfies the general shape of iterating
+        // an array that could in principle be empty.
+        /* v8 ignore next */
+        for (const target of namedChildren(interfaces)) {
+            if (isHeritageName(target))
+                refs.push({ sourceKey, targetName: target.text, relation: 'implements' });
+        }
+    }
+    return refs;
+}
+/**
+ * Dart `import_specification` extraction — the URI sits three levels down, in a `configurable_uri` →
+ * `uri` → `string_literal` chain, none of them bound to a field of their own; an `as` alias adds a
+ * sibling `identifier`. This grammar's `string_literal` carries no separate content child (unlike
+ * ECMAScript's `string_fragment`/PHP's escaped content) — its text is read directly off the quoted node
+ * itself, stripping the surrounding quote characters. Verified against a real parse, not guessed.
+ * @param node - the `import_specification` node.
+ * @returns the single import binding this statement introduces.
+ */
+function dartImports(node) {
+    // Every `import_specification` shape checked against a real parse — a plain import, an aliased one,
+    // and a conditional import (`if (dart.library.html) '...'`, whose primary `uri` sits alongside rather
+    // than inside the conditional part) — resolves this same `configurable_uri` → `uri` → `string_literal`
+    // chain; each undefined/type-mismatch fallback below only satisfies `Array.prototype.find`'s and
+    // `childForFieldName`'s general return types, not a shape actually seen.
+    /* v8 ignore next */
+    const configurableUri = namedChildren(node).find(child => child.type === 'configurable_uri');
+    /* v8 ignore next */
+    const uri = configurableUri === undefined ? undefined : namedChildren(configurableUri).find(child => child.type === 'uri');
+    /* v8 ignore next */
+    const stringLiteral = uri === undefined ? undefined : namedChildren(uri)[0];
+    /* v8 ignore next */
+    if (stringLiteral?.type !== 'string_literal')
+        return [];
+    const specifier = stringLiteral.text.slice(1, -1);
+    const alias = namedChildren(node).find(child => child.type === 'identifier');
+    return [{ localName: alias?.text ?? '', importedName: '*', specifier }];
+}
+/**
+ * Scala `import_declaration` extraction, covering both its shapes: a plain dotted path (`import
+ * scala.math.abs`, whose `path` field's own trailing `identifier` descendant is the imported symbol),
+ * and a selector list (`import scala.collection.{List, Map}`, whose sibling `import_selectors` node
+ * binds each imported name directly). An `import_selectors` entry renamed with `=>` or a wildcard `_`
+ * import is not named here — the same "don't guess" precedent this file already follows for a shape it
+ * does not fully resolve; every `import_selectors` child this does not recognize is simply filtered out
+ * rather than mis-read. Verified against a real parse, not guessed.
+ * @param node - the `import_declaration` node.
+ * @returns every import binding this statement introduces.
+ */
+function scalaImports(node) {
+    const path = node.childForFieldName('path');
+    // `import_declaration` always binds a `path` field — verified against a real parse for a single
+    // bare-name import, a dotted one, and a comma-separated multi-import (each still binds its own `path`);
+    // the empty-array case only satisfies `childForFieldName`'s general return type.
+    /* v8 ignore next */
+    if (path === null)
+        return [];
+    const prefix = path.text;
+    const selectors = namedChildren(node).find(child => child.type === 'import_selectors');
+    if (selectors === undefined) {
+        const last = descendantsOfType(path, ['identifier']).at(-1);
+        // The grammar's `stable_identifier`/`identifier` path always wraps at least one `identifier`
+        // segment; the empty-array case only satisfies `Array.prototype.at`'s general return type.
+        /* v8 ignore next */
+        if (last === undefined)
+            return [];
+        return [{ localName: last.text, importedName: last.text, specifier: prefix }];
+    }
+    return namedChildren(selectors)
+        .filter(child => child.type === 'identifier')
+        .map(name => ({ localName: name.text, importedName: name.text, specifier: `${prefix}.${name.text}` }));
+}
 /** The definition rule matching `node`, or `undefined` when it introduces no declaration. */
 function matchDefinition(node, definitions) {
     for (const rule of definitions) {
@@ -245,7 +729,11 @@ function matchDefinition(node, definitions) {
             : rule.nameField === DECLARATOR_NAME_FIELD ? declaratorName(node)
                 : rule.nameField === FIRST_CHILD_NAME_FIELD ? firstChildName(node)
                     : rule.nameField === PHP_ELEMENT_NAME_FIELD ? phpElementName(node)
-                        : soleNamedField(node, rule.nameField);
+                        : rule.nameField === KOTLIN_NAME_FIELD ? kotlinDeclaredName(node)
+                            : rule.nameField === SWIFT_PROPERTY_NAME_FIELD ? swiftPropertyName(node)
+                                : rule.nameField === SWIFT_FUNCTION_NAME_FIELD ? swiftFunctionName(node)
+                                    : rule.nameField === DART_FIELD_NAME_FIELD ? dartFieldName(node)
+                                        : soleNamedField(node, rule.nameField);
         if (nameNode === undefined)
             continue;
         if (rule.nameNodeTypes !== undefined && !rule.nameNodeTypes.includes(nameNode.type))
@@ -270,10 +758,17 @@ function calleeName(callee) {
     // Verified against a real parse, not guessed.
     if (callee.type === 'generic_function') {
         const inner = callee.childForFieldName('function');
+        // `generic_function` always binds a `function` field per the grammar; the undefined case only
+        // satisfies `childForFieldName`'s general return type.
+        /* v8 ignore next */
         return inner === null ? undefined : calleeName(inner);
     }
     if (callee.type === 'identifier')
         return callee.text;
+    // Kotlin's bare-name node type — `kotlinCallee` already resolves a call's callee (bare or member) down
+    // to this node type directly before `calleeName` ever sees it. Verified against a real parse.
+    if (callee.type === 'simple_identifier')
+        return callee.text;
     // PHP's bare-name node type — the resolved `callFunctionFieldByType` field value for all three of its
     // call shapes (`function_call_expression`'s simple case, `member_call_expression`'s and
     // `scoped_call_expression`'s method name) is this node type directly, never wrapped in a further
@@ -294,9 +789,12 @@ function calleeName(callee) {
     // (`obj.Method()`), and Rust's `scoped_identifier` (`Type::method()`, `std::mem::swap()`) — no other
     // call-callee shape in this file's language tables binds a field called `name` for anything else,
     // and Rust's `field_expression` (`obj.method()`) binds `field` instead, already covered below.
+    // `member` covers Zig's own `field_expression` (`obj.method()`, `Point.init()`) instead — Zig's
+    // grammar names this field `member`, not `field`, the only grammar in this file's tables to do so.
     // Verified against a real parse, not guessed.
     const property = callee.childForFieldName('property')
         ?? callee.childForFieldName('field')
+        ?? callee.childForFieldName('member')
         ?? callee.childForFieldName('attribute')
         ?? callee.childForFieldName('name');
     if (property !== null && property.type !== 'computed_property_name')
@@ -348,6 +846,42 @@ function commonJsRequireImport(node) {
         return { localName: '', importedName: '*', specifier };
     return undefined;
 }
+/**
+ * A Ruby `require '...'`/`require_relative '...'` call recognized as an import binding — Ruby's
+ * grammar has no dedicated import-statement node type at all (see `LANGUAGE_TABLE`'s `ruby` entry),
+ * so this dispatches off an ordinary `call` node the same way `commonJsRequireImport` does for
+ * CommonJS. Binds no local name — like a C `#include` or a Go whole-package import, `require` pulls
+ * in a file for its side effects, not a single symbol this package tracks by name. Verified against a
+ * real parse, not guessed.
+ * @param node - a `call` node.
+ * @returns the import binding, or `undefined` when `node` is not a bare top-level `require`/
+ * `require_relative` call.
+ */
+function rubyRequireImport(node) {
+    const method = node.childForFieldName('method');
+    // A `call` node's `method` field always resolves to a plain `identifier` regardless of receiver shape
+    // — verified against a real parse for a bare call, a receiver call (`obj.require(...)`), a scope-
+    // resolution call (`Foo::require(...)`), and a safe-nav call (`obj&.require(...)`), every one still
+    // binding `method` to the same `identifier` node type; neither fallback below is known to be reachable.
+    /* v8 ignore next */
+    if (method === null || method.type !== 'identifier')
+        return undefined;
+    if (method.text !== 'require' && method.text !== 'require_relative')
+        return undefined;
+    const argsNode = node.childForFieldName('arguments');
+    // A `call` node always binds an `arguments` field, even to an empty `argument_list` for a call with no
+    // arguments at all — verified against a real parse; a bare `require` with neither parentheses nor
+    // arguments parses as a plain `identifier`, never reaching a `call` node in the first place.
+    /* v8 ignore next */
+    if (argsNode === null)
+        return undefined;
+    const args = namedChildren(argsNode);
+    const specifierNode = args.length === 1 ? args[0] : undefined;
+    if (specifierNode?.type !== 'string')
+        return undefined;
+    const specifier = namedChildren(specifierNode)[0]?.text ?? specifierNode.text.slice(1, -1);
+    return { localName: '', importedName: '*', specifier };
+}
 /** ECMAScript-family import extraction: `import_statement` with a `import_clause` and a `source`. */
 function ecmascriptImports(node) {
     // `source` is required by the grammar; the null case only satisfies `childForFieldName`'s general
@@ -725,9 +1259,18 @@ function rustUseTarget(node, prefix) {
         /* v8 ignore next */
         if (list === null)
             return [];
+        // A `scoped_use_list` is exactly what distinguishes a path-prefixed braced group (`foo::{bar}`) from
+        // a bare one (`use {foo, bar};`, which parses as a plain `use_list` instead, never reaching this
+        // branch at all) — its `path` field is therefore always present whenever this node type is matched;
+        // the fallback only satisfies `childForFieldName`'s general return type.
+        /* v8 ignore next */
         const newPrefix = path === null ? prefix : combineRustPrefix(prefix, path.text);
         return namedChildren(list).flatMap(child => rustUseTarget(child, newPrefix));
     }
+    // Every node type a `_use_clause` alternative can hold is handled by an earlier branch above; falling
+    // through to here would require some other node type, which the grammar never produces in this
+    // position.
+    /* v8 ignore next */
     if (node.type === 'use_list') {
         return namedChildren(node).flatMap(child => rustUseTarget(child, prefix));
     }
@@ -747,9 +1290,10 @@ function rustImports(node) {
 }
 /** Whether `node` is a bare name this package resolves heritage references against — a member
  * expression (`ns.Base`) or a call (a mixin, `f(Base)`) is not, matching the "don't guess" precedent
- * `calleeName`/`ecmascriptImports` already follow for shapes they do not fully resolve. */
+ * `calleeName`/`ecmascriptImports` already follow for shapes they do not fully resolve. `constant` is
+ * Ruby's own bare-name node type (see `rubyClassHeritage`), verified against a real parse. */
 function isHeritageName(node) {
-    return node.type === 'identifier' || node.type === 'type_identifier' || node.type === 'name';
+    return node.type === 'identifier' || node.type === 'type_identifier' || node.type === 'name' || node.type === 'constant';
 }
 /**
  * ECMAScript-family `extends`/`implements` extraction from a `class_declaration`'s `class_heritage`
@@ -923,6 +1467,25 @@ function phpHeritage(node, sourceKey) {
     }
     return refs;
 }
+/**
+ * Ruby `class` superclass extraction from its `superclass` field (`class Dog < Animal`) — the field
+ * wraps the extended name directly, one level above the bare `constant`, the same shape C's
+ * `type_definition`'s `declarator` field wraps its target one level down. Ruby draws no
+ * `implements`-shaped distinction of its own (a mixin `include Module` is an ordinary method call,
+ * structurally indistinguishable from any other, so it is not extracted — the "don't guess" precedent
+ * `pythonClassHeritage` already documents for a comparable ambiguity), so every entry reports `extends`.
+ * Verified against a real parse, not guessed.
+ * @param node - the `class` node.
+ * @param sourceKey - the declaring class's own {@link RawDefinition.key}.
+ * @returns every heritage reference the class declares.
+ */
+function rubyClassHeritage(node, sourceKey) {
+    const superclass = node.childForFieldName('superclass');
+    const target = superclass === null ? undefined : namedChildren(superclass)[0];
+    if (target !== undefined && isHeritageName(target))
+        return [{ sourceKey, targetName: target.text, relation: 'extends' }];
+    return [];
+}
 /**
  * Rust `trait_item` supertrait extraction from its `bounds` field (`trait Shape: Debug + Display {}`).
  * Every supertrait requirement is reported as `extends`, matching `tsInterfaceHeritage`'s and
@@ -944,6 +1507,38 @@ function rustTraitHeritage(node, sourceKey) {
         .filter(isHeritageName)
         .map(target => ({ sourceKey, targetName: target.text, relation: 'extends' }));
 }
+/**
+ * Scala `class_definition`/`object_definition`/`trait_definition` heritage extraction from an
+ * `extends_clause`'s `type` field — a single base (`extends Base`) is a bare `type_identifier`; one or
+ * more `with` mixins added to it (`extends Base with Shape with Other`) wrap all of them together in one
+ * `compound_type`, whose own `base` field names the first (the real superclass, reported `extends`) with
+ * every other named child being an additional mixin (reported `implements`, matching this package's
+ * class/interface-conflating-list precedent already documented for `pythonClassHeritage`/
+ * `baseListHeritage`). Verified against a real parse, not guessed.
+ * @param node - the declaring `class_definition`/`object_definition`/`trait_definition` node.
+ * @param sourceKey - the declaring definition's own {@link RawDefinition.key}.
+ * @returns every heritage reference the declaration declares.
+ */
+function scalaHeritage(node, sourceKey) {
+    const extendsClause = node.childForFieldName('extend');
+    const type = extendsClause === null ? null : extendsClause.childForFieldName('type');
+    if (type === null)
+        return [];
+    if (type.type !== 'compound_type') {
+        return isHeritageName(type) ? [{ sourceKey, targetName: type.text, relation: 'extends' }] : [];
+    }
+    const base = type.childForFieldName('base');
+    const refs = [];
+    if (base !== null && isHeritageName(base))
+        refs.push({ sourceKey, targetName: base.text, relation: 'extends' });
+    for (const mixin of namedChildren(type)) {
+        if (base !== null && mixin.equals(base))
+            continue;
+        if (isHeritageName(mixin))
+            refs.push({ sourceKey, targetName: mixin.text, relation: 'implements' });
+    }
+    return refs;
+}
 /**
  * Dispatch heritage extraction to the language family that owns a captured class, struct, or interface
  * node's syntax. Go is absent: its interfaces are satisfied structurally, never declared at the
@@ -955,10 +1550,10 @@ function rustTraitHeritage(node, sourceKey) {
  * @returns every heritage reference the definition declares.
  */
 function extractHeritage(node, kind, sourceKey, language) {
-    // `kind === 'trait'` only ever comes from Rust's `trait_item` rule — no other language in
-    // LANGUAGE_TABLE produces it.
+    // `kind === 'trait'` only ever comes from Rust's `trait_item` rule or Scala's `trait_definition` rule
+    // — no other language in LANGUAGE_TABLE produces it.
     if (kind === 'trait')
-        return rustTraitHeritage(node, sourceKey);
+        return language === 'scala' ? scalaHeritage(node, sourceKey) : rustTraitHeritage(node, sourceKey);
     // `kind === 'interface'` only ever comes from TYPESCRIPT_DEFINITIONS's, Java's, or C#'s
     // `interface_declaration` rule — no other language in LANGUAGE_TABLE produces it.
     if (kind === 'interface') {
@@ -968,13 +1563,21 @@ function extractHeritage(node, kind, sourceKey, language) {
             return baseListHeritage(node, sourceKey, 'base_list');
         if (language === 'php')
             return phpHeritage(node, sourceKey);
+        if (language === 'kotlin')
+            return kotlinHeritage(node, sourceKey);
+        if (language === 'swift')
+            return swiftHeritage(node, sourceKey);
         return tsInterfaceHeritage(node, sourceKey);
     }
-    // `kind === 'struct'` only ever comes from C/C++'s `struct_specifier`/`union_specifier` or C#'s
-    // `struct_declaration` rule — a plain C struct/union has no base-list syntax at all, so
-    // `baseListHeritage` simply finds nothing to report for it.
-    if (kind === 'struct')
+    // `kind === 'struct'` only ever comes from C/C++'s `struct_specifier`/`union_specifier`, C#'s
+    // `struct_declaration`, or Swift's own `class_declaration` (`declaration_kind` field `struct`) rule —
+    // a plain C struct/union has no base-list syntax at all, so `baseListHeritage` simply finds nothing to
+    // report for it.
+    if (kind === 'struct') {
+        if (language === 'swift')
+            return swiftHeritage(node, sourceKey);
         return baseListHeritage(node, sourceKey, language === 'csharp' ? 'base_list' : 'base_class_clause');
+    }
     // `kind === 'enum'` only ever comes from PHP's `enum_declaration` rule today — no other language's
     // enum rule reaches this dispatch (TypeScript's/Java's/C#'s enum kinds carry no heritage syntax of
     // their own this package extracts elsewhere), so every other language reports nothing here.
@@ -993,6 +1596,16 @@ function extractHeritage(node, kind, sourceKey, language) {
         return baseListHeritage(node, sourceKey, 'base_list');
     if (language === 'php')
         return phpHeritage(node, sourceKey);
+    if (language === 'ruby')
+        return rubyClassHeritage(node, sourceKey);
+    if (language === 'kotlin')
+        return kotlinHeritage(node, sourceKey);
+    if (language === 'swift')
+        return swiftHeritage(node, sourceKey);
+    if (language === 'dart')
+        return dartHeritage(node, sourceKey);
+    if (language === 'scala')
+        return scalaHeritage(node, sourceKey);
     // Otherwise only comes from ECMASCRIPT_DEFINITIONS's `class_declaration` rule — Go has no class
     // concept, so this is never reached with `language === 'go'`.
     return ecmascriptClassHeritage(node, sourceKey);
@@ -1030,7 +1643,11 @@ export function extractFile(tree, spec) {
                 : rule.nameField === DECLARATOR_NAME_FIELD ? declaratorName(node)
                     : rule.nameField === FIRST_CHILD_NAME_FIELD ? firstChildName(node)
                         : rule.nameField === PHP_ELEMENT_NAME_FIELD ? phpElementName(node)
-                            : node.childForFieldName(rule.nameField);
+                            : rule.nameField === KOTLIN_NAME_FIELD ? kotlinDeclaredName(node)
+                                : rule.nameField === SWIFT_PROPERTY_NAME_FIELD ? swiftPropertyName(node)
+                                    : rule.nameField === SWIFT_FUNCTION_NAME_FIELD ? swiftFunctionName(node)
+                                        : rule.nameField === DART_FIELD_NAME_FIELD ? dartFieldName(node)
+                                            : node.childForFieldName(rule.nameField);
             // A matched rule's node type is always the NAMED-declaration form the grammar mandates a name
             // for; the anonymous form (`function_expression`, `class` as an expression, both produced by an
             // anonymous default export) parses as a different node type this rule never matches.
@@ -1038,10 +1655,25 @@ export function extractFile(tree, spec) {
             if (nameNode !== null) {
                 const key = `${node.startPosition.row}:${node.startPosition.column}`;
                 const parentKey = containerKeys[containerKeys.length - 1] ?? null;
+                // Zig's own `variable_declaration` rule, Kotlin's own `class_declaration` rule, and Swift's own
+                // `class_declaration`/`property_declaration` rules each report one fixed placeholder kind in
+                // `LANGUAGE_TABLE` (no rule can vary `kind` by a value's shape or a keyword the way any of them
+                // needs) — the real kind is computed here instead, see
+                // `zigDeclarationKind`/`kotlinClassKind`/`swiftDeclarationKind`. Every other language's rule
+                // already carries the right kind.
+                const kind = spec.language === 'zig' && node.type === 'variable_declaration' ? zigDeclarationKind(node)
+                    : spec.language === 'kotlin' && node.type === 'class_declaration' ? kotlinClassKind(node)
+                        : spec.language === 'swift' && (node.type === 'class_declaration' || node.type === 'property_declaration') ? swiftDeclarationKind(node)
+                            : rule.kind;
+                if (spec.language === 'zig' && node.type === 'variable_declaration') {
+                    const zigImport = zigImportBinding(node, nameNode.text);
+                    if (zigImport !== undefined)
+                        imports.push(zigImport);
+                }
                 definitions.push({
                     key,
                     parentKey,
-                    kind: rule.kind,
+                    kind,
                     name: nameNode.text,
                     container: [...containerNames],
                     startLine: node.startPosition.row + 1,
@@ -1061,14 +1693,14 @@ export function extractFile(tree, spec) {
                                     : hasKeywordChild(node, 'static'),
                     decorators: pythonDecorators(node, spec.language),
                 });
-                heritage.push(...extractHeritage(node, rule.kind, key, spec.language));
+                heritage.push(...extractHeritage(node, kind, key, spec.language));
                 containerNames.push(nameNode.text);
                 containerKeys.push(key);
                 // A C/C++/C# `struct` is scoped exactly like a `class` for this purpose — a `scopeRestricted`
                 // field rule must fire directly inside either body, not just a `class` one. Rust's `mod`
                 // (`namespace`) is scoped like the module top level it nests, not like a function body — a
                 // `scopeRestricted` `const`/`static` rule must still fire directly inside one.
-                scopeKinds.push(rule.kind === 'class' || rule.kind === 'struct' ? 'class' : rule.kind === 'namespace' ? 'module' : 'other');
+                scopeKinds.push(kind === 'class' || kind === 'struct' ? 'class' : kind === 'namespace' ? 'module' : 'other');
                 for (const child of namedChildren(node))
                     visit(child);
                 scopeKinds.pop();
@@ -1078,17 +1710,36 @@ export function extractFile(tree, spec) {
             }
         }
         if (spec.callTypes.includes(node.type)) {
-            // Every call-shaped node type in every language table entry requires its callee field; the null
-            // case only satisfies `childForFieldName`'s general return type.
+            // Kotlin's and Swift's `call_expression` bind no field of their own at all — see `kotlinCallee`'s/
+            // `swiftCallee`'s doc comments — so this consults one of them directly instead of
+            // `node.childForFieldName`, which could never resolve anything for either grammar regardless of
+            // which field name `LanguageSpec.callFunctionField` names. Every call-shaped node type in every
+            // OTHER language table entry requires its callee field; the null case only satisfies
+            // `childForFieldName`'s general return type.
             const calleeField = spec.callFunctionFieldByType?.[node.type] ?? spec.callFunctionField;
-            const callee = node.childForFieldName(calleeField);
+            // `kotlinCallee`/`swiftCallee` are not known to return `undefined` for any real `call_expression`
+            // — every shape checked against a real parse (a bare call, a member call, a chained member call, a
+            // `super` receiver, a safe-nav/optional-chaining receiver, a call on a parenthesized or indexing
+            // expression) resolves to a node; the `?? null` fallback exists only to match
+            // `childForFieldName`'s `Node | null` shape for the other languages' branch below, not a case seen.
+            /* v8 ignore next 2 */
+            const callee = spec.language === 'kotlin' ? kotlinCallee(node) ?? null
+                : spec.language === 'swift' ? swiftCallee(node) ?? null
+                    : node.childForFieldName(calleeField);
             /* v8 ignore next */
             const name = callee === null ? undefined : calleeName(callee);
             if (name !== undefined) {
                 // `callee` is non-null whenever `name` is: the optional chaining only satisfies the type
                 // system's view of the field lookup above, not a real possibility here.
                 /* v8 ignore next */
-                const isBareCallee = callee?.type === 'identifier' || callee?.type === 'name';
+                // Kotlin's `kotlinCallee`/Swift's `swiftCallee` already unwrap a member call's receiver chain
+                // down to the same `simple_identifier` node type a bare call's callee is, so its own type alone
+                // can no longer distinguish the two for either language — a bare call's `call_expression` has
+                // that `simple_identifier` as its own first child directly, while a member call's has a
+                // `navigation_expression` there instead (see `kotlinCallee`/`swiftCallee`). Verified against a
+                // real parse, not guessed.
+                const isBareCallee = callee?.type === 'identifier' || callee?.type === 'name'
+                    || ((spec.language === 'kotlin' || spec.language === 'swift') && namedChildren(node)[0]?.type === 'simple_identifier');
                 calls.push({
                     callerKey: containerKeys[containerKeys.length - 1] ?? null,
                     calleeName: name,
@@ -1102,9 +1753,13 @@ export function extractFile(tree, spec) {
                     // LANGUAGE_TABLE binds either field, so both are a no-op for every other language. Without
                     // `isBareCallee` also accepting PHP's `'name'` type alongside `'identifier'`, every PHP call —
                     // including an ordinary global `function_call_expression` — would be misclassified as
-                    // member-like, since PHP's bare-name node type is `name`, never `identifier`. Verified against
-                    // a real parse, not guessed.
-                    isMemberCall: !isBareCallee || node.childForFieldName('object') !== null || node.childForFieldName('scope') !== null,
+                    // member-like, since PHP's bare-name node type is `name`, never `identifier`. The `receiver`
+                    // check covers Ruby's `call` node (`obj.method_name(x)`), whose callee is always a bare
+                    // `identifier` in its own `method` field regardless of receiver — unlike every other grammar's
+                    // member expression, the receiver sits in a distinct sibling field instead of wrapping the
+                    // callee; no other call-type node in LANGUAGE_TABLE binds a field named `receiver`. Verified
+                    // against a real parse, not guessed.
+                    isMemberCall: !isBareCallee || node.childForFieldName('object') !== null || node.childForFieldName('scope') !== null || node.childForFieldName('receiver') !== null,
                 });
             }
         }
@@ -1116,6 +1771,11 @@ export function extractFile(tree, spec) {
             if (requireImport !== undefined)
                 imports.push(requireImport);
         }
+        if (node.type === 'call' && spec.language === 'ruby') {
+            const requireImport = rubyRequireImport(node);
+            if (requireImport !== undefined)
+                imports.push(requireImport);
+        }
         // A callback or IIFE's function value is never itself captured as a definition (only a *named*
         // declaration, or one assigned through a captured `variable_declarator`, is) — but a `const`/`var`
         // in its body is still function-local, so its scope must flip to `'other'` here regardless.
@@ -1153,6 +1813,14 @@ function extractImports(node, language) {
             return phpImports(node);
         case 'rust':
             return rustImports(node);
+        case 'kotlin':
+            return kotlinImports(node);
+        case 'swift':
+            return swiftImports(node);
+        case 'dart':
+            return dartImports(node);
+        case 'scala':
+            return scalaImports(node);
         /* v8 ignore next 2 -- exhaustive over LANGUAGE_TABLE's current language labels; unreachable. */
         default:
             return [];
@@ -1251,6 +1919,43 @@ function isExported(node, language, name, commonJsExports) {
     }
     if (language === 'python')
         return false;
+    // Ruby's `private`/`protected`/`public` are ordinary method calls that toggle visibility for
+    // subsequently defined methods, not a keyword on the declaration itself, and there is no separate
+    // module-level export construct at all — matching Python's precedent, every Ruby declaration reports
+    // `false` rather than guess one from tracking those calls' effect through the file.
+    if (language === 'ruby')
+        return false;
+    // Zig marks a declaration exported by an explicit bare `pub` keyword — a plain, always-anonymous
+    // token directly on the declaration itself, the same shape Rust's bare `pub` `visibility_modifier`
+    // has (see `rustIsPublic`), except Zig's grammar gives this token no named-child wrapper of its own
+    // to check `hasKeywordChild` still finds it. Verified against a real parse, not guessed.
+    if (language === 'zig')
+        return hasKeywordChild(node, 'pub');
+    // Kotlin's default visibility (no keyword at all) is already public — the inverse of every other
+    // language's "not exported unless an explicit keyword says so" convention — so this reports `true`
+    // unless an explicit `private`/`internal`/`protected` keyword (wrapped in the declaration's own
+    // `modifiers` node — see `kotlinHasVisibility`) narrows it. `protected` is treated as not exported:
+    // visible only to subclasses, not to an arbitrary importer, the same bar `internal`'s
+    // module-restricted visibility already fails to clear.
+    if (language === 'kotlin') {
+        return !kotlinHasVisibility(node, 'private') && !kotlinHasVisibility(node, 'internal') && !kotlinHasVisibility(node, 'protected');
+    }
+    // Swift's default visibility (no keyword at all) is `internal` — visible within the same module, but
+    // not to another module's importer — so unlike Kotlin's default-public convention, this reports `true`
+    // only for an explicit `public`/`open` keyword. Swift wraps its visibility keyword in the very same
+    // `modifiers` → `visibility_modifier` shape Kotlin's grammar does (verified against a real parse), so
+    // `kotlinHasVisibility` is reused directly rather than duplicated under a new name.
+    if (language === 'swift')
+        return kotlinHasVisibility(node, 'public') || kotlinHasVisibility(node, 'open');
+    // Dart has no visibility keyword at all — the language's own convention is a leading underscore
+    // marking a name library-private, matching Go's capitalization-based convention but spelled with a
+    // naming convention instead of a keyword.
+    if (language === 'dart')
+        return !name.startsWith('_');
+    // Scala's default visibility (no keyword at all) is already public, matching Kotlin's convention —
+    // this reports `true` unless an explicit `private`/`protected` keyword narrows it.
+    if (language === 'scala')
+        return !scalaHasModifier(node, 'private') && !scalaHasModifier(node, 'protected');
     // A PHP top-level function/class/interface/trait/enum carries no visibility keyword of its own — the
     // language has no export construct for them, matching Python's precedent, and this reports `false`
     // for all of them since `phpHasVisibility` finds no `visibility_modifier` to check. A class/enum