Method extract_subroutines

src/extraction/msbasic2_extractor.rs:314–450

Synthesize subroutine Function nodes from REM-labelled sections that end with RETURN. MS BASIC 2.0 has no formal subroutine syntax. We detect patterns like: ```basic 100 REM LOG A MESSAGE 110 REM PARAMS: ... 200 PRINT ... 210 RETURN ``` A REM line (or consecutive REM lines) followed by code ending with RETURN is treated as a subroutine. The REM text becomes the docstring, and a function name is d

(state: &mut ExtractionState, lines: &[BasicLine<'_>])

    /// is treated as a subroutine. The REM text becomes the docstring, and a
    /// function name is derived from the first REM text.
    fn extract_subroutines(state: &mut ExtractionState, lines: &[BasicLine<'_>]) {
        let mut i = 0;
        while i < lines.len() {
            // Look for a REM line that starts a potential subroutine.
            if lines[i].statement_kind == "comment" {
                // Gather consecutive REM lines.
                let rem_start = i;
                let mut rem_comments: Vec<String> = Vec::new();
                while i < lines.len() && lines[i].statement_kind == "comment" {
                    if let Some(ref text) = lines[i].comment_text {
                        rem_comments.push(text.clone());
                    }
                    i += 1;
                }

                // Check if the lines following the REM block end with RETURN.
                let body_start = i;
                let mut body_end = i;
                let mut has_return = false;
                while body_end < lines.len() {
                    if lines[body_end].statement_kind == "return_statement" {
                        has_return = true;
                        body_end += 1;
                        break;
                    }
                    // Stop at the next REM block (which would be the start of another subroutine).
                    if lines[body_end].statement_kind == "comment" {
                        break;
                    }
                    body_end += 1;
                }

                if has_return && body_start < body_end {
                    // Derive a function name from the first REM comment.
                    let fn_name = derive_function_name(&rem_comments);
                    let docstring = if rem_comments.is_empty() {
                        None
                    } else {
                        Some(rem_comments.join("\n"))
                    };

                    // The subroutine spans from the first REM line to the RETURN line.
                    let first_node = lines[rem_start].node;
                    let last_node = lines[body_end - 1].node;
                    let start_line = first_node.start_position().row as u32;
                    let end_line = last_node.end_position().row as u32;
                    let start_column = first_node.start_position().column as u32;
                    let end_column = last_node.end_position().column as u32;
                    let qualified_name = format!("{}::{}", state.qualified_prefix(), fn_name);
                    let fn_id = generate_node_id(
                        &state.file_path,
                        &NodeKind::Function,
                        &fn_name,
                        start_line,
                    );

                    // Count complexity by walking body lines' AST nodes.
                    let mut branches: u32 = 0;