verter_core 0.0.1-beta.1

//! Lightweight token scanner for recovering macro/function info from broken scripts.
//!
//! When OXC's partial AST has damaged macros (e.g., user is typing inside a
//! `defineProps<{...}>()` call), the normal AST-based macro detection fails.
//! This scanner performs a single-pass token scan to recover:
//!
//! - **Macro calls**: `defineProps`, `defineEmits`, `withDefaults`, `defineModel`,
//!   `defineExpose`, `defineOptions`, `defineSlots` — with optional binding name
//!   from `const NAME = macroCall(...)`.
//! - **Function declarations**: `function name(...)` — with name and params span
//!   for hover annotation.
//!
//! The scanner handles comments, strings, template literals, and bracket matching
//! but does NOT build an AST or parse expressions/types.
//!
//! Currently only macro recovery is used in production (for `NormalSkipDamagedMacros`
//! strategy). Function recovery and `binding_span` are tested and available for
//! future hover annotation of event handler params from the broken tail.

use verter_span::Span;

/// Known Vue macro kinds for the token scanner.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RecoveredMacroKind {
    DefineProps,
    DefineEmits,
    WithDefaults,
    DefineModel,
    DefineExpose,
    DefineOptions,
    DefineSlots,
}

/// A macro call recovered by the token scanner.
#[derive(Debug)]
pub struct RecoveredMacro<'a> {
    /// What kind of macro was found.
    pub kind: RecoveredMacroKind,
    /// Binding name from `const NAME = macroCall(...)`, if present.
    pub binding_name: Option<&'a str>,
    /// Span of the binding name identifier (used in tests; reserved for future hover annotation).
    #[allow(dead_code)]
    pub binding_span: Option<Span>,
    /// Span of the entire macro call expression (from identifier to closing paren/bracket).
    pub call_span: Span,
}

/// A function declaration recovered by the token scanner.
#[derive(Debug)]
pub struct RecoveredFunction<'a> {
    /// Function name.
    pub name: &'a str,
    /// Span of the function name identifier (used in tests; reserved for future hover annotation).
    #[allow(dead_code)]
    pub name_span: Span,
    /// Span of the parameter list (used in tests; reserved for future param annotation).
    #[allow(dead_code)]
    pub params_span: Span,
}

/// A variable declaration recovered by the token scanner.
#[derive(Debug)]
pub struct RecoveredVariable<'a> {
    /// Variable name.
    pub name: &'a str,
    /// Span of the variable name identifier (used in tests; reserved for future hover annotation).
    #[allow(dead_code)]
    pub name_span: Span,
    /// Declaration kind (`const`, `let`, or `var`).
    pub kind: RecoveredVarKind,
}

/// Variable declaration keyword.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RecoveredVarKind {
    Const,
    Let,
    Var,
}

/// Result of token-based recovery scanning.
#[derive(Debug)]
pub struct TokenizerRecovery<'a> {
    pub macros: Vec<RecoveredMacro<'a>>,
    pub functions: Vec<RecoveredFunction<'a>>,
    pub variables: Vec<RecoveredVariable<'a>>,
}

/// Lightweight token scanner for recovering structural info from broken scripts.
///
/// Single-pass, handles comments, strings, template literals, bracket matching.
/// Does NOT build an AST or parse expressions/types.
pub struct ScriptTokenScanner<'a> {
    source: &'a str,
    bytes: &'a [u8],
    pos: usize,
    /// SFC-absolute offset added to all span positions.
    content_start: u32,
}

const MACRO_NAMES: &[(&str, RecoveredMacroKind)] = &[
    ("defineProps", RecoveredMacroKind::DefineProps),
    ("defineEmits", RecoveredMacroKind::DefineEmits),
    ("withDefaults", RecoveredMacroKind::WithDefaults),
    ("defineModel", RecoveredMacroKind::DefineModel),
    ("defineExpose", RecoveredMacroKind::DefineExpose),
    ("defineOptions", RecoveredMacroKind::DefineOptions),
    ("defineSlots", RecoveredMacroKind::DefineSlots),
];

