backtrace_ls/

lib.rs

//! Testing Language Server - LSP for running tests and showing diagnostics.

use std::{
    collections::HashMap,
    io,
    path::{Path, PathBuf},
    process::{Output, Stdio},
};

use async_lsp::lsp_types::{
    Diagnostic, DiagnosticRelatedInformation, Location, Position, Range, Url,
};
use regex::Regex;
use serde::{Deserialize, Serialize};
use tokio::process::Command;
use tree_sitter::{Language, Point, Query, QueryCursor, Tree};

pub mod cli;
mod config;
mod error;
mod lsp;
mod runner;
pub mod text;
mod workspace;

pub use lsp::server;

// Language-specific modules
mod cpp;
mod go;
mod javascript;
mod php;
mod rust;

// Re-export config types for convenience
use config::Config;

/// If the character value is greater than the line length it defaults back to
/// the line length.
pub(crate) const MAX_CHAR_LENGTH: u32 = 10000;

// --- Utility Functions ---

/// Run a command asynchronously and capture its output.
pub(crate) async fn run_command(cmd: &mut Command) -> io::Result<Output> {
    log::debug!("Running shell command:\n{cmd:?}");
    cmd.stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .output()
        .await
}

/// Clean ANSI escape sequences from text.
#[must_use]
pub(crate) fn clean_ansi(input: &str) -> String {
    let re = Regex::new(r"\x1B\[([0-9]{1,2}(;[0-9]{1,2})*)?[m|K]").unwrap();
    re.replace_all(input, "").to_string()
}

/// Convert a file path to a file:// URI string.
/// Returns None if the path is not absolute.
#[must_use]
pub(crate) fn path_to_uri_string(path: &Path) -> Option<String> {
    if !path.is_absolute() {
        return None;
    }
    let path_str = path.to_string_lossy();
    // On Unix, paths start with /, so file:///path
    // On Windows, paths start with drive letter, so file:///C:/path
    #[cfg(windows)]
    let uri_string = format!("file:///{}", path_str.replace('\\', "/"));
    #[cfg(not(windows))]
    let uri_string = format!("file://{path_str}");
    Some(uri_string)
}

/// Convert a file path to a file:// URI.
/// Returns None if the path is not absolute.
#[must_use]
fn path_to_uri(path: &Path) -> Option<Url> {
    path_to_uri_string(path).and_then(|s| s.parse().ok())
}

/// Convert a tree-sitter Point to a Range covering the start of that line.
#[must_use]
pub(crate) const fn point_to_start_range(point: Point) -> Range {
    Range {
        start: Position {
            line: point.row as u32,
            character: point.column as u32,
        },
        end: Position {
            line: point.row as u32,
            character: MAX_CHAR_LENGTH,
        },
    }
}

/// Convert a tree-sitter Point to a Range covering the end of that line.
#[must_use]
pub(crate) const fn point_to_end_range(point: Point) -> Range {
    Range {
        start: Position {
            line: point.row as u32,
            character: 0,
        },
        end: Position {
            line: point.row as u32,
            character: point.column as u32,
        },
    }
}

/// Find the smallest function span containing a given position using a
/// tree-sitter query. The query should capture function nodes as
/// `@function.definition`.
#[must_use]
pub(crate) fn find_smallest_function_span(
    tree: &Tree,
    position: Point,
    language: &Language,
    query_str: &str,
) -> Option<Range> {
    let query = Query::new(language, query_str).ok()?;
    let mut cursor = QueryCursor::new();

    let mut best_match: Option<Range> = None;
    let mut best_size = usize::MAX;

    for m in cursor.matches(&query, tree.root_node(), &[] as &[u8]) {
        for capture in m.captures {
            let node = capture.node;
            let start = node.start_position();
            let end = node.end_position();

            if point_within_range(position, start, end) {
                let size = node.byte_range().len();
                if size < best_size {
                    best_size = size;
                    best_match = Some(Range {
                        start: Position {
                            line: start.row as u32,
                            character: start.column as u32,
                        },
                        end: Position {
                            line: end.row as u32,
                            character: end.column as u32,
                        },
                    });
                }
            }
        }
    }

    best_match
}

