@opensip-cli/graph-rust 0.1.0

package/dist/resolve-dependencies.js

@@ -0,0 +1,261 @@
+/**
+ * @fileoverview Rust `use`-path → dependency-edge resolution.
+ *
+ * Extracted from `resolve.ts` so the call-site resolver and the
+ * dependency resolver each live in a focused module. This file owns the
+ * Rust-specific module-path logic (Cargo.toml lookup, `crate`/`self`/
+ * `super`/`<pkg-name>` rewriting, file-path → module-path mapping).
+ *
+ * Phase 4 of opensip's substrate consolidation (DEC-498).
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export function resolveDependencies(sites, catalog, projectDirAbs) {
+    const packageName = readCargoPackageName(projectDirAbs);
+    const { moduleInitByModulePath, modulePathByFilePath } = buildCrateModuleIndex(catalog);
+    const out = new Map();
+    for (const site of sites) {
+        const importerModulePath = lookupImporterModulePath(catalog, modulePathByFilePath, site.ownerHash);
+        const edge = buildDependencyEdge(site, packageName, importerModulePath, moduleInitByModulePath);
+        appendDependencyEdge(out, site.ownerHash, edge);
+    }
+    return out;
+}
+/**
+ * Walk the catalog once to derive the two indices used during `use`-path
+ * resolution: `modulePath → moduleInit bodyHash` (for forward lookup) and
+ * `filePath → modulePath` (used to rewrite `super::` / `self::` paths
+ * relative to the importer's own module).
+ */
+function buildCrateModuleIndex(catalog) {
+    const moduleInitByModulePath = new Map();
+    const modulePathByFilePath = new Map();
+    for (const occs of Object.values(catalog.functions)) {
+        if (!occs)
+            continue;
+        for (const o of occs) {
+            if (o.kind !== 'module-init')
+                continue;
+            const modulePath = filePathToRustModulePath(o.filePath);
+            if (modulePath === null)
+                continue;
+            moduleInitByModulePath.set(modulePath, o.bodyHash);
+            modulePathByFilePath.set(o.filePath, modulePath);
+        }
+    }
+    return { moduleInitByModulePath, modulePathByFilePath };
+}
+/**
+ * Resolve the importer's module path (e.g. `crate::foo::bar`) from its
+ * `ownerHash`. Returns `null` when the owner isn't a recognizable crate
+ * module — `super::` / `self::` rewriting is then impossible.
+ */
+function lookupImporterModulePath(catalog, modulePathByFilePath, ownerHash) {
+    const importerFilePath = filePathOfOwner(catalog, ownerHash);
+    if (importerFilePath === null)
+        return null;
+    return modulePathByFilePath.get(importerFilePath) ?? null;
+}
+/** Build a single `DependencyEdge` for one dependency site. */
+function buildDependencyEdge(site, packageName, importerModulePath, moduleInitByModulePath) {
+    const to = resolveRustUseSpecifier(site.specifier, packageName, importerModulePath, moduleInitByModulePath);
+    return {
+        to,
+        line: site.line,
+        column: site.column,
+        specifier: site.specifier,
+    };
+}
+/** Append a dependency edge to the per-owner bucket, creating the bucket on first write. */
+function appendDependencyEdge(out, ownerHash, edge) {
+    const existing = out.get(ownerHash);
+    if (existing === undefined) {
+        out.set(ownerHash, [edge]);
+        return;
+    }
+    existing.push(edge);
+}
+/**
+ * Look up the importer's filePath from the catalog via owner bodyHash.
+ * Needed for `super::` / `self::` rewriting since the catalog already
+ * carries the project-relative filePath.
+ */
+function filePathOfOwner(catalog, ownerHash) {
+    for (const occs of Object.values(catalog.functions)) {
+        if (!occs)
+            continue;
+        for (const o of occs) {
+            if (o.bodyHash === ownerHash)
+                return o.filePath;
+        }
+    }
+    /* v8 ignore next */
+    return null;
+}
+/**
+ * Extract the package name from `Cargo.toml`'s `[package]` section.
+ * Strategy: line-grep for `name = "<value>"` inside the `[package]`
+ * section header. We intentionally do NOT pull in a TOML parser — this
+ * is a v1 limitation. Returns `null` when `Cargo.toml` is missing,
+ * unparseable, or has no `[package] name = …`.
+ *
+ * Edge cases NOT handled (deferred):
+ *   - `[workspace]`-only roots without a `[package]` (Cargo workspace
+ *     virtual-manifest); we'd need to recurse into `members = […]`.
+ *   - `[package] name = 'single-quoted'` (TOML allows this; rare).
+ *   - Multi-line table arrays / nested tables that re-open `[package]`.
+ *   - Dev-dependencies / feature flags — irrelevant to resolution.
+ */
+function readCargoPackageName(projectDirAbs) {
+    let content;
+    try {
+        content = readFileSync(join(projectDirAbs, 'Cargo.toml'), 'utf8');
+    }
+    catch {
+        // @fitness-ignore-next-line error-handling-quality -- missing/unreadable Cargo.toml is the expected "no package name" signal for projects that aren't a Cargo crate; caller treats null as "skip package-name resolution".
+        return null;
+    }
+    let inPackage = false;
+    for (const rawLine of content.split('\n')) {
+        const line = rawLine.trim();
+        if (line.length === 0 || line.startsWith('#'))
+            continue;
+        if (line.startsWith('[')) {
+            // New section header — `[package]` enters, anything else exits.
+            inPackage = /^\[package\]\s*$/.test(line);
+            continue;
+        }
+        if (!inPackage)
+            continue;
+        const match = /^name\s*=\s*"([^"]+)"\s*$/.exec(line);
+        if (match)
+            return match[1] ?? null;
+    }
+    return null;
+}
+/**
+ * Map a project-relative POSIX filePath to its Rust crate module path.
+ * Returns `null` when the file isn't recognizable as a crate module
+ * (e.g. lives outside `src/`, or doesn't follow the canonical layout).
+ *
+ * Conventions handled:
+ *   - `src/lib.rs`           → `crate`
+ *   - `src/main.rs`          → `crate`
+ *   - `src/<n>.rs`           → `crate::<n>`
+ *   - `src/<n>/mod.rs`       → `crate::<n>`
+ *   - `src/<a>/<b>.rs`       → `crate::<a>::<b>`
+ *   - `src/<a>/<b>/mod.rs`   → `crate::<a>::<b>`
+ *
+ * Files outside `src/` (e.g. `tests/it.rs`, `examples/foo.rs`,
+ * `benches/bench.rs`) return `null` — they're separate compilation
+ * units, not part of the library/binary crate's module tree.
+ */
+function filePathToRustModulePath(filePath) {
+    if (!filePath.endsWith('.rs'))
+        return null;
+    if (!filePath.startsWith('src/') && filePath !== 'src.rs')
+        return null;
+    // Strip `src/` prefix.
+    const rel = filePath.slice('src/'.length);
+    if (rel === 'lib.rs' || rel === 'main.rs')
+        return 'crate';
+    // Strip trailing `.rs`.
+    const noExt = rel.slice(0, -'.rs'.length);
+    // Treat `…/mod` (from `…/mod.rs`) as the parent directory itself.
+    const segments = noExt.split('/');
+    if (segments.at(-1) === 'mod')
+        segments.pop();
+    if (segments.length === 0)
+        return 'crate';
+    return ['crate', ...segments].join('::');
+}
+/**
+ * Resolve one Rust `use`-specifier to its target module-init
+ * bodyHash(es). Returns `[]` for stdlib, third-party, globs, and
+ * unresolvable relative paths.
+ *
+ * Multi-target: at v1 every match is a single module (Rust modules
+ * aren't directory-spanning the way Go packages are), so the returned
+ * array is either `[]` or a single hash. The `readonly string[]` shape
+ * is kept for engine-model symmetry.
+ */
+function resolveRustUseSpecifier(specifier, packageName, importerModulePath, moduleInitByModulePath) {
+    // Glob — documented v1 limitation. Skip resolution.
+    if (specifier.endsWith('::*') || specifier === '*')
+        return [];
+    const segments = specifier.split('::');
+    if (segments.length === 0 || segments[0] === undefined)
+        return [];
+    // Rewrite the head segment into an absolute `crate::…` path.
+    const absolute = rewriteToAbsoluteModulePath(segments, packageName, importerModulePath);
+    if (absolute === null)
+        return [];
+    return lookupRustModule(absolute, moduleInitByModulePath);
+}
+/**
+ * Rewrite a `use`-path's segments into the absolute `crate::…` form
+ * suitable for catalog lookup. Returns `null` when the path is external
+ * (stdlib, third-party crate other than the host package).
+ */
+function rewriteToAbsoluteModulePath(segments, packageName, importerModulePath) {
+    const head = segments[0];
+    if (head === undefined) /* v8 ignore next */
+        return null;
+    if (head === 'crate') {
+        return segments;
+    }
+    if (head === 'self') {
+        // `self::x::y` — current module + remainder.
+        if (importerModulePath === null)
+            return null;
+        const current = importerModulePath.split('::');
+        return [...current, ...segments.slice(1)];
+    }
+    if (head === 'super') {
+        // Count consecutive leading `super` segments and walk up that many.
+        if (importerModulePath === null)
+            return null;
+        let supers = 0;
+        while (segments[supers] === 'super')
+            supers++;
+        const current = importerModulePath.split('::');
+        // Strip `supers` trailing module segments from the current path.
+        // Note: `current` always starts with `crate`, so we must not strip
+        // past index 1.
+        const remaining = current.slice(0, Math.max(1, current.length - supers));
+        return [...remaining, ...segments.slice(supers)];
+    }
+    // External crate reference, possibly the host package referring to
+    // itself by name (`<package-name>::foo` ≡ `crate::foo`).
+    if (packageName !== null && head === toRustIdent(packageName)) {
+        return ['crate', ...segments.slice(1)];
+    }
+    return null;
+}
+/**
+ * Look up a fully-qualified Rust module path against the catalog. The
+ * specifier may name a module OR an item inside a module (a type, fn,
+ * const, etc.). Tree-sitter can't distinguish the two, so we walk from
+ * the longest module-prefix match toward `crate`, returning the first
+ * hit.
+ */
+function lookupRustModule(segments, moduleInitByModulePath) {
+    const cur = [...segments];
+    while (cur.length > 0) {
+        const key = cur.join('::');
+        const hash = moduleInitByModulePath.get(key);
+        if (hash !== undefined)
+            return [hash];
+        cur.pop();
+    }
+    return [];
+}
+/**
+ * Cargo package names allow `-` but Rust identifiers don't — Cargo
+ * substitutes `-` → `_` when synthesizing the crate's Rust-visible
+ * name. Mirror that.
+ */
+function toRustIdent(packageName) {
+    return packageName.replaceAll('-', '_');
+}
+//# sourceMappingURL=resolve-dependencies.js.map

package/dist/resolve-dependencies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-dependencies.js","sourceRoot":"","sources":["../src/resolve-dependencies.ts"],"names":[],"mappings":"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"}

package/dist/resolve.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Rust resolveCallSites — name-based catalog lookup with `impl`-block
+ * receiver-type context.
+ *
+ * Tree-sitter has no symbol table; we resolve by simple name. For
+ * each call site:
+ *
+ *   1. Decode the called expression. Five shapes matter:
+ *      - `foo(args)`              — call target is `foo`.
+ *      - `obj.method(args)`       — field_expression call target is
+ *                                   the trailing `field_identifier`.
+ *      - `Type::method(args)`     — scoped_identifier; target is the
+ *                                   trailing identifier.
+ *      - `path::to::fn(args)`     — same scoped_identifier shape.
+ *      - `name!(args)`            — macro_invocation target is the
+ *                                   leading identifier.
+ *
+ *   2. Look up matching catalog entries. For method calls
+ *      (`obj.method`), we narrow by `enclosingClass` if the receiver
+ *      type is statically known (literal, simple-typed local). The
+ *      narrow is best-effort, NOT type-aware — we don't track types
+ *      across statements. With the narrow:
+ *      - 1 method match in the receiver's impl  → 'high' confidence
+ *        ... actually no — even with narrowing, tree-sitter never
+ *        produces 'high' for ordinary calls, because the receiver
+ *        type itself is name-based. We use 'medium' for the
+ *        narrowed case and 'low' for the un-narrowed case.
+ *      Confidence ladder for plain calls:
+ *      - 0 matches  → `to: []`, resolution `'unknown'`,    confidence `'low'`
+ *      - 1 match    → `to: [hash]`, resolution `'static'`, confidence `'medium'`
+ *      - N matches  → `to: [allHashes]`, resolution `'method-dispatch'`,
+ *                     confidence `'low'`
+ *
+ *   Macros are emitted as edges with `resolution: 'unknown'` and
+ *   `confidence: 'low'` since macros are rarely first-party functions
+ *   in the catalog. Their value to the call-graph is letting
+ *   `no-side-effect-path` see `println!` calls; the edge text carries
+ *   the macro name for that match.
+ *
+ * Per I-4: this function does NOT mutate the input catalog.
+ */
+import type { RustParsedProject } from './parse.js';
+import type { ResolveInput, ResolveOutput } from '@opensip-cli/graph';
+export declare function resolveCallSites(input: ResolveInput<RustParsedProject>): ResolveOutput;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../src/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAaH,OAAO,KAAK,EAAkB,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpE,OAAO,KAAK,EAKV,YAAY,EACZ,aAAa,EACd,MAAM,oBAAoB,CAAC;AAyB5B,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,CAAC,iBAAiB,CAAC,GAAG,aAAa,CAwCtF"}