impl<'a> ScriptTokenScanner<'a> {
    pub fn new(source: &'a str, content_start: u32) -> Self {
        Self {
            source,
            bytes: source.as_bytes(),
            pos: 0,
            content_start,
        }
    }

    /// Run the recovery scan and return all recovered macros, functions, and variables.
    pub fn recover(mut self) -> TokenizerRecovery<'a> {
        let mut macros = Vec::new();
        let mut functions = Vec::new();
        let mut variables = Vec::new();

        while self.pos < self.bytes.len() {
            // Skip whitespace
            if self.bytes[self.pos].is_ascii_whitespace() {
                self.pos += 1;
                continue;
            }

            // Line comment
            if self.looking_at(b"//") {
                self.skip_line_comment();
                continue;
            }

            // Block comment
            if self.looking_at(b"/*") {
                self.skip_block_comment();
                continue;
            }

            // String literals
            if self.bytes[self.pos] == b'"' || self.bytes[self.pos] == b'\'' {
                self.skip_string(self.bytes[self.pos]);
                continue;
            }

            // Template literal
            if self.bytes[self.pos] == b'`' {
                self.skip_template_literal();
                continue;
            }

            // Identifier
            if is_ident_start(self.bytes[self.pos]) {
                let ident_start = self.pos;
                let ident = self.read_ident();

                // Check for `function` keyword
                if ident == "function" {
                    if let Some(func) = self.try_recover_function() {
                        functions.push(func);
                    }
                    continue;
                }

                // Check for variable declaration keywords
                let var_kind = match ident {
                    "const" => Some(RecoveredVarKind::Const),
                    "let" => Some(RecoveredVarKind::Let),
                    "var" => Some(RecoveredVarKind::Var),
                    _ => None,
                };
                if let Some(kind) = var_kind {
                    // Must be at a word boundary (not part of a larger identifier)
                    if !self.is_ident_at(self.pos) {
                        if let Some(var) = self.try_recover_variable(kind) {
                            // Check if the initializer is a known macro — if so, skip
                            // (the macro branch handles its own binding)
                            variables.push(var);
                        }
                    }
                    continue;
                }

                // Check for known macro names
                if let Some(&(_, kind)) = MACRO_NAMES.iter().find(|&&(name, _)| name == ident) {
                    if let Some(call_end) = self.try_match_macro_call() {
                        let call_span = Span::new(
                            self.content_start + ident_start as u32,
                            self.content_start + call_end as u32,
                        );
                        let (binding_name, binding_span) =
                            self.scan_backward_for_binding(ident_start);
                        macros.push(RecoveredMacro {
                            kind,
                            binding_name,
                            binding_span,
                            call_span,
                        });
                    }
                    continue;
                }

                continue;
            }

            // Skip anything else
            self.pos += 1;
        }

