use proc_macro2::{Delimiter, TokenStream, TokenTree};
use syn::spanned::Spanned;
use syn::visit::Visit;
use super::super::face::{compact, split_typed_range};
use super::super::{FaceSyntaxError, SyntaxLocation, compact_tokens, location, syntax_error};
fn endpoint_span(span: proc_macro2::Span) -> GraftEndpointSpan {
let end = span.end();
GraftEndpointSpan {
start: location(span),
end: SyntaxLocation {
line: end.line,
column: end.column + 1,
},
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct GraftSyntax {
pub cut: String,
pub cut_end: Option<String>,
pub graft: String,
pub full: bool,
pub location: SyntaxLocation,
pub cfg: Option<String>,
pub expressions: Option<GraftExpressions>,
pub spans: Option<GraftSpans>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct GraftEndpointSpan {
pub start: SyntaxLocation,
pub end: SyntaxLocation,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct GraftSpans {
pub cut: GraftEndpointSpan,
pub cut_end: Option<GraftEndpointSpan>,
pub graft: GraftEndpointSpan,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct GraftExpressions {
pub cut: String,
pub cut_end: Option<String>,
pub graft: String,
}
struct GraftVisitor<'a> {
entries: &'a mut Vec<GraftSyntax>,
error: Option<FaceSyntaxError>,
module_cfgs: Vec<String>,
imports: super::super::imports::Imports,
}
impl<'ast> Visit<'ast> for GraftVisitor<'_> {
fn visit_file(&mut self, file: &'ast syn::File) {
super::super::imports::collect(&file.items, &mut self.imports);
syn::visit::visit_file(self, file);
}
fn visit_item_const(&mut self, item: &'ast syn::ItemConst) {
if self.error.is_some() {
return;
}
let gates = item
.attrs
.iter()
.filter(|a| a.path().is_ident("cfg"))
.filter_map(|a| a.parse_args::<TokenStream>().ok())
.map(|t| compact(&t))
.collect::<Vec<_>>();
if gates.iter().any(|gate| cfg_is_test_only(gate)) {
return;
}
match super::native_graft::entries(item, &self.imports) {
Ok(Some(entries)) => {
let own = combined_cfg(&gates, None);
for mut entry in entries {
entry.cfg = combined_cfg(&self.module_cfgs, own.as_deref());
self.entries.push(entry);
}
}
Ok(None) => {}
Err(error) => self.error = Some(error),
}
}
fn visit_item_fn(&mut self, _: &'ast syn::ItemFn) {}
fn visit_item_macro(&mut self, item: &'ast syn::ItemMacro) {
self.visit_macro_entry(item);
}
fn visit_item_mod(&mut self, item: &'ast syn::ItemMod) {
let gates = module_cfgs(item);
if gates.iter().any(|gate| cfg_is_test_only(gate)) {
return;
}
let saved_imports = self.imports.clone();
if let Some((_, items)) = &item.content {
super::super::imports::collect(items, &mut self.imports);
}
let depth = self.module_cfgs.len();
self.module_cfgs.extend(gates);
syn::visit::visit_item_mod(self, item);
self.module_cfgs.truncate(depth);
self.imports = saved_imports;
}
}
fn module_cfgs(item: &syn::ItemMod) -> Vec<String> {
item.attrs
.iter()
.filter(|attribute| attribute.path().is_ident("cfg"))
.filter_map(|attribute| {
attribute
.parse_args::<TokenStream>()
.ok()
.map(|tokens| compact(&tokens))
})
.collect()
}
fn cfg_is_test_only(expression: &str) -> bool {
syn::parse_str::<syn::Meta>(expression).is_ok_and(|meta| cfg_meta_is_test_only(&meta))
}
fn cfg_meta_is_test_only(meta: &syn::Meta) -> bool {
match meta {
syn::Meta::Path(path) => path.is_ident("test"),
syn::Meta::List(list) => {
let Ok(nested) = list.parse_args_with(
syn::punctuated::Punctuated::<syn::Meta, syn::Token![,]>::parse_terminated,
) else {
return false;
};
if list.path.is_ident("all") {
nested.iter().any(cfg_meta_is_test_only)
} else if list.path.is_ident("any") {
!nested.is_empty() && nested.iter().all(cfg_meta_is_test_only)
} else {
false
}
}
syn::Meta::NameValue(_) => false,
}
}
fn combined_cfg(module_cfgs: &[String], own: Option<&str>) -> Option<String> {
let mut gates = module_cfgs.to_vec();
gates.extend(own.map(str::to_owned));
match gates.len() {
0 => None,
1 => gates.pop(),
_ => Some(format!("all({})", gates.join(", "))),
}
}
impl<'a> GraftVisitor<'a> {
fn visit_macro_entry(&mut self, item: &syn::ItemMacro) {
let cfg = item.attrs.iter().find_map(|attribute| {
attribute
.path()
.is_ident("cfg")
.then(|| {
attribute
.parse_args::<TokenStream>()
.ok()
.map(|tokens| compact(&tokens))
})
.flatten()
});
let mac = &item.mac;
let Some(name) = mac
.path
.segments
.last()
.map(|segment| segment.ident.to_string())
else {
return;
};
if !matches!(
name.as_str(),
"runtime_graft_plan" | "graft_plan" | "static_graft_plan"
) {
return;
}
let tokens = mac.tokens.clone().into_iter().collect::<Vec<_>>();
let mut index = 0;
while index < tokens.len() {
if !matches!(&tokens[index], TokenTree::Ident(value) if value == "cut") {
index += 1;
continue;
}
index += 1;
let path_token = tokens.get(index).cloned();
index += 1;
let typed_cut = match &path_token {
Some(TokenTree::Group(group)) if group.delimiter() == Delimiter::Parenthesis => {
let inner = group.stream().into_iter().collect::<Vec<_>>();
let pair = match split_typed_range(inner) {
Some((start, finish)) => (start, Some(finish)),
None => (compact_tokens(group.stream()), None),
};
Some((pair, group.span()))
}
_ => None,
};
let (cut, end, cut_span, typed) = match typed_cut {
Some(((start, finish), span)) => (start, finish, span, true),
None => {
let (path_tokens, path_span, path_text) = match path_token {
Some(TokenTree::Group(group)) => (
group.stream().into_iter().collect::<Vec<_>>(),
group.span(),
None,
),
Some(TokenTree::Literal(literal)) => {
let text = syn::parse_str::<syn::LitStr>(&literal.to_string())
.map(|value| value.value())
.map_err(|_| {
syntax_error(literal.span(), "graft cut path must be a string")
});
let Ok(text) = text else {
self.error = text.err();
return;
};
(Vec::new(), literal.span(), Some(text))
}
_ => {
self.error = Some(syntax_error(
mac.span(),
"graft cut expects `[path]`, a path string, or `(<expression>)`",
));
return;
}
};
let range = path_text.is_none()
&& path_tokens.len() == 3
&& matches!(&path_tokens[1], TokenTree::Ident(value) if value == "to");
let resolved = if range {
let start = syn::parse2::<syn::LitStr>(path_tokens[0].clone().into())
.map_err(|_| {
syntax_error(path_span, "graft range start must be a string")
});
let finish = syn::parse2::<syn::LitStr>(path_tokens[2].clone().into())
.map_err(|_| {
syntax_error(path_span, "graft range end must be a string")
});
match (start, finish) {
(Ok(start), Ok(finish)) => Ok((start.value(), Some(finish.value()))),
(Err(error), _) | (_, Err(error)) => Err(error),
}
} else {
Ok((
path_text.unwrap_or_else(|| {
syn::parse2::<syn::LitStr>(
path_tokens.clone().into_iter().collect(),
)
.map(|value| value.value())
.unwrap_or_else(|_| {
path_tokens
.iter()
.map(ToString::to_string)
.collect::<String>()
})
}),
None,
))
};
let (cut, end) = match resolved {
Ok(pair) => pair,
Err(error) => {
self.error = Some(error);
return;
}
};
(cut, end, path_span, false)
}
};
if cut.is_empty() {
self.error = Some(syntax_error(cut_span, "graft cut path is empty"));
return;
}
let full =
matches!(tokens.get(index), Some(TokenTree::Ident(value)) if value == "full");
if full {
index += 1;
if end.is_some() {
self.error = Some(syntax_error(cut_span, range_full_refusal()));
return;
}
}
if !matches!(tokens.get(index), Some(TokenTree::Ident(value)) if value == "graft") {
let misplaced_full =
matches!(tokens.get(index), Some(TokenTree::Ident(value)) if value == "full");
self.error = Some(syntax_error(
cut_span,
if misplaced_full {
"`full` is written **before** `graft`: `cut(…) [to …] full graft(…)`"
} else {
"graft cut expects `graft <implementation>`"
},
));
return;
}
index += 1;
let graft_token = tokens.get(index).cloned();
let mut graft_span = None;
let (graft, graft_expr) = match graft_token {
Some(TokenTree::Group(group)) if group.delimiter() == Delimiter::Parenthesis => {
graft_span = Some(group.span());
let text = compact_tokens(group.stream());
(text.clone(), Some(text))
}
Some(TokenTree::Literal(value)) => {
let Ok(text) = syn::parse_str::<syn::LitStr>(&value.to_string()) else {
self.error = Some(syntax_error(
value.span(),
"graft implementation must be a string literal or `(<expression>)`",
));
return;
};
(text.value(), None)
}
_ => {
self.error = Some(syntax_error(
cut_span,
"graft expects a string literal or `(<expression>)`",
));
return;
}
};
let expressions = match (typed, graft_expr) {
(true, Some(graft)) => Some(GraftExpressions {
cut: crate::syntax::catalog_reference(&cut),
cut_end: end.as_deref().map(crate::syntax::catalog_reference),
graft: crate::syntax::catalog_reference(&graft),
}),
(false, None) => None,
_ => {
self.error = Some(syntax_error(
cut_span,
"a graft cut must name both sides with Rust expressions or both with strings",
));
return;
}
};
if let Some(TokenTree::Ident(stray)) = tokens.get(index + 1)
&& stray == "full"
{
self.error = Some(syntax_error(
stray.span(),
"`full` is written **before** `graft`: `cut(…) [to …] full graft(…)`",
));
return;
}
let is_typed_range = typed && end.is_some();
self.entries.push(GraftSyntax {
cut,
cut_end: end,
graft,
full,
location: location(cut_span),
cfg: combined_cfg(&self.module_cfgs, cfg.as_deref()),
expressions,
spans: (!is_typed_range && typed).then(|| {
GraftSpans {
cut: endpoint_span(cut_span),
cut_end: None,
graft: endpoint_span(graft_span.unwrap_or(cut_span)),
}
}),
});
index += 1;
}
}
}
pub fn render_graft_expression(
cut: &str,
cut_end: Option<&str>,
full: bool,
graft: &str,
) -> Result<String, FaceSyntaxError> {
for (what, value) in [("cut", cut), ("graft", graft)] {
if value.trim().is_empty() {
return Err(spelling_error(format!("{what} must not be empty")));
}
if value.contains(['"', '[', ']', '\n', '\r']) {
return Err(spelling_error(format!(
"{what} `{value}` carries punctuation that belongs to another spelling of this \
grammar; this renderer writes the typed-expression form only"
)));
}
if value.split("::").any(|segment| segment.trim() == "to") {
return Err(spelling_error(format!(
"{what} `{value}` has a `to` segment, which the parser reads as a range separator"
)));
}
}
if let Some(end) = cut_end
&& (end.trim().is_empty() || end.contains(['"', '[', ']', '\n', '\r']))
{
return Err(spelling_error(format!(
"the range end `{end}` is not an expression this renderer can write"
)));
}
if cut_end.is_some() && full {
return Err(spelling_error(range_full_refusal()));
}
let range = cut_end.map_or(String::new(), |end| format!(" to {end}"));
let whole = if full { " full" } else { "" };
Ok(format!("cut({cut}{range}){whole} graft({graft})"))
}
fn range_full_refusal() -> String {
"`full` on a range cut has no defined meaning: a range already names every slot it covers, so \
there is no one subtree for `full` to replace. Write one cut per face, or drop `full`."
.to_owned()
}
fn spelling_error(message: String) -> FaceSyntaxError {
FaceSyntaxError {
message,
location: None,
}
}
pub fn graft_entries(source: &str) -> Result<Vec<GraftSyntax>, FaceSyntaxError> {
let file = super::super::nesting::parse_file(source)?;
let mut entries = Vec::new();
let mut visitor = GraftVisitor {
entries: &mut entries,
error: None,
module_cfgs: Vec::new(),
imports: Default::default(),
};
visitor.visit_file(&file);
visitor.error.map_or(Ok(entries), Err)
}
#[cfg(test)]
#[path = "graft_tests.rs"]
mod graft_tests;