Run all enabled detectors on the given content

* Update the status bar badge based on the current state

* Update status bar

* Logs an error message both to the VS Code error notification and console * @param {string} errorMessage - The error message to display

* Gets the target directory path by combining workspace root with the target path from constants * @returns {Promise<string>} The absolute path to th

* Gets the root path of the current workspace * @returns {string} The absolute path to the workspace root * @throws {Error} If no workspace folder i

* Loads and parses a coverage report from a file * @param {vscode.Uri} filePath - URI of the coverage report file to load * @throws {Error} If t

* Disposes of the HTTP server and closes all connections * @public

* Executes a shell command * @param {string} command - The command to execute * @returns {Promise<void>} * @throws {Error} If the command execution

* Removes specified files from the filesystem * @param {string[]} files - Array of file paths to remove * @returns {Promise<void>} * @throws {Error

Add a detector to the registry

* Create a rich tooltip with clickable actions (rust-analyzer style) * Actions are directly clickable in the tooltip using command links

* Displays code coverage information in the editor * @param {CoverageReport} coverageReport - The coverage report to display * @param {vscode.Te

Check if an expression references an immutable account field through `ctx.accounts.<field>`. Returns the field name if it does.

Report lint warnings: one on the mutation site, one on the field declaration

Run lints on a workspace

* Handles the selection of a coverage file based on available files * If no files are found, shows a file picker * If one file is found, loads i

Convert to LSP Diagnostic. `workspace_root` is used to resolve relative file paths in related information.

* Clears all coverage information from the editor * @param {vscode.TestController} coverageTestController - The test controller instance

Create a default detector registry with all available detectors

* Override emit to also emit an 'any' event with the event name * This allows the coverage manager to listen for all events with a single listener

* Extracts paths of corrupted profraw files from error output * @param {string} stderr - Error output containing file corruption messages * @returns

* Searches for coverage report files in the parent directory of the target directory * @returns {Promise<vscode.Uri[]>} Array of URIs to found cove

* Get current state

* Gets the contents of a directory * @param {string} dirPath - The path to the directory * @returns {Promise<[string, vscode.FileType][]>} Array of

* Reads the list of profraw files from a list file * @param {string} profrawListPath - Path to the file containing the list of profraw files * @retu

* Sets up a listener for active editor changes to update coverage decorations * @private

* Check if nightly Rust toolchain and dylint-driver are available/configured

Check if an arithmetic operation is potentially unsafe and return appropriate message

* Displays line coverage decorations in all visible editors * @param {CoverageReport} coverageReport - The coverage report to display

* Cleans up all resources used by the coverage manager

Get files with security issues

* Handles incoming HTTP notification requests and emits appropriate events * Routes requests based on URL path and emits events for the coverage ma

* Check if dylint-driver is available

* Check if nightly is available

Check if an expression is a small literal that's unlikely to overflow This helps reduce false positives for common patterns like: - Array indexing: `

Return true if expression is the integer literal 0 (possibly wrapped).

Normalize type strings for comparison

* Re-check Rust toolchain (useful after installing nightly)

Set the workspace root directory

* Sets up dynamic coverage by setting the coverage type * to dynamic and verifying the trident tests directory * @private

* Initiates coverage visualization based on selected coverage type * Handles both static coverage from files and dynamic coverage from running fuzz

Peel common wrappers so we can reason about the "real" expression: - Parentheses: ( .. ) - References: &expr - Deref: *expr - Try: expr? (Expr::Try)

* Verifies the presence of the trident tests directory * @throws {Error} If the trident tests directory is not found

Add workspace detector libraries to the runner

Get Anchor program files

Build the registry

Build and cache a detector (without loading it)

Get the cache directory path (for external access)

Store a compiled library in the cache The filename includes the detector name and nightly version for easy identification

* Calculates the coverage level based on execution count * @param {number} count - The execution count * @returns {number} The calculated covera

* Check if dylint-driver is installed

Check if a Cargo.toml represents a dylint detector

Check a program function for missing signer

Check if a struct has a Signer field

Clean up cache directories from old extension versions

* Removes the status bars next to the file names in the sidebar * @param {vscode.TestController} coverageTestController - The test controller insta

* Clears all line coverage decorations from visible editors * @private

* Closes coverage visualization and cleans up resources * Disposes of listeners and watchers, and clears coverage display

Compile a dylint detector crate with the extension's required nightly Rust version All detectors must be compatible with REQUIRED_NIGHTLY_VERSION

* Creates a decoration for a specific code segment * @param {CoverageSegment} segment - The coverage segment * @param {CoverageFileData} coverag

* Displays coverage information in the status bars next to the file names in the sidebar * @param {CoverageReport} coverageReport - The coverage re

* Handles display final report event from the coverage server * @private

* Disposes all line coverage decorations

Extract the DefId of type T from a `Context<T>` parameter

Extract the Context<T> type from function parameters

Extract crate name from Cargo.toml content

Extract parameters from an instruction handler function and return (context_struct_name, parameters)

Extract a clean type string from a syn::Type

* Finds an available port by iteratively probing upward from the starting port * @param {number} startPort - The starting port to probe from * @

Recursively walk field access expressions to find an immutable account reference. Matches patterns like: ctx.accounts.<field> ctx.accounts.<field>.som

Find all Cargo.toml files in the workspace

Find the compiled library file (.so on Linux, .dylib on macOS, .dll on Windows)