@opensip-cli/lang-rust 0.1.0

package/dist/__tests__/substrate.test.js

@@ -0,0 +1,79 @@
+import { RunScope, runWithScopeSync } from '@opensip-cli/core';
+import { initParseCache, clearParseCache } from '@opensip-cli/core/languages/parse-cache.js';
+import { nameOf, walkNodes } from '@opensip-cli/tree-sitter';
+import { describe, expect, it } from 'vitest';
+import { findEnclosingFunction, getEnclosingFunctionName, isMethod } from '../enclosing.js';
+import { parseRust } from '../parse.js';
+import { isComment, isConditional, isFunction, isImpl, isLoop, isString, isStruct, } from '../predicates.js';
+import { getSharedTree } from '../shared-tree.js';
+const SRC = [
+    '// c',
+    'struct S { x: i32 }',
+    'impl S {',
+    '    fn m(&self) -> i32 {',
+    '        let s = "h";',
+    '        if true { return 1; }',
+    '        for _i in 0..3 {}',
+    '        2',
+    '    }',
+    '}',
+    'fn free() -> i32 { 0 }',
+    '',
+].join('\n');
+function root() {
+    const tree = parseRust(SRC, 's.rs');
+    if (!tree)
+        throw new Error('no tree');
+    return tree.tree.rootNode;
+}
+function count(pred) {
+    let n = 0;
+    walkNodes(root(), (node) => {
+        if (pred(node))
+            n++;
+    });
+    return n;
+}
+describe('rust substrate', () => {
+    it('predicates match the tree-sitter-rust node types', () => {
+        expect(count(isFunction)).toBe(2);
+        expect(count(isStruct)).toBe(1);
+        expect(count(isImpl)).toBe(1);
+        expect(count(isComment)).toBe(1);
+        expect(count(isString)).toBeGreaterThanOrEqual(1);
+        expect(count(isConditional)).toBe(1);
+        expect(count(isLoop)).toBe(1);
+    });
+    it('isMethod: a fn in an impl is true, a free fn is false', () => {
+        const seen = [];
+        walkNodes(root(), (n) => {
+            if (isFunction(n))
+                seen.push({ name: nameOf(n), method: isMethod(n) });
+        });
+        expect(seen).toContainEqual({ name: 'm', method: true });
+        expect(seen).toContainEqual({ name: 'free', method: false });
+    });
+    it('getSharedTree caches within an active parse cache', () => {
+        runWithScopeSync(new RunScope(), () => {
+            initParseCache();
+            try {
+                const a = getSharedTree('x.rs', 'fn x() {}');
+                const b = getSharedTree('x.rs', 'fn x() {}');
+                expect(a).toBe(b);
+            }
+            finally {
+                clearParseCache();
+            }
+        });
+    });
+    it('findEnclosingFunction resolves the nearest fn', () => {
+        const strings = [];
+        walkNodes(root(), (n) => {
+            if (n.type === 'string_literal')
+                strings.push(n);
+        });
+        expect(getEnclosingFunctionName(strings[0])).toBe('m');
+        expect(findEnclosingFunction(strings[0])?.type).toBe('function_item');
+    });
+});
+//# sourceMappingURL=substrate.test.js.map

package/dist/__tests__/substrate.test.js.map

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

package/dist/adapter.d.ts

@@ -0,0 +1,6 @@
+import { type RustTree } from './parse.js';
+import type { LanguageAdapter } from '@opensip-cli/core';
+export declare const rustAdapter: LanguageAdapter<RustTree>;
+/** Plugin contract — exported as the lang plugin's `adapters` array. */
+export declare const adapters: readonly [LanguageAdapter<import("@opensip-cli/tree-sitter").ParsedFile, unknown>];
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,eAAO,MAAM,WAAW,EAAE,eAAe,CAAC,QAAQ,CAOjD,CAAC;AAEF,wEAAwE;AACxE,eAAO,MAAM,QAAQ,oFAAyB,CAAC"}

package/dist/adapter.js