/// Check if a position is within a range defined by start and end points.
const fn point_within_range(position: Point, start: Point, end: Point) -> bool {
    if position.row < start.row || position.row > end.row {
        return false;
    }
    if position.row == start.row && position.column < start.column {
        return false;
    }
    if position.row == end.row && position.column > end.column {
        return false;
    }
    true
}

// --- Core Types ---

/// A single test item discovered in a file.
#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Clone)]
pub(crate) struct TestItem {
    pub(crate) id: String,
    pub(crate) name: String,
    pub(crate) path: PathBuf,
    pub(crate) start_position: Range,
    pub(crate) end_position: Range,
}

/// A location in a source file (path + range).
#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Clone)]
pub(crate) struct SourceSpan {
    pub(crate) path: PathBuf,
    pub(crate) range: Range,
}

/// A backtrace frame with function name and location.
#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Clone)]
pub(crate) struct BacktraceFrame {
    pub(crate) function_name: String,
    pub(crate) path: PathBuf,
    pub(crate) range: Range,
    /// The enclosing function span (if found via tree-sitter)
    pub(crate) function_span: Option<Range>,
}

/// Test function context: location and name.
#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Clone)]
pub(crate) struct FailureContext {
    /// The test function definition location
    pub(crate) span: SourceSpan,
    /// Short name for context (e.g., for Rust test, the test function name that
    /// failed `test_add_fails`)
    pub(crate) name: String,
}

/// User-facing failure: assertion/panic location with message.
#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Clone)]
pub(crate) struct UserFacingFailure {
    /// The assertion/panic location
    pub(crate) span: SourceSpan,
    /// The failure message (assertion text or panic message)
    pub(crate) message: String,
    /// The enclosing function span (if found via tree-sitter)
    pub(crate) function_span: Option<Range>,
}

/// A single test failure with its diagnostic spans.
#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Clone)]
pub(crate) struct TestFailure {
    /// The assertion/panic or most important user facing error (ERROR severity)
    pub(crate) user_facing_failure: Option<UserFacingFailure>,
    /// The context surrounding the user error (WARNING severity)
    pub(crate) context: Option<FailureContext>,
    /// Backtrace frames in user code (INFO severity)
    pub(crate) stack_frames: Vec<BacktraceFrame>,
    /// Diagnostic source (e.g., "cargo-test", "jest")
    pub(crate) runner_id: String,
    /// Type of failure (e.g., "unit-test-failed")
    pub(crate) failure_type_code: String,
    /// Human-readable context type (e.g., "test", "test method", "describe
    /// block")
    pub(crate) context_kind: String,
}

impl TestFailure {
    /// Primary span used for cache invalidation (assertion or context
    /// location).
    #[must_use]
    pub(crate) fn primary_span(&self) -> Option<&SourceSpan> {
        self.user_facing_failure
            .as_ref()
            .map(|f| &f.span)
            .or_else(|| self.context.as_ref().map(|c| &c.span))
    }

    /// Generate a unique ID for this failure based on test name and assertion
    /// location.
    #[must_use]
    pub(crate) fn failure_id(&self) -> String {
        let location = self
            .primary_span()
            .map(|s| format!("{}:{}", s.path.display(), s.range.start.line))
            .unwrap_or_default();
        let name = self.context.as_ref().map_or("unknown", |c| c.name.as_str());
        format!("{name}@{location}")
    }

    /// Get all navigation spans in order: assertion, backtrace frames, test
    /// function.
    #[must_use]
    pub(crate) fn all_spans(&self) -> Vec<SourceSpan> {
        let mut spans = Vec::new();
        if let Some(failure) = &self.user_facing_failure {
            spans.push(failure.span.clone());
        }
        spans.extend(self.stack_frames.iter().map(|frame| SourceSpan {
            path: frame.path.clone(),
            range: frame.range,
        }));
        if let Some(ctx) = &self.context {
            spans.push(ctx.span.clone());
        }
        spans
    }
}