        TokenizerRecovery {
            macros,
            functions,
            variables,
        }
    }

    // ── Helpers ──────────────────────────────────────────────────────

    fn looking_at(&self, needle: &[u8]) -> bool {
        self.bytes[self.pos..].starts_with(needle)
    }

    fn skip_line_comment(&mut self) {
        self.pos += 2; // skip //
        while self.pos < self.bytes.len() && self.bytes[self.pos] != b'\n' {
            self.pos += 1;
        }
    }

    fn skip_block_comment(&mut self) {
        self.pos += 2; // skip /*
        while self.pos + 1 < self.bytes.len() {
            if self.bytes[self.pos] == b'*' && self.bytes[self.pos + 1] == b'/' {
                self.pos += 2;
                return;
            }
            self.pos += 1;
        }
        self.pos = self.bytes.len(); // unclosed
    }

    fn skip_string(&mut self, quote: u8) {
        self.pos += 1; // skip opening quote
        while self.pos < self.bytes.len() {
            if self.bytes[self.pos] == b'\\' {
                self.pos += 2; // skip escape
                continue;
            }
            if self.bytes[self.pos] == quote {
                self.pos += 1;
                return;
            }
            self.pos += 1;
        }
        // unclosed string — pos is at end
    }

    fn skip_template_literal(&mut self) {
        self.pos += 1; // skip opening backtick
        while self.pos < self.bytes.len() {
            if self.bytes[self.pos] == b'\\' {
                self.pos += 2;
                continue;
            }
            if self.bytes[self.pos] == b'`' {
                self.pos += 1;
                return;
            }
            if self.bytes[self.pos] == b'$'
                && self.pos + 1 < self.bytes.len()
                && self.bytes[self.pos + 1] == b'{'
            {
                self.pos += 2; // skip ${
                self.skip_bracket_matched(b'{', b'}');
                continue;
            }
            self.pos += 1;
        }
        // unclosed template literal
    }

    fn read_ident(&mut self) -> &'a str {
        let start = self.pos;
        while self.pos < self.bytes.len() && is_ident_continue(self.bytes[self.pos]) {
            self.pos += 1;
        }
        &self.source[start..self.pos]
    }

    /// Skip whitespace and comments, returning true if any were skipped.
    fn skip_ws_and_comments(&mut self) -> bool {
        let start = self.pos;
        loop {
            if self.pos >= self.bytes.len() {
                break;
            }
            if self.bytes[self.pos].is_ascii_whitespace() {
                self.pos += 1;
                continue;
            }
            if self.looking_at(b"//") {
                self.skip_line_comment();
                continue;
            }
            if self.looking_at(b"/*") {
                self.skip_block_comment();
                continue;
            }
            break;
        }
        self.pos > start
    }

    /// Try to match a macro call after the macro identifier has been consumed.
    /// Matches optional `<...>` type params followed by `(...)`.
    /// Returns the end position of the call if matched, None otherwise.
    fn try_match_macro_call(&mut self) -> Option<usize> {
        let saved = self.pos;
        self.skip_ws_and_comments();

        // Optional generic type params: <...>
        if self.pos < self.bytes.len() && self.bytes[self.pos] == b'<' {
            self.pos += 1;
            if !self.skip_bracket_matched(b'<', b'>') {
                // Unclosed generic — still try to match what we can
                self.pos = saved;
                self.skip_ws_and_comments();
            } else {
                self.skip_ws_and_comments();
            }
        }

        // Required call parens: (...)
        if self.pos < self.bytes.len() && self.bytes[self.pos] == b'(' {
            self.pos += 1;
            if self.skip_bracket_matched(b'(', b')') {
                return Some(self.pos);
            }
        }

        self.pos = saved;
        None
    }

    /// Skip forward matching brackets, handling nesting and string/comment skipping.
    /// Starts AFTER the opening bracket has been consumed.
    /// Returns true if the closing bracket was found.
    fn skip_bracket_matched(&mut self, open: u8, close: u8) -> bool {
        let mut depth = 1u32;
        while self.pos < self.bytes.len() && depth > 0 {
            let b = self.bytes[self.pos];

            // Skip strings
            if b == b'"' || b == b'\'' {
                self.skip_string(b);
                continue;
            }
            if b == b'`' {
                self.skip_template_literal();
                continue;
            }

            // Skip comments
            if self.looking_at(b"//") {
                self.skip_line_comment();
                continue;
            }
            if self.looking_at(b"/*") {
                self.skip_block_comment();
                continue;
            }

            if b == open {
                depth += 1;
            } else if b == close {
                depth -= 1;
                if depth == 0 {
                    self.pos += 1; // consume closing bracket
                    return true;
                }
            }
            self.pos += 1;
        }
        false // unclosed
    }

    /// Scan backward from `macro_start` looking for `const NAME =` or `let NAME =` pattern.
    fn scan_backward_for_binding(&self, macro_start: usize) -> (Option<&'a str>, Option<Span>) {
        // Walk backward skipping whitespace
        let mut p = macro_start;
        p = self.skip_back_ws(p);

        // Expect '='
        if p == 0 || self.bytes[p - 1] != b'=' {
            return (None, None);
        }
        p -= 1;
        p = self.skip_back_ws(p);

        // Read identifier backward
        if p == 0 || !is_ident_continue(self.bytes[p - 1]) {
            return (None, None);
        }
        let ident_end = p;
        while p > 0 && is_ident_continue(self.bytes[p - 1]) {
            p -= 1;
        }
        let ident_start = p;
        let name = &self.source[ident_start..ident_end];

        // Verify it's preceded by const/let/var (with word boundary check)
        p = self.skip_back_ws(p);
        let make_span = || {
            Span::new(
                self.content_start + ident_start as u32,
                self.content_start + ident_end as u32,
            )
        };

        // Helper: check the keyword doesn't have an ident char before it
        let is_word_boundary = |before_kw: usize| -> bool {
            before_kw == 0 || !is_ident_continue(self.bytes[before_kw - 1])
        };

        if p >= 3 && &self.source[p - 3..p] == "var" && is_word_boundary(p - 3) {
            return (Some(name), Some(make_span()));
        }
        if p >= 3 && &self.source[p - 3..p] == "let" && is_word_boundary(p - 3) {
            return (Some(name), Some(make_span()));
        }
        if p >= 5 && &self.source[p - 5..p] == "const" && is_word_boundary(p - 5) {
            return (Some(name), Some(make_span()));
        }

        (None, None)
    }

    fn skip_back_ws(&self, mut p: usize) -> usize {
        while p > 0 && self.bytes[p - 1].is_ascii_whitespace() {
            p -= 1;
        }
        p
    }

    /// Check if there's an identifier character at position `pos`.
    /// Returns false if pos is out of bounds.
    fn is_ident_at(&self, pos: usize) -> bool {
        // Handle underflow: if the subtraction would go below 0
        if pos >= self.bytes.len() {
            return false;
        }
        is_ident_continue(self.bytes[pos])
    }

    /// Try to recover a variable declaration after `const`/`let`/`var` keyword has been consumed.
    ///
    /// Reads the binding name identifier. Handles simple identifiers only (not destructuring).
    fn try_recover_variable(&mut self, kind: RecoveredVarKind) -> Option<RecoveredVariable<'a>> {
        self.skip_ws_and_comments();

        if self.pos >= self.bytes.len() || !is_ident_start(self.bytes[self.pos]) {
            return None;
        }
        let name_start = self.pos;
        let name = self.read_ident();
        let name_end = self.pos;

        Some(RecoveredVariable {
            name,
            name_span: Span::new(
                self.content_start + name_start as u32,
                self.content_start + name_end as u32,
            ),
            kind,
        })
    }

    /// Try to recover a function declaration after `function` keyword has been consumed.
    fn try_recover_function(&mut self) -> Option<RecoveredFunction<'a>> {
        self.skip_ws_and_comments();

        // Read function name
        if self.pos >= self.bytes.len() || !is_ident_start(self.bytes[self.pos]) {
            return None;
        }
        let name_start = self.pos;
        let name = self.read_ident();
        let name_end = self.pos;

        self.skip_ws_and_comments();

        // Optional type params <...>
        if self.pos < self.bytes.len() && self.bytes[self.pos] == b'<' {
            self.pos += 1;
            if !self.skip_bracket_matched(b'<', b'>') {
                return None; // unclosed generic
            }
            self.skip_ws_and_comments();
        }

        // Params (...)
        if self.pos >= self.bytes.len() || self.bytes[self.pos] != b'(' {
            return None;
        }
        let params_start = self.pos;
        self.pos += 1; // skip (
        if !self.skip_bracket_matched(b'(', b')') {
            return None; // unclosed params
        }
        let params_end = self.pos;

        Some(RecoveredFunction {
            name,
            name_span: Span::new(
                self.content_start + name_start as u32,
                self.content_start + name_end as u32,
            ),
            params_span: Span::new(
                self.content_start + params_start as u32,
                self.content_start + params_end as u32,
            ),
        })
    }
}

