use std::iter::Peekable;
use proc_macro2::{
Delimiter, Group, Ident, Punct, Spacing, Span, TokenStream, TokenTree, token_stream,
};
use syn::{Error, Result};
use crate::schema::{BodySpec, Shape};
pub(crate) const AUTHOR_SIGIL: char = '$';
pub(crate) const EMBEDDED_SIGIL: char = '#';
type Tokens = Peekable<token_stream::IntoIter>;
pub(crate) fn embed(tokens: TokenStream) -> TokenStream {
let mut output = Vec::new();
let mut tokens = tokens.into_iter().peekable();
while let Some(token) = tokens.next() {
match token {
TokenTree::Punct(punct)
if punct.as_char() == AUTHOR_SIGIL
&& matches!(tokens.peek(), Some(TokenTree::Ident(ident)) if ident != "crate") =>
{
let mut sigil = Punct::new(EMBEDDED_SIGIL, Spacing::Alone);
sigil.set_span(punct.span());
output.push(TokenTree::Punct(sigil));
}
TokenTree::Group(group) => {
let mut new_group = Group::new(group.delimiter(), embed(group.stream()));
new_group.set_span(group.span());
output.push(TokenTree::Group(new_group));
}
other => output.push(other),
}
}
output.into_iter().collect()
}
pub(crate) struct Template {
nodes: Vec<Node>,
}
enum Node {
Token(TokenTree),
Group(Delimiter, Span, Vec<Node>),
Value(Path),
For {
var: String,
path: Path,
body: Vec<Node>,
},
IfLet {
var: String,
path: Path,
then: Vec<Node>,
otherwise: Vec<Node>,
},
Ident {
case: Case,
span: Span,
parts: Vec<Part>,
},
ConstArg {
span: Span,
inner: Vec<Node>,
},
}
#[derive(Clone, Copy)]
enum Case {
Exact,
Snake,
Upper,
}
enum Part {
Text(String),
Value(Path),
}
struct Path {
root: Ident,
fields: Vec<Ident>,
}
#[derive(Clone, Copy)]
enum Ty<'a> {
Leaf {
ident_like: bool,
},
Optional(&'a Shape),
Decl(&'a BodySpec),
Block(&'a BodySpec),
Member(&'a BodySpec),
Members,
}
const DECL_BUILTINS: [&str; 5] = ["name", "vis", "doc", "attrs", "members"];
const MEMBER_BUILTINS: [&str; 5] = ["name", "vis", "doc", "attrs", "index"];
const NOT_VARIABLES: [&str; 2] = ["decl", "crate"];
impl Ty<'_> {
fn builtins(self) -> &'static [&'static str] {
match self {
Ty::Decl(_) => &DECL_BUILTINS,
Ty::Member(_) => &MEMBER_BUILTINS,
_ => &[],
}
}
}
struct Scope<'a> {
name: String,
ty: Ty<'a>,
}
struct Parser<'a> {
sigil: char,
body: &'a BodySpec,
scopes: Vec<Scope<'a>>,
}
impl Template {
pub(crate) fn parse(tokens: TokenStream, body: &BodySpec, sigil: char) -> Result<Self> {
let member_fields = body
.members
.iter()
.flat_map(|members| members.body.fields.iter().map(|field| (field, "member")));
for (field, namespace) in body
.fields
.iter()
.map(|field| (field, "decl"))
.chain(member_fields)
{
let word = field.name.to_string();
let builtins: &[&str] = if namespace == "decl" {
&DECL_BUILTINS
} else {
&MEMBER_BUILTINS
};
if builtins.contains(&word.as_str()) {
return Err(Error::new(
field.name.span(),
format!(
"field `{word}` collides with the template's built-in `${namespace}.{word}`; rename the field"
),
));
}
}
let mut parser = Parser {
sigil,
body,
scopes: Vec::new(),
};
let nodes = parser.nodes(tokens)?;
Ok(Self { nodes })
}
pub(crate) fn render(&self, data: &Data) -> TokenStream {
let mut env: Vec<(String, &Data)> = Vec::new();
let mut output = TokenStream::new();
render_nodes(&self.nodes, data, &mut env, &mut output);
output
}
}
impl<'a> Parser<'a> {
fn nodes(&mut self, tokens: TokenStream) -> Result<Vec<Node>> {
let mut nodes = Vec::new();
let mut tokens = tokens.into_iter().peekable();
while let Some(token) = tokens.next() {
match token {
TokenTree::Punct(punct)
if punct.as_char() == self.sigil
&& matches!(tokens.peek(), Some(TokenTree::Ident(ident)) if ident != "crate") =>
{
let keyword = expect_ident(&mut tokens, punct.span(), "a template construct")?;
nodes.push(self.construct(punct.span(), keyword, &mut tokens)?);
}
TokenTree::Punct(punct)
if punct.as_char() == AUTHOR_SIGIL && self.sigil == AUTHOR_SIGIL =>
{
let is_crate =
matches!(tokens.peek(), Some(TokenTree::Ident(ident)) if ident == "crate");
if !is_crate {
return Err(Error::new(
punct.span(),
"`$` must start a template construct (`$value`, `$for`, `$if`, `$ident(...)`, `$const_arg(...)`) or `$crate`",
));
}
nodes.push(Node::Token(TokenTree::Punct(punct)));
}
TokenTree::Group(group) => {
let inner = self.nodes(group.stream())?;
nodes.push(Node::Group(group.delimiter(), group.span(), inner));
}
other => nodes.push(Node::Token(other)),
}
}
Ok(nodes)
}
fn construct(&mut self, sigil_span: Span, keyword: Ident, tokens: &mut Tokens) -> Result<Node> {
let word = keyword.to_string();
let is_call = matches!(
tokens.peek(),
Some(TokenTree::Group(group)) if group.delimiter() == Delimiter::Parenthesis
);
match word.as_str() {
"for" => self.for_node(&keyword, tokens),
"if" => self.if_node(&keyword, tokens),
"const_arg" if is_call => {
let args = expect_group(tokens, keyword.span(), Delimiter::Parenthesis, "`(...)`")?;
Ok(Node::ConstArg {
span: args.span(),
inner: self.nodes(args.stream())?,
})
}
"ident" | "snake" | "upper" if is_call => {
let args = expect_group(tokens, keyword.span(), Delimiter::Parenthesis, "`(...)`")?;
let case = match word.as_str() {
"ident" => Case::Exact,
"snake" => Case::Snake,
_ => Case::Upper,
};
Ok(Node::Ident {
case,
span: sigil_span,
parts: self.parts(args.stream(), args.span())?,
})
}
_ => {
let (path, ty) = self.path(keyword, tokens)?;
match ty {
Ty::Leaf { .. } => Ok(Node::Value(path)),
Ty::Optional(_) => Err(path_error(
&path,
"is optional; read it with `$if let Some(x) = ... { ... }`",
)),
Ty::Members => Err(path_error(
&path,
"is the member list; loop over it with `$for member in $decl.members { ... }`",
)),
Ty::Decl(body) => Err(path_error(
&path,
&format!(
"is the declaration, not a value; name one of {}",
field_list(ty.builtins(), body)
),
)),
Ty::Block(_) | Ty::Member(_) => Err(path_error(
&path,
"is a block, not a value; name one of its fields",
)),
}
}
}
}
fn for_node(&mut self, keyword: &Ident, tokens: &mut Tokens) -> Result<Node> {
let var = expect_ident(tokens, keyword.span(), "a loop variable after `$for`")?;
expect_word(tokens, var.span(), "in")?;
expect_sigil(tokens, self.sigil, var.span())?;
let root = expect_ident(tokens, var.span(), "`$decl.members` after `in`")?;
let (path, ty) = self.path(root, tokens)?;
let (Ty::Members, Some(members)) = (ty, &self.body.members) else {
return Err(path_error(
&path,
"is not the member list; loop over `$decl.members`",
));
};
let body = expect_group(tokens, var.span(), Delimiter::Brace, "`{ ... }`")?;
self.check_new_name(&var)?;
self.scopes.push(Scope {
name: var.to_string(),
ty: Ty::Member(&members.body),
});
let body = self.nodes(body.stream());
self.scopes.pop();
Ok(Node::For {
var: var.to_string(),
path,
body: body?,
})
}
fn if_node(&mut self, keyword: &Ident, tokens: &mut Tokens) -> Result<Node> {
expect_word(tokens, keyword.span(), "let")?;
expect_word(tokens, keyword.span(), "Some")?;
let binding = expect_group(tokens, keyword.span(), Delimiter::Parenthesis, "`Some(x)`")?;
let var: Ident = syn::parse2(binding.stream())
.map_err(|_| Error::new(binding.span(), "expected one variable name in `Some(...)`"))?;
match tokens.next() {
Some(TokenTree::Punct(punct)) if punct.as_char() == '=' => {}
_ => return Err(Error::new(var.span(), "expected `=` after `Some(...)`")),
}
expect_sigil(tokens, self.sigil, var.span())?;
let root = expect_ident(tokens, var.span(), "an optional value after `=`")?;
let (path, ty) = self.path(root, tokens)?;
let Ty::Optional(shape) = ty else {
return Err(path_error(
&path,
"is not optional; `$if let` needs an optional field",
));
};
let then_tokens = expect_group(tokens, var.span(), Delimiter::Brace, "`{ ... }`")?;
let otherwise_tokens = if matches!(tokens.peek(), Some(TokenTree::Ident(ident)) if ident == "else")
{
tokens.next();
Some(expect_group(
tokens,
var.span(),
Delimiter::Brace,
"`{ ... }` after `else`",
)?)
} else {
None
};
self.check_new_name(&var)?;
self.scopes.push(Scope {
name: var.to_string(),
ty: shape_ty(false, shape),
});
let then = self.nodes(then_tokens.stream());
self.scopes.pop();
let otherwise = match otherwise_tokens {
Some(group) => self.nodes(group.stream())?,
None => Vec::new(),
};
Ok(Node::IfLet {
var: var.to_string(),
path,
then: then?,
otherwise,
})
}
fn parts(&mut self, tokens: TokenStream, span: Span) -> Result<Vec<Part>> {
let mut parts = Vec::new();
let mut tokens = tokens.into_iter().peekable();
while let Some(token) = tokens.next() {
match token {
TokenTree::Punct(punct) if punct.as_char() == self.sigil => {
let root = expect_ident(&mut tokens, punct.span(), "a value after `$`")?;
let (path, ty) = self.path(root, &mut tokens)?;
let Ty::Leaf { ident_like: true } = ty else {
return Err(path_error(
&path,
"is not an identifier; identifier parts must be `ident` fields, `$decl.name`, `$member.name`, or `$member.index`",
));
};
parts.push(Part::Value(path));
}
TokenTree::Ident(ident) => parts.push(Part::Text(ident.to_string())),
TokenTree::Literal(literal)
if literal
.to_string()
.bytes()
.all(|byte| byte.is_ascii_digit()) =>
{
parts.push(Part::Text(literal.to_string()));
}
other => {
return Err(Error::new(
other.span(),
"identifier parts must be identifiers, integers, or `$` values",
));
}
}
match tokens.next() {
None => break,
Some(TokenTree::Punct(punct)) if punct.as_char() == ',' => {}
Some(other) => {
return Err(Error::new(
other.span(),
"expected `,` between identifier parts",
));
}
}
}
if parts.is_empty() {
return Err(Error::new(span, "an identifier needs at least one part"));
}
Ok(parts)
}
fn path(&self, root: Ident, tokens: &mut Tokens) -> Result<(Path, Ty<'a>)> {
let mut ty = self.root_ty(&root)?;
let mut fields = Vec::new();
while let Ty::Decl(body) | Ty::Block(body) | Ty::Member(body) = ty {
let mut lookahead = tokens.clone();
let (Some(TokenTree::Punct(dot)), Some(TokenTree::Ident(field))) =
(lookahead.next(), lookahead.next())
else {
break;
};
if dot.as_char() != '.' {
break;
}
tokens.next();
tokens.next();
let word = field.to_string();
ty = match word.as_str() {
builtin if !ty.builtins().contains(&builtin) => match body.field(&field) {
Some(spec) => shape_ty(spec.optional, &spec.shape),
None => {
return Err(Error::new(
field.span(),
format!(
"no value `{field}` here; expected one of {}",
field_list(ty.builtins(), body)
),
));
}
},
"name" | "index" => Ty::Leaf { ident_like: true },
"members" => Ty::Members,
_ => Ty::Leaf { ident_like: false },
};
fields.push(field);
}
Ok((Path { root, fields }, ty))
}
fn root_ty(&self, root: &Ident) -> Result<Ty<'a>> {
let word = root.to_string();
if let Some(scope) = self.scopes.iter().rev().find(|scope| scope.name == word) {
return Ok(scope.ty);
}
if word == "decl" {
return Ok(Ty::Decl(self.body));
}
let decl = Ty::Decl(self.body);
let hint = if decl.builtins().contains(&word.as_str()) || self.body.field(root).is_some() {
format!("write `$decl.{word}`")
} else {
let mut names = vec!["`$decl`".to_owned()];
names.extend(self.scopes.iter().map(|scope| format!("`${}`", scope.name)));
format!("expected {}", names.join(", "))
};
Err(Error::new(
root.span(),
format!("unknown template value `${word}`; {hint}"),
))
}
fn check_new_name(&self, var: &Ident) -> Result<()> {
let word = var.to_string();
if NOT_VARIABLES.contains(&word.as_str()) {
return Err(Error::new(
var.span(),
format!("`{word}` is reserved in templates; choose another variable name"),
));
}
if self.scopes.iter().any(|scope| scope.name == word) {
return Err(Error::new(
var.span(),
format!("`${word}` is already in scope; choose another variable name"),
));
}
Ok(())
}
}
fn shape_ty(optional: bool, shape: &Shape) -> Ty<'_> {
match (optional, shape) {
(true, shape) => Ty::Optional(shape),
(false, Shape::Leaf { kind, .. }) => Ty::Leaf {
ident_like: kind.name() == "ident",
},
(false, Shape::Block(block)) => Ty::Block(block),
}
}
fn field_list(builtins: &[&str], body: &BodySpec) -> String {
builtins
.iter()
.filter(|&&name| name != "members" || body.members.is_some())
.map(|name| format!("`{name}`"))
.chain(body.fields.iter().map(|field| format!("`{}`", field.name)))
.collect::<Vec<_>>()
.join(", ")
}
fn path_error(path: &Path, message: &str) -> Error {
let text = std::iter::once(path.root.to_string())
.chain(path.fields.iter().map(Ident::to_string))
.collect::<Vec<_>>()
.join(".");
let span = path.fields.last().unwrap_or(&path.root).span();
Error::new(span, format!("`${text}` {message}"))
}
fn expect_ident(tokens: &mut Tokens, after: Span, what: &str) -> Result<Ident> {
match tokens.next() {
Some(TokenTree::Ident(ident)) => Ok(ident),
Some(other) => Err(Error::new(other.span(), format!("expected {what}"))),
None => Err(Error::new(after, format!("expected {what}"))),
}
}
fn expect_word(tokens: &mut Tokens, after: Span, word: &str) -> Result<()> {
match tokens.next() {
Some(TokenTree::Ident(ident)) if ident == word => Ok(()),
Some(other) => Err(Error::new(other.span(), format!("expected `{word}`"))),
None => Err(Error::new(after, format!("expected `{word}`"))),
}
}
fn expect_sigil(tokens: &mut Tokens, sigil: char, after: Span) -> Result<()> {
match tokens.next() {
Some(TokenTree::Punct(punct)) if punct.as_char() == sigil => Ok(()),
Some(other) => Err(Error::new(other.span(), "expected a `$` value")),
None => Err(Error::new(after, "expected a `$` value")),
}
}
fn expect_group(
tokens: &mut Tokens,
after: Span,
delimiter: Delimiter,
what: &str,
) -> Result<Group> {
match tokens.next() {
Some(TokenTree::Group(group)) if group.delimiter() == delimiter => Ok(group),
Some(other) => Err(Error::new(other.span(), format!("expected {what}"))),
None => Err(Error::new(after, format!("expected {what}"))),
}
}
pub(crate) enum Data {
Leaf(TokenStream),
Absent,
Fields(Vec<(String, Data)>),
Members(Vec<Data>),
}
impl Data {
fn get(&self, name: &str) -> Option<&Data> {
match self {
Data::Fields(fields) => fields
.iter()
.find(|(field, _)| field == name)
.map(|(_, data)| data),
_ => None,
}
}
}
fn lookup<'d>(root: &'d Data, env: &[(String, &'d Data)], path: &Path) -> Option<&'d Data> {
let name = path.root.to_string();
let mut data = match env.iter().rev().find(|(scope, _)| *scope == name) {
Some((_, data)) => *data,
None => root,
};
for field in &path.fields {
data = data.get(&field.to_string())?;
}
Some(data)
}
fn const_arg(tokens: TokenStream, span: Span) -> TokenStream {
let mut trees = tokens.clone().into_iter();
match (trees.next(), trees.next()) {
(Some(TokenTree::Literal(_) | TokenTree::Ident(_)), None) => tokens,
_ => {
let mut group = Group::new(Delimiter::Brace, tokens);
group.set_span(span);
TokenTree::Group(group).into()
}
}
}
fn render_nodes<'d>(
nodes: &[Node],
root: &'d Data,
env: &mut Vec<(String, &'d Data)>,
output: &mut TokenStream,
) {
for node in nodes {
match node {
Node::Token(token) => output.extend([token.clone()]),
Node::Group(delimiter, span, inner) => {
let mut stream = TokenStream::new();
render_nodes(inner, root, env, &mut stream);
let mut group = Group::new(*delimiter, stream);
group.set_span(*span);
output.extend([TokenTree::Group(group)]);
}
Node::Value(path) => {
if let Some(Data::Leaf(tokens)) = lookup(root, env, path) {
output.extend(tokens.clone());
}
}
Node::For { var, path, body } => {
if let Some(Data::Members(members)) = lookup(root, env, path) {
for member in members {
env.push((var.clone(), member));
render_nodes(body, root, env, output);
env.pop();
}
}
}
Node::IfLet {
var,
path,
then,
otherwise,
} => match lookup(root, env, path) {
Some(Data::Absent) | None => render_nodes(otherwise, root, env, output),
Some(data) => {
env.push((var.clone(), data));
render_nodes(then, root, env, output);
env.pop();
}
},
Node::ConstArg { span, inner } => {
let mut stream = TokenStream::new();
render_nodes(inner, root, env, &mut stream);
output.extend(const_arg(stream, *span));
}
Node::Ident { case, span, parts } => {
let mut text = String::new();
let mut ident_span = None;
for part in parts {
match part {
Part::Text(part_text) => text.push_str(part_text),
Part::Value(path) => {
if let Some(Data::Leaf(tokens)) = lookup(root, env, path) {
for token in tokens.clone() {
ident_span.get_or_insert(token.span());
text.push_str(&token.to_string());
}
}
}
}
}
let text = match case {
Case::Exact => text,
Case::Snake => to_snake_case(&text),
Case::Upper => to_snake_case(&text).to_uppercase(),
};
output.extend([TokenTree::Ident(Ident::new(
&text,
ident_span.unwrap_or(*span),
))]);
}
}
}
}
pub(crate) fn to_snake_case(text: &str) -> String {
let chars: Vec<char> = text.chars().collect();
let mut output = String::new();
for (index, &character) in chars.iter().enumerate() {
if character.is_uppercase() && index > 0 {
let previous = chars[index - 1];
let next_is_lower = chars.get(index + 1).is_some_and(|next| next.is_lowercase());
let after_lowercase_digits = previous.is_ascii_digit()
&& chars[..index]
.iter()
.rev()
.find(|earlier| !earlier.is_ascii_digit())
.is_some_and(|earlier| earlier.is_lowercase());
let starts_word = previous.is_lowercase()
|| after_lowercase_digits
|| (previous.is_uppercase() && next_is_lower);
if starts_word && !output.ends_with('_') {
output.push('_');
}
}
output.extend(character.to_lowercase());
}
output
}