Function find_enclosing_docblock

src/code_actions/phpstan/add_throws.rs:274–388

Find the enclosing function/method and its docblock by walking backward from the given line. We find the function signature by tracking brace depth: from the diagnostic line we walk backward until we find the opening `{` at depth -1 (exiting the function body). Then we look backward past modifiers to find the docblock.

(content: &str, diag_line: usize)

/// depth -1 (exiting the function body).  Then we look backward past
/// modifiers to find the docblock.
fn find_enclosing_docblock(content: &str, diag_line: usize) -> Option<DocblockInfo> {
    let lines: Vec<&str> = content.lines().collect();
    if diag_line >= lines.len() {
        return None;
    }

    // Convert the diagnostic line to a byte offset to start searching.
    let mut diag_byte_offset = 0usize;
    for (i, line) in lines.iter().enumerate() {
        if i == diag_line {
            break;
        }
        diag_byte_offset += line.len() + 1; // +1 for newline
    }

    let search_area = content.get(..diag_byte_offset)?;

    // Walk backward tracking brace depth to find the opening `{` of
    // the enclosing function body.
    let mut brace_depth = 0i32;
    let mut func_open_brace: Option<usize> = None;

    for (i, ch) in search_area.char_indices().rev() {
        match ch {
            '}' => brace_depth += 1,
            '{' => {
                brace_depth -= 1;
                if brace_depth < 0 {
                    func_open_brace = Some(i);
                    break;
                }
            }
            _ => {}
        }
    }

    let brace_pos = func_open_brace?;

    // Find the `function` keyword before the brace.
    let before_brace = content.get(..brace_pos)?;
    let mut sig_start = before_brace.len().saturating_sub(2000);
    while sig_start > 0 && !before_brace.is_char_boundary(sig_start) {
        sig_start -= 1;
    }
    let sig_region = &before_brace[sig_start..];
    let func_kw_rel = sig_region.rfind("function")?;
    let func_kw_pos = sig_start + func_kw_rel;

    // Walk backward from `function` past modifier keywords and whitespace
    // to find where the signature truly starts (for docblock detection).
    let before_func = content.get(..func_kw_pos)?;
    let trimmed = before_func.trim_end();

    // Strip trailing modifier keywords (public, protected, private, static,
    // abstract, final, readonly).
    let after_mods = strip_trailing_modifiers(trimmed);

    // Determine the byte offset of the start of the signature line