fn is_ident_start(b: u8) -> bool {
    b.is_ascii_alphabetic() || b == b'_' || b == b'$'
}

fn is_ident_continue(b: u8) -> bool {
    b.is_ascii_alphanumeric() || b == b'_' || b == b'$'
}

#[cfg(test)]
mod tests {
    use super::*;

    fn scan(source: &str) -> TokenizerRecovery<'_> {
        ScriptTokenScanner::new(source, 0).recover()
    }

    fn scan_offset(source: &str, offset: u32) -> TokenizerRecovery<'_> {
        ScriptTokenScanner::new(source, offset).recover()
    }

    // ── Macro detection ─────────────────────────────────────────────

    #[test]
    fn finds_define_props() {
        let r = scan("defineProps<{ count: number }>()");
        assert_eq!(r.macros.len(), 1);
        assert_eq!(r.macros[0].kind, RecoveredMacroKind::DefineProps);
        assert!(r.macros[0].binding_name.is_none());
    }

    #[test]
    fn finds_define_props_with_binding() {
        let r = scan("const props = defineProps<{ count: number }>()");
        assert_eq!(r.macros.len(), 1);
        assert_eq!(r.macros[0].kind, RecoveredMacroKind::DefineProps);
        assert_eq!(r.macros[0].binding_name, Some("props"));
    }

    #[test]
    fn finds_define_emits_with_binding() {
        let r = scan("const emit = defineEmits<{ click: [e: MouseEvent] }>()");
        assert_eq!(r.macros.len(), 1);
        assert_eq!(r.macros[0].kind, RecoveredMacroKind::DefineEmits);
        assert_eq!(r.macros[0].binding_name, Some("emit"));
    }

    #[test]
    fn finds_with_defaults() {
        let r = scan("const props = withDefaults(defineProps<Props>(), { count: 0 })");
        // withDefaults is the outermost macro — scanner consumes defineProps inside bracket match
        assert!(r
            .macros
            .iter()
            .any(|m| m.kind == RecoveredMacroKind::WithDefaults));
        assert_eq!(r.macros[0].binding_name, Some("props"));
    }

    #[test]
    fn finds_define_model() {
        let r = scan("const modelValue = defineModel<string>()");
        assert_eq!(r.macros.len(), 1);
        assert_eq!(r.macros[0].kind, RecoveredMacroKind::DefineModel);
        assert_eq!(r.macros[0].binding_name, Some("modelValue"));
    }

    #[test]
    fn finds_define_expose() {
        let r = scan("defineExpose({ foo: 1 })");
        assert_eq!(r.macros.len(), 1);
        assert_eq!(r.macros[0].kind, RecoveredMacroKind::DefineExpose);
    }

    #[test]
    fn finds_define_options() {
        let r = scan("defineOptions({ name: 'Foo' })");
        assert_eq!(r.macros.len(), 1);
        assert_eq!(r.macros[0].kind, RecoveredMacroKind::DefineOptions);
    }

    #[test]
    fn finds_define_slots() {
        let r = scan("const slots = defineSlots<{ default(): any }>()");
        assert_eq!(r.macros.len(), 1);
        assert_eq!(r.macros[0].kind, RecoveredMacroKind::DefineSlots);
        assert_eq!(r.macros[0].binding_name, Some("slots"));
    }

    #[test]
    fn finds_multiple_macros() {
        let r = scan(
            "const props = defineProps<{ x: number }>()\nconst emit = defineEmits<{ click: [] }>()",
        );
        assert_eq!(r.macros.len(), 2);
    }

    // ── Comment/string skipping ─────────────────────────────────────

    #[test]
    fn ignores_macro_in_line_comment() {
        let r = scan("// defineProps<{ count: number }>()");
        assert!(r.macros.is_empty(), "should not find macro in line comment");
    }

    #[test]
    fn ignores_macro_in_block_comment() {
        let r = scan("/* defineProps<{ count: number }>() */");
        assert!(
            r.macros.is_empty(),
            "should not find macro in block comment"
        );
    }

    #[test]
    fn ignores_macro_in_string() {
        let r = scan(r#""defineProps<{ count: number }>()""#);
        assert!(r.macros.is_empty(), "should not find macro in string");
    }

    #[test]
    fn ignores_macro_in_single_quote_string() {
        let r = scan("'defineProps()'");
        assert!(
            r.macros.is_empty(),
            "should not find macro in single-quote string"
        );
    }

    #[test]
    fn ignores_macro_in_template_literal() {
        let r = scan("`defineProps()`");
        assert!(
            r.macros.is_empty(),
            "should not find macro in template literal"
        );
    }

    #[test]
    fn finds_macro_after_block_comment() {
        let r = scan("/* comment */\ndefineProps()");
        assert_eq!(r.macros.len(), 1);
        assert_eq!(r.macros[0].kind, RecoveredMacroKind::DefineProps);
    }

    #[test]
    fn handles_template_literal_with_interpolation() {
        let r = scan("`${defineProps()}` \n defineEmits()");
        // defineProps inside template literal interpolation should be found
        // (it's real code in the interpolation)
        // Actually, the ${...} content IS executable code, so we should find it
        // But our simple scanner skips the entire template literal including interpolation
        // This is acceptable — the scanner is conservative
        assert!(
            !r.macros.is_empty(),
            "should find at least defineEmits after template literal"
        );
        assert!(
            r.macros
                .iter()
                .any(|m| m.kind == RecoveredMacroKind::DefineEmits),
            "should find defineEmits"
        );
    }

    // ── Bracket matching ────────────────────────────────────────────

    #[test]
    fn handles_nested_brackets_in_type_params() {
        let r = scan("defineProps<{ items: Array<{ name: string }> }>()");
        assert_eq!(r.macros.len(), 1);
        assert_eq!(r.macros[0].kind, RecoveredMacroKind::DefineProps);
    }

    #[test]
    fn handles_nested_parens_in_call() {
        let r = scan("defineProps(foo(bar()))");
        assert_eq!(r.macros.len(), 1);
    }

    #[test]
    fn handles_strings_inside_brackets() {
        let r = scan(r#"defineProps<{ foo: "bar<baz>" }>()"#);
        assert_eq!(r.macros.len(), 1);
    }

    // ── Backward binding scan ───────────────────────────────────────

    #[test]
    fn backward_scan_const() {
        let r = scan("const props = defineProps()");
        assert_eq!(r.macros[0].binding_name, Some("props"));
    }

    #[test]
    fn backward_scan_let() {
        let r = scan("let props = defineProps()");
        assert_eq!(r.macros[0].binding_name, Some("props"));
    }

    #[test]
    fn backward_scan_var() {
        let r = scan("var props = defineProps()");
        assert_eq!(r.macros[0].binding_name, Some("props"));
    }

    #[test]
    fn no_binding_without_keyword() {
        let r = scan("props = defineProps()");
        assert!(
            r.macros[0].binding_name.is_none(),
            "should not find binding without const/let/var"
        );
    }

    #[test]
    fn backward_scan_with_extra_whitespace() {
        let r = scan("const   props   =   defineProps()");
        assert_eq!(r.macros[0].binding_name, Some("props"));
    }

    // ── Function detection ──────────────────────────────────────────

    #[test]
    fn finds_function_declaration() {
        let r = scan("function handleClick(event) {}");
        assert_eq!(r.functions.len(), 1);
        assert_eq!(r.functions[0].name, "handleClick");
    }

    #[test]
    fn finds_function_with_multiple_params() {
        let r = scan("function handleDrag(startEvent, endEvent) {}");
        assert_eq!(r.functions.len(), 1);
        assert_eq!(r.functions[0].name, "handleDrag");
    }

    #[test]
    fn finds_function_with_type_params() {
        let r = scan("function foo<T>(x: T) {}");
        assert_eq!(r.functions.len(), 1);
        assert_eq!(r.functions[0].name, "foo");
    }

    #[test]
    fn finds_multiple_functions() {
        let r = scan("function foo() {}\nfunction bar() {}");
        assert_eq!(r.functions.len(), 2);
        assert_eq!(r.functions[0].name, "foo");
        assert_eq!(r.functions[1].name, "bar");
    }

    #[test]
    fn ignores_function_in_comment() {
        let r = scan("// function foo() {}");
        assert!(r.functions.is_empty());
    }

    // ── Edge cases ──────────────────────────────────────────────────

    #[test]
    fn macro_at_start_of_file() {
        let r = scan("defineProps()");
        assert_eq!(r.macros.len(), 1);
    }

    #[test]
    fn macro_at_end_of_file_no_trailing_newline() {
        let r = scan("const x = defineProps()");
        assert_eq!(r.macros.len(), 1);
        assert_eq!(r.macros[0].binding_name, Some("x"));
    }

    #[test]
    fn adjacent_macros() {
        let r = scan("defineProps()\ndefineEmits()");
        assert_eq!(r.macros.len(), 2);
    }

    #[test]
    fn macro_after_comment() {
        let r = scan("// This sets up props\nconst props = defineProps()");
        assert_eq!(r.macros.len(), 1);
        assert_eq!(r.macros[0].binding_name, Some("props"));
    }

    #[test]
    fn empty_source() {
        let r = scan("");
        assert!(r.macros.is_empty());
        assert!(r.functions.is_empty());
    }

    #[test]
    fn only_whitespace() {
        let r = scan("   \n\n  ");
        assert!(r.macros.is_empty());
        assert!(r.functions.is_empty());
    }

    #[test]
    fn unclosed_string_doesnt_panic() {
        let r = scan(r#"const x = "unclosed"#);
        // Should not panic, just stop scanning
        let _ = r;
    }

    #[test]
    fn unclosed_template_literal_doesnt_panic() {
        let r = scan("const x = `unclosed");
        let _ = r;
    }

    #[test]
    fn unclosed_block_comment_doesnt_panic() {
        let r = scan("/* unclosed block comment\ndefineProps()");
        // macro should not be found (inside block comment)
        assert!(r.macros.is_empty());
    }

    // ── Span offsets ────────────────────────────────────────────────

    #[test]
    fn spans_include_content_start_offset() {
        let r = scan_offset("defineProps()", 100);
        assert_eq!(r.macros.len(), 1);
        assert_eq!(r.macros[0].call_span.start, 100);
        assert_eq!(r.macros[0].call_span.end, 113); // 100 + 13
    }

    #[test]
    fn binding_span_includes_offset() {
        let r = scan_offset("const props = defineProps()", 50);
        assert_eq!(r.macros[0].binding_span.unwrap().start, 56); // 50 + 6
        assert_eq!(r.macros[0].binding_span.unwrap().end, 61); // 50 + 11
    }

    #[test]
    fn function_spans_include_offset() {
        let r = scan_offset("function foo() {}", 200);
        assert_eq!(r.functions[0].name_span.start, 209); // 200 + 9
        assert_eq!(r.functions[0].name_span.end, 212); // 200 + 12
        assert_eq!(r.functions[0].params_span.start, 212); // 200 + 12
        assert_eq!(r.functions[0].params_span.end, 214); // 200 + 14
    }

    // ── Mixed scenarios ─────────────────────────────────────────────

    #[test]
    fn macros_and_functions_together() {
        let r = scan("const props = defineProps<{ x: number }>()\nfunction handleClick(event) {}");
        assert_eq!(r.macros.len(), 1);
        assert_eq!(r.functions.len(), 1);
        assert_eq!(r.macros[0].binding_name, Some("props"));
        assert_eq!(r.functions[0].name, "handleClick");
    }

    #[test]
    fn broken_macro_no_parens() {
        // defineProps< — no closing > or ()
        let r = scan("defineProps<");
        // Should not find a complete macro call (missing parens)
        assert!(
            r.macros.is_empty(),
            "incomplete macro should not be recovered"
        );
    }

    #[test]
    fn broken_macro_unclosed_generic() {
        // defineProps<{ count. — error in type, no closing
        let r = scan("defineProps<{ count.");
        assert!(
            r.macros.is_empty(),
            "unclosed generic should not produce a macro"
        );
    }

    #[test]
    fn partial_define_props_but_later_valid_macro() {
        let r = scan("defineProps<{\nconst emit = defineEmits()");
        // First defineProps is broken (unclosed generic), second is valid
        assert!(r
            .macros
            .iter()
            .any(|m| m.kind == RecoveredMacroKind::DefineEmits));
    }

    #[test]
    fn keyword_const_not_partial_match() {
        // "constant" should NOT match "const" prefix
        let r = scan("constant = defineProps()");
        assert!(
            r.macros[0].binding_name.is_none(),
            "constant should not match const"
        );
    }

    // ── Variable recovery ───────────────────────────────────────────

    #[test]
    fn finds_const_variable() {
        let r = scan("const count = ref(0)");
        assert_eq!(r.variables.len(), 1);
        assert_eq!(r.variables[0].name, "count");
        assert_eq!(r.variables[0].kind, RecoveredVarKind::Const);
    }

    #[test]
    fn finds_let_variable() {
        let r = scan("let x = 1");
        assert_eq!(r.variables.len(), 1);
        assert_eq!(r.variables[0].name, "x");
        assert_eq!(r.variables[0].kind, RecoveredVarKind::Let);
    }

    #[test]
    fn finds_var_variable() {
        let r = scan("var y = 2");
        assert_eq!(r.variables.len(), 1);
        assert_eq!(r.variables[0].name, "y");
        assert_eq!(r.variables[0].kind, RecoveredVarKind::Var);
    }

    #[test]
    fn finds_multiple_variables() {
        let r = scan("const a = 1\nlet b = 2\nvar c = 3");
        assert_eq!(r.variables.len(), 3);
        assert_eq!(r.variables[0].name, "a");
        assert_eq!(r.variables[1].name, "b");
        assert_eq!(r.variables[2].name, "c");
    }

    #[test]
    fn variable_span_includes_offset() {
        let r = scan_offset("const count = 1", 100);
        assert_eq!(r.variables[0].name_span.start, 106); // 100 + 6
        assert_eq!(r.variables[0].name_span.end, 111); // 100 + 11
    }

    #[test]
    fn const_in_comment_not_variable() {
        let r = scan("// const x = 1\nconst y = 2");
        assert_eq!(r.variables.len(), 1);
        assert_eq!(r.variables[0].name, "y");
    }

    #[test]
    fn const_in_string_not_variable() {
        let r = scan(r#""const x = 1""#);
        assert!(r.variables.is_empty());
    }

    #[test]
    fn variables_with_macros_and_functions() {
        let r = scan("const count = ref(0)\nconst props = defineProps()\nfunction handle() {}");
        assert_eq!(r.variables.len(), 2); // count + props (const keyword parsed)
        assert_eq!(r.macros.len(), 1); // defineProps
        assert_eq!(r.functions.len(), 1); // handle
    }

    #[test]
    fn constant_keyword_not_variable() {
        // "constant" is not "const"
        let r = scan("constant = 1");
        assert!(r.variables.is_empty());
    }

    #[test]
    fn letter_keyword_not_variable() {
        // "letter" is not "let"
        let r = scan("letter = 1");
        assert!(r.variables.is_empty());
    }
}