scribe_analysis/

parser.rs

//! # Code Parsing Infrastructure
//!
//! Placeholder module for language-specific parsers.

use crate::ast::AstNode;
use scribe_core::Result;

/// Simple character-based tokenizer without regex
struct SimpleTokenizer {
    input: Vec<char>,
    position: usize,
}

impl SimpleTokenizer {
    fn new(input: &str) -> Self {
        Self {
            input: input.chars().collect(),
            position: 0,
        }
    }

    fn is_at_end(&self) -> bool {
        self.position >= self.input.len()
    }

    fn advance(&mut self) {
        if !self.is_at_end() {
            self.position += 1;
        }
    }

    fn peek_char(&self) -> Option<char> {
        self.input.get(self.position).copied()
    }

    fn peek_ahead(&self, offset: usize) -> Option<char> {
        self.input.get(self.position + offset).copied()
    }

    fn current_char(&self) -> Option<char> {
        self.input.get(self.position).copied()
    }

    fn skip_whitespace(&mut self) {
        while !self.is_at_end() {
            match self.current_char() {
                Some(' ') | Some('\t') | Some('\r') => self.advance(),
                _ => break,
            }
        }
    }

    fn skip_line(&mut self) {
        while !self.is_at_end() {
            if self.current_char() == Some('\n') {
                self.advance();
                break;
            }
            self.advance();
        }
    }

    fn peek_word(&self, word: &str) -> bool {
        let word_chars: Vec<char> = word.chars().collect();

        if self.position + word_chars.len() > self.input.len() {
            return false;
        }

        // Check if characters match
        for (i, &expected_char) in word_chars.iter().enumerate() {
            if let Some(actual_char) = self.input.get(self.position + i) {
                if *actual_char != expected_char {
                    return false;
                }
            } else {
                return false;
            }
        }

        // Check that it's a complete word (not part of a larger identifier)
        if let Some(next_char) = self.input.get(self.position + word_chars.len()) {
            if next_char.is_alphanumeric() || *next_char == '_' {
                return false;
            }
        }

        true
    }

    fn consume_word(&mut self, word: &str) -> Result<()> {
        if self.peek_word(word) {
            self.position += word.chars().count();
            Ok(())
        } else {
            Err(scribe_core::ScribeError::parse(&format!(
                "Expected '{}'",
                word
            )))
        }
    }

    fn next(&mut self) -> Option<String> {
        self.skip_whitespace();

        if self.is_at_end() {
            return None;
        }

        let mut token = String::new();

        // Collect alphanumeric characters and underscores
        while !self.is_at_end() {
            let ch = self.current_char().unwrap();
            if ch.is_alphanumeric() || ch == '_' {
                token.push(ch);
                self.advance();
            } else {
                break;
            }
        }

        if token.is_empty() {
            // Single character token
            if let Some(ch) = self.current_char() {
                token.push(ch);
                self.advance();
            }
        }

        if token.is_empty() {
            None
        } else {
            Some(token)
        }
    }
}

#[derive(Debug, Clone)]
pub struct ParseResult {
    pub ast: AstNode,
    pub errors: Vec<String>,
}

impl ParseResult {
    pub fn new(ast: AstNode) -> Self {
        Self {
            ast,
            errors: Vec::new(),
        }
    }

    pub fn with_errors(mut self, errors: Vec<String>) -> Self {
        self.errors = errors;
        self
    }
}

pub struct Parser;

impl Parser {
    pub fn new() -> Result<Self> {
        Ok(Self)
    }

    // Helper function to create nodes with children
    fn create_node_with_children(node_type: &str, children: Vec<AstNode>) -> AstNode {
        let mut node = AstNode::new(node_type.to_string());
        for child in children {
            node = node.add_child(child);
        }
        node
    }

    pub fn parse(&self, code: &str, language: &str) -> Result<AstNode> {
        let mut tokenizer = SimpleTokenizer::new(code);

        match language.to_lowercase().as_str() {
            "rust" | "rs" => self.parse_rust(&mut tokenizer),
            "python" | "py" => self.parse_python(&mut tokenizer),
            "javascript" | "js" | "typescript" | "ts" => self.parse_javascript(&mut tokenizer),
            _ => self.parse_generic(&mut tokenizer),
        }
    }

    fn parse_rust(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        let mut statements = Vec::new();

        while !tokenizer.is_at_end() {
            if let Some(stmt) = self.parse_statement(tokenizer)? {
                statements.push(stmt);
            }
        }

        Ok(Self::create_node_with_children("block", statements))
    }

    fn parse_python(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        // Simple Python parsing - detect basic structures
        let mut statements = Vec::new();

        while !tokenizer.is_at_end() {
            if let Some(stmt) = self.parse_python_statement(tokenizer)? {
                statements.push(stmt);
            }
        }

        Ok(Self::create_node_with_children("block", statements))
    }

