@rigour-labs/core 5.0.1 → 5.1.0

package/dist/gates/{side-effect-helpers.js → side-effect-helpers/pattern-detection.js}

@@ -1,456 +1,4 @@
-/**
- * Side-Effect Analysis Helpers
- *
- * Context-aware utilities for smart side-effect detection.
- * Follows the same architectural patterns as promise-safety-helpers.ts:
- *   - Scope-aware analysis (brace/indent tracking)
- *   - Variable binding tracking (pair resource creation with cleanup)
- *   - Framework detection (React useEffect, Go defer, Python with, etc.)
- *   - Path overlap analysis (circular file watcher detection)
- *
- * These helpers make side-effect detection SMART — instead of asking
- * "does clearInterval exist anywhere in the file?", we ask
- * "is the specific timer variable cleaned up in the right scope?"
- *
- * @since v4.3.0
- */
-// ── Language detection ──
-export const LANG_MAP = {
-    '.ts': 'ts', '.tsx': 'ts', '.mts': 'ts',
-    '.js': 'js', '.jsx': 'js', '.mjs': 'js', '.cjs': 'js',
-    '.py': 'py',
-    '.go': 'go',
-    '.rs': 'rs',
-    '.cs': 'cs',
-    '.java': 'java',
-    '.rb': 'rb',
-};
-export const FILE_GLOBS = [
-    '**/*.{ts,tsx,mts,js,jsx,mjs,cjs}',
-    '**/*.py',
-    '**/*.go',
-    '**/*.rs',
-    '**/*.cs',
-    '**/*.java',
-    '**/*.rb',
-];
-// ── Strip string contents to avoid false positives in regex matching ──
-export function stripStrings(line) {
-    return line
-        .replace(/`[^`]*`/g, '""')
-        .replace(/"(?:[^"\\]|\\.)*"/g, '""')
-        .replace(/'(?:[^'\\]|\\.)*'/g, '""');
-}
-// ═══════════════════════════════════════════════════════════════════
-// SCOPE ANALYSIS — Find function/block boundaries
-// ═══════════════════════════════════════════════════════════════════
-/**
- * Find the enclosing function scope for a given line.
- * Returns { start, end } of the function body.
- * For module-level code, returns { start: 0, end: lines.length }.
- *
- * Follows promise-safety's approach of backward scanning with brace tracking.
- */
-export function findEnclosingFunction(lines, lineIdx, lang) {
-    if (lang === 'py')
-        return findEnclosingFunctionPython(lines, lineIdx);
-    if (lang === 'rb')
-        return findEnclosingFunctionRuby(lines, lineIdx);
-    return findEnclosingFunctionBrace(lines, lineIdx, lang);
-}
-function findEnclosingFunctionBrace(lines, lineIdx, lang) {
-    // Walk backwards tracking brace depth to find function definition
-    let braceDepth = 0;
-    const funcPatterns = getFunctionPatterns(lang);
-    for (let j = lineIdx; j >= Math.max(0, lineIdx - 200); j--) {
-        const stripped = stripStrings(lines[j]);
-        // Count braces (reverse direction: } increases, { decreases)
-        for (const ch of stripped) {
-            if (ch === '}')
-                braceDepth++;
-            if (ch === '{')
-                braceDepth--;
-        }
-        // If braceDepth < 0, we've exited the enclosing block going backwards
-        if (braceDepth < 0) {
-            // Check if this line is a function definition
-            for (const pat of funcPatterns) {
-                if (pat.test(stripped)) {
-                    const end = findBlockEndBrace(lines, j);
-                    return { start: j, end };
-                }
-            }
-            // It's some other block (if/for/etc), keep looking
-            braceDepth = 0;
-        }
-    }
-    // Module level
-    return { start: 0, end: lines.length };
-}
-function findEnclosingFunctionPython(lines, lineIdx) {
-    const lineIndent = lines[lineIdx].length - lines[lineIdx].trimStart().length;
-    for (let j = lineIdx - 1; j >= 0; j--) {
-        const trimmed = lines[j].trim();
-        if (trimmed === '' || trimmed.startsWith('#'))
-            continue;
-        const indent = lines[j].length - lines[j].trimStart().length;
-        if (indent < lineIndent && /^\s*(?:async\s+)?def\s+\w+/.test(lines[j])) {
-            const end = findBlockEndIndent(lines, j);
-            return { start: j, end };
-        }
-        if (indent === 0 && /^\s*(?:class|def|async\s+def)\s/.test(lines[j])) {
-            const end = findBlockEndIndent(lines, j);
-            return { start: j, end };
-        }
-    }
-    return { start: 0, end: lines.length };
-}
-function findEnclosingFunctionRuby(lines, lineIdx) {
-    for (let j = lineIdx - 1; j >= Math.max(0, lineIdx - 100); j--) {
-        const trimmed = lines[j].trim();
-        if (/^def\s+\w+/.test(trimmed)) {
-            const end = findBlockEndRuby(lines, j);
-            return { start: j, end };
-        }
-    }
-    return { start: 0, end: lines.length };
-}
-/**
- * Find the end of a brace-delimited block starting at `start`.
- */
-export function findBlockEndBrace(lines, start) {
-    let braces = 0;
-    let started = false;
-    const maxScan = Math.min(lines.length, start + 300);
-    for (let j = start; j < maxScan; j++) {
-        const stripped = stripStrings(lines[j]);
-        for (const ch of stripped) {
-            if (ch === '{') {
-                braces++;
-                started = true;
-            }
-            if (ch === '}')
-                braces--;
-        }
-        if (started && braces <= 0)
-            return j + 1;
-    }
-    return maxScan;
-}
-/**
- * Find the end of an indentation-delimited block (Python).
- */
-export function findBlockEndIndent(lines, start) {
-    const baseIndent = lines[start].length - lines[start].trimStart().length;
-    const maxScan = Math.min(lines.length, start + 300);
-    for (let j = start + 1; j < maxScan; j++) {
-        const trimmed = lines[j].trim();
-        if (trimmed === '' || trimmed.startsWith('#'))
-            continue;
-        const indent = lines[j].length - lines[j].trimStart().length;
-        if (indent <= baseIndent)
-            return j;
-    }
-    return maxScan;
-}
-function findBlockEndRuby(lines, start) {
-    let depth = 0;
-    const maxScan = Math.min(lines.length, start + 300);
-    const openers = /\b(?:def|do|class|module|if|unless|while|until|for|begin|case)\b/;
-    for (let j = start; j < maxScan; j++) {
-        const trimmed = lines[j].trim();
-        if (openers.test(trimmed))
-            depth++;
-        if (/^\s*end\b/.test(trimmed)) {
-            depth--;
-            if (depth <= 0)
-                return j + 1;
-        }
-    }
-    return maxScan;
-}
-function getFunctionPatterns(lang) {
-    switch (lang) {
-        case 'go':
-            return [/\bfunc\s+/];
-        case 'rs':
-            return [/\bfn\s+\w+/];
-        case 'java':
-        case 'cs':
-            return [/(?:public|private|protected|static|async|void|int|string|Task|var)\s+\w+\s*\(/];
-        default: // js, ts
-            return [
-                /(?:export\s+)?(?:async\s+)?function\s+\w+/,
-                /(?:const|let|var)\s+\w+\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
-                /\w+\s*\([^)]*\)\s*\{/, // method shorthand
-            ];
-    }
-}
-// ═══════════════════════════════════════════════════════════════════
-// VARIABLE BINDING — Track resource creation → cleanup pairs
-// ═══════════════════════════════════════════════════════════════════
-/**
- * Extract the variable name from an assignment.
- * "const timer = setInterval(...)"  → "timer"
- * "let fd = fs.open(...)"           → "fd"
- * "self.watcher = chokidar.watch()" → "self.watcher"
- * "timer := time.NewTicker(...)"    → "timer" (Go)
- *
- * Returns null if the call result is NOT stored in a variable.
- */
-export function extractVariableBinding(line, lang) {
-    const stripped = stripStrings(line).trim();
-    if (lang === 'go') {
-        // Go: `ticker := time.NewTicker(...)` or `ticker, _ := ...`
-        const goMatch = stripped.match(/^(\w+)(?:\s*,\s*\w+)*\s*:?=\s*/);
-        if (goMatch)
-            return goMatch[1];
-        return null;
-    }
-    if (lang === 'py') {
-        // Python: `timer = threading.Timer(...)` or `self.timer = ...`
-        const pyMatch = stripped.match(/^((?:self\.)?[\w.]+)\s*=\s*(?!==)/);
-        if (pyMatch)
-            return pyMatch[1];
-        return null;
-    }
-    if (lang === 'rb') {
-        // Ruby: `@watcher = Listen.to(...)` or `watcher = ...`
-        const rbMatch = stripped.match(/^(@?\w+)\s*=\s*/);
-        if (rbMatch)
-            return rbMatch[1];
-        return null;
-    }
-    // JS/TS/Java/C#/Rust: `const x = ...`, `let x = ...`, `var x = ...`, `auto x = ...`
-    const jsMatch = stripped.match(/^(?:const|let|var|final|auto|val)\s+(\w+)\s*=\s*/);
-    if (jsMatch)
-        return jsMatch[1];
-    // Member assignment: `this.timer = ...`, `self.timer = ...`
-    const memberMatch = stripped.match(/^(?:this|self)\.([\w]+)\s*=\s*/);
-    if (memberMatch)
-        return memberMatch[1];
-    // Simple assignment: `timer = ...`
-    const simpleMatch = stripped.match(/^(\w+)\s*=\s*(?!==)/);
-    if (simpleMatch) {
-        // Exclude control flow keywords
-        const name = simpleMatch[1];
-        if (['if', 'for', 'while', 'switch', 'return', 'throw'].includes(name))
-            return null;
-        return name;
-    }
-    return null;
-}
-/**
- * Check if a specific variable is used in a cleanup call within a scope.
- *
- * Unlike the naive "does clearInterval exist in the file?", this checks:
- * 1. The cleanup function references the specific variable
- * 2. The cleanup is within the correct scope (same function or cleanup callback)
- *
- * Example: for variable "timer" and cleanup patterns [/clearInterval/],
- * matches: `clearInterval(timer)`, `clearInterval(this.timer)`, `timer.close()`
- */
-export function hasCleanupForVariable(lines, varName, scopeStart, scopeEnd, cleanupPatterns, lang) {
-    const scope = lines.slice(scopeStart, scopeEnd);
-    for (let i = 0; i < scope.length; i++) {
-        const stripped = stripStrings(scope[i]);
-        // Check cleanup patterns that reference the specific variable
-        for (const pat of cleanupPatterns) {
-            if (!pat.test(stripped))
-                continue;
-            // The cleanup call should reference our variable
-            const escapedVar = varName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            const varRef = new RegExp(`\\b${escapedVar}\\b`);
-            if (varRef.test(stripped))
-                return true;
-            // Also check method calls on the variable: timer.close(), timer.stop()
-            // The pattern might match a generic .close() — check if it's on our var
-        }
-        // Direct method cleanup on the variable: varName.close(), varName.Stop()
-        const escapedVar = varName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const methodCleanup = new RegExp(`\\b${escapedVar}\\.(?:close|stop|destroy|kill|terminate|dispose|cancel|shutdown|unsubscribe|disconnect|end|release|Clear|Stop|Dispose|Close|Cancel)\\s*\\(`);
-        if (methodCleanup.test(stripped))
-            return true;
-    }
-    return false;
-}
-/**
- * Check if a line is inside a cleanup/teardown context.
- *
- * Cleanup contexts where resource cleanup is expected:
- * - JS/TS: useEffect return function, componentWillUnmount, beforeDestroy, ngOnDestroy, dispose()
- * - Python: __del__, __exit__, close(), cleanup(), teardown
- * - Go: defer statement
- * - Java: finally block, close() method, @PreDestroy
- * - C#: Dispose(), using block, finalizer
- * - Ruby: ensure block, at_exit
- */
-export function isInsideCleanupContext(lines, lineIdx, lang) {
-    // Scan backwards up to 30 lines for cleanup context markers
-    for (let j = lineIdx; j >= Math.max(0, lineIdx - 30); j--) {
-        const trimmed = lines[j].trim();
-        switch (lang) {
-            case 'js':
-            case 'ts':
-                // React useEffect cleanup: `return () => { cleanup }`
-                if (/\breturn\s+(?:\(\)\s*=>|function\s*\()/.test(trimmed))
-                    return true;
-                // Lifecycle: componentWillUnmount, ngOnDestroy, beforeDestroy
-                if (/\b(?:componentWillUnmount|ngOnDestroy|beforeDestroy|dispose)\s*\(/.test(trimmed))
-                    return true;
-                // Event: 'beforeunload', 'unload'
-                if (/['"](?:beforeunload|unload)['"]\s*,/.test(trimmed))
-                    return true;
-                break;
-            case 'py':
-                if (/\bdef\s+(?:__del__|__exit__|close|cleanup|teardown|dispose)\s*\(/.test(trimmed))
-                    return true;
-                if (/\bfinally\s*:/.test(trimmed))
-                    return true;
-                break;
-            case 'go':
-                if (/\bdefer\b/.test(trimmed))
-                    return true;
-                break;
-            case 'java':
-                if (/\bfinally\s*\{/.test(trimmed))
-                    return true;
-                if (/\b(?:close|destroy|cleanup|dispose)\s*\(/.test(trimmed))
-                    return true;
-                if (/@PreDestroy/.test(trimmed))
-                    return true;
-                break;
-            case 'cs':
-                if (/\bDispose\s*\(/.test(trimmed))
-                    return true;
-                if (/\busing\s*\(/.test(trimmed))
-                    return true;
-                if (/~\w+\s*\(/.test(trimmed))
-                    return true; // finalizer
-                break;
-            case 'rb':
-                if (/\bensure\b/.test(trimmed))
-                    return true;
-                break;
-            case 'rs':
-                if (/\bimpl\s+Drop\b/.test(trimmed))
-                    return true;
-                break;
-        }
-        // Stop at function boundaries
-        if (isFunctionBoundary(trimmed, lang))
-            break;
-    }
-    return false;
-}
-// ═══════════════════════════════════════════════════════════════════
-// FRAMEWORK-AWARE PATTERNS — Detect safe idioms per ecosystem
-// ═══════════════════════════════════════════════════════════════════
-/**
- * Check if a timer/resource creation is inside a React useEffect
- * that returns a cleanup function.
- *
- * Pattern:
- *   useEffect(() => {
- *     const timer = setInterval(...)  ← creation
- *     return () => clearInterval(timer)  ← cleanup
- *   }, [deps])
- */
-export function isInUseEffectWithCleanup(lines, lineIdx) {
-    // Walk backwards to find useEffect
-    let braceDepth = 0;
-    for (let j = lineIdx; j >= Math.max(0, lineIdx - 30); j--) {
-        const stripped = stripStrings(lines[j]);
-        for (const ch of stripped) {
-            if (ch === '}')
-                braceDepth++;
-            if (ch === '{')
-                braceDepth--;
-        }
-        if (/\buseEffect\s*\(/.test(stripped) && braceDepth <= 0) {
-            // Found enclosing useEffect — now check if it has a return () => ...
-            const effectEnd = findBlockEndBrace(lines, j);
-            const effectBody = lines.slice(j, effectEnd).join('\n');
-            // Look for cleanup return: `return () =>` or `return function`
-            if (/\breturn\s+(?:\(\)\s*=>|function\s*\()/.test(effectBody)) {
-                return true;
-            }
-            return false;
-        }
-    }
-    return false;
-}
-/**
- * Check if a Go resource open is immediately followed by defer close.
- *
- * Idiomatic Go:
- *   f, err := os.Open(path)
- *   if err != nil { return err }
- *   defer f.Close()
- */
-export function hasGoDefer(lines, openLine, varName) {
-    // Check lines between open and open+5 for defer using the variable
-    const escaped = varName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const deferPat = new RegExp(`\\bdefer\\s+${escaped}\\.`);
-    for (let j = openLine + 1; j < Math.min(lines.length, openLine + 6); j++) {
-        if (deferPat.test(lines[j]))
-            return true;
-        // Also match: defer func() { varName.Close() }()
-        if (/\bdefer\s+func\s*\(\)/.test(lines[j])) {
-            const endDefer = findBlockEndBrace(lines, j);
-            const body = lines.slice(j, endDefer).join('\n');
-            if (new RegExp(`\\b${escaped}\\.`).test(body))
-                return true;
-        }
-    }
-    return false;
-}
-/**
- * Check if a Python open() is inside a `with` statement (context manager).
- */
-export function isPythonWithStatement(line) {
-    return /\bwith\s+/.test(stripStrings(line));
-}
-/**
- * Check if a Java resource open is inside try-with-resources.
- * Pattern: try (var x = new FileStream(...)) { ... }
- */
-export function isJavaTryWithResources(lines, lineIdx) {
-    for (let j = lineIdx; j >= Math.max(0, lineIdx - 3); j--) {
-        if (/\btry\s*\(/.test(stripStrings(lines[j])))
-            return true;
-    }
-    return false;
-}
-/**
- * Check if a C# resource is inside a using statement/declaration.
- * Patterns: `using (var x = ...)` or `using var x = ...` (C# 8+)
- */
-export function isCSharpUsing(line) {
-    const stripped = stripStrings(line);
-    return /\busing\s*\(/.test(stripped) || /\busing\s+(?:var|await)\b/.test(stripped);
-}
-/**
- * Check if a Ruby File.open uses block form (auto-closes).
- * Pattern: File.open(path) do |f| ... end
- *          File.open(path) { |f| ... }
- */
-export function isRubyBlockForm(line) {
-    return /\bdo\s*\|/.test(line) || /\{\s*\|/.test(line);
-}
-/**
- * Check if a Rust resource is automatically dropped (RAII).
- * In Rust, all resources are dropped when they go out of scope,
- * so we only flag resources in unsafe blocks or static/global context.
- */
-export function isRustAutoDropped(lines, lineIdx) {
-    // Check if inside unsafe block (manual memory management)
-    for (let j = lineIdx; j >= Math.max(0, lineIdx - 20); j--) {
-        if (/\bunsafe\s*\{/.test(lines[j]))
-            return false; // Not auto-dropped in unsafe
-    }
-    return true; // Normal Rust = RAII applies
-}
+import { stripStrings } from './types.js';
 // ═══════════════════════════════════════════════════════════════════
 // CIRCULAR TRIGGER DETECTION — Path overlap analysis
 // ═══════════════════════════════════════════════════════════════════
@@ -523,6 +71,7 @@ export function pathsOverlap(watchPath, writePath) {
 // ═══════════════════════════════════════════════════════════════════
 // LOOP & RECURSION ANALYSIS — Context-aware body extraction
 // ═══════════════════════════════════════════════════════════════════
+import { findBlockEndBrace, findBlockEndIndent } from './scope-analysis.js';
 /**
  * Extract loop body with correct scope tracking.
  * Uses brace/indent matching (not just "next N lines").
@@ -536,6 +85,22 @@ export function extractLoopBody(lines, loopLine, lang) {
     const body = lines.slice(loopLine, end).join('\n');
     return { body, start: loopLine, end };
 }
+function findBlockEndRuby(lines, start) {
+    let depth = 0;
+    const maxScan = Math.min(lines.length, start + 300);
+    const openers = /\b(?:def|do|class|module|if|unless|while|until|for|begin|case)\b/;
+    for (let j = start; j < maxScan; j++) {
+        const trimmed = lines[j].trim();
+        if (openers.test(trimmed))
+            depth++;
+        if (/^\s*end\b/.test(trimmed)) {
+            depth--;
+            if (depth <= 0)
+                return j + 1;
+        }
+    }
+    return maxScan;
+}
 /**
  * Extract all function definitions with their bodies.
  * Used for recursion detection — need to check if function calls itself
@@ -730,22 +295,8 @@ export function hasCatchWithContinue(body, lang) {
     return /\bcatch\b[\s\S]*?\bcontinue\b/.test(body);
 }
 // ═══════════════════════════════════════════════════════════════════
-// UTILITY
+// PROCESS & TIMER OPERATIONS
 // ═══════════════════════════════════════════════════════════════════
-function isFunctionBoundary(trimmed, lang) {
-    switch (lang) {
-        case 'py':
-            return /^(?:def|class|async\s+def)\s/.test(trimmed);
-        case 'go':
-            return /^func\s/.test(trimmed);
-        case 'rb':
-            return /^(?:def|class|module)\s/.test(trimmed);
-        case 'rs':
-            return /^(?:fn|impl|pub\s+fn|pub\s+async\s+fn)\s/.test(trimmed);
-        default:
-            return /^(?:export\s+)?(?:async\s+)?(?:function|class)\s/.test(trimmed);
-    }
-}
 /**
  * Check if a line contains a process spawn call.
  */
@@ -879,6 +430,9 @@ export function getProcessCleanupPatterns(lang) {
             return [];
     }
 }
+// ═══════════════════════════════════════════════════════════════════
+// LOOP PATTERNS & RESOURCE DETECTION
+// ═══════════════════════════════════════════════════════════════════
 /**
  * Check if a line contains an unbounded loop construct.
  */

package/dist/gates/side-effect-helpers/resource-tracking.d.ts

@@ -0,0 +1,80 @@
+import { SideEffectLang } from './types.js';
+/**
+ * Extract the variable name from an assignment.
+ * "const timer = setInterval(...)"  → "timer"
+ * "let fd = fs.open(...)"           → "fd"
+ * "self.watcher = chokidar.watch()" → "self.watcher"
+ * "timer := time.NewTicker(...)"    → "timer" (Go)
+ *
+ * Returns null if the call result is NOT stored in a variable.
+ */
+export declare function extractVariableBinding(line: string, lang: SideEffectLang): string | null;
+/**
+ * Check if a specific variable is used in a cleanup call within a scope.
+ *
+ * Unlike the naive "does clearInterval exist in the file?", this checks:
+ * 1. The cleanup function references the specific variable
+ * 2. The cleanup is within the correct scope (same function or cleanup callback)
+ *
+ * Example: for variable "timer" and cleanup patterns [/clearInterval/],
+ * matches: `clearInterval(timer)`, `clearInterval(this.timer)`, `timer.close()`
+ */
+export declare function hasCleanupForVariable(lines: string[], varName: string, scopeStart: number, scopeEnd: number, cleanupPatterns: RegExp[], lang: SideEffectLang): boolean;
+/**
+ * Check if a line is inside a cleanup/teardown context.
+ *
+ * Cleanup contexts where resource cleanup is expected:
+ * - JS/TS: useEffect return function, componentWillUnmount, beforeDestroy, ngOnDestroy, dispose()
+ * - Python: __del__, __exit__, close(), cleanup(), teardown
+ * - Go: defer statement
+ * - Java: finally block, close() method, @PreDestroy
+ * - C#: Dispose(), using block, finalizer
+ * - Ruby: ensure block, at_exit
+ */
+export declare function isInsideCleanupContext(lines: string[], lineIdx: number, lang: SideEffectLang): boolean;
+/**
+ * Check if a timer/resource creation is inside a React useEffect
+ * that returns a cleanup function.
+ *
+ * Pattern:
+ *   useEffect(() => {
+ *     const timer = setInterval(...)  ← creation
+ *     return () => clearInterval(timer)  ← cleanup
+ *   }, [deps])
+ */
+export declare function isInUseEffectWithCleanup(lines: string[], lineIdx: number): boolean;
+/**
+ * Check if a Go resource open is immediately followed by defer close.
+ *
+ * Idiomatic Go:
+ *   f, err := os.Open(path)
+ *   if err != nil { return err }
+ *   defer f.Close()
+ */
+export declare function hasGoDefer(lines: string[], openLine: number, varName: string): boolean;
+/**
+ * Check if a Python open() is inside a `with` statement (context manager).
+ */
+export declare function isPythonWithStatement(line: string): boolean;
+/**
+ * Check if a Java resource open is inside try-with-resources.
+ * Pattern: try (var x = new FileStream(...)) { ... }
+ */
+export declare function isJavaTryWithResources(lines: string[], lineIdx: number): boolean;
+/**
+ * Check if a C# resource is inside a using statement/declaration.
+ * Patterns: `using (var x = ...)` or `using var x = ...` (C# 8+)
+ */
+export declare function isCSharpUsing(line: string): boolean;
+/**
+ * Check if a Ruby File.open uses block form (auto-closes).
+ * Pattern: File.open(path) do |f| ... end
+ *          File.open(path) { |f| ... }
+ */
+export declare function isRubyBlockForm(line: string): boolean;
+/**
+ * Check if a Rust resource is automatically dropped (RAII).
+ * In Rust, all resources are dropped when they go out of scope,
+ * so we only flag resources in unsafe blocks or static/global context.
+ */
+export declare function isRustAutoDropped(lines: string[], lineIdx: number): boolean;