ruka_syntax/

lib.rs

//! Syntax crate for lexing, parsing, CST helpers, and browser graph rendering.

/// Frontend AST re-exports used by the parser and downstream stages.
pub mod ast {
    pub use ruka_frontend::*;
}

/// Parser and syntax helpers re-exported under the historic `syntax` path.
pub mod syntax {
    pub use crate::SourceLocation;
    pub use crate::SyntaxError;
    pub use crate::ast;
    pub use crate::browser_graph;
    pub use crate::cst;
    pub use crate::lexer;
    pub use crate::parse_program;
    pub use crate::parse_program_cst;
    pub use crate::parse_program_with_file_id;
    pub use crate::token;
}

/// Browser-friendly AST graph rendering for interactive viewers.
pub mod browser_graph;
/// Concrete syntax tree helpers built from parsed AST values.
pub mod cst;
/// Token stream lexer for source text.
pub mod lexer;
/// Token and lex-error definitions used by the parser.
pub mod token;

use lalrpop_util::ParseError;
use thiserror::Error;

use crate::ast::{ExternFunctionDecl, Program, TypeExpr};
use crate::cst::SyntaxNode;
use crate::lexer::Lexer;
use crate::token::{LexError, Token};

/// Generated LALRPOP parser implementation.
mod grammar {
    include!(concat!(env!("OUT_DIR"), "/grammar.rs"));
}

pub use ruka_frontend::{FileId, SourceLocation};

/// Parser error reported while lexing or parsing source text.
#[derive(Debug, Error)]
pub enum SyntaxError {
    /// Lexing failed before parsing could continue.
    #[error("{error}")]
    Lex {
        /// Underlying lexer error.
        error: LexError,
    },
    /// Parser encountered an unexpected token.
    #[error(
        "unexpected token {found:?} at {line}:{column} (byte {byte})",
        line = location.line,
        column = location.column,
        byte = location.byte
    )]
    UnexpectedToken {
        /// Source location of the unexpected token.
        location: SourceLocation,
        /// Unexpected token value.
        found: Token,
    },
    /// Parser reached end of input unexpectedly.
    #[error(
        "unexpected end of input at {line}:{column} (byte {byte})",
        line = location.line,
        column = location.column,
        byte = location.byte
    )]
    UnexpectedEof {
        /// Source location where input ended.
        location: SourceLocation,
    },
    /// Parser reported an invalid token location.
    #[error(
        "invalid token at {line}:{column} (byte {byte})",
        line = location.line,
        column = location.column,
        byte = location.byte
    )]
    InvalidToken {
        /// Source location of the invalid token.
        location: SourceLocation,
    },
    /// Extern signature contained a generic type application.
    #[error(
        "generic type applications are not allowed in extern signatures at {line}:{column} (byte {byte})",
        line = location.line,
        column = location.column,
        byte = location.byte
    )]
    InvalidExternTypeApplication {
        /// Source location of the invalid extern type expression.
        location: SourceLocation,
    },
}

/// Parse a source string into a frontend program AST.
pub fn parse_program(input: &str) -> Result<Program, SyntaxError> {
    parse_program_with_file_id(FileId::from_u32(0), input)
}

/// Parse a source string into a frontend program AST with a concrete file id.
pub fn parse_program_with_file_id(file_id: FileId, input: &str) -> Result<Program, SyntaxError> {
    let mut tokens = Vec::new();
    for item in Lexer::new(input) {
        tokens.push(item.map_err(|error| SyntaxError::Lex { error })?);
    }
    let tokens: Vec<_> = tokens
        .into_iter()
        .filter(|(_, token, _)| !matches!(token, Token::Comment))
        .collect();
    let program = grammar::ProgramParser::new()
        .parse(file_id, tokens.into_iter())
        .map_err(map_parse_error)?;
    validate_extern_signatures(&program)?;
    Ok(program)
}

/// Parse a source string and build a CST view from the resulting AST.
pub fn parse_program_cst(input: &str) -> Result<SyntaxNode, SyntaxError> {
    let ast = parse_program(input)?;
    Ok(cst::build_program_cst(&ast))
}

fn map_parse_error(error: ParseError<SourceLocation, Token, LexError>) -> SyntaxError {
    match error {
        ParseError::InvalidToken { location } => SyntaxError::InvalidToken { location },
        ParseError::UnrecognizedEof { location, .. } => SyntaxError::UnexpectedEof { location },
        ParseError::UnrecognizedToken { token, .. } => {
            let (start, found, _) = token;
            SyntaxError::UnexpectedToken {
                location: start,
                found,
            }
        }
        ParseError::ExtraToken { token } => {
            let (start, found, _) = token;
            SyntaxError::UnexpectedToken {
                location: start,
                found,
            }
        }
        ParseError::User { error } => SyntaxError::Lex { error },
    }
}

fn validate_extern_signatures(program: &Program) -> Result<(), SyntaxError> {
    for module in &program.extern_modules {
        for function in &module.functions {
            validate_extern_function(function)?;
        }
    }
    Ok(())
}

fn validate_extern_function(function: &ExternFunctionDecl) -> Result<(), SyntaxError> {
    for param in &function.params {
        reject_extern_type_apply(&param.ty.ty, function)?;
    }
    reject_extern_type_apply(&function.return_type.ty, function)
}

fn reject_extern_type_apply(
    ty: &TypeExpr,
    function: &ExternFunctionDecl,
) -> Result<(), SyntaxError> {
    match ty {
        TypeExpr::TypeKind | TypeExpr::Named(_) => Ok(()),
        TypeExpr::Pointer { item } | TypeExpr::Slice { item } => {
            reject_extern_type_apply(item, function)
        }
        TypeExpr::Array { item, .. } => reject_extern_type_apply(item, function),
        TypeExpr::Tuple(items) => {
            for item in items {
                reject_extern_type_apply(item, function)?;
            }
            Ok(())
        }
        TypeExpr::Apply { .. } => Err(SyntaxError::InvalidExternTypeApplication {
            location: function.span.start,
        }),
        TypeExpr::Struct { fields } | TypeExpr::Union { fields } => {
            for field in fields {
                reject_extern_type_apply(&field.ty, function)?;
            }
            Ok(())
        }
        TypeExpr::Enum { variants } => {
            for variant in variants {
                for payload in &variant.payload {
                    reject_extern_type_apply(payload, function)?;
                }
            }
            Ok(())
        }
    }
}

#[cfg(test)]
mod tests;