    fn parse_javascript(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        // Simple JavaScript parsing
        let mut statements = Vec::new();

        while !tokenizer.is_at_end() {
            if let Some(stmt) = self.parse_js_statement(tokenizer)? {
                statements.push(stmt);
            }
        }

        Ok(Self::create_node_with_children("block", statements))
    }

    fn parse_generic(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        // Generic parsing - just count basic structures
        let mut statements = Vec::new();

        while !tokenizer.is_at_end() {
            if let Some(token) = tokenizer.next() {
                statements.push(AstNode::new(token));
            }
        }

        Ok(Self::create_node_with_children("block", statements))
    }

    fn parse_statement(&self, tokenizer: &mut SimpleTokenizer) -> Result<Option<AstNode>> {
        tokenizer.skip_whitespace();

        if tokenizer.is_at_end() {
            return Ok(None);
        }

        // Look for common keywords
        if tokenizer.peek_word("if") {
            return Ok(Some(self.parse_if_statement(tokenizer)?));
        }

        if tokenizer.peek_word("while") {
            return Ok(Some(self.parse_while_statement(tokenizer)?));
        }

        if tokenizer.peek_word("for") {
            return Ok(Some(self.parse_for_statement(tokenizer)?));
        }

        if tokenizer.peek_word("match") {
            return Ok(Some(self.parse_match_statement(tokenizer)?));
        }

        // Skip to next line for other statements
        tokenizer.skip_line();
        Ok(Some(AstNode::new("statement".to_string())))
    }

    fn parse_python_statement(&self, tokenizer: &mut SimpleTokenizer) -> Result<Option<AstNode>> {
        tokenizer.skip_whitespace();

        if tokenizer.is_at_end() {
            return Ok(None);
        }

        if tokenizer.peek_word("if") {
            return Ok(Some(self.parse_python_if(tokenizer)?));
        }

        if tokenizer.peek_word("while") {
            return Ok(Some(self.parse_python_while(tokenizer)?));
        }

        if tokenizer.peek_word("for") {
            return Ok(Some(self.parse_python_for(tokenizer)?));
        }

        tokenizer.skip_line();
        Ok(Some(AstNode::new("statement".to_string())))
    }

    fn parse_js_statement(&self, tokenizer: &mut SimpleTokenizer) -> Result<Option<AstNode>> {
        tokenizer.skip_whitespace();

        if tokenizer.is_at_end() {
            return Ok(None);
        }

        if tokenizer.peek_word("if") {
            return Ok(Some(self.parse_js_if(tokenizer)?));
        }

        if tokenizer.peek_word("while") {
            return Ok(Some(self.parse_js_while(tokenizer)?));
        }

        if tokenizer.peek_word("for") {
            return Ok(Some(self.parse_js_for(tokenizer)?));
        }

        if tokenizer.peek_word("switch") {
            return Ok(Some(self.parse_js_switch(tokenizer)?));
        }

        tokenizer.skip_line();
        Ok(Some(AstNode::new("statement".to_string())))
    }

    fn parse_if_statement(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        tokenizer.consume_word("if")?;
        let _condition = self.parse_condition(tokenizer)?;
        let then_branch = self.parse_block(tokenizer)?;

        let mut children = vec![then_branch];

        if tokenizer.peek_word("else") {
            tokenizer.consume_word("else")?;
            let else_branch = self.parse_block(tokenizer)?;
            children.push(else_branch);
        }

        Ok(Self::create_node_with_children("if", children))
    }

    fn parse_while_statement(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        tokenizer.consume_word("while")?;
        let _condition = self.parse_condition(tokenizer)?;
        let body = self.parse_block(tokenizer)?;

        Ok(Self::create_node_with_children("while", vec![body]))
    }

    fn parse_for_statement(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        tokenizer.consume_word("for")?;

        // Simplified for loop parsing
        let _init = "init".to_string();
        let _condition = "condition".to_string();
        let _update = "update".to_string();
        let body = self.parse_block(tokenizer)?;

        Ok(Self::create_node_with_children("for", vec![body]))
    }

    fn parse_match_statement(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        tokenizer.consume_word("match")?;
        let _condition = self.parse_condition(tokenizer)?;

        // Simplified match parsing - just count arms
        let mut cases = Vec::new();

        // Skip to opening brace and count patterns
        while !tokenizer.is_at_end() && tokenizer.current_char() != Some('}') {
            if tokenizer.current_char() == Some('=') && tokenizer.peek_ahead(1) == Some('>') {
                cases.push(AstNode::new("match_arm".to_string()));
            }
            tokenizer.advance();
        }

        Ok(Self::create_node_with_children("match", cases))
    }

