graph-indexer 2.1.1 → 3.0.1

package/src/parse/lang/native.mjs

@@ -0,0 +1,126 @@
+/** C and C++ extraction specs. */
+
+const C_DEFS = `
+(function_definition declarator: (function_declarator declarator: (identifier) @name)) @def.function
+(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @def.function
+(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name)))) @def.function
+(struct_specifier name: (type_identifier) @name body: (_)) @def.struct
+(union_specifier name: (type_identifier) @name body: (_)) @def.struct
+(enum_specifier name: (type_identifier) @name body: (_)) @def.enum
+(type_definition declarator: (type_identifier) @name) @def.type
+(type_definition declarator: (pointer_declarator declarator: (type_identifier) @name)) @def.type
+(type_definition declarator: (function_declarator declarator: (parenthesized_declarator (pointer_declarator declarator: (type_identifier) @name)))) @def.type
+(preproc_function_def name: (identifier) @name) @def.macro
+(preproc_def name: (identifier) @name) @def.constant
+(enumerator name: (identifier) @name) @def.constant
+(field_declaration declarator: (field_identifier) @name) @def.field
+(field_declaration declarator: (pointer_declarator declarator: (field_identifier) @name)) @def.field
+`;
+
+const C_REFS = `
+(return_statement (_) @ret)
+(call_expression function: (identifier) @name) @ref.call
+(call_expression function: (field_expression argument: (_) @recv field: (field_identifier) @name)) @ref.call
+(type_identifier) @name @ref.type
+(argument_list (identifier) @name) @ref.value
+(init_declarator value: (identifier) @name) @ref.value
+(initializer_list (identifier) @name) @ref.value
+(preproc_include) @import
+`;
+
+const CPP_DEFS = `
+(function_definition declarator: (function_declarator declarator: (identifier) @name)) @def.function
+(function_definition declarator: (function_declarator declarator: (field_identifier) @name)) @def.method
+(function_definition declarator: (function_declarator declarator: (qualified_identifier scope: (_) @owner name: (identifier) @name))) @def.method
+(function_definition declarator: (function_declarator declarator: (qualified_identifier scope: (_) @owner name: (destructor_name) @name))) @def.method
+(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @def.function
+(function_definition declarator: (reference_declarator (function_declarator declarator: (identifier) @name))) @def.function
+(field_declaration declarator: (function_declarator declarator: (field_identifier) @name)) @def.method
+(declaration declarator: (function_declarator declarator: (identifier) @name)) @def.function
+(class_specifier name: (type_identifier) @name body: (_)) @def.class
+(struct_specifier name: (type_identifier) @name body: (_)) @def.struct
+(union_specifier name: (type_identifier) @name body: (_)) @def.struct
+(enum_specifier name: (type_identifier) @name body: (_)) @def.enum
+(namespace_definition name: (_) @name) @def.module
+(alias_declaration name: (type_identifier) @name) @def.type
+(type_definition declarator: (type_identifier) @name) @def.type
+(preproc_function_def name: (identifier) @name) @def.macro
+(field_declaration declarator: (field_identifier) @name) @def.field
+(enumerator name: (identifier) @name) @def.constant
+`;
+
+const CPP_REFS = `
+(lambda_expression) @scope
+(return_statement (_) @ret)
+(call_expression function: (identifier) @name) @ref.call
+(call_expression function: (field_expression argument: (_) @recv field: (field_identifier) @name)) @ref.call
+(call_expression function: (qualified_identifier scope: (_) @recv name: (identifier) @name)) @ref.call
+(call_expression function: (template_function name: (identifier) @name)) @ref.call
+(new_expression type: (type_identifier) @name) @ref.new
+(base_class_clause (type_identifier) @name) @ref.inherit
+(base_class_clause (qualified_identifier name: (type_identifier) @name)) @ref.inherit
+(type_identifier) @name @ref.type
+(argument_list (identifier) @name) @ref.value
+(preproc_include) @import
+(declaration type: (type_identifier) @bind.type declarator: (identifier) @bind.name) @bind
+(declaration type: (type_identifier) @bind.type declarator: (init_declarator declarator: (identifier) @bind.name)) @bind
+(parameter_declaration type: (type_identifier) @bind.type declarator: [(identifier) @bind.name (pointer_declarator declarator: (identifier) @bind.name) (reference_declarator (identifier) @bind.name)]) @bind
+(field_declaration type: (type_identifier) @field.type declarator: [(field_identifier) @field.name (pointer_declarator declarator: (field_identifier) @field.name)]) @field
+`;
+
+const C_BUILTINS = new Set(['printf', 'fprintf', 'sprintf', 'snprintf', 'malloc', 'calloc', 'realloc', 'free', 'memcpy',
+    'memset', 'memmove', 'memcmp', 'strlen', 'strcpy', 'strncpy', 'strcmp', 'strncmp', 'strcat', 'strchr', 'strstr',
+    'assert', 'sizeof', 'exit', 'abort', 'puts', 'putchar', 'fopen', 'fclose', 'fread', 'fwrite', 'fgets', 'fputs',
+    'atoi', 'atof', 'strtol', 'strtod', 'va_start', 'va_end', 'va_arg', 'isdigit', 'isspace', 'isalpha', 'tolower',
+    'toupper', 'abs', 'fabs', 'floor', 'ceil', 'pow', 'sqrt', 'static_cast', 'dynamic_cast', 'reinterpret_cast',
+    'const_cast', 'move', 'forward', 'make_shared', 'make_unique']);
+
+function parseInclude(node) {
+    const p = node.childForFieldName('path');
+    if (!p) return [];
+    if (p.type === 'system_lib_string') return [{ source: p.text.replace(/^<|>$/g, ''), imported: '*', local: null, system: true }];
+    return [{ source: p.text.replace(/^"|"$/g, ''), imported: '*', local: null }];
+}
+
+function cVisibility(node) {
+    return node.namedChildren.some(c => c.type === 'storage_class_specifier' && c.text === 'static') ? 'private' : null;
+}
+
+const common = {
+    implicitThis: false,
+    selfNames: ['this'],
+    externalReceivers: new Set(['std']),
+    builtinCalls: C_BUILTINS,
+    testFile: /(^|\/)(tests?|test_\w+)\/|_test\.(c|cc|cpp)$|(^|\/)test_[^/]*\.(c|cc|cpp)$/,
+    commentTypes: ['comment'],
+    parseImport: parseInclude,
+    isExported: (node) => cVisibility(node) !== 'private',
+    visibility: cVisibility,
+    isPrimitiveType: (t) => /^(int|char|void|float|double|long|short|unsigned|signed|bool|size_t|u?int\d+_t|string|auto)$/.test(t),
+    bodyField: 'body',
+};
+
+export const c = {
+    ...common,
+    id: 'c',
+    grammar: 'c',
+    extensions: ['.c', '.h'],
+    family: 'c',
+    query: C_DEFS + C_REFS,
+};
+
+export const cpp = {
+    ...common,
+    id: 'cpp',
+    grammar: 'cpp',
+    extensions: ['.cc', '.cpp', '.cxx', '.hpp', '.hh', '.hxx', '.h++', '.c++', '.ipp', '.inl'],
+    family: 'c',
+    implicitThis: true,
+    query: CPP_DEFS + CPP_REFS,
+    cleanType: (t) => t.replace(/\b(std|boost)::/g, ''),
+    transparentTypes: new Set(['unique_ptr', 'shared_ptr', 'weak_ptr', 'optional', 'reference_wrapper', 'atomic']),
+    elementTypes: new Set(['vector', 'list', 'deque', 'set', 'unordered_set', 'multiset', 'array', 'span', 'forward_list']),
+    elementMethods: new Set(['at', 'front', 'back', 'top']),
+    mapTypes: new Set(['map', 'unordered_map', 'multimap', 'unordered_multimap']),
+    mapMethods: new Set(['at']),
+};