impl TestFailure {
    /// Convert to LSP diagnostics grouped by file path.
    /// Each diagnostic includes related information linking to other spans in
    /// this failure.
    ///
    /// When `show_surrounding_function` is true, additional HINT diagnostics
    /// are emitted to highlight the surrounding function body.
    #[must_use]
    #[allow(clippy::too_many_lines)]
    fn to_diagnostics(&self, show_surrounding_function: bool) -> Vec<(PathBuf, Diagnostic)> {
        use async_lsp::lsp_types::{DiagnosticSeverity, NumberOrString};

        let failure_id = self.failure_id();
        let mut result = Vec::new();

        // Build related information for all spans
        let related_info = self.build_related_info();

        // Assertion diagnostic (ERROR) - always at the specific assertion line
        if let Some(failure) = &self.user_facing_failure {
            let related = filter_related_info(&related_info, &failure.span);
            result.push((
                failure.span.path.clone(),
                Diagnostic {
                    range: failure.span.range,
                    message: failure.message.clone(),
                    severity: Some(DiagnosticSeverity::ERROR),
                    source: Some(self.runner_id.clone()),
                    code: Some(NumberOrString::String(self.failure_type_code.clone())),
                    related_information: if related.is_empty() {
                        None
                    } else {
                        Some(related)
                    },
                    data: Some(serde_json::json!({
                        "failureId": failure_id,
                        "spanType": "assertion",
                        "spanIndex": 0
                    })),
                    ..Diagnostic::default()
                },
            ));

            // Additional HINT diagnostic for function body highlighting
            if show_surrounding_function
                && let Some(fn_span) = failure.function_span
                && fn_span != failure.span.range
            {
                result.push((
                    failure.span.path.clone(),
                    Diagnostic {
                        range: fn_span,
                        message: "contains failing assertion".to_string(),
                        severity: Some(DiagnosticSeverity::HINT),
                        source: Some(self.runner_id.clone()),
                        code: Some(NumberOrString::String("function-context".to_string())),
                        related_information: None,
                        data: Some(serde_json::json!({
                            "failureId": failure_id,
                            "spanType": "function_highlight",
                            "spanIndex": 0
                        })),
                        ..Diagnostic::default()
                    },
                ));
            }
        }

        // Backtrace diagnostics (INFO) - always at the specific line
        for (idx, frame) in self.stack_frames.iter().enumerate() {
            let msg = format!("frame {}: {}", idx, frame.function_name);
            let frame_span = SourceSpan {
                path: frame.path.clone(),
                range: frame.range,
            };
            let related = filter_related_info(&related_info, &frame_span);
            result.push((
                frame.path.clone(),
                Diagnostic {
                    range: frame.range,
                    message: msg,
                    severity: Some(DiagnosticSeverity::INFORMATION),
                    source: Some(self.runner_id.clone()),
                    code: Some(NumberOrString::String("backtrace".to_string())),
                    related_information: if related.is_empty() {
                        None
                    } else {
                        Some(related)
                    },
                    data: Some(serde_json::json!({
                        "failureId": failure_id,
                        "spanType": "backtrace",
                        "spanIndex": idx
                    })),
                    ..Diagnostic::default()
                },
            ));

            // Additional HINT diagnostic for function body highlighting
            if show_surrounding_function
                && let Some(fn_span) = frame.function_span
                && fn_span != frame.range
            {
                result.push((
                    frame.path.clone(),
                    Diagnostic {
                        range: fn_span,
                        message: format!("contains frame {}: {}", idx, frame.function_name),
                        severity: Some(DiagnosticSeverity::HINT),
                        source: Some(self.runner_id.clone()),
                        code: Some(NumberOrString::String("function-context".to_string())),
                        related_information: None,
                        data: Some(serde_json::json!({
                            "failureId": failure_id,
                            "spanType": "function_highlight",
                            "spanIndex": idx
                        })),
                        ..Diagnostic::default()
                    },
                ));
            }
        }

        // Test function diagnostic (WARNING)
        // Skip when show_surrounding_function is enabled since the function
        // is already highlighted as part of the assertion or backtrace frame spans.
        if !show_surrounding_function && let Some(ctx) = &self.context {
            let msg = format!("`{}` failed", ctx.name);
            let related = filter_related_info(&related_info, &ctx.span);
            let span_index = 1 + self.stack_frames.len(); // after assertion and backtrace
            result.push((
                ctx.span.path.clone(),
                Diagnostic {
                    range: ctx.span.range,
                    message: msg,
                    severity: Some(DiagnosticSeverity::WARNING),
                    source: Some(self.runner_id.clone()),
                    code: Some(NumberOrString::String("test-failed".to_string())),
                    related_information: if related.is_empty() {
                        None
                    } else {
                        Some(related)
                    },
                    data: Some(serde_json::json!({
                        "failureId": failure_id,
                        "spanType": "test_function",
                        "spanIndex": span_index
                    })),
                    ..Diagnostic::default()
                },
            ));
        }

        result
    }