    fn parse_python_if(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        tokenizer.consume_word("if")?;
        let condition = self.parse_condition(tokenizer)?;
        let then_branch = Box::new(self.parse_python_block(tokenizer)?);

        let else_branch = if tokenizer.peek_word("else") {
            tokenizer.consume_word("else")?;
            Some(Box::new(self.parse_python_block(tokenizer)?))
        } else {
            None
        };

        Ok(Self::create_node_with_children("if", vec![*then_branch]))
    }

    fn parse_python_while(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        tokenizer.consume_word("while")?;
        let condition = self.parse_condition(tokenizer)?;
        let body = Box::new(self.parse_python_block(tokenizer)?);

        Ok(Self::create_node_with_children("while", vec![*body]))
    }

    fn parse_python_for(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        tokenizer.consume_word("for")?;

        let init = "for_init".to_string();
        let condition = "for_condition".to_string();
        let update = "for_update".to_string();
        let body = Box::new(self.parse_python_block(tokenizer)?);

        Ok(Self::create_node_with_children("for", vec![*body]))
    }

    fn parse_js_if(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        tokenizer.consume_word("if")?;
        let condition = self.parse_condition(tokenizer)?;
        let then_branch = Box::new(self.parse_js_block(tokenizer)?);

        let else_branch = if tokenizer.peek_word("else") {
            tokenizer.consume_word("else")?;
            Some(Box::new(self.parse_js_block(tokenizer)?))
        } else {
            None
        };

        Ok(Self::create_node_with_children("if", vec![*then_branch]))
    }

    fn parse_js_while(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        tokenizer.consume_word("while")?;
        let condition = self.parse_condition(tokenizer)?;
        let body = Box::new(self.parse_js_block(tokenizer)?);

        Ok(Self::create_node_with_children("while", vec![*body]))
    }

    fn parse_js_for(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        tokenizer.consume_word("for")?;

        let init = "for_init".to_string();
        let condition = "for_condition".to_string();
        let update = "for_update".to_string();
        let body = Box::new(self.parse_js_block(tokenizer)?);

        Ok(Self::create_node_with_children("for", vec![*body]))
    }

    fn parse_js_switch(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        tokenizer.consume_word("switch")?;
        let condition = self.parse_condition(tokenizer)?;

        let mut cases = Vec::new();

        // Count case statements
        while !tokenizer.is_at_end() {
            if tokenizer.peek_word("case") || tokenizer.peek_word("default") {
                cases.push(AstNode::new("case".to_string()));
            }
            tokenizer.advance();
        }

        Ok(Self::create_node_with_children("switch", cases))
    }

    fn parse_condition(&self, tokenizer: &mut SimpleTokenizer) -> Result<String> {
        // Simple condition parsing - just collect until we hit a delimiter
        let mut condition = String::new();

        tokenizer.skip_whitespace();

        while !tokenizer.is_at_end() {
            let ch = tokenizer.peek_char().unwrap_or(' ');
            if ch == '{' || ch == ':' || ch == '\n' {
                break;
            }
            condition.push(ch);
            tokenizer.advance();
        }

        Ok(condition.trim().to_string())
    }

    fn parse_block(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        let mut statements = Vec::new();

        // Look for opening brace
        tokenizer.skip_whitespace();
        if tokenizer.peek_char() == Some('{') {
            tokenizer.advance(); // consume '{'

            let mut brace_count = 1;
            while !tokenizer.is_at_end() && brace_count > 0 {
                if tokenizer.peek_char() == Some('{') {
                    brace_count += 1;
                } else if tokenizer.peek_char() == Some('}') {
                    brace_count -= 1;
                }

                if brace_count > 0 {
                    if let Some(stmt) = self.parse_statement(tokenizer)? {
                        statements.push(stmt);
                    }
                } else {
                    tokenizer.advance(); // consume '}'
                }
            }
        }

        Ok(Self::create_node_with_children("block", statements))
    }

    fn parse_python_block(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        let mut statements = Vec::new();

        // Python uses indentation
        tokenizer.skip_line(); // Skip to next line

        // For simplicity, just parse a few lines
        for _ in 0..5 {
            if tokenizer.is_at_end() {
                break;
            }
            if let Some(stmt) = self.parse_python_statement(tokenizer)? {
                statements.push(stmt);
            }
        }

        Ok(Self::create_node_with_children("block", statements))
    }

    fn parse_js_block(&self, tokenizer: &mut SimpleTokenizer) -> Result<AstNode> {
        // JavaScript blocks are similar to Rust
        self.parse_block(tokenizer)
    }
}

impl Default for Parser {
    fn default() -> Self {
        Self::new().expect("Failed to create Parser")
    }
}