use std::path::PathBuf;
use crate::OptimizationOptions;
#[cfg(feature = "generator")]
use crate::emission::emit_files_with_options;
use crate::error::{Diagnostic, EmitError, Severity};
#[derive(Clone, Debug)]
pub struct Config {
grammars: Vec<PathBuf>,
out_dir: Option<PathBuf>,
lib_dirs: Vec<PathBuf>,
gen_listener: bool,
gen_visitor: bool,
cargo_directives: bool,
quiet: bool,
optimization: OptimizationOptions,
pinned_release_version: Option<String>,
pinned_release_sha256: Option<String>,
pinned_release_base_url: Option<String>,
}
impl Config {
pub fn new(grammar: impl Into<PathBuf>) -> Self {
Self {
grammars: vec![grammar.into()],
out_dir: None,
lib_dirs: Vec::new(),
gen_listener: true,
gen_visitor: false,
cargo_directives: true,
quiet: false,
optimization: OptimizationOptions::default(),
pinned_release_version: None,
pinned_release_sha256: None,
pinned_release_base_url: None,
}
}
pub fn grammar(&mut self, grammar: impl Into<PathBuf>) -> &mut Self {
self.grammars.push(grammar.into());
self
}
pub fn out_dir(&mut self, out_dir: impl Into<PathBuf>) -> &mut Self {
self.out_dir = Some(out_dir.into());
self
}
pub fn lib_dir(&mut self, dir: impl Into<PathBuf>) -> &mut Self {
self.lib_dirs.push(dir.into());
self
}
pub const fn listener(&mut self, generate: bool) -> &mut Self {
self.gen_listener = generate;
self
}
pub const fn visitor(&mut self, generate: bool) -> &mut Self {
self.gen_visitor = generate;
self
}
pub const fn cargo_directives(&mut self, print: bool) -> &mut Self {
self.cargo_directives = print;
self
}
pub const fn quiet(&mut self, enabled: bool) -> &mut Self {
self.quiet = enabled;
self
}
pub const fn static_lexer_dfa(&mut self, enabled: bool) -> &mut Self {
self.optimization.static_lexer_dfa(enabled);
self
}
pub const fn static_parser_dfa(&mut self, enabled: bool) -> &mut Self {
self.optimization.static_parser_dfa(enabled);
self
}
pub const fn static_dfa_only(&mut self, enabled: bool) -> &mut Self {
self.optimization.static_dfa_only(enabled);
self
}
pub fn dump_dfas(&mut self, spec: impl Into<String>) -> &mut Self {
self.optimization.dump_dfas(spec);
self
}
pub const fn profile_decisions(&mut self, enabled: bool) -> &mut Self {
self.optimization.profile_decisions(enabled);
self
}
pub const fn optimization(&mut self) -> &mut OptimizationOptions {
&mut self.optimization
}
pub fn entry_rule(&mut self, name: impl Into<String>) -> &mut Self {
self.optimization.entry_rule(name);
self
}
pub const fn prune_unreachable_rules(&mut self, enabled: bool) -> &mut Self {
self.optimization.prune_unreachable_rules(enabled);
self
}
pub const fn inline_trivial_rules(&mut self, enabled: bool) -> &mut Self {
self.optimization.inline_trivial_rules(enabled);
self
}
pub const fn optimize_precedence_ladders(&mut self, enabled: bool) -> &mut Self {
self.optimization.optimize_precedence_ladders(enabled);
self
}
pub const fn report_only(&mut self, enabled: bool) -> &mut Self {
self.optimization.report_only(enabled);
self
}
pub const fn strict(&mut self, enabled: bool) -> &mut Self {
self.optimization.strict(enabled);
self
}
#[cfg(feature = "download")]
pub fn pinned_release(&mut self, version: impl Into<String>) -> &mut Self {
self.pinned_release_version = Some(version.into());
self
}
#[cfg(feature = "download")]
pub fn pinned_release_sha256(&mut self, sha256: impl Into<String>) -> &mut Self {
self.pinned_release_sha256 = Some(sha256.into());
self
}
#[cfg(feature = "download")]
pub fn pinned_release_base_url(&mut self, base_url: impl Into<String>) -> &mut Self {
self.pinned_release_base_url = Some(base_url.into());
self
}
#[allow(clippy::print_stdout)]
pub fn generate(&self) -> Result<Vec<PathBuf>, EmitError> {
let generation = self.generate_detailed()?;
if self.cargo_directives {
for directive in cargo_warnings(generation.diagnostics(), self.quiet) {
println!("{directive}");
}
}
Ok(generation.into_written_files())
}
#[allow(clippy::print_stdout)]
pub fn generate_detailed(&self) -> Result<Generation, EmitError> {
if self.grammars.is_empty() {
return Err(EmitError::Config("no grammars configured".to_owned()));
}
if self.cargo_directives {
for grammar in &self.grammars {
println!("cargo:rerun-if-changed={}", grammar.display());
if let Some(parent) = grammar.parent().filter(|dir| !dir.as_os_str().is_empty()) {
println!("cargo:rerun-if-changed={}", parent.display());
}
}
for dir in &self.lib_dirs {
println!("cargo:rerun-if-changed={}", dir.display());
}
}
if let Some(version) = &self.pinned_release_version {
let out_dir = self.output_dir()?;
create_out_dir(&out_dir)?;
return self.generate_pinned(version, &out_dir);
}
let out_dir = if self.optimization.is_report_only() {
None
} else {
let out_dir = self.output_dir()?;
create_out_dir(&out_dir)?;
Some(out_dir)
};
self.generate_in_process(out_dir.as_deref())
}
fn output_dir(&self) -> Result<PathBuf, EmitError> {
if let Some(dir) = &self.out_dir {
return Ok(dir.clone());
}
let out_dir = std::env::var_os("OUT_DIR").ok_or_else(|| {
EmitError::Config(
"no output directory: call Config::out_dir or run from a build \
script (OUT_DIR is not set)"
.to_owned(),
)
})?;
Ok(PathBuf::from(out_dir))
}
#[cfg(feature = "download")]
fn generate_pinned(
&self,
version: &str,
out_dir: &std::path::Path,
) -> Result<Generation, EmitError> {
if self.optimization.has_parser_reports() {
return Err(EmitError::Config(
"dump_dfas and profile_decisions need the in-process generator; \
pinned-release generation cannot render their reports"
.to_owned(),
));
}
let release = crate::download::PinnedRelease {
version: version.to_owned(),
expected_sha256: self.pinned_release_sha256.clone(),
base_url: self.pinned_release_base_url.clone(),
};
let written = crate::download::generate_with_pinned_binary(
&release,
&self.grammars,
&self.lib_dirs,
self.gen_listener,
self.gen_visitor,
&self.optimization,
out_dir,
)?;
Ok(Generation {
written,
diagnostics: Vec::new(),
optimization_messages: Vec::new(),
reports: Vec::new(),
})
}
#[cfg(not(feature = "download"))]
fn generate_pinned(
&self,
version: &str,
out_dir: &std::path::Path,
) -> Result<Generation, EmitError> {
let _ = (version, out_dir);
let _ = (&self.pinned_release_sha256, &self.pinned_release_base_url);
Err(EmitError::Config(
"pinned_release requires the `download` feature of dbt-antlr-codegen".to_owned(),
))
}
#[cfg(feature = "generator")]
fn generate_in_process(
&self,
out_dir: Option<&std::path::Path>,
) -> Result<Generation, EmitError> {
let mut written = Vec::new();
let mut diagnostics = Vec::new();
let mut optimization_messages = Vec::new();
let mut reports = Vec::new();
for grammar in &self.grammars {
let output = emit_files_with_options(
grammar,
&self.lib_dirs,
self.gen_listener,
self.gen_visitor,
&self.optimization,
)?;
if let Some(out_dir) = out_dir {
for file in &output.files {
let path = out_dir.join(&file.name);
std::fs::write(&path, &file.content).map_err(|source| EmitError::Write {
path: path.clone(),
source,
})?;
written.push(path);
}
write_optimization_manifest(
out_dir,
grammar,
output.optimization_manifest,
&mut written,
)?;
}
diagnostics.extend(output.diagnostics);
optimization_messages.extend(output.optimization_messages);
reports.extend(output.reports);
}
Ok(Generation {
written,
diagnostics,
optimization_messages,
reports,
})
}
#[cfg(not(feature = "generator"))]
fn generate_in_process(
&self,
out_dir: Option<&std::path::Path>,
) -> Result<Generation, EmitError> {
let _ = out_dir;
Err(EmitError::Config(
"this build of dbt-antlr-codegen was compiled without the `generator` feature; \
enable it or use Config::pinned_release"
.to_owned(),
))
}
}
fn cargo_warnings(diagnostics: &[Diagnostic], quiet: bool) -> Vec<String> {
diagnostics
.iter()
.filter(|diagnostic| !quiet || diagnostic.severity() == Severity::Error)
.flat_map(|diagnostic| {
diagnostic
.to_string()
.lines()
.map(|line| format!("cargo:warning={line}"))
.collect::<Vec<_>>()
})
.collect()
}
fn create_out_dir(out_dir: &std::path::Path) -> Result<(), EmitError> {
std::fs::create_dir_all(out_dir).map_err(|source| EmitError::Write {
path: out_dir.to_path_buf(),
source,
})
}
#[cfg(feature = "generator")]
fn write_optimization_manifest(
out_dir: &std::path::Path,
grammar: &std::path::Path,
manifest: Option<String>,
written: &mut Vec<PathBuf>,
) -> Result<(), EmitError> {
let path = out_dir.join(optimization_manifest_name(grammar));
match manifest {
Some(manifest) => {
std::fs::write(&path, manifest).map_err(|source| EmitError::Write {
path: path.clone(),
source,
})?;
written.push(path);
}
None => remove_stale_manifest(&path)?,
}
for legacy in ["optimizations.txt", "optimizations.json"] {
remove_stale_manifest(&out_dir.join(legacy))?;
}
Ok(())
}
#[cfg(feature = "generator")]
fn optimization_manifest_name(grammar: &std::path::Path) -> String {
let stem = grammar
.file_stem()
.map_or_else(String::new, |stem| stem.to_string_lossy().to_lowercase());
format!("{stem}.optimizations.txt")
}
#[cfg(feature = "generator")]
fn remove_stale_manifest(path: &std::path::Path) -> Result<(), EmitError> {
match std::fs::remove_file(path) {
Ok(()) => Ok(()),
Err(source) if source.kind() == std::io::ErrorKind::NotFound => Ok(()),
Err(source) => Err(EmitError::Write {
path: path.to_path_buf(),
source,
}),
}
}
#[derive(Clone, Debug)]
pub struct Generation {
written: Vec<PathBuf>,
diagnostics: Vec<Diagnostic>,
optimization_messages: Vec<String>,
reports: Vec<String>,
}
impl Generation {
pub fn written_files(&self) -> &[PathBuf] {
&self.written
}
pub fn diagnostics(&self) -> &[Diagnostic] {
&self.diagnostics
}
pub fn optimization_messages(&self) -> &[String] {
&self.optimization_messages
}
pub fn reports(&self) -> &[String] {
&self.reports
}
pub fn into_written_files(self) -> Vec<PathBuf> {
self.written
}
}
#[cfg(all(test, feature = "generator"))]
mod tests {
use std::path::PathBuf;
use super::cargo_warnings;
use crate::error::{Diagnostic, Severity};
#[test]
fn cargo_warnings_give_each_diagnostic_line_a_directive() {
let diagnostics = [
Diagnostic::new(
"G4S030",
Severity::Warning,
"implicit definition of token CACHE in parser".to_owned(),
PathBuf::from("P.g4"),
Some((3, 24)),
None,
),
Diagnostic::new(
"G4S192",
Severity::Warning,
"first line\nsecond line".to_owned(),
PathBuf::from("P.g4"),
None,
None,
),
];
assert_eq!(
cargo_warnings(&diagnostics, false),
[
"cargo:warning=warning[G4S030]: P.g4:3:24: implicit definition of token CACHE in parser",
"cargo:warning=warning[G4S192]: P.g4: first line",
"cargo:warning=second line",
]
);
}
#[test]
fn quiet_cargo_warnings_keep_only_the_errors() {
let diagnostics = [
Diagnostic::new(
"G4S192",
Severity::Warning,
"lookahead budget".to_owned(),
PathBuf::from("P.g4"),
Some((7, 1)),
None,
),
Diagnostic::new(
"G4S030",
Severity::Error,
"implicit definition of token CACHE in parser".to_owned(),
PathBuf::from("P.g4"),
Some((3, 24)),
None,
),
];
assert_eq!(
cargo_warnings(&diagnostics, true),
[
"cargo:warning=error[G4S030]: P.g4:3:24: implicit definition of token CACHE in parser"
]
);
}
}