    fn build_related_info(&self) -> Vec<DiagnosticRelatedInformation> {
        let mut info = Vec::new();

        if let Some(failure) = &self.user_facing_failure
            && let Some(uri) = path_to_uri(&failure.span.path)
        {
            info.push(DiagnosticRelatedInformation {
                location: Location {
                    uri,
                    range: failure.span.range,
                },
                message: "assertion".to_string(),
            });
        }

        for (idx, frame) in self.stack_frames.iter().enumerate() {
            if let Some(uri) = path_to_uri(&frame.path) {
                info.push(DiagnosticRelatedInformation {
                    location: Location {
                        uri,
                        range: frame.range,
                    },
                    message: format!("frame {}: {}", idx, frame.function_name),
                });
            }
        }

        if let Some(ctx) = &self.context
            && let Some(uri) = path_to_uri(&ctx.span.path)
        {
            info.push(DiagnosticRelatedInformation {
                location: Location {
                    uri,
                    range: ctx.span.range,
                },
                message: format!("test `{}`", ctx.name),
            });
        }

        info
    }
}

fn filter_related_info(
    all: &[DiagnosticRelatedInformation],
    current_span: &SourceSpan,
) -> Vec<DiagnosticRelatedInformation> {
    let current_uri = path_to_uri(&current_span.path);
    all.iter()
        .filter(|info| {
            // Exclude the current span from related info
            current_uri.as_ref() != Some(&info.location.uri)
                || info.location.range != current_span.range
        })
        .cloned()
        .collect()
}

/// Diagnostics for a single file (used for LSP publishing).
#[derive(Debug, Clone)]
pub(crate) struct FileDiagnostics {
    pub(crate) path: PathBuf,
    pub(crate) diagnostics: Vec<Diagnostic>,
}

/// Convert test failures to file diagnostics grouped by path.
///
/// When `show_surrounding_function` is true, diagnostic ranges span the
/// entire surrounding function body. When false, diagnostics point to
/// the specific line only.
pub(crate) fn failures_to_file_diagnostics(
    failures: impl IntoIterator<Item = TestFailure>,
    show_surrounding_function: bool,
) -> impl Iterator<Item = FileDiagnostics> {
    use std::collections::HashMap;

    let mut by_file: HashMap<PathBuf, Vec<Diagnostic>> = HashMap::new();

    for failure in failures {
        for (path, diag) in failure.to_diagnostics(show_surrounding_function) {
            by_file.entry(path).or_default().push(diag);
        }
    }

    by_file
        .into_iter()
        .map(|(path, diagnostics)| FileDiagnostics { path, diagnostics })
}

/// Map of workspace roots to their contained files.
#[derive(Debug, Serialize, Clone, Deserialize, Default)]

pub struct Workspaces {
    pub(crate) map: HashMap<PathBuf, Vec<PathBuf>>,
}