Function parse_source

prqlc/prqlc-parser/src/test.rs:11–56

Parse into statements

(source: &str)

/// Parse into statements
pub(crate) fn parse_source(source: &str) -> Result<Vec<Stmt>, Vec<Error>> {
    let tokens = crate::lexer::lex_source(source)?;

    // Filter out comments
    let semantic_tokens: Vec<_> = tokens
        .0
        .into_iter()
        .filter(|token| {
            !matches!(
                token.kind,
                crate::lexer::lr::TokenKind::Comment(_) | crate::lexer::lr::TokenKind::LineWrap(_)
            )
        })
        .collect();

    let input = semantic_tokens
        .as_slice()
        .map_span(|simple_span: SimpleSpan| {
            let start_idx = simple_span.start();
            let end_idx = simple_span.end();

            let start = semantic_tokens
                .get(start_idx)
                .map(|t| t.span.start)
                .unwrap_or(0);
            let end = semantic_tokens
                .get(end_idx.saturating_sub(1))
                .map(|t| t.span.end)
                .unwrap_or(start);

            Span {
                start,
                end,
                source_id: 0,
            }
        });

    let parse_result = stmt::source().parse(input);
    let (ast, parse_errors) = parse_result.into_output_errors();

    if !parse_errors.is_empty() {
        log::info!("ast: {ast:?}");
        return Err(parse_errors.into_iter().map(|e| e.into()).collect());
    }
    Ok(ast.unwrap())
}

#[test]
fn test_error_unicode_string() {