package/src/parse/lang/python.mjs

@@ -0,0 +1,153 @@
+/** Python extraction spec. See ../extract.mjs for the capture convention. */
+
+const QUERY = `
+(function_definition name: (identifier) @name return_type: (type) @type) @def.function
+(function_definition name: (identifier) @name) @def.function
+(class_definition name: (identifier) @name) @def.class
+(module (expression_statement (assignment left: (identifier) @name)) @def.variable)
+(class_definition body: (block (expression_statement (assignment left: (identifier) @name type: (type) @type)) @def.field))
+(class_definition body: (block (expression_statement (assignment left: (identifier) @name)) @def.field))
+(expression_statement (assignment left: (attribute object: (identifier) @_self attribute: (identifier) @name) (#eq? @_self "self")) @def.field)
+
+(call function: (identifier) @name) @ref.call
+(call function: (attribute object: (_) @recv attribute: (identifier) @name)) @ref.call
+(class_definition superclasses: (argument_list (identifier) @name)) @ref.inherit
+(class_definition superclasses: (argument_list (attribute object: (_) @recv attribute: (identifier) @name))) @ref.inherit
+(decorator (identifier) @name) @ref.decorator
+(decorator (attribute object: (_) @recv attribute: (identifier) @name)) @ref.decorator
+(decorator (call function: (identifier) @name)) @ref.decorator
+(decorator (call function: (attribute object: (_) @recv attribute: (identifier) @name))) @ref.decorator
+(type (identifier) @name) @ref.type
+(type (attribute object: (_) @recv attribute: (identifier) @name)) @ref.type
+(type (generic_type (identifier) @name)) @ref.type
+(type (generic_type (type_parameter (type (identifier) @name)))) @ref.type
+(type (string (string_content) @name)) @ref.type
+(argument_list (identifier) @name) @ref.value
+(keyword_argument value: (identifier) @name) @ref.value
+(list (identifier) @name) @ref.value
+(pair value: (identifier) @name) @ref.value
+(assignment right: (identifier) @name) @ref.value
+(attribute object: (_) @recv attribute: (identifier) @name) @ref.read
+
+[(lambda) (list_comprehension) (set_comprehension) (dictionary_comprehension) (generator_expression)] @scope
+(return_statement (_) @ret)
+(import_statement) @import
+(import_from_statement) @import
+
+(assignment left: (identifier) @bind.name right: (_) @bind.expr) @bind
+(assignment left: (identifier) @bind.name type: (type) @bind.type) @bind
+(typed_parameter (identifier) @bind.name type: (type) @bind.type) @bind
+(typed_default_parameter name: (identifier) @bind.name type: (type) @bind.type) @bind
+(for_statement left: (identifier) @bind.name right: (_) @bind.elem) @bind
+(for_in_clause left: (identifier) @bind.name right: (_) @bind.elem) @bind
+(with_item value: (as_pattern (_) @bind.expr alias: (as_pattern_target (identifier) @bind.name))) @bind
+(assignment left: (attribute object: (identifier) @_self attribute: (identifier) @field.name) right: (_) @field.expr (#eq? @_self "self")) @field
+(assignment left: (attribute object: (identifier) @_self attribute: (identifier) @field.name) type: (type) @field.type (#eq? @_self "self")) @field
+(class_definition body: (block (expression_statement (assignment left: (identifier) @field.name type: (type) @field.type)) @field))
+`;
+
+const BUILTIN_CALLS = new Set([
+    'print', 'len', 'range', 'isinstance', 'issubclass', 'hasattr', 'getattr', 'setattr', 'delattr', 'super',
+    'str', 'int', 'float', 'bool', 'list', 'dict', 'set', 'tuple', 'frozenset', 'bytes', 'bytearray', 'type',
+    'object', 'enumerate', 'zip', 'map', 'filter', 'sorted', 'reversed', 'min', 'max', 'sum', 'any', 'all',
+    'abs', 'round', 'repr', 'hash', 'id', 'iter', 'next', 'open', 'callable', 'vars', 'dir', 'format',
+    'staticmethod', 'classmethod', 'property', 'NotImplementedError', 'ValueError', 'TypeError', 'KeyError',
+    'RuntimeError', 'Exception', 'AttributeError', 'IndexError', 'StopIteration', 'AssertionError', 'OSError',
+    'IOError', 'ImportError', 'NameError', 'ZeroDivisionError', 'PermissionError', 'FileNotFoundError',
+]);
+const EXTERNAL_RECEIVERS = new Set(['os', 'sys', 're', 'json', 'math', 'time', 'datetime', 'logging', 'logger',
+    'log', 'typing', 'collections', 'itertools', 'functools', 'asyncio', 'subprocess', 'shutil', 'pathlib', 'random',
+    'np', 'pd', 'torch', 'tf', 'pytest', 'unittest', 'mock', 'warnings', 'inspect', 'copy', 'pickle', 'uuid', 'base64',
+    'hashlib', 'threading', 'contextlib', 'dataclasses', 'enum', 'abc', 'io', 'tempfile', 'glob', 'string', 'decimal']);
+const PRIMITIVES = new Set(['str', 'int', 'float', 'bool', 'bytes', 'None', 'Any', 'object', 'list', 'dict', 'set',
+    'tuple', 'List', 'Dict', 'Set', 'Tuple', 'Optional', 'Union', 'Callable', 'Iterable', 'Iterator', 'Sequence',
+    'Mapping', 'Type', 'Generator', 'AsyncGenerator', 'Awaitable', 'Coroutine', 'Literal', 'ClassVar', 'Self']);
+
+function stripDocString(t) {
+    return t.replace(/^[rRbBuUfF]*("""|'''|"|')/, '').replace(/("""|'''|"|')$/, '')
+        .split('\n').map(l => l.trim()).filter(Boolean).join(' ');
+}
+
+function docOf(defNode) {
+    const body = defNode.childForFieldName('body');
+    const first = body?.namedChild(0);
+    if (first?.type === 'expression_statement') {
+        const s = first.namedChild(0);
+        if (s?.type === 'string') return stripDocString(s.text);
+    }
+    return null; // fall back to comments above
+}
+
+function dotted(node) { return node ? node.text.replace(/\s+/g, '') : null; }
+
+function parseImport(node) {
+    const out = [];
+    if (node.type === 'import_statement') {
+        for (const c of node.namedChildren) {
+            if (c.type === 'dotted_name') {
+                const mod = dotted(c);
+                out.push({ source: mod, imported: '*', local: mod });
+            } else if (c.type === 'aliased_import') {
+                const mod = dotted(c.childForFieldName('name'));
+                out.push({ source: mod, imported: '*', local: c.childForFieldName('alias')?.text || mod });
+            }
+        }
+    } else if (node.type === 'import_from_statement') {
+        const modNode = node.childForFieldName('module_name');
+        const source = dotted(modNode) || '.';
+        let any = false;
+        for (const c of node.namedChildren) {
+            if (c === modNode || c.id === modNode?.id) continue;
+            if (c.type === 'dotted_name') { const n = dotted(c); out.push({ source, imported: n, local: n.split('.').pop() }); any = true; }
+            else if (c.type === 'aliased_import') {
+                const n = dotted(c.childForFieldName('name'));
+                out.push({ source, imported: n, local: c.childForFieldName('alias')?.text || n }); any = true;
+            } else if (c.type === 'wildcard_import') { out.push({ source, imported: '*', local: null, wildcard: true }); any = true; }
+        }
+        if (!any) out.push({ source, imported: null, local: null });
+    }
+    return out;
+}
+
+function isModuleLevel(node) {
+    // (module (expression_statement (assignment)))
+    return node.parent?.type === 'module';
+}
+
+export const python = {
+    id: 'python',
+    // `self.x = …` inside a method declares an instance attribute of the class (first assignment wins)
+    hoistMemberFields: true,
+    grammar: 'python',
+    extensions: ['.py', '.pyi'],
+    family: 'python',
+    query: QUERY,
+    implicitThis: false,
+    selfNames: ['self', 'cls'],
+    externalReceivers: EXTERNAL_RECEIVERS,
+    builtinCalls: BUILTIN_CALLS,
+    testFile: /(^|\/)(tests?|testing)\/|(^|\/)test_[^/]*\.py$|_test\.py$|(^|\/)conftest\.py$/,
+    commentTypes: ['comment'],
+    docWrappers: new Set(['decorated_definition']),
+    docOf,
+    parseImport,
+    isModuleLevel,
+    isExported: (node, name) => !name.startsWith('_') || /^__\w+__$/.test(name),
+    visibility: (node, name) => (name && name.startsWith('_') && !/^__\w+__$/.test(name) ? 'private' : null),
+    isPrimitiveType: (t) => PRIMITIVES.has(t),
+    isStatic: (node) => node.parent?.type === 'decorated_definition' && node.parent.namedChildren.some(c => c.type === 'decorator' && /^@(staticmethod|classmethod)\b/.test(c.text)),
+    transparentTypes: new Set(['Optional', 'Final', 'ClassVar', 'Annotated', 'Type', 'type', 'Awaitable', 'Required', 'NotRequired', 'ReadOnly']),
+    elementTypes: new Set(['list', 'List', 'Sequence', 'MutableSequence', 'Iterable', 'Iterator', 'AsyncIterable', 'AsyncIterator',
+        'Generator', 'AsyncGenerator', 'set', 'Set', 'frozenset', 'FrozenSet', 'AbstractSet', 'MutableSet', 'Collection', 'Deque', 'deque', 'tuple', 'Tuple']),
+    elementMethods: new Set(['pop', 'popleft']),
+    mapTypes: new Set(['dict', 'Dict', 'Mapping', 'MutableMapping', 'DefaultDict', 'defaultdict', 'OrderedDict']),
+    mapMethods: new Set(['get', 'pop', 'setdefault']),
+    mapValueMethods: new Set(['values']),
+    decoratorsOf(node) {
+        const p = node.parent;
+        if (p?.type !== 'decorated_definition') return [];
+        return p.namedChildren.filter(c => c.type === 'decorator').map(d => d.text.replace(/^@/, '').split('(')[0].trim()).slice(0, 8);
+    },
+    bodyField: 'body',
+    signatureCleanup: (text) => text.replace(/:$/, ''),
+};

package/src/parse/lang/rust.mjs

@@ -0,0 +1,157 @@
+/** Rust extraction spec. `impl Type { fn m() }` methods are qualified as Type.m. */
+
+const TH = (cap) => `[(type_identifier) @${cap} (generic_type type: (type_identifier) @${cap}) (scoped_type_identifier name: (type_identifier) @${cap}) (reference_type type: (type_identifier) @${cap}) (reference_type type: (generic_type type: (type_identifier) @${cap}))]`;
+// a whole type (normalizeType unwraps references, Box/Rc/Arc/Option/Result, and sees Vec<T> as T[])
+const TW = (cap) => `[(type_identifier) (generic_type) (scoped_type_identifier) (reference_type) (array_type) (pointer_type)] @${cap}`;
+
+const QUERY = `
+(function_item name: (identifier) @name return_type: ${TW('type')}) @def.function
+(function_item name: (identifier) @name) @def.function
+(function_signature_item name: (identifier) @name return_type: ${TW('type')}) @def.function
+(function_signature_item name: (identifier) @name) @def.function
+(struct_item name: (type_identifier) @name) @def.struct
+(enum_item name: (type_identifier) @name) @def.enum
+(union_item name: (type_identifier) @name) @def.struct
+(trait_item name: (type_identifier) @name) @def.trait
+(type_item name: (type_identifier) @name) @def.type
+(const_item name: (identifier) @name) @def.constant
+(static_item name: (identifier) @name) @def.constant
+(mod_item name: (identifier) @name body: (_)) @def.module
+(macro_definition name: (identifier) @name) @def.macro
+(field_declaration name: (field_identifier) @name type: ${TW('type')}) @def.field
+(field_declaration name: (field_identifier) @name) @def.field
+(enum_variant name: (identifier) @name) @def.constant
+
+(call_expression function: (identifier) @name) @ref.call
+(call_expression function: (field_expression value: (_) @recv field: (field_identifier) @name)) @ref.call
+(call_expression function: (scoped_identifier path: (_) @recv name: (identifier) @name)) @ref.call
+(call_expression function: (generic_function function: (identifier) @name)) @ref.call
+(call_expression function: (generic_function function: (scoped_identifier path: (_) @recv name: (identifier) @name))) @ref.call
+(call_expression function: (generic_function function: (field_expression value: (_) @recv field: (field_identifier) @name))) @ref.call
+(macro_invocation macro: (identifier) @name) @ref.call
+(struct_expression name: (type_identifier) @name) @ref.new
+(struct_expression name: (scoped_type_identifier path: (_) @recv name: (type_identifier) @name)) @ref.new
+(type_identifier) @name @ref.type
+(impl_item trait: ${TH('name')}) @ref.inherit
+(trait_item bounds: (trait_bounds ${TH('name')})) @ref.inherit
+(arguments (identifier) @name) @ref.value
+(arguments (scoped_identifier path: (_) @recv name: (identifier) @name)) @ref.value
+
+(closure_expression) @scope
+(return_expression (_) @ret)
+(function_item body: (block [(call_expression) (struct_expression) (field_expression) (identifier) (self) (reference_expression) (try_expression) (scoped_identifier)] @ret .))
+(use_declaration) @import
+
+(let_declaration pattern: (identifier) @bind.name type: ${TW('bind.type')}) @bind
+(let_declaration pattern: (mut_pattern (identifier) @bind.name) type: ${TW('bind.type')}) @bind
+(let_declaration pattern: (identifier) @bind.name value: (_) @bind.expr) @bind
+(let_declaration pattern: (mut_pattern (identifier) @bind.name) value: (_) @bind.expr) @bind
+(for_expression pattern: (identifier) @bind.name value: (_) @bind.elem) @bind
+(let_declaration pattern: (identifier) @bind.name value: (struct_expression name: (type_identifier) @bind.new)) @bind
+(let_declaration pattern: (identifier) @bind.name value: (call_expression function: (scoped_identifier path: (identifier) @bind.new name: (identifier) @_ctor))) @bind
+(let_declaration pattern: (mut_pattern (identifier) @bind.name) value: (call_expression function: (scoped_identifier path: (identifier) @bind.new name: (identifier) @_ctor))) @bind
+(let_declaration pattern: (identifier) @bind.name value: (call_expression function: (identifier) @bind.call)) @bind
+(parameter pattern: (identifier) @bind.name type: ${TW('bind.type')}) @bind
+`;
+
+const PRIMITIVES = new Set(['i8', 'i16', 'i32', 'i64', 'i128', 'isize', 'u8', 'u16', 'u32', 'u64', 'u128', 'usize',
+    'f32', 'f64', 'bool', 'char', 'str', 'String', 'Option', 'Result', 'Vec', 'Box', 'Rc', 'Arc', 'RefCell',
+    'Cell', 'HashMap', 'HashSet', 'BTreeMap', 'BTreeSet', 'Cow', 'Mutex', 'RwLock', 'Pin', 'PhantomData']);
+const BUILTIN_MACROS = new Set(['println', 'print', 'eprintln', 'eprint', 'format', 'vec', 'panic', 'assert',
+    'assert_eq', 'assert_ne', 'debug_assert', 'debug_assert_eq', 'write', 'writeln', 'unreachable', 'unimplemented',
+    'todo', 'matches', 'include_str', 'include_bytes', 'concat', 'stringify', 'env', 'cfg', 'dbg', 'format_args', 'Ok',
+    'Err', 'Some', 'None', 'Box', 'Default', 'drop', 'Into', 'From']);
+
+function implOwner(node) {
+    // function_item inside (impl_item body: (declaration_list ...))
+    const list = node.parent;
+    const impl = list?.parent;
+    if (list?.type === 'declaration_list' && impl?.type === 'impl_item') {
+        const t = impl.childForFieldName('type');
+        if (!t) return null;
+        if (t.type === 'type_identifier') return t.text;
+        const inner = t.childForFieldName('type') ?? t.childForFieldName('name');
+        return inner?.type === 'type_identifier' ? inner.text : t.text.replace(/<.*$/s, '').split('::').pop();
+    }
+    return null;
+}
+
+function flattenUse(node, prefix, out) {
+    switch (node.type) {
+        case 'scoped_identifier': case 'identifier': case 'crate': case 'self': case 'super': {
+            const full = (prefix ? prefix + '::' : '') + node.text;
+            const name = full.split('::').pop();
+            out.push({ source: full.split('::').slice(0, -1).join('::'), imported: name, local: name === 'self' ? full.split('::').slice(-2, -1)[0] : name });
+            break;
+        }
+        case 'use_as_clause': {
+            const p = node.childForFieldName('path');
+            const full = (prefix ? prefix + '::' : '') + (p?.text ?? '');
+            out.push({ source: full.split('::').slice(0, -1).join('::'), imported: full.split('::').pop(), local: node.childForFieldName('alias')?.text });
+            break;
+        }
+        case 'use_wildcard': {
+            const inner = node.namedChildren[0];
+            out.push({ source: (prefix ? prefix + '::' : '') + (inner?.text ?? ''), imported: '*', local: null, wildcard: true });
+            break;
+        }
+        case 'scoped_use_list': {
+            const p = node.childForFieldName('path');
+            const np = (prefix ? prefix + '::' : '') + (p?.text ?? '');
+            const list = node.childForFieldName('list');
+            for (const c of list?.namedChildren ?? []) flattenUse(c, np, out);
+            break;
+        }
+        case 'use_list':
+            for (const c of node.namedChildren) flattenUse(c, prefix, out);
+            break;
+        default: break;
+    }
+}
+
+function parseImport(node) {
+    const arg = node.childForFieldName('argument');
+    const out = [];
+    if (arg) flattenUse(arg, '', out);
+    return out;
+}
+
+function visibility(node) {
+    const v = node.namedChildren.find(c => c.type === 'visibility_modifier');
+    return v ? 'public' : 'private';
+}
+
+export const rust = {
+    id: 'rust',
+    grammar: 'rust',
+    extensions: ['.rs'],
+    family: 'rust',
+    query: QUERY,
+    implicitThis: false,
+    selfNames: ['self'],
+    externalReceivers: new Set(['std', 'core', 'alloc', 'fmt', 'io', 'mem', 'ptr', 'env', 'fs', 'thread', 'log', 'tracing']),
+    builtinCalls: BUILTIN_MACROS,
+    testFile: /(^|\/)(tests|benches)\/|_test\.rs$/,
+    commentTypes: ['line_comment', 'block_comment'],
+    skipBeforeDoc: new Set(['attribute_item', 'inner_attribute_item']),
+    parseImport,
+    ownerOf: implOwner,
+    refineKind(kind, d, parent) {
+        if (kind === 'function' && implOwner(d.node)) return 'method';
+        return kind;
+    },
+    isExported: (node) => node.namedChildren.some(c => c.type === 'visibility_modifier') || node.parent?.parent?.type === 'trait_item',
+    visibility,
+    isPrimitiveType: (t) => PRIMITIVES.has(t),
+    transparentTypes: new Set(['Box', 'Rc', 'Arc', 'Cow', 'RefCell', 'Cell', 'Mutex', 'RwLock', 'MutexGuard', 'RwLockReadGuard', 'RwLockWriteGuard', 'Ref', 'RefMut', 'Pin', 'Option', 'Result', 'Weak']),
+    elementTypes: new Set(['Vec', 'VecDeque', 'HashSet', 'BTreeSet', 'BinaryHeap', 'LinkedList', 'IntoIter', 'Iter', 'IterMut', 'Drain']),
+    elementMethods: new Set(['first', 'last', 'get', 'get_mut', 'first_mut', 'last_mut', 'pop', 'pop_front', 'pop_back', 'front', 'back', 'remove', 'swap_remove', 'next', 'peek', 'find']),
+    mapTypes: new Set(['HashMap', 'BTreeMap', 'IndexMap', 'DashMap']),
+    mapMethods: new Set(['get', 'get_mut', 'remove', 'insert']),
+    mapValueMethods: new Set(['values', 'values_mut', 'into_values']),
+    // calls that hand back (a view of) the same value: unwrap, clone, borrow, lock, iter …
+    identityMethods: new Set(['unwrap', 'expect', 'unwrap_or_default', 'unwrap_or', 'unwrap_or_else', 'as_ref', 'as_mut', 'as_deref', 'as_deref_mut',
+        'clone', 'borrow', 'borrow_mut', 'lock', 'read', 'write', 'to_owned', 'deref', 'deref_mut', 'cloned', 'copied', 'iter', 'iter_mut', 'into_iter', 'drain', 'upgrade']),
+    normalizeRefName: (name, r) => (r.node.type === 'macro_invocation' ? (BUILTIN_MACROS.has(name) ? null : name) : name),
+    bodyField: 'body',
+};