@@ -0,0 +1,13 @@
+import { parseRust } from './parse.js';
+import { stripComments, stripStrings } from './strip.js';
+export const rustAdapter = {
+    id: 'rust',
+    fileExtensions: ['.rs'],
+    aliases: ['rs'],
+    parse: parseRust,
+    stripStrings,
+    stripComments,
+};
+/** Plugin contract — exported as the lang plugin's `adapters` array. */
+export const adapters = [rustAdapter];
+//# sourceMappingURL=adapter.js.map

package/dist/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAiB,MAAM,YAAY,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAIzD,MAAM,CAAC,MAAM,WAAW,GAA8B;IACpD,EAAE,EAAE,MAAM;IACV,cAAc,EAAE,CAAC,KAAK,CAAC;IACvB,OAAO,EAAE,CAAC,IAAI,CAAC;IACf,KAAK,EAAE,SAAS;IAChB,YAAY;IACZ,aAAa;CACd,CAAC;AAEF,wEAAwE;AACxE,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,WAAW,CAAU,CAAC"}

package/dist/enclosing.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Composed enclosing-scope helpers for Rust (ADR-0010) — the per-language layer
+ * over the generic `findEnclosing`/`nameOf` from `@opensip-cli/tree-sitter`.
+ */
+import { type Node } from '@opensip-cli/tree-sitter';
+/** The nearest enclosing `fn` of `node`, or `null` at module scope. */
+export declare function findEnclosingFunction(node: Node): Node | null;
+/** The name of the nearest enclosing `fn`, or `null`. */
+export declare function getEnclosingFunctionName(node: Node): string | null;
+/**
+ * True when `node` is a method — a `fn` item whose nearest enclosing
+ * function-or-impl is an `impl` block. A free function (or a `fn` nested in
+ * another `fn`) is therefore not a method.
+ */
+export declare function isMethod(node: Node): boolean;
+//# sourceMappingURL=enclosing.d.ts.map

package/dist/enclosing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enclosing.d.ts","sourceRoot":"","sources":["../src/enclosing.ts"],"names":[],"mappings":"AACA;;;GAGG;AAEH,OAAO,EAAyB,KAAK,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAI5E,uEAAuE;AACvE,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAE7D;AAED,yDAAyD;AACzD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAGlE;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAI5C"}

package/dist/enclosing.js

@@ -0,0 +1,28 @@
+// @fitness-ignore-file duplicate-utility-functions -- ADR-0010: the per-language tree-sitter vocabulary intentionally shares helper names across lang-* with grammar-specific implementations; consolidating would defeat the substrate design.
+/**
+ * Composed enclosing-scope helpers for Rust (ADR-0010) — the per-language layer
+ * over the generic `findEnclosing`/`nameOf` from `@opensip-cli/tree-sitter`.
+ */
+import { findEnclosing, nameOf } from '@opensip-cli/tree-sitter';
+import { isFunction, isImpl } from './predicates.js';
+/** The nearest enclosing `fn` of `node`, or `null` at module scope. */
+export function findEnclosingFunction(node) {
+    return findEnclosing(node, isFunction);
+}
+/** The name of the nearest enclosing `fn`, or `null`. */
+export function getEnclosingFunctionName(node) {
+    const fn = findEnclosingFunction(node);
+    return fn ? nameOf(fn) : null;
+}
+/**
+ * True when `node` is a method — a `fn` item whose nearest enclosing
+ * function-or-impl is an `impl` block. A free function (or a `fn` nested in
+ * another `fn`) is therefore not a method.
+ */
+export function isMethod(node) {
+    if (!isFunction(node))
+        return false;
+    const enclosing = findEnclosing(node, (n) => isFunction(n) || isImpl(n));
+    return enclosing !== null && isImpl(enclosing);
+}
+//# sourceMappingURL=enclosing.js.map

