use std::path::{Path, PathBuf};
use crate::error::Error;
use crate::grammar::atn::{encode_lexer_atn, encode_packed_atn};
use crate::grammar::compiler;
use crate::grammar::loader::LoadOptions;
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct GrammarAtnData {
pub name: String,
pub parser_packed_words: Option<Vec<u32>>,
pub lexer_atn_words: Option<Vec<i32>>,
}
pub fn compile_atn_data(
grammar_path: &Path,
library_directories: &[PathBuf],
) -> Result<Vec<GrammarAtnData>, Error> {
let roots = vec![grammar_path.to_path_buf()];
let compilation = compiler::compile(LoadOptions {
roots: roots.clone(),
library_directories: library_directories.to_vec(),
})
.map_err(|error| crate::compile_error::compilation_error(&error, &roots))?;
let mut units = Vec::with_capacity(compilation.parsers.len() + compilation.lexers.len());
units.extend(compilation.parsers.values().map(|parser| GrammarAtnData {
name: parser.semantic.unit.name.clone(),
parser_packed_words: Some(encode_packed_atn(parser.atn)),
lexer_atn_words: None,
}));
units.extend(compilation.lexers.values().map(|lexer| GrammarAtnData {
name: lexer.semantic.unit.name.clone(),
parser_packed_words: None,
lexer_atn_words: Some(encode_lexer_atn(lexer.atn)),
}));
Ok(units)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::grammar::atn::SERIALIZED_VERSION;
use dbt_antlr_runtime::atn_packed_deserializer::PackedATNDeserializer;
const PARSER_ATN_MAGIC: u32 = 0x5041_544e;
const PARSER_ATN_FORMAT_VERSION: u32 = 3;
#[test]
fn parser_grammar_exports_packed_words() {
let units = compile_atn_data(&fixture("parser-basic").join("ParserBasic.g4"), &[])
.expect("parser fixture should compile");
let [unit] = units.as_slice() else {
panic!("parser-only fixture should produce one unit");
};
assert_eq!(unit.name, "ParserBasic");
assert!(unit.lexer_atn_words.is_none());
let packed = unit
.parser_packed_words
.as_ref()
.expect("parser unit has packed words");
assert!(packed.len() > 2);
assert_eq!(packed[0], PARSER_ATN_MAGIC);
assert_eq!(packed[1], PARSER_ATN_FORMAT_VERSION);
PackedATNDeserializer::new()
.deserialize(packed)
.expect("packed words should deserialize");
}
#[test]
fn combined_grammar_exports_parser_and_lexer_words() {
let units = compile_atn_data(&fixture("vscode-sentences").join("sentences.g4"), &[])
.expect("combined fixture should compile");
let parser = units
.iter()
.find(|unit| unit.parser_packed_words.is_some())
.expect("combined grammar yields a parser unit");
let lexer = units
.iter()
.find(|unit| unit.lexer_atn_words.is_some())
.expect("combined grammar yields a lexer unit");
assert_eq!(parser.name, "sentencesParser");
assert_eq!(lexer.name, "sentencesLexer");
let packed = parser
.parser_packed_words
.as_ref()
.expect("parser unit has packed words");
assert_eq!(packed[0], PARSER_ATN_MAGIC);
assert_eq!(packed[1], PARSER_ATN_FORMAT_VERSION);
PackedATNDeserializer::new()
.deserialize(packed)
.expect("packed words should deserialize");
let words = lexer
.lexer_atn_words
.as_ref()
.expect("lexer unit has ATN words");
assert!(words.len() > 2);
assert_eq!(words[0], SERIALIZED_VERSION);
assert_eq!(words[1], 0, "lexer grammar type");
}
fn fixture(name: &str) -> PathBuf {
Path::new(env!("CARGO_MANIFEST_DIR"))
.join("tests/codegen-direct/fixtures")
.join(name)
}
}