package/dist/resolve.js

@@ -0,0 +1,262 @@
+/**
+ * Rust resolveCallSites — name-based catalog lookup with `impl`-block
+ * receiver-type context.
+ *
+ * Tree-sitter has no symbol table; we resolve by simple name. For
+ * each call site:
+ *
+ *   1. Decode the called expression. Five shapes matter:
+ *      - `foo(args)`              — call target is `foo`.
+ *      - `obj.method(args)`       — field_expression call target is
+ *                                   the trailing `field_identifier`.
+ *      - `Type::method(args)`     — scoped_identifier; target is the
+ *                                   trailing identifier.
+ *      - `path::to::fn(args)`     — same scoped_identifier shape.
+ *      - `name!(args)`            — macro_invocation target is the
+ *                                   leading identifier.
+ *
+ *   2. Look up matching catalog entries. For method calls
+ *      (`obj.method`), we narrow by `enclosingClass` if the receiver
+ *      type is statically known (literal, simple-typed local). The
+ *      narrow is best-effort, NOT type-aware — we don't track types
+ *      across statements. With the narrow:
+ *      - 1 method match in the receiver's impl  → 'high' confidence
+ *        ... actually no — even with narrowing, tree-sitter never
+ *        produces 'high' for ordinary calls, because the receiver
+ *        type itself is name-based. We use 'medium' for the
+ *        narrowed case and 'low' for the un-narrowed case.
+ *      Confidence ladder for plain calls:
+ *      - 0 matches  → `to: []`, resolution `'unknown'`,    confidence `'low'`
+ *      - 1 match    → `to: [hash]`, resolution `'static'`, confidence `'medium'`
+ *      - N matches  → `to: [allHashes]`, resolution `'method-dispatch'`,
+ *                     confidence `'low'`
+ *
+ *   Macros are emitted as edges with `resolution: 'unknown'` and
+ *   `confidence: 'low'` since macros are rarely first-party functions
+ *   in the catalog. Their value to the call-graph is letting
+ *   `no-side-effect-path` see `println!` calls; the edge text carries
+ *   the macro name for that match.
+ *
+ * Per I-4: this function does NOT mutate the input catalog.
+ */
+import { logger } from '@opensip-cli/core';
+import { appendEdge, createMutableStats, pushCreationEdge, truncateForCallEdge, } from '@opensip-cli/graph';
+import { isReturnValueDiscarded } from '@opensip-cli/graph-adapter-common';
+import { resolveDependencies } from './resolve-dependencies.js';
+function rustPosition(node, file) {
+    return {
+        line: node.startPosition.row + 1,
+        column: node.startPosition.column,
+        text: file.source.slice(node.startIndex, node.endIndex),
+    };
+}
+export function resolveCallSites(input) {
+    logger.info({ evt: 'graph.edges.start', module: 'graph:edges:rust' });
+    const index = buildIndex(input.catalog.functions);
+    const edgesByOwner = new Map();
+    const stats = createMutableStats();
+    const sink = { edgesByOwner, stats };
+    for (const r of input.callSites) {
+        const node = r.nodeRef;
+        const file = r.sourceFileRef;
+        if (r.kind === 'creation') {
+            if (r.childHash === undefined)
+                continue;
+            pushCreationEdge(rustPosition(node, file), r.ownerHash, r.childHash, sink);
+            continue;
+        }
+        pushCallEdge(node, file, r.ownerHash, index, sink);
+    }
+    const finalStats = {
+        totalCallSites: stats.totalCallSites,
+        resolvedHigh: stats.resolvedHigh,
+        resolvedMedium: stats.resolvedMedium,
+        resolvedLow: stats.resolvedLow,
+        unresolved: stats.unresolved,
+    };
+    logger.info({ evt: 'graph.edges.complete', module: 'graph:edges:rust', ...finalStats });
+    // Phase 4 (DEC-498): resolve dependency sites if any. Mirrors the
+    // Python adapter's relative-import handling, adapted to Rust's
+    // `crate::` / `super::` / `self::` path prefixes and Cargo's
+    // `src/lib.rs` / `src/main.rs` / `src/foo.rs` / `src/foo/mod.rs`
+    // module layout conventions.
+    const dependenciesByOwner = input.dependencySites && input.dependencySites.length > 0
+        ? resolveDependencies(input.dependencySites, input.catalog, input.projectDirAbs)
+        : undefined;
+    return dependenciesByOwner === undefined
+        ? { edgesByOwner, stats: finalStats }
+        : { edgesByOwner, dependenciesByOwner, stats: finalStats };
+}
+function buildIndex(functions) {
+    const all = new Map();
+    const methods = new Map();
+    for (const [name, occs] of Object.entries(functions)) {
+        if (!occs)
+            continue;
+        if (name.startsWith('<'))
+            continue;
+        const list = all.get(name) ?? [];
+        for (const o of occs) {
+            list.push(o);
+            if (o.enclosingClass !== null) {
+                const key = `${o.enclosingClass}::${o.simpleName}`;
+                const ml = methods.get(key) ?? [];
+                ml.push(o);
+                methods.set(key, ml);
+            }
+        }
+        all.set(name, list);
+    }
+    return { all, methods };
+}
+function pushCallEdge(node, file, ownerHash, index, sink) {
+    const { edgesByOwner, stats } = sink;
+    stats.totalCallSites++;
+    const target = decodeCallTarget(node);
+    const pos = rustPosition(node, file);
+    const truncated = truncateForCallEdge(pos.text);
+    const discarded = isReturnValueDiscarded(node);
+    const edge = resolveTarget(target, index, {
+        line: pos.line,
+        column: pos.column,
+        text: truncated,
+        discarded,
+    });
+    stats.apply(edge);
+    appendEdge(edgesByOwner, ownerHash, edge);
+}
+function decodeCallTarget(node) {
+    if (node.type === 'macro_invocation') {
+        const m = node.childForFieldName('macro') ?? node.namedChild(0);
+        if (!m)
+            return null;
+        return { name: m.text.split('::').pop() ?? m.text, receiverType: null, isMacro: true };
+    }
+    if (node.type !== 'call_expression')
+        return null;
+    const fn = node.childForFieldName('function');
+    if (!fn)
+        return null;
+    if (fn.type === 'identifier') {
+        return { name: fn.text, receiverType: null, isMacro: false };
+    }
+    if (fn.type === 'field_expression') {
+        const field = fn.childForFieldName('field');
+        if (!field)
+            return null;
+        return { name: field.text, receiverType: null, isMacro: false };
+    }
+    if (fn.type === 'scoped_identifier') {
+        const name = fn.childForFieldName('name') ?? fn.namedChild(fn.namedChildCount - 1);
+        if (!name)
+            return null;
+        const path = fn.childForFieldName('path');
+        const receiver = decodeReceiverPath(path);
+        return { name: name.text, receiverType: receiver, isMacro: false };
+    }
+    return null;
+}
+function decodeReceiverPath(path) {
+    if (!path)
+        return null;
+    // For `Type::name`, path is a `type_identifier` or `identifier`.
+    // For `mod::Type::name`, path is a `scoped_identifier` whose own
+    // trailing component is the type. We walk down the path looking for
+    // the last `type_identifier` / `identifier`.
+    if (path.type === 'type_identifier' || path.type === 'identifier')
+        return path.text;
+    if (path.type === 'scoped_identifier') {
+        const inner = path.childForFieldName('name') ?? path.namedChild(path.namedChildCount - 1);
+        return inner ? inner.text : null;
+    }
+    return null;
+}
+function resolveTarget(target, index, loc) {
+    if (target === null) {
+        return {
+            to: [],
+            line: loc.line,
+            column: loc.column,
+            resolution: 'unknown',
+            confidence: 'low',
+            text: loc.text,
+            discarded: loc.discarded,
+        };
+    }
+    // Macros: tag the edge for side-effect detection but mark unresolved.
+    // The edge text carries `name!` so rules can match against the
+    // primitive list (e.g. `println!`).
+    if (target.isMacro) {
+        return {
+            to: [],
+            line: loc.line,
+            column: loc.column,
+            resolution: 'unknown',
+            confidence: 'low',
+            text: `${target.name}! ${loc.text}`,
+            discarded: loc.discarded,
+        };
+    }
+    // Receiver-narrowed lookup if we have a Type::method shape.
+    if (target.receiverType !== null) {
+        const narrowed = index.methods.get(`${target.receiverType}::${target.name}`);
+        if (narrowed && narrowed.length > 0) {
+            const hashes = narrowed.map((o) => o.bodyHash);
+            return {
+                to: hashes,
+                line: loc.line,
+                column: loc.column,
+                resolution: hashes.length === 1 ? 'static' : 'method-dispatch',
+                confidence: 'medium',
+                text: loc.text,
+                discarded: loc.discarded,
+            };
+        }
+        // Receiver was named but no method — fall through to broad name lookup.
+    }
+    const matches = index.all.get(target.name);
+    if (!matches || matches.length === 0) {
+        return {
+            to: [],
+            line: loc.line,
+            column: loc.column,
+            resolution: 'unknown',
+            confidence: 'low',
+            text: loc.text,
+            discarded: loc.discarded,
+        };
+    }
+    if (matches.length === 1) {
+        const only = matches[0];
+        if (!only) {
+            return {
+                to: [],
+                line: loc.line,
+                column: loc.column,
+                resolution: 'unknown',
+                confidence: 'low',
+                text: loc.text,
+                discarded: loc.discarded,
+            };
+        }
+        return {
+            to: [only.bodyHash],
+            line: loc.line,
+            column: loc.column,
+            resolution: 'static',
+            confidence: 'medium',
+            text: loc.text,
+            discarded: loc.discarded,
+        };
+    }
+    return {
+        to: matches.map((o) => o.bodyHash),
+        line: loc.line,
+        column: loc.column,
+        resolution: 'method-dispatch',
+        confidence: 'low',
+        text: loc.text,
+        discarded: loc.discarded,
+    };
+}
+//# sourceMappingURL=resolve.js.map

package/dist/resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.js","sourceRoot":"","sources":["../src/resolve.ts"],"names":[],"mappings":"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"}

package/dist/rule-hints.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Rust rule hints — language-specific signals for rules.
+ *
+ * Lands in PR 6 of plan docs/plans/10-graph-language-pluggability.md.
+ *
+ * `isTestFile` is file-path-based here for simplicity: `tests/`
+ * directory or `*_test.rs`. Note that Rust convention also supports
+ * `#[test]`-annotated functions in any file (commonly inside
+ * `#[cfg(test)] mod tests { … }`); the walk pass tags those
+ * occurrences' `inTestFile` flag as true based on the attribute, so
+ * `test-only-reachable` still works for them. The hint here is the
+ * file-level fallback for rules that consult the predicate directly.
+ */
+import type { RuleHints } from '@opensip-cli/graph';
+export declare const rustRuleHints: RuleHints;
+//# sourceMappingURL=rule-hints.d.ts.map

package/dist/rule-hints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-hints.d.ts","sourceRoot":"","sources":["../src/rule-hints.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAkCpD,eAAO,MAAM,aAAa,EAAE,SAK3B,CAAC"}

package/dist/rule-hints.js

@@ -0,0 +1,50 @@
+/**
+ * Rust rule hints — language-specific signals for rules.
+ *
+ * Lands in PR 6 of plan docs/plans/10-graph-language-pluggability.md.
+ *
+ * `isTestFile` is file-path-based here for simplicity: `tests/`
+ * directory or `*_test.rs`. Note that Rust convention also supports
+ * `#[test]`-annotated functions in any file (commonly inside
+ * `#[cfg(test)] mod tests { … }`); the walk pass tags those
+ * occurrences' `inTestFile` flag as true based on the attribute, so
+ * `test-only-reachable` still works for them. The hint here is the
+ * file-level fallback for rules that consult the predicate directly.
+ */
+import { isTestFile } from './walk.js';
+const RUST_SIDE_EFFECT_PRIMITIVES = [
+    'println!',
+    'eprintln!',
+    'print!',
+    'eprint!',
+    'std::fs::read',
+    'std::fs::write',
+    'std::fs::remove_file',
+    'std::fs::remove_dir',
+    'std::fs::create_dir',
+    'std::io::stdin',
+    'std::io::stdout',
+    'std::io::stderr',
+    'std::process::exit',
+    'std::process::abort',
+    'std::env::set_var',
+    'std::env::remove_var',
+    'std::thread::sleep',
+    'rand::random',
+];
+// `raise` doesn't exist in Rust; the closest analogues are `panic!`,
+// `return Err(...)`, and `?` — but only `panic!` is structural. Use
+// the `panic!` macro shape.
+const RUST_THROW_REGEX = /\bpanic!\s*\(/;
+const RUST_GENERATED_FILE_PATTERNS = [
+    '**/target/**',
+    '**/build/**',
+    '**/*.generated.rs',
+];
+export const rustRuleHints = {
+    isTestFile,
+    generatedFilePatterns: RUST_GENERATED_FILE_PATTERNS,
+    sideEffectPrimitives: RUST_SIDE_EFFECT_PRIMITIVES,
+    throwSyntaxRegex: RUST_THROW_REGEX,
+};
+//# sourceMappingURL=rule-hints.js.map