#![forbid(unsafe_code)]
pub mod ast;
pub mod diagnostics;
mod kind;
mod lexer;
pub mod ops;
mod parser;
pub mod tokens;
mod tree;
pub use diagnostics::{Code, Diagnostic, Severity};
pub use kind::{SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, TlaLanguage};
pub use rowan::{GreenNode, TextRange, TextSize};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Parse {
green: GreenNode,
diagnostics: Vec<Diagnostic>,
}
impl Parse {
#[must_use]
pub fn syntax(&self) -> SyntaxNode {
SyntaxNode::new_root(self.green.clone())
}
#[must_use]
pub fn green(&self) -> &GreenNode {
&self.green
}
#[must_use]
pub fn diagnostics(&self) -> &[Diagnostic] {
&self.diagnostics
}
#[must_use]
pub fn is_ok(&self) -> bool {
!self.diagnostics.iter().any(Diagnostic::is_error)
}
#[must_use]
pub fn module(&self) -> Option<ast::Module> {
ast::SourceFile::cast(self.syntax()).and_then(|f| f.module())
}
#[must_use]
pub fn check_file_name(&self, file_name: &str) -> Option<Diagnostic> {
if !self.is_ok() {
return None;
}
let stem = file_name.rfind('.').map_or(file_name, |i| &file_name[..i]);
let module = self.module()?;
let name = module.name()?;
if name == stem {
return None;
}
let range = module
.syntax()
.children()
.find(|n| n.kind() == SyntaxKind::MODULE_HEADER)
.and_then(|h| {
h.children_with_tokens()
.filter_map(rowan::NodeOrToken::into_token)
.find(|t| t.kind() == SyntaxKind::IDENT)
})
.map_or_else(|| module.syntax().text_range(), |t| t.text_range());
Some(
Diagnostic::error(
Code::ModuleNameMismatch,
range,
format!("file name `{stem}` does not match the module name `{name}`"),
)
.with_help(format!(
"rename the file to `{name}.tla` or the module to `{stem}`"
)),
)
}
}
use ast::AstNode as _;
#[must_use]
pub fn parse_module(source: &str) -> Parse {
if u32::try_from(source.len()).is_err() {
let mut b = rowan::GreenNodeBuilder::new();
b.start_node(SyntaxKind::SOURCE_FILE.into());
b.finish_node();
return Parse {
green: b.finish(),
diagnostics: vec![Diagnostic::error(
Code::InputTooLarge,
TextRange::empty(TextSize::from(0)),
"input larger than 4 GiB is not supported",
)],
};
}
let lexed = lexer::lex(source);
let out = parser::Parser::new(source, &lexed).parse();
let green = tree::build_green(
&out.root,
&tree::GreenInput {
src: source,
lexed: &lexed,
sig: &out.sig,
kinds: &out.kinds,
trailer_from: out.trailer_from,
},
);
let mut diagnostics = parser::lexer_diagnostics(&lexed, out.trailer_from);
diagnostics.extend(out.diags);
diagnostics.sort_by_key(|d| (d.range.start(), d.range.end()));
Parse { green, diagnostics }
}