package/dist/enclosing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enclosing.js","sourceRoot":"","sources":["../src/enclosing.ts"],"names":[],"mappings":"AAAA,gPAAgP;AAChP;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,EAAa,MAAM,0BAA0B,CAAC;AAE5E,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAErD,uEAAuE;AACvE,MAAM,UAAU,qBAAqB,CAAC,IAAU;IAC9C,OAAO,aAAa,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;AACzC,CAAC;AAED,yDAAyD;AACzD,MAAM,UAAU,wBAAwB,CAAC,IAAU;IACjD,MAAM,EAAE,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC;IACvC,OAAO,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAChC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAC,IAAU;IACjC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;QAAE,OAAO,KAAK,CAAC;IACpC,MAAM,SAAS,GAAG,aAAa,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IACzE,OAAO,SAAS,KAAK,IAAI,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC;AACjD,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { rustAdapter, adapters } from './adapter.js';
+export { parseRust, type RustTree } from './parse.js';
+export { getSharedTree } from './shared-tree.js';
+export { stripStrings, stripComments } from './strip.js';
+export { isFunction, isStruct, isImpl, isComment, isString, isConditional, isLoop, } from './predicates.js';
+export { findEnclosingFunction, getEnclosingFunctionName, isMethod } from './enclosing.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EACL,UAAU,EACV,QAAQ,EACR,MAAM,EACN,SAAS,EACT,QAAQ,EACR,aAAa,EACb,MAAM,GACP,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export { rustAdapter, adapters } from './adapter.js';
+export { parseRust } from './parse.js';
+export { getSharedTree } from './shared-tree.js';
+export { stripStrings, stripComments } from './strip.js';
+export { isFunction, isStruct, isImpl, isComment, isString, isConditional, isLoop, } from './predicates.js';
+export { findEnclosingFunction, getEnclosingFunctionName, isMethod } from './enclosing.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,SAAS,EAAiB,MAAM,YAAY,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EACL,UAAU,EACV,QAAQ,EACR,MAAM,EACN,SAAS,EACT,QAAQ,EACR,aAAa,EACb,MAAM,GACP,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/parse.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @fileoverview Rust parse — web-tree-sitter + vendored tree-sitter-rust.wasm.
+ *
+ * ADR-0010: `lang-rust` is the canonical Rust parse substrate — fitness checks
+ * parse via the adapter (`getSharedTree`) and the graph Rust adapter consumes
+ * this too. The grammar loads once at module top level (the WASM runtime is
+ * initialized by `@opensip-cli/tree-sitter`'s top-level `Parser.init()`); a
+ * single reused parser keeps `parse()` synchronous. Tree-sitter recovers from
+ * syntax errors with MISSING nodes, so a malformed file yields a partial tree
+ * (non-null) rather than throwing.
+ */
+import { type ParsedFile } from '@opensip-cli/tree-sitter';
+/** Parsed Rust source: tree-sitter parse tree plus the original source text. */
+export type RustTree = ParsedFile;
+/** Parses Rust source into a {@link RustTree}, or null when no tree is produced. */
+export declare function parseRust(content: string, _filePath: string): RustTree | null;
+//# sourceMappingURL=parse.d.ts.map

package/dist/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,EAA0C,KAAK,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAOnG,gFAAgF;AAChF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC;AAElC,oFAAoF;AACpF,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAG7E"}

package/dist/parse.js

@@ -0,0 +1,21 @@
+/**
+ * @fileoverview Rust parse — web-tree-sitter + vendored tree-sitter-rust.wasm.
+ *
+ * ADR-0010: `lang-rust` is the canonical Rust parse substrate — fitness checks
+ * parse via the adapter (`getSharedTree`) and the graph Rust adapter consumes
+ * this too. The grammar loads once at module top level (the WASM runtime is
+ * initialized by `@opensip-cli/tree-sitter`'s top-level `Parser.init()`); a
+ * single reused parser keeps `parse()` synchronous. Tree-sitter recovers from
+ * syntax errors with MISSING nodes, so a malformed file yields a partial tree
+ * (non-null) rather than throwing.
+ */
+import { fileURLToPath } from 'node:url';
+import { loadGrammar, createParser, parseToTree } from '@opensip-cli/tree-sitter';
+const grammar = await loadGrammar(fileURLToPath(new URL('../wasm/tree-sitter-rust.wasm', import.meta.url)));
+const parser = createParser(grammar);
+/** Parses Rust source into a {@link RustTree}, or null when no tree is produced. */
+export function parseRust(content, _filePath) {
+    const tree = parseToTree(parser, content);
+    return tree ? { tree, source: content } : null;
+}
+//# sourceMappingURL=parse.js.map

package/dist/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.js","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAmB,MAAM,0BAA0B,CAAC;AAEnG,MAAM,OAAO,GAAG,MAAM,WAAW,CAC/B,aAAa,CAAC,IAAI,GAAG,CAAC,+BAA+B,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CACzE,CAAC;AACF,MAAM,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;AAKrC,oFAAoF;AACpF,MAAM,UAAU,SAAS,CAAC,OAAe,EAAE,SAAiB;IAC1D,MAAM,IAAI,GAAG,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC1C,OAAO,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AACjD,CAAC"}

package/dist/predicates.d.ts

@@ -0,0 +1,24 @@
+/**
+ * v1 per-language node-kind predicates for Rust (ADR-0010). The generic
+ * traversal/position helpers live in `@opensip-cli/tree-sitter`; only the
+ * grammar-specific node `type` strings differ per language. Node types are from
+ * the tree-sitter-rust grammar. Rust has no class or try/catch — methods are
+ * `fn` items inside an `impl` block (see `isMethod` in enclosing.ts), and error
+ * handling is `Result`/`?` rather than exceptions.
+ */
+import type { Node } from '@opensip-cli/tree-sitter';
+/** A `fn` item — free functions and methods are both `function_item`. */
+export declare const isFunction: (node: Node) => boolean;
+/** A `struct` declaration. */
+export declare const isStruct: (node: Node) => boolean;
+/** An `impl` block. */
+export declare const isImpl: (node: Node) => boolean;
+/** A line comment or a block comment. */
+export declare const isComment: (node: Node) => boolean;
+/** A string literal. */
+export declare const isString: (node: Node) => boolean;
+/** An `if` expression. */
+export declare const isConditional: (node: Node) => boolean;
+/** A `for`, `while`, or `loop` expression. */
+export declare const isLoop: (node: Node) => boolean;
+//# sourceMappingURL=predicates.d.ts.map

package/dist/predicates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicates.d.ts","sourceRoot":"","sources":["../src/predicates.ts"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAErD,yEAAyE;AACzE,eAAO,MAAM,UAAU,GAAI,MAAM,IAAI,KAAG,OAAwC,CAAC;AAEjF,8BAA8B;AAC9B,eAAO,MAAM,QAAQ,GAAI,MAAM,IAAI,KAAG,OAAsC,CAAC;AAE7E,uBAAuB;AACvB,eAAO,MAAM,MAAM,GAAI,MAAM,IAAI,KAAG,OAAoC,CAAC;AAEzE,yCAAyC;AACzC,eAAO,MAAM,SAAS,GAAI,MAAM,IAAI,KAAG,OACwB,CAAC;AAEhE,wBAAwB;AACxB,eAAO,MAAM,QAAQ,GAAI,MAAM,IAAI,KAAG,OAAyC,CAAC;AAEhF,0BAA0B;AAC1B,eAAO,MAAM,aAAa,GAAI,MAAM,IAAI,KAAG,OAAwC,CAAC;AAEpF,8CAA8C;AAC9C,eAAO,MAAM,MAAM,GAAI,MAAM,IAAI,KAAG,OAGH,CAAC"}

package/dist/predicates.js

@@ -0,0 +1,26 @@
+// @fitness-ignore-file duplicate-utility-functions -- ADR-0010: the per-language tree-sitter vocabulary intentionally shares helper names across lang-* with grammar-specific implementations; consolidating would defeat the substrate design.
+/**
+ * v1 per-language node-kind predicates for Rust (ADR-0010). The generic
+ * traversal/position helpers live in `@opensip-cli/tree-sitter`; only the
+ * grammar-specific node `type` strings differ per language. Node types are from
+ * the tree-sitter-rust grammar. Rust has no class or try/catch — methods are
+ * `fn` items inside an `impl` block (see `isMethod` in enclosing.ts), and error
+ * handling is `Result`/`?` rather than exceptions.
+ */
+/** A `fn` item — free functions and methods are both `function_item`. */
+export const isFunction = (node) => node.type === 'function_item';
+/** A `struct` declaration. */
+export const isStruct = (node) => node.type === 'struct_item';
+/** An `impl` block. */
+export const isImpl = (node) => node.type === 'impl_item';
+/** A line comment or a block comment. */
+export const isComment = (node) => node.type === 'line_comment' || node.type === 'block_comment';
+/** A string literal. */
+export const isString = (node) => node.type === 'string_literal';
+/** An `if` expression. */
+export const isConditional = (node) => node.type === 'if_expression';
+/** A `for`, `while`, or `loop` expression. */
+export const isLoop = (node) => node.type === 'for_expression' ||
+    node.type === 'while_expression' ||
+    node.type === 'loop_expression';
+//# sourceMappingURL=predicates.js.map

package/dist/predicates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicates.js","sourceRoot":"","sources":["../src/predicates.ts"],"names":[],"mappings":"AAAA,gPAAgP;AAChP;;;;;;;GAOG;AAIH,yEAAyE;AACzE,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,IAAU,EAAW,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,eAAe,CAAC;AAEjF,8BAA8B;AAC9B,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,IAAU,EAAW,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,aAAa,CAAC;AAE7E,uBAAuB;AACvB,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,IAAU,EAAW,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,WAAW,CAAC;AAEzE,yCAAyC;AACzC,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,IAAU,EAAW,EAAE,CAC/C,IAAI,CAAC,IAAI,KAAK,cAAc,IAAI,IAAI,CAAC,IAAI,KAAK,eAAe,CAAC;AAEhE,wBAAwB;AACxB,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,IAAU,EAAW,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,gBAAgB,CAAC;AAEhF,0BAA0B;AAC1B,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,IAAU,EAAW,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,eAAe,CAAC;AAEpF,8CAA8C;AAC9C,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,IAAU,EAAW,EAAE,CAC5C,IAAI,CAAC,IAAI,KAAK,gBAAgB;IAC9B,IAAI,CAAC,IAAI,KAAK,kBAAkB;IAChC,IAAI,CAAC,IAAI,KAAK,iBAAiB,CAAC"}

package/dist/shared-tree.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Cached Rust parse entry point — the analog of `lang-typescript`'s
+ * `getSharedSourceFile`. Routes through `core`'s active `LanguageParseCache`
+ * so a file parsed by a fitness check and by the graph adapter in the same run
+ * is parsed once; falls back to a direct parse when no cache is active.
+ */
+import type { RustTree } from './parse.js';
+/** Returns the shared (cached) Rust parse tree for `filePath`, or null when unparseable. */
+export declare function getSharedTree(filePath: string, content: string): RustTree | null;
+//# sourceMappingURL=shared-tree.d.ts.map

package/dist/shared-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-tree.d.ts","sourceRoot":"","sources":["../src/shared-tree.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,4FAA4F;AAC5F,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAEhF"}

package/dist/shared-tree.js

@@ -0,0 +1,14 @@
+// @fitness-ignore-file duplicate-utility-functions -- ADR-0010: the per-language tree-sitter vocabulary intentionally shares helper names across lang-* with grammar-specific implementations; consolidating would defeat the substrate design.
+/**
+ * Cached Rust parse entry point — the analog of `lang-typescript`'s
+ * `getSharedSourceFile`. Routes through `core`'s active `LanguageParseCache`
+ * so a file parsed by a fitness check and by the graph adapter in the same run
+ * is parsed once; falls back to a direct parse when no cache is active.
+ */
+import { getParseTree } from '@opensip-cli/core/languages/parse-cache.js';
+import { rustAdapter } from './adapter.js';
+/** Returns the shared (cached) Rust parse tree for `filePath`, or null when unparseable. */
+export function getSharedTree(filePath, content) {
+    return getParseTree(rustAdapter, filePath, content);
+}
+//# sourceMappingURL=shared-tree.js.map

package/dist/shared-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-tree.js","sourceRoot":"","sources":["../src/shared-tree.ts"],"names":[],"mappings":"AAAA,gPAAgP;AAChP;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAE1E,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAI3C,4FAA4F;AAC5F,MAAM,UAAU,aAAa,CAAC,QAAgB,EAAE,OAAe;IAC7D,OAAO,YAAY,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;AACtD,CAAC"}

package/dist/strip.d.ts

@@ -0,0 +1,5 @@
+/** Replace string literal content with whitespace; preserves length. */
+export declare const stripStrings: (content: string) => string;
+/** Replace string literals AND comments with whitespace; preserves length. */
+export declare const stripComments: (content: string) => string;
+//# sourceMappingURL=strip.d.ts.map

package/dist/strip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip.d.ts","sourceRoot":"","sources":["../src/strip.ts"],"names":[],"mappings":"AA2KA,wEAAwE;AACxE,eAAO,MAAM,YAAY,6BAAwB,CAAC;AAClD,8EAA8E;AAC9E,eAAO,MAAM,aAAa,6BAAyB,CAAC"}

package/dist/strip.js

@@ -0,0 +1,157 @@
+// Rust string and comment stripping.
+//
+// Hand-written lexer that recognizes:
+// - Line comments (//) and nested block comments (slash-star ... star-slash)
+// - Regular strings ("...") with escape handling — Rust regular strings
+//   may span multiple lines (unlike Java/Go/C++), so we pass
+//   `allowMultiline: true` to core's shared scanner.
+// - Raw strings (r"...", r#"..."#, ..., r####"..."####)
+// - Byte strings (b"...") and byte-raw strings (br#"..."#) — note that
+//   byte-string content is treated as opaque bytes; this layer does NOT
+//   enforce the ASCII-only / valid-escape rules of `b"..."`. A future
+//   check that wants to flag invalid byte literals will have to layer
+//   that validation on top of the region scan.
+// - Char literals ('a', '\n', '\u{1234}') — preserved as-is, with the
+//   lifetime-vs-literal disambiguation done at the call site here.
+//
+// Both strip functions preserve byte length: replacement is whitespace
+// (newlines preserved) so line/column positions remain stable.
+import { makeStripper, scanBlockCommentNesting, scanLineComment, scanRegularString, } from '@opensip-cli/core';
+// eslint-disable-next-line sonarjs/cognitive-complexity -- token-state-machine: cyclomatic complexity is inherent to lexer-style scanners; splitting hurts readability
+function scan(src) {
+    const stringRegions = [];
+    const commentRegions = [];
+    const len = src.length;
+    let i = 0;
+    while (i < len) {
+        const c = src[i];
+        const next = src[i + 1];
+        // Line comment: // ... \n
+        if (c === '/' && next === '/') {
+            const start = i;
+            const lc = scanLineComment(src, i);
+            i = lc.end;
+            commentRegions.push({ start, end: i });
+            continue;
+        }
+        // Block comment: /* ... */ with nesting
+        if (c === '/' && next === '*') {
+            const start = i;
+            const bc = scanBlockCommentNesting(src, i);
+            i = bc.end;
+            commentRegions.push({ start, end: i });
+            continue;
+        }
+        // Raw string: r"..." or r#"..."# or r##"..."## (any number of #)
+        // Byte-raw string: br"..." or br#"..."#
+        if ((c === 'r' && (next === '"' || next === '#')) ||
+            (c === 'b' && src[i + 1] === 'r' && (src[i + 2] === '"' || src[i + 2] === '#'))) {
+            const prefixLen = c === 'b' ? 2 : 1; // br vs r
+            let j = i + prefixLen;
+            let hashes = 0;
+            while (j < len && src[j] === '#') {
+                hashes++;
+                j++;
+            }
+            if (j < len && src[j] === '"') {
+                const contentStart = j + 1;
+                j++;
+                // Find closing " followed by `hashes` # characters
+                while (j < len) {
+                    if (src[j] === '"') {
+                        let k = 0;
+                        while (k < hashes && src[j + 1 + k] === '#')
+                            k++;
+                        if (k === hashes) {
+                            const contentEnd = j;
+                            stringRegions.push({ start: contentStart, end: contentEnd });
+                            j += 1 + hashes;
+                            i = j;
+                            break;
+                        }
+                    }
+                    j++;
+                }
+                if (j >= len) {
+                    // Unterminated raw string — record what we have
+                    stringRegions.push({ start: contentStart, end: len });
+                    i = len;
+                }
+                continue;
+            }
+            // Not actually a raw string (e.g. `r` is just an identifier)
+            i++;
+            continue;
+        }
+        // Byte string: b"..." — Rust strings may span multiple lines.
+        if (c === 'b' && next === '"') {
+            i++;
+            const result = scanRegularString(src, i, { allowMultiline: true });
+            stringRegions.push({ start: i + 1, end: result.contentEnd });
+            i = result.next;
+            continue;
+        }
+        // Regular string: "..." — Rust strings may span multiple lines.
+        if (c === '"') {
+            const result = scanRegularString(src, i, { allowMultiline: true });
+            stringRegions.push({ start: i + 1, end: result.contentEnd });
+            i = result.next;
+            continue;
+        }
+        // Char literal: '...' — skip without recording (char literals are single chars)
+        // Use a heuristic: if we see ' followed by content that closes within ~6 chars, treat as char.
+        // Otherwise it's a lifetime annotation ('a, 'static, etc.).
+        if (c === "'") {
+            // Lifetime: 'identifier (no closing quote)
+            const after = src[i + 1];
+            if (after === undefined) {
+                i++;
+                continue;
+            }
+            // Look ahead to see if there's a closing quote within ~8 chars.
+            // (Same heuristic the previous inline scanner used.) Core's
+            // scanCharLiteral helper *does* distinguish overflow from success
+            // (overflow returns `end === start + 1`, success returns
+            // `end > start + 1`), so a migration to that helper with a
+            // `result.end === i + 1` lifetime branch is feasible. We keep
+            // this look-ahead inline because it makes the lifetime branch
+            // decision local to the lexer state machine and the explicit
+            // `escape`/`foundClose` variables are easier to follow for the
+            // Rust-specific edge cases the test suite exercises.
+            const maxScan = Math.min(i + 8, len);
+            let foundClose = -1;
+            let escape = false;
+            for (let k = i + 1; k < maxScan; k++) {
+                if (escape) {
+                    escape = false;
+                    continue;
+                }
+                if (src[k] === '\\') {
+                    escape = true;
+                    continue;
+                }
+                if (src[k] === "'") {
+                    foundClose = k;
+                    break;
+                }
+            }
+            if (foundClose >= 0) {
+                // Char literal — preserve as code (don't strip)
+                i = foundClose + 1;
+            }
+            else {
+                // Lifetime — skip the apostrophe and continue
+                i++;
+            }
+            continue;
+        }
+        i++;
+    }
+    return { stringRegions, commentRegions };
+}
+const stripper = makeStripper(scan);
+/** Replace string literal content with whitespace; preserves length. */
+export const stripStrings = stripper.stripStrings;
+/** Replace string literals AND comments with whitespace; preserves length. */
+export const stripComments = stripper.stripComments;
+//# sourceMappingURL=strip.js.map

package/dist/strip.js.map

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

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@opensip-cli/lang-rust",
+  "version": "0.1.0",
+  "license": "Apache-2.0",
+  "description": "Rust language adapter for opensip-cli",
+  "keywords": [
+    "opensip-cli",
+    "static-analysis",
+    "code-quality",
+    "parser",
+    "ast",
+    "tree-sitter",
+    "rust"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/opensip-ai/opensip-cli.git",
+    "directory": "packages/languages/lang-rust"
+  },
+  "homepage": "https://github.com/opensip-ai/opensip-cli",
+  "bugs": {
+    "url": "https://github.com/opensip-ai/opensip-cli/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "wasm",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "dependencies": {
+    "@opensip-cli/core": "0.1.0",
+    "@opensip-cli/tree-sitter": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.2",
+    "vitest": "^4.1.8"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}