graph-indexer 3.0.1 → 3.1.0

package/src/parse/lang/jvm.mjs

@@ -1,3 +1,4 @@
+import { simpleParamType } from '../arity.mjs';
 /** Java extraction spec (Kotlin/Scala live in their own modules). */
 
 const T = (cap) => `[(type_identifier) @${cap} (generic_type (type_identifier) @${cap}) (scoped_type_identifier (type_identifier) @${cap} .) (generic_type (scoped_type_identifier (type_identifier) @${cap} .))]`;
@@ -34,6 +35,9 @@ const JAVA_QUERY = `
 (method_invocation object: ((identifier) @name @ref.type (#match? @name "^[A-Z]\\w*[a-z]")))
 (field_access object: ((identifier) @name @ref.type (#match? @name "^[A-Z]\\w*[a-z]")))
 (method_reference . ((identifier) @name @ref.type (#match? @name "^[A-Z]\\w*[a-z]")))
+; a nested class named through its outer one: Token.TokenType.EOF, Document.QuirksMode.quirks
+(field_access object: (field_access object: (identifier) @recv field: (identifier) @name (#match? @name "^[A-Z]\\w*[a-z]")) @ref.type)
+(method_invocation object: (field_access object: (identifier) @recv field: (identifier) @name (#match? @name "^[A-Z]\\w*[a-z]")) @ref.type)
 (argument_list (identifier) @name) @ref.value
 
 (lambda_expression) @scope
@@ -63,6 +67,34 @@ function javaImport(node) {
     return [{ source: parts.join('.'), imported: name, local: name, static: isStatic }];
 }
 
+/** The static type of a call argument where the source says it (literals, typed locals, `new`, casts), else null. */
+function javaArgType(n, rawOfLocal) {
+    switch (n.type) {
+        case 'string_literal': case 'text_block': return 'String';
+        case 'character_literal': return 'char';
+        case 'decimal_integer_literal': case 'hex_integer_literal': case 'octal_integer_literal': case 'binary_integer_literal': return /[lL]$/.test(n.text) ? 'long' : 'int';
+        case 'decimal_floating_point_literal': case 'hex_floating_point_literal': return /[fF]$/.test(n.text) ? 'float' : 'double';
+        case 'true': case 'false': return 'boolean';
+        case 'null_literal': return '*';
+        case 'identifier': return simpleParamType(rawOfLocal(n.text));
+        case 'object_creation_expression': return simpleParamType(n.childForFieldName('type')?.text);
+        case 'cast_expression': return simpleParamType(n.childForFieldName('type')?.text);
+        case 'array_creation_expression': { const t = simpleParamType(n.childForFieldName('type')?.text); return t ? t + '[]'.repeat(Math.max(1, n.namedChildren.filter(c => c.type === 'dimensions_expr' || c.type === 'dimensions').length)) : null; }
+        case 'array_access': {
+            const arr = n.childForFieldName('array');
+            const t = arr?.type === 'identifier' ? simpleParamType(rawOfLocal(arr.text)) : null;
+            return t?.endsWith('[]') ? t.slice(0, -2) : null;
+        }
+        case 'parenthesized_expression': return n.namedChildren[0] ? javaArgType(n.namedChildren[0], rawOfLocal) : null;
+        case 'binary_expression': {
+            // `"a" + x` is a String
+            if (n.childForFieldName('operator')?.text === '+' && [n.childForFieldName('left'), n.childForFieldName('right')].some(c => c?.type === 'string_literal')) return 'String';
+            return null;
+        }
+        default: return null;
+    }
+}
+
 function modifiersText(node) {
     const m = node.namedChildren.find(c => c.type === 'modifiers');
     return m ? m.text : '';
@@ -76,6 +108,7 @@ function javaFileInfo(root) {
 export const java = {
     id: 'java',
     distinctOverloads: true, // each overload is a method of its own: calls bind by argument count
+    argType: javaArgType,    // … and, among overloads of one count, by the argument types the source shows
     localValues: true, // an argument named like a local or parameter is that variable
     nestedTypes: true, // `Token.Comment` names the class Comment nested in Token
     // an anonymous class (`new Transformer<>() {…}`) is `<anonymous>`, a subclass of what it instantiates

package/src/parse/lang/markdown.mjs

@@ -0,0 +1,92 @@
+/**
+ * Markdown documentation: one `section` definition per heading, spanning the text up to the next
+ * heading of the same or a higher level, nested like the headings. Sections are searchable
+ * (search_code, explore) and readable by name (read_code "docs/ARCHITECTURE.md:Storage"), so a
+ * question about why or how something is designed finds the design notes next to the code.
+ * No grammar: headings are read line by line, skipping fenced code blocks.
+ */
+
+const ATX = /^ {0,3}(#{1,6})[ \t]+(.+?)[ \t]*#*[ \t]*$/;
+const SETEXT = /^ {0,3}(=+|-+)[ \t]*$/;
+const FENCE = /^ {0,3}(`{3,}|~{3,})/;
+
+/** Heading text without inline markup: `code`, **bold**, [links](…), <tags>. */
+function plain(s) {
+    let t = s;
+    for (let prev; prev !== t;) { prev = t; t = t.replace(/<[^>]*>/g, ''); }
+    return t.replace(/!?\[([^\]]*)\]\([^)]*\)/g, '$1').replace(/[`*_~]/g, '').replace(/\s+/g, ' ').trim();
+}
+
+export function extractMarkdown(source) {
+    const lines = source.split('\n');
+    const heads = []; // { level, text, line }
+    let fence = null;
+    for (let i = 0; i < lines.length; i++) {
+        const l = lines[i];
+        const f = FENCE.exec(l);
+        if (f) {
+            if (!fence) fence = f[1][0];
+            else if (f[1][0] === fence) fence = null;
+            continue;
+        }
+        if (fence) continue;
+        const m = ATX.exec(l);
+        if (m) { const text = plain(m[2]); if (text) heads.push({ level: m[1].length, text, line: i + 1 }); continue; }
+        // setext: a non-blank paragraph line underlined with === or ---
+        if (i + 1 < lines.length && SETEXT.test(lines[i + 1]) && l.trim() && !/^ {0,3}([-*+>]|\d+[.)]|\|)/.test(l) && (i === 0 || !lines[i - 1].trim())) {
+            const text = plain(l);
+            if (text) { heads.push({ level: lines[i + 1].trim()[0] === '=' ? 1 : 2, text, line: i + 1 }); i++; }
+        }
+    }
+    const symbols = [];
+    const stack = []; // indices into symbols, by nesting
+    for (let h = 0; h < heads.length; h++) {
+        const { level, text, line } = heads[h];
+        let end = lines.length;
+        for (let k = h + 1; k < heads.length; k++) if (heads[k].level <= level) { end = heads[k].line - 1; break; }
+        while (end > line && !lines[end - 1].trim()) end--;
+        while (stack.length && symbols[stack[stack.length - 1]].level >= level) stack.pop();
+        const parentIdx = stack.length ? stack[stack.length - 1] : -1;
+        const parent = parentIdx >= 0 ? symbols[parentIdx] : null;
+        // first paragraph under the heading, as its doc line
+        let doc = '';
+        for (let k = line; k < Math.min(end, line + 30); k++) {
+            const t = lines[k].trim();
+            if (!t) { if (doc) break; continue; }
+            if (ATX.test(lines[k]) || FENCE.test(lines[k]) || /^[|<]/.test(t)) { if (doc) break; continue; }
+            doc += (doc ? ' ' : '') + plain(t.replace(/^([-*+>]|\d+[.)])\s+/, ''));
+            if (doc.length > 240) break;
+        }
+        symbols.push({
+            name: text,
+            qname: parent ? `${parent.qname} › ${text}` : text,
+            kind: 'section',
+            level,
+            parentIdx,
+            lexParent: parentIdx,
+            owner: null,
+            startLine: line, startCol: 0,
+            endLine: Math.max(line, end), endCol: (lines[Math.max(line, end) - 1] ?? '').length,
+            nameLine: line, nameCol: lines[line - 1].indexOf(text[0]) >= 0 ? lines[line - 1].indexOf(text[0]) : 0,
+            sig: `${'#'.repeat(level)} ${text}`,
+            doc: doc.slice(0, 300) || null,
+            exported: true,
+            visibility: null,
+            decorators: [],
+            bases: [],
+            type: null,
+            isStatic: false,
+        });
+        stack.push(symbols.length - 1);
+    }
+    for (const s of symbols) delete s.level;
+    return { symbols, refs: [], imports: [], fields: [], fileInfo: null, errors: 0 };
+}
+
+export const markdown = {
+    id: 'markdown',
+    docs: true,                       // prose: indexed for search and reading, never parsed as code
+    extensions: ['.md', '.mdx', '.markdown'],
+    testFile: null,
+    extract: (source) => extractMarkdown(source),
+};

package/src/parse/lang/python.mjs

@@ -1,5 +1,11 @@
 /** Python extraction spec. See ../extract.mjs for the capture convention. */
 
+// PEP 604 unions in annotations (`A | B.C | None`) nest left to right: one pattern per depth
+const UNION_TYPES = [1, 2, 3, 4].flatMap(d => [
+    `(type ${'(binary_operator '.repeat(d)}(identifier) @name${')'.repeat(d)}) @ref.type`,
+    `(type ${'(binary_operator '.repeat(d)}(attribute object: (_) @recv attribute: (identifier) @name)${')'.repeat(d)}) @ref.type`,
+]).join('\n');
+
 const QUERY = `
 (function_definition name: (identifier) @name return_type: (type) @type) @def.function
 (function_definition name: (identifier) @name) @def.function
@@ -22,11 +28,34 @@ const QUERY = `
 (type (generic_type (identifier) @name)) @ref.type
 (type (generic_type (type_parameter (type (identifier) @name)))) @ref.type
 (type (string (string_content) @name)) @ref.type
+${UNION_TYPES}
+(call function: [(identifier) (attribute)] @_tv arguments: (argument_list (keyword_argument name: (identifier) @_bound value: (string (string_content) @name))) (#match? @_tv "TypeVar$") (#eq? @_bound "bound")) @ref.type
+(expression_statement (assignment left: (identifier) @_all right: [(list (string (string_content) @name)) (tuple (string (string_content) @name))] (#eq? @_all "__all__"))) @ref.value
+(attribute object: (identifier) @name (#match? @name "^[A-Z]")) @ref.value
 (argument_list (identifier) @name) @ref.value
 (keyword_argument value: (identifier) @name) @ref.value
 (list (identifier) @name) @ref.value
+(tuple (identifier) @name) @ref.value
+(set (identifier) @name) @ref.value
 (pair value: (identifier) @name) @ref.value
 (assignment right: (identifier) @name) @ref.value
+(return_statement (identifier) @name) @ref.value
+(pair key: (identifier) @name) @ref.value
+(subscript value: (identifier) @_generic subscript: (identifier) @name (#match? @_generic "^[A-Z]")) @ref.type
+(subscript value: (identifier) @_generic subscript: (attribute object: (_) @recv attribute: (identifier) @name) (#match? @_generic "^[A-Z]")) @ref.type
+(subscript value: (attribute) subscript: (identifier) @name (#match? @name "^[A-Z]")) @ref.type
+(subscript value: (attribute) subscript: (attribute object: (_) @recv attribute: (identifier) @name) (#match? @name "^[A-Z]")) @ref.type
+(subscript value: [(identifier) (attribute)] subscript: (list (identifier) @name) (#match? @name "^[A-Z]")) @ref.type
+(subscript value: [(identifier) (attribute)] subscript: (string (string_content) @name) (#match? @name "^[A-Z][A-Za-z0-9_]*$")) @ref.type
+(except_clause value: (identifier) @name) @ref.type
+(except_clause value: (attribute object: (_) @recv attribute: (identifier) @name)) @ref.type
+(except_clause value: (tuple (identifier) @name)) @ref.type
+(except_clause value: (tuple (attribute object: (_) @recv attribute: (identifier) @name))) @ref.type
+(except_clause value: (as_pattern (identifier) @name)) @ref.type
+(except_clause value: (as_pattern (attribute object: (_) @recv attribute: (identifier) @name))) @ref.type
+(except_clause value: (as_pattern (tuple (identifier) @name))) @ref.type
+(except_clause value: (as_pattern (tuple (attribute object: (_) @recv attribute: (identifier) @name)))) @ref.type
+(return_statement (expression_list (identifier) @name)) @ref.value
 (attribute object: (_) @recv attribute: (identifier) @name) @ref.read
 
 [(lambda) (list_comprehension) (set_comprehension) (dictionary_comprehension) (generator_expression)] @scope
@@ -37,6 +66,11 @@ const QUERY = `
 (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
+(parameters (identifier) @bind.name @bind.local) @bind
+(default_parameter name: (identifier) @bind.name @bind.local) @bind
+(parameters (list_splat_pattern (identifier) @bind.name @bind.local)) @bind
+(parameters (dictionary_splat_pattern (identifier) @bind.name @bind.local)) @bind
+(lambda_parameters (identifier) @bind.name @bind.local) @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
@@ -87,6 +121,9 @@ function parseImport(node) {
             if (c.type === 'dotted_name') {
                 const mod = dotted(c);
                 out.push({ source: mod, imported: '*', local: mod });
+                // `import a.b` also binds `a`, to the package a
+                const top = mod.split('.')[0];
+                if (top !== mod && !out.some(o => o.local === top)) out.push({ source: top, imported: '*', local: top });
             } else if (c.type === 'aliased_import') {
                 const mod = dotted(c.childForFieldName('name'));
                 out.push({ source: mod, imported: '*', local: c.childForFieldName('alias')?.text || mod });
@@ -118,7 +155,13 @@ export const python = {
     id: 'python',
     // `self.x = …` inside a method declares an instance attribute of the class (first assignment wins)
     hoistMemberFields: true,
+    // a bare name bound in the function (parameter, assignment, loop variable) is that local
+    localNames: true,
     grammar: 'python',
+    // Python 3.15's lazy imports (PEP 810): `lazy` is a soft keyword before `import`/`from` at the
+    // start of a statement, which tree-sitter-python 0.25 does not know; blanked, the import
+    // statement is read as written (same length, so positions are unchanged)
+    rewriteSource: (src) => (src.includes('lazy') ? src.replace(/^([ \t]*)lazy(?=[ \t]+(?:import|from)[ \t])/gm, '$1    ') : src),
     extensions: ['.py', '.pyi'],
     family: 'python',
     query: QUERY,

package/src/parse/lang/rust.mjs

@@ -1,8 +1,8 @@
 /** 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}))]`;
+const TH = (cap) => `[(type_identifier) @${cap} (generic_type type: (type_identifier) @${cap}) (scoped_type_identifier path: (_) @recv 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 TW = (cap) => `[(type_identifier) (generic_type) (scoped_type_identifier) (reference_type) (array_type) (pointer_type) (tuple_type)] @${cap}`;
 
 const QUERY = `
 (function_item name: (identifier) @name return_type: ${TW('type')}) @def.function
@@ -32,6 +32,9 @@ const QUERY = `
 (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
+(scoped_type_identifier path: (_) @recv name: (type_identifier) @name) @ref.type
+(scoped_identifier path: [(identifier) @name (scoped_identifier path: (_) @recv name: (identifier) @name)]) @ref.type
+(identifier) @name @ref.value
 (impl_item trait: ${TH('name')}) @ref.inherit
 (trait_item bounds: (trait_bounds ${TH('name')})) @ref.inherit
 (arguments (identifier) @name) @ref.value
@@ -48,10 +51,24 @@ const QUERY = `
 (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: (scoped_identifier path: (identifier) @bind.new name: (identifier) @_ctor)) (#not-match? @bind.new "^(Arc|Rc|Box|Pin)$")) @bind
+(let_declaration pattern: (mut_pattern (identifier) @bind.name) value: (call_expression function: (scoped_identifier path: (identifier) @bind.new name: (identifier) @_ctor)) (#not-match? @bind.new "^(Arc|Rc|Box|Pin)$")) @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
+(parameter pattern: (mut_pattern (identifier) @bind.name) type: ${TW('bind.type')}) @bind
+(let_declaration pattern: (tuple_pattern) @bind.tuple value: (_) @bind.expr) @bind
+(let_condition pattern: (tuple_struct_pattern type: (identifier) @_wrap [(identifier) @bind.name (ref_pattern (identifier) @bind.name) (mut_pattern (identifier) @bind.name)]) value: (_) @bind.expr (#match? @_wrap "^(Some|Ok)$")) @bind
+(struct_item name: (type_identifier) @tuple.owner body: (ordered_field_declaration_list) @tuple.fields)
+(enum_variant name: (identifier) @tuple.variant body: (ordered_field_declaration_list) @tuple.fields)
+(match_arm pattern: (match_pattern (tuple_struct_pattern) @bind.variant)) @bind
+(let_condition pattern: (tuple_struct_pattern) @bind.variant) @bind
+(match_expression value: (_) @bind.expr body: (match_block (match_arm pattern: (match_pattern . (identifier) @bind.name .)) @bind) (#match? @bind.name "^[a-z_]"))
+(for_expression pattern: (tuple_pattern (_) (identifier) @bind.name .) value: (call_expression function: (field_expression value: (_) @bind.elem field: (field_identifier) @_en)) (#eq? @_en "enumerate")) @bind
+(block) @scope.block
+(match_arm) @scope.block
+(if_expression) @scope.block
+(while_expression) @scope.block
+(for_expression) @scope.block
 `;
 
 const PRIMITIVES = new Set(['i8', 'i16', 'i32', 'i64', 'i128', 'isize', 'u8', 'u16', 'u32', 'u64', 'u128', 'usize',
@@ -62,16 +79,72 @@ const BUILTIN_MACROS = new Set(['println', 'print', 'eprintln', 'eprint', 'forma
     'todo', 'matches', 'include_str', 'include_bytes', 'concat', 'stringify', 'env', 'cfg', 'dbg', 'format_args', 'Ok',
     'Err', 'Some', 'None', 'Box', 'Default', 'drop', 'Into', 'From']);
 
+/** The type a type expression names: `&'a mut Deserializer<R>`, `Box<T>` and `a::B<C>` name Deserializer, Box and B. */
+function typeHead(t) {
+    for (let g = 0; t && g < 8; g++) {
+        if (t.type === 'type_identifier' || t.type === 'primitive_type') return t.text;
+        if (t.type === 'reference_type' || t.type === 'pointer_type' || t.type === 'generic_type') t = t.childForFieldName('type');
+        else if (t.type === 'scoped_type_identifier') t = t.childForFieldName('name');
+        else return null;
+    }
+    return null;
+}
+
+const implOf = (node) => (node.parent?.type === 'declaration_list' && node.parent.parent?.type === 'impl_item' ? node.parent.parent : null);
+
+/**
+ * The type whose method a function in an impl block is. A blanket impl over a type parameter
+ * (`impl<'a, M: Matcher> Matcher for &'a M`, `… for Box<M>`) adds the trait's methods to every implementor:
+ * its methods belong to the trait.
+ */
 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();
+    const impl = implOf(node);
+    if (!impl) return null;
+    const type = impl.childForFieldName('type');
+    const head = typeHead(type);
+    const params = (impl.childForFieldName('type_parameters')?.namedChildren ?? []).filter(p => p.type === 'type_parameter').map(p => p.childForFieldName('name')?.text);
+    // `impl<M: Matcher> Matcher for Box<M>`: a wrapper around the parameter is the parameter
+    let inner = head;
+    if (WRAPPERS.has(head) && type?.type === 'generic_type') inner = typeHead(type.childForFieldName('type_arguments')?.namedChildren[0]) ?? head;
+    const isParam = inner && params.includes(inner);
+    const trait = isParam ? impl.childForFieldName('trait') : null;
+    return trait ? typeHead(trait) ?? head : head;
+}
+
+/** The trait an impl block implements, for the functions declared in it (`impl fmt::Debug for Number` → Debug). */
+function implTrait(node) {
+    if (node.type !== 'function_item' && node.type !== 'function_signature_item') return [];
+    const t = implOf(node)?.childForFieldName('trait');
+    const h = t ? typeHead(t) : null;
+    return h ? [h] : [];
+}
+
+// bounds that say nothing about the methods a value has
+const MARKER_TRAITS = new Set(['Copy', 'Clone', 'Send', 'Sync', 'Sized', 'Unpin', 'Debug', 'Display', 'Default', 'Eq', 'PartialEq',
+    'Hash', 'Ord', 'PartialOrd', 'Any', 'UnwindSafe', 'RefUnwindSafe']);
+const GENERIC_ITEMS = new Set(['function_item', 'function_signature_item', 'impl_item', 'trait_item', 'struct_item', 'enum_item']);
+
+/**
+ * The traits a type parameter in scope at `node` is bound by (`fn f<R: Read>(r: &mut R)`,
+ * `impl<W, F: Formatter> Serializer<W, F>`, `where R: Read<'de>`), so `r.read()` and `R::read(x)`
+ * reach the trait's method (`A + B` when several give it methods: `W: AsyncWrite + AsyncSeek`);
+ * null when `name` is no type parameter there or its bounds are markers.
+ */
+function typeParamBound(node, name) {
+    for (let n = node; n; n = n.parent) {
+        if (!GENERIC_ITEMS.has(n.type)) continue;
+        let declared = false;
+        const bounds = [];
+        const take = (list) => { for (const b of list?.namedChildren ?? []) { const t = b.type === 'higher_ranked_trait_bound' ? b.childForFieldName('type') : b; const h = typeHead(t); if (h && !MARKER_TRAITS.has(h) && !bounds.includes(t.text)) bounds.push(t.text); } };
+        for (const p of n.childForFieldName('type_parameters')?.namedChildren ?? []) {
+            if (p.type !== 'type_parameter' || p.childForFieldName('name')?.text !== name) continue;
+            declared = true;
+            take(p.childForFieldName('bounds'));
+        }
+        for (const w of n.namedChildren.find(c => c.type === 'where_clause')?.namedChildren ?? []) {
+            if (w.type === 'where_predicate' && w.childForFieldName('left')?.text === name) { declared ||= GENERIC_ITEMS.has(n.type); take(w.childForFieldName('bounds')); }
+        }
+        if (declared) return bounds.length ? bounds.join(' + ') : null;
     }
     return null;
 }
@@ -116,6 +189,102 @@ function parseImport(node) {
     return out;
 }
 
+/**
+ * Macro arguments are a token tree to tree-sitter: `tri!(self.parse(x))` and `assert_eq!(a.f(), 1)`
+ * hold calls the index would not see, and `cfg_rt! { pub struct Runtime … }` holds whole items. Before
+ * extraction, invocations whose arguments are plain Rust are rewritten in place, to text of the same
+ * length (so every position stays where it is): `m!(args)` → `m (args)` (a call of `m`), `m![args]`
+ * → `   [args]` (an array) and, where an item may stand, `m! { items }` → the items unwrapped.
+ * A rewrite is kept only if its text parses without errors on its own; macros inside the arguments
+ * become nodes once the outer one is rewritten, so this repeats a few rounds. Macro definitions
+ * (`macro_rules!`, with `$x` fragments) are left alone.
+ */
+function rewriteMacros(source, parse) {
+    let text = source;
+    for (let round = 0; round < 4; round++) {
+        const tree = parse(text);
+        const edits = [];
+        try {
+            const stack = [tree.rootNode];
+            while (stack.length) {
+                const n = stack.pop();
+                if (n.type === 'macro_definition') continue;
+                if (n.type === 'macro_invocation') {
+                    const e = macroEdit(n, text, parse);
+                    if (e) edits.push(e);
+                    continue;
+                }
+                for (let i = n.namedChildCount - 1; i >= 0; i--) stack.push(n.namedChild(i));
+            }
+        } finally { tree.delete(); }
+        if (!edits.length) break;
+        let out = '', at = 0;
+        for (const e of edits.sort((a, b) => a.from - b.from)) { out += text.slice(at, e.from) + e.text; at = e.to; }
+        text = out + text.slice(at);
+    }
+    return text;
+}
+
+const blank = (s) => s.replace(/[^\n]/g, ' ');
+const ITEM_PARENTS = new Set(['source_file', 'declaration_list']);
+
+/** The same-length rewrite of one macro invocation, or null when its arguments are not plain Rust. */
+function macroEdit(node, text, parse) {
+    const macro = node.childForFieldName('macro');
+    const tt = node.namedChildren[node.namedChildCount - 1];
+    if (!macro || tt?.type !== 'token_tree' || macro.text === 'macro_rules') return null;
+    const bang = text.indexOf('!', macro.endIndex);
+    if (bang < 0 || bang >= tt.startIndex || text.slice(macro.endIndex, bang).trim()) return null;
+    const open = text[tt.startIndex], inner = text.slice(tt.startIndex + 1, tt.endIndex - 1);
+    let edit, probe;
+    if (open === '(') {
+        edit = { from: bang, to: bang + 1, text: ' ' };
+        probe = `fn __() { let _ = __(${inner}); }`;
+    } else if (open === '[') {
+        edit = { from: node.startIndex, to: bang + 1, text: blank(text.slice(node.startIndex, bang + 1)) };
+        probe = `fn __() { let _ = [${inner}]; }`;
+    } else if (open === '{' && ITEM_PARENTS.has(node.parent?.type) && inner.trim()) {
+        edit = { from: node.startIndex, to: tt.endIndex, text: blank(text.slice(node.startIndex, tt.startIndex + 1)) + inner + ' ' };
+        probe = `mod __ {${inner}}`;
+    } else return null;
+    // `$x` metavariables belong to a macro definition's body (a nested one is not a node here)
+    if (/\$[\w(]/.test(inner)) return null;
+    const t = parse(probe);
+    try { return t.rootNode.hasError ? null : edit; } finally { t.delete(); }
+}
+
+// `Arc::new(x)`, `Box::pin(f)`, `Pin::new(&mut x)`, `Rc::clone(&x)`: a value of the wrapped type
+const WRAPPERS = new Set(['Arc', 'Rc', 'Box', 'Pin']);
+const WRAP_CTORS = new Set(['new', 'pin', 'clone', 'new_unchecked', 'from']);
+
+function wrappedValue(node, describe) {
+    // `(*self).m()`, `(**self).m()`: method calls dereference on their own
+    if (node.type === 'unary_expression' && node.text.startsWith('*') && node.namedChildren[0]) return describe(node.namedChildren[0]);
+    if (node.type !== 'call_expression') return undefined;
+    const fn = node.childForFieldName('function');
+    if (fn?.type !== 'scoped_identifier') return undefined;
+    const owner = fn.childForFieldName('path')?.text.split('::').pop();
+    if (!WRAPPERS.has(owner) || !WRAP_CTORS.has(fn.childForFieldName('name')?.text)) return undefined;
+    const args = node.childForFieldName('arguments')?.namedChildren.filter(c => !c.type.endsWith('comment')) ?? [];
+    return args.length === 1 ? describe(args[0]) : undefined;
+}
+
+/**
+ * A file whose own crate defines a type named like a transparent wrapper (tokio's `Mutex`,
+ * `RwLock`, `Semaphore`…) keeps that type: `inner: Mutex<Inner>` is tokio's Mutex, whose
+ * methods (`get_mut`, `lock`) are the repository's, not a view of Inner.
+ */
+function specForSource(source) {
+    let shadowed = null;
+    for (const t of rust.transparentTypes) {
+        if (!source.includes(t)) continue;
+        const own = new RegExp(`\\b(?:struct|enum|type|trait|union)\\s+${t}\\b|\\buse\\s+(?:crate|self|super)::[^;]*\\b${t}\\b[^;]*;`).test(source);
+        if (own) (shadowed ??= new Set()).add(t);
+    }
+    if (!shadowed) return null;
+    return { ...rust, transparentTypes: new Set([...rust.transparentTypes].filter(t => !shadowed.has(t))) };
+}
+
 function visibility(node) {
     const v = node.namedChildren.find(c => c.type === 'visibility_modifier');
     return v ? 'public' : 'private';
@@ -135,7 +304,23 @@ export const rust = {
     commentTypes: ['line_comment', 'block_comment'],
     skipBeforeDoc: new Set(['attribute_item', 'inner_attribute_item']),
     parseImport,
+    rewriteSource: rewriteMacros,
+    specForSource,
+    receiverDescriptor: wrappedValue,
+    typeParamBound,
+    tupleTypes: true,
+    shadowing: true,
+    pathCalls: true,
     ownerOf: implOwner,
+    implicitBases: implTrait,
+    // the impl a method is declared in (`impl Cursor<Vec<u8>>`): methods of one name in impls of one
+    // type are `#[cfg]` variants of one method, in impls of different types (or traits) methods of their own
+    decoratorsOf: (node) => {
+        const impl = (node.type === 'function_item' || node.type === 'function_signature_item') ? implOf(node) : null;
+        const t = impl?.childForFieldName('type');
+        return t ? ['impl ' + t.text.replace(/\s+/g, ' ')] : [];
+    },
+    traitPathCalls: true,
     refineKind(kind, d, parent) {
         if (kind === 'function' && implOwner(d.node)) return 'method';
         return kind;
@@ -143,6 +328,7 @@ export const rust = {
     isExported: (node) => node.namedChildren.some(c => c.type === 'visibility_modifier') || node.parent?.parent?.type === 'trait_item',
     visibility,
     isPrimitiveType: (t) => PRIMITIVES.has(t),
+    markerTraits: MARKER_TRAITS,
     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']),
@@ -151,7 +337,21 @@ export const rust = {
     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),
+        'clone', 'borrow', 'borrow_mut', 'lock', 'read', 'write', 'to_owned', 'deref', 'deref_mut', 'cloned', 'copied', 'iter', 'iter_mut', 'into_iter', 'drain', 'upgrade',
+        'get_mut', 'get_ref', 'into_inner', 'take',
+        // pin-project's projections have the fields of the value they project (`self.project().inner`)
+        'project', 'project_ref']),
+    normalizeRefName(name, r) {
+        if (r.node.type === 'macro_invocation') return BUILTIN_MACROS.has(name) ? null : name;
+        // a type named by the path of `Type::item` / `Enum::Variant`, and a unit struct or constant
+        // used as a value (`&Mmap`), are capitalised; modules and locals are not
+        if ((r.kind === 'type' && r.node.type === 'scoped_identifier') || (r.kind === 'value' && r.node.type === 'identifier')) {
+            if (!/^[A-Z]/.test(name)) return null;
+            // the last segment of a path (`Value::Number`) is the path's own reference
+            if (r.kind === 'value' && (r.nameNode.parent?.type === 'scoped_identifier' || r.nameNode.parent?.type === 'scoped_type_identifier')) return null;
+            for (let p = r.nameNode.parent; p; p = p.parent) if (p.type === 'token_tree' || p.type === 'use_declaration' || p.type === 'attribute_item' || p.type === 'macro_definition') return null;
+        }
+        return name;
+    },
     bodyField: 'body',
 };

package/src/parse/lang/sfc.mjs

@@ -0,0 +1,125 @@
+/**
+ * Single-file components: Vue (`.vue`) and Svelte (`.svelte`). The `<script>` blocks are TypeScript
+ * or JavaScript, extracted as such; the template is where a component uses others, the edge that
+ * "find the uses of this component" needs.
+ *
+ * The source is rewritten before parsing, every line kept where it is: the script blocks stay as
+ * they are, everything else becomes blank, and the template becomes a function — the component's
+ * default export, named in PascalCase after its file (`…Component` when the script imports another
+ * component of that name; `render` when the script has
+ * its own `export default {…}`, the Options API) — in which each tag of a component the script
+ * imports or declares is a call at the tag's line: `<UserCard :user="u" />` and
+ * `<user-card>` are calls to `UserCard`, bound through the script's import like any other.
+ * Tags of components registered globally (`app.component(…)`) and not named in the script are left
+ * out, as are HTML elements and the frameworks' own (`<Transition>`, `<svelte:self>`).
+ */
+import { typescript } from './ecma.mjs';
+
+const BUILTIN = new Set(['Transition', 'TransitionGroup', 'KeepAlive', 'Teleport', 'Suspense', 'Component', 'Slot', 'Template', 'RouterView', 'RouterLink']);
+
+const pascal = (tag) => tag.replace(/(^|-)(\w)/g, (_, __, c) => c.toUpperCase());
+
+/** [start, end) offsets of the content of each `<name …>…</name>` block at the top level. */
+function blocks(source, name) {
+    const out = [];
+    const open = new RegExp(`<${name}(\\s[^>]*)?>`, 'gi');
+    let m;
+    while ((m = open.exec(source))) {
+        const start = m.index + m[0].length;
+        const close = source.toLowerCase().indexOf(`</${name}>`, start);
+        if (close < 0) break;
+        out.push([start, close, m.index]);
+        open.lastIndex = close + name.length + 3;
+    }
+    return out;
+}
+
+/** Vue's template: from its opening tag to the last `</template>` (templates nest, for slots). */
+function vueTemplate(source) {
+    const m = /<template(\s[^>]*)?>/i.exec(source);
+    if (!m) return null;
+    const end = source.toLowerCase().lastIndexOf('</template>');
+    return end > m.index ? [m.index + m[0].length, end, m.index] : null;
+}
+
+function rewrite(source, kind) {
+    const scripts = blocks(source, 'script');
+    const scriptText = scripts.map(([a, b]) => source.slice(a, b)).join('\n');
+    // keep the scripts' characters, blank the rest (newlines kept, so every position stays)
+    const keep = new Uint8Array(source.length);
+    for (const [a, b] of scripts) keep.fill(1, a, b);
+    let blanked = '';
+    for (let i = 0; i < source.length; i++) blanked += keep[i] || source[i] === '\n' ? source[i] : (source[i] === '\t' ? '\t' : ' ');
+    const lines = blanked.split('\n');
+    const lineOf = (off) => { let n = 0; for (let i = 0; i < off; i++) if (source[i] === '\n') n++; return n; };
+
+    // the markup: Vue's <template>, or for Svelte everything outside <script> and <style>
+    let ranges;
+    if (kind === 'vue') { const t = vueTemplate(source); ranges = t ? [t] : []; }
+    else {
+        const skip = [...scripts, ...blocks(source, 'style')].map(([a, b, tag]) => [tag, source.indexOf('>', b) + 1]).sort((x, y) => x[0] - y[0]);
+        ranges = [];
+        let at = 0;
+        for (const [a, b] of skip) { if (a > at) ranges.push([at, a, at]); at = Math.max(at, b); }
+        if (at < source.length) ranges.push([at, source.length, at]);
+        ranges = ranges.filter(([a, b]) => source.slice(a, b).trim());
+    }
+    if (!ranges.length) return lines.join('\n');
+    const known = (name) => !BUILTIN.has(name) && new RegExp(`\\b${name}\\b`).test(scriptText);
+    const tags = [];
+    for (const [a, b] of ranges) {
+        const markup = source.slice(a, b).replace(/<!--[\s\S]*?-->/g, (c) => c.replace(/[^\n]/g, ' '));
+        for (const m of markup.matchAll(/<([A-Za-z][\w-]*)/g)) {
+            const raw = m[1];
+            const name = kind === 'vue' && raw.includes('-') ? pascal(raw) : raw;
+            if (!/^[A-Z]/.test(name) || !known(name)) continue;
+            const off = a + m.index;
+            const line = lineOf(off);
+            tags.push({ name, line, col: off - (source.lastIndexOf('\n', off - 1) + 1) + 1 });
+        }
+    }
+    // write `name` at `col` of a line, past what was written there already; a line grows if it must
+    const cursor = new Map();
+    const put = (line, col, text) => {
+        let l = lines[line];
+        const at = Math.max(col, cursor.get(line) ?? 0);
+        if (l.length < at + text.length) l = l.padEnd(at + text.length, ' ');
+        lines[line] = l.slice(0, at) + text + l.slice(at + text.length);
+        cursor.set(line, at + text.length + 1);
+    };
+    const first = lineOf(ranges[0][2]), last = lineOf(ranges[ranges.length - 1][1]);
+    const optionsApi = kind === 'vue' && /^\s*export\s+default\b/m.test(scriptText);
+    put(first, 0, optionsApi ? 'function render() {' : 'export default function () {');
+    for (const t of tags) put(t.line, t.col, `${t.name}();`);
+    put(last, 0, '}');
+    return lines.join('\n');
+}
+
+// compiler macros of `<script setup>` (Vue) and runes (Svelte 5): not functions anyone defines
+const MACROS = {
+    vue: ['defineProps', 'defineEmits', 'defineExpose', 'defineSlots', 'defineModel', 'defineOptions', 'withDefaults'],
+    svelte: ['$state', '$derived', '$effect', '$props', '$bindable', '$inspect', '$host'],
+};
+
+const sfc = (id, extensions) => ({
+    ...typescript,
+    id,
+    extensions,
+    builtinCalls: new Set([...typescript.builtinCalls, ...MACROS[id]]),
+    // the component is named in PascalCase after its file (`user-card.vue` → UserCard), as importers name it
+    normalizeName: (name, d, relPath) => {
+        const n = typescript.normalizeName(name, d, relPath);
+        if (d.node.type !== 'export_statement' || !n) return n;
+        const comp = n[0].toUpperCase() + n.slice(1);
+        // a component that imports another of its own name (`Valves.svelte` using common/Valves):
+        // its template's tags are that import, so the component itself takes another name
+        const root = d.node.tree?.rootNode ?? d.node.parent;
+        const imports = (root?.namedChildren ?? []).filter(c => c.type === 'import_statement').map(c => c.text).join('\n');
+        return new RegExp(`\\b${comp}\\b`).test(imports) ? `${comp}Component` : comp;
+    },
+    rewriteSource: (source) => rewrite(source, id),
+    testFile: /(^|\/)(__tests__|tests?|spec|e2e)\//,
+});
+
+export const vue = sfc('vue', ['.vue']);
+export const svelte = sfc('svelte', ['.svelte']);