forked from libre-chip/fayalite
initial public commit
This commit is contained in:
commit
0b958e7852
SSH key fingerprint:
SHA256:B1iRVvUJkvd7upMIiMqn6OyxvD2SgJkAH3ZnUOj6z+c
56 changed files with 30235 additions and 0 deletions
426
crates/fayalite-visit-gen/src/lib.rs
Normal file
426
crates/fayalite-visit-gen/src/lib.rs
Normal file
|
|
@ -0,0 +1,426 @@
|
|||
// SPDX-License-Identifier: LGPL-3.0-or-later
|
||||
// See Notices.txt for copyright information
|
||||
use proc_macro2::{Span, TokenStream};
|
||||
use quote::{format_ident, quote, ToTokens};
|
||||
use std::{collections::BTreeMap, fs};
|
||||
use syn::{fold::Fold, parse_quote};
|
||||
|
||||
pub mod ast;
|
||||
|
||||
fn map_camel_case_to_snake_case(s: &str) -> String {
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
enum State {
|
||||
Start,
|
||||
Lowercase,
|
||||
PushedUpper(char),
|
||||
}
|
||||
let mut state = State::Start;
|
||||
let mut retval = String::new();
|
||||
for ch in s.chars() {
|
||||
state = match ch {
|
||||
'A'..='Z' => {
|
||||
match state {
|
||||
State::Start => {}
|
||||
State::Lowercase => retval.push('_'),
|
||||
State::PushedUpper(upper) => retval.push(upper.to_ascii_lowercase()),
|
||||
}
|
||||
State::PushedUpper(ch)
|
||||
}
|
||||
_ => {
|
||||
match state {
|
||||
State::PushedUpper(upper) => {
|
||||
retval.push(upper.to_ascii_lowercase());
|
||||
}
|
||||
State::Start | State::Lowercase => {}
|
||||
}
|
||||
retval.push(ch);
|
||||
State::Lowercase
|
||||
}
|
||||
};
|
||||
}
|
||||
match state {
|
||||
State::Lowercase | State::Start => {}
|
||||
State::PushedUpper(upper) => retval.push(upper.to_ascii_lowercase()),
|
||||
}
|
||||
retval
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct DefinitionState {
|
||||
fn_name_suffix: syn::Ident,
|
||||
generics: syn::Generics,
|
||||
fold_generics: syn::Generics,
|
||||
folder_generics: syn::Generics,
|
||||
visit_generics: syn::Generics,
|
||||
visitor_generics: syn::Generics,
|
||||
}
|
||||
|
||||
impl DefinitionState {
|
||||
fn folder_fn_name(&self) -> syn::Ident {
|
||||
format_ident!("fold_{}", self.fn_name_suffix)
|
||||
}
|
||||
fn visitor_fn_name(&self) -> syn::Ident {
|
||||
format_ident!("visit_{}", self.fn_name_suffix)
|
||||
}
|
||||
fn folder_fn(&self, path: &ast::Path) -> TokenStream {
|
||||
let folder_fn_name = self.folder_fn_name();
|
||||
let (impl_generics, type_generics, where_clause) = self.folder_generics.split_for_impl();
|
||||
quote! {
|
||||
fn #folder_fn_name #impl_generics(&mut self, v: #path #type_generics) -> Result<#path #type_generics, Self::Error> #where_clause {
|
||||
Fold::default_fold(v, self)
|
||||
}
|
||||
}
|
||||
}
|
||||
fn visitor_fn(&self, path: &ast::Path) -> TokenStream {
|
||||
let visitor_fn_name = self.visitor_fn_name();
|
||||
let (impl_generics, type_generics, where_clause) = self.visitor_generics.split_for_impl();
|
||||
quote! {
|
||||
fn #visitor_fn_name #impl_generics(&mut self, v: &#path #type_generics) -> Result<(), Self::Error> #where_clause {
|
||||
Visit::default_visit(v, self)
|
||||
}
|
||||
}
|
||||
}
|
||||
fn fold_impl(&self, path: &ast::Path, body: impl ToTokens) -> TokenStream {
|
||||
let folder_fn_name = self.folder_fn_name();
|
||||
let (_, self_type_generics, _) = self.generics.split_for_impl();
|
||||
let (trait_impl_generics, _, trait_where_clause) = self.fold_generics.split_for_impl();
|
||||
quote! {
|
||||
#[automatically_derived]
|
||||
#[allow(clippy::init_numbered_fields)]
|
||||
impl #trait_impl_generics Fold<State> for #path #self_type_generics #trait_where_clause {
|
||||
fn fold(self, state: &mut State) -> Result<Self, State::Error> {
|
||||
state.#folder_fn_name(self)
|
||||
}
|
||||
fn default_fold(self, state: &mut State) -> Result<Self, State::Error> {
|
||||
#body
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
fn visit_impl(&self, path: &ast::Path, body: impl ToTokens) -> TokenStream {
|
||||
let visitor_fn_name = self.visitor_fn_name();
|
||||
let (_, self_type_generics, _) = self.generics.split_for_impl();
|
||||
let (trait_impl_generics, _, trait_where_clause) = self.visit_generics.split_for_impl();
|
||||
quote! {
|
||||
#[automatically_derived]
|
||||
impl #trait_impl_generics Visit<State> for #path #self_type_generics #trait_where_clause {
|
||||
fn visit(&self, state: &mut State) -> Result<(), State::Error> {
|
||||
state.#visitor_fn_name(self)
|
||||
}
|
||||
fn default_visit(&self, state: &mut State) -> Result<(), State::Error> {
|
||||
#body
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct GenerateState<'a> {
|
||||
def_states: BTreeMap<&'a ast::Path, DefinitionState>,
|
||||
definitions: &'a ast::Definitions,
|
||||
}
|
||||
|
||||
struct MapStateToSelf;
|
||||
|
||||
impl syn::fold::Fold for MapStateToSelf {
|
||||
fn fold_ident(&mut self, i: syn::Ident) -> syn::Ident {
|
||||
if i == "State" {
|
||||
syn::Ident::new("Self", i.span())
|
||||
} else {
|
||||
i
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> GenerateState<'a> {
|
||||
fn make_definition_state(&mut self, path: &'a ast::Path) -> syn::Result<()> {
|
||||
let ast::Definition {
|
||||
fn_name_suffix,
|
||||
generics,
|
||||
fold_where,
|
||||
visit_where,
|
||||
data: _,
|
||||
} = self.definitions.types.get(path).ok_or_else(|| {
|
||||
syn::Error::new(
|
||||
Span::call_site(),
|
||||
format!("can't find named type: {path:?}"),
|
||||
)
|
||||
})?;
|
||||
let fn_name_suffix = fn_name_suffix
|
||||
.as_ref()
|
||||
.map(syn::Ident::from)
|
||||
.unwrap_or_else(|| format_ident!("{}", map_camel_case_to_snake_case(&path.last().0)));
|
||||
let generics = generics.clone().map(|v| v.0).unwrap_or_default();
|
||||
let mut fold_generics = generics.clone();
|
||||
let mut folder_generics = generics.clone();
|
||||
fold_generics
|
||||
.params
|
||||
.insert(0, parse_quote! {State: ?Sized + Folder});
|
||||
if let Some(fold_where) = fold_where {
|
||||
fold_generics
|
||||
.make_where_clause()
|
||||
.predicates
|
||||
.extend(fold_where.0.iter().cloned());
|
||||
folder_generics.make_where_clause().predicates.extend(
|
||||
fold_where
|
||||
.0
|
||||
.iter()
|
||||
.cloned()
|
||||
.map(|v| MapStateToSelf.fold_where_predicate(v)),
|
||||
);
|
||||
}
|
||||
let mut visit_generics = generics.clone();
|
||||
let mut visitor_generics = generics.clone();
|
||||
visit_generics
|
||||
.params
|
||||
.insert(0, parse_quote! {State: ?Sized + Visitor});
|
||||
if let Some(visit_where) = visit_where {
|
||||
visit_generics
|
||||
.make_where_clause()
|
||||
.predicates
|
||||
.extend(visit_where.0.iter().cloned());
|
||||
visitor_generics.make_where_clause().predicates.extend(
|
||||
visit_where
|
||||
.0
|
||||
.iter()
|
||||
.cloned()
|
||||
.map(|v| MapStateToSelf.fold_where_predicate(v)),
|
||||
);
|
||||
}
|
||||
self.def_states.insert(
|
||||
path,
|
||||
DefinitionState {
|
||||
fn_name_suffix,
|
||||
generics,
|
||||
fold_generics,
|
||||
folder_generics,
|
||||
visit_generics,
|
||||
visitor_generics,
|
||||
},
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
fn new(ast: &'a ast::Definitions) -> syn::Result<Self> {
|
||||
let mut retval = GenerateState {
|
||||
def_states: BTreeMap::new(),
|
||||
definitions: ast,
|
||||
};
|
||||
let ast::Definitions { types } = ast;
|
||||
for path in types.keys() {
|
||||
retval.make_definition_state(path)?;
|
||||
}
|
||||
Ok(retval)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn generate(ast: &ast::Definitions) -> syn::Result<String> {
|
||||
let state = GenerateState::new(ast)?;
|
||||
let mut visitor_fns = vec![];
|
||||
let mut visit_impls = vec![];
|
||||
let mut folder_fns = vec![];
|
||||
let mut fold_impls = vec![];
|
||||
for (&def_path, def_state) in state.def_states.iter() {
|
||||
folder_fns.push(def_state.folder_fn(def_path));
|
||||
visitor_fns.push(def_state.visitor_fn(def_path));
|
||||
let fold_body;
|
||||
let visit_body;
|
||||
let ast::Definition {
|
||||
fn_name_suffix: _,
|
||||
generics: _,
|
||||
fold_where: _,
|
||||
visit_where: _,
|
||||
data,
|
||||
} = ast.types.get(def_path).unwrap();
|
||||
match data {
|
||||
ast::Data::ManualImpl => {
|
||||
continue;
|
||||
}
|
||||
ast::Data::Opaque => {
|
||||
fold_body = quote! {
|
||||
let _ = state;
|
||||
Ok(self)
|
||||
};
|
||||
visit_body = quote! {
|
||||
let _ = state;
|
||||
Ok(())
|
||||
};
|
||||
}
|
||||
ast::Data::Struct(ast::Fields {
|
||||
constructor,
|
||||
fields,
|
||||
}) => {
|
||||
let mut visit_members = vec![];
|
||||
let mut fold_members = vec![];
|
||||
for (field_name, field) in fields {
|
||||
let fold_member_name = if constructor.is_some() {
|
||||
None
|
||||
} else {
|
||||
let member = field_name.to_member();
|
||||
if member.is_none() {
|
||||
return Err(syn::Error::new(Span::call_site(), format!("struct must have `$constructor` since it contains a non-plain field: {def_path:?} {field_name:?}")));
|
||||
}
|
||||
member
|
||||
};
|
||||
let fold_member_name = fold_member_name.as_slice();
|
||||
let fold_member = match field {
|
||||
ast::Field::Opaque => {
|
||||
quote! {
|
||||
#(#fold_member_name:)* self.#field_name
|
||||
}
|
||||
}
|
||||
ast::Field::Visible => {
|
||||
visit_members.push(quote! {
|
||||
Visit::visit(&self.#field_name, state)?;
|
||||
});
|
||||
quote! {
|
||||
#(#fold_member_name:)* Fold::fold(self.#field_name, state)?
|
||||
}
|
||||
}
|
||||
ast::Field::RefVisible => {
|
||||
visit_members.push(quote! {
|
||||
Visit::visit(self.#field_name, state)?;
|
||||
});
|
||||
quote! {
|
||||
#(#fold_member_name:)* Fold::fold(self.#field_name.clone(), state)?
|
||||
}
|
||||
}
|
||||
};
|
||||
fold_members.push(fold_member);
|
||||
}
|
||||
let match_members = constructor
|
||||
.is_none()
|
||||
.then(|| {
|
||||
fields
|
||||
.keys()
|
||||
.map(|k| k.to_member())
|
||||
.collect::<Option<Vec<_>>>()
|
||||
.map(|members| {
|
||||
if members.is_empty() {
|
||||
quote! {
|
||||
let _ = state;
|
||||
let Self {} = self;
|
||||
}
|
||||
} else {
|
||||
quote! {
|
||||
let Self {
|
||||
#(#members: _,)*
|
||||
} = self;
|
||||
}
|
||||
}
|
||||
})
|
||||
})
|
||||
.flatten();
|
||||
visit_body = quote! {
|
||||
#match_members
|
||||
#(#visit_members)*
|
||||
Ok(())
|
||||
};
|
||||
let fold_body_tail = if let Some(constructor) = constructor {
|
||||
quote! {
|
||||
Ok(#constructor(#(#fold_members),*))
|
||||
}
|
||||
} else {
|
||||
quote! {
|
||||
Ok(Self {
|
||||
#(#fold_members,)*
|
||||
})
|
||||
}
|
||||
};
|
||||
fold_body = quote! {
|
||||
#match_members
|
||||
#fold_body_tail
|
||||
};
|
||||
}
|
||||
ast::Data::Enum(ast::Variants { variants }) => {
|
||||
let mut fold_arms = vec![];
|
||||
let mut visit_arms = vec![];
|
||||
let mut state_unused = true;
|
||||
for (variant_name, variant_field) in variants {
|
||||
let fold_arm;
|
||||
let visit_arm;
|
||||
match variant_field {
|
||||
Some(ast::Field::Visible) => {
|
||||
state_unused = false;
|
||||
fold_arm = quote! {
|
||||
Self::#variant_name(v) => Fold::fold(v, state).map(Self::#variant_name),
|
||||
};
|
||||
visit_arm = quote! {
|
||||
Self::#variant_name(v) => Visit::visit(v, state),
|
||||
};
|
||||
}
|
||||
Some(ast::Field::RefVisible) => {
|
||||
return Err(syn::Error::new(
|
||||
Span::call_site(),
|
||||
"enum variant field must not be RefVisible",
|
||||
));
|
||||
}
|
||||
Some(ast::Field::Opaque) => {
|
||||
fold_arm = quote! {
|
||||
Self::#variant_name(_) => Ok(self),
|
||||
};
|
||||
visit_arm = quote! {
|
||||
Self::#variant_name(_) => Ok(()),
|
||||
};
|
||||
}
|
||||
None => {
|
||||
fold_arm = quote! {
|
||||
Self::#variant_name => Ok(self),
|
||||
};
|
||||
visit_arm = quote! {
|
||||
Self::#variant_name => Ok(()),
|
||||
};
|
||||
}
|
||||
}
|
||||
fold_arms.push(fold_arm);
|
||||
visit_arms.push(visit_arm);
|
||||
}
|
||||
let ignore_state = state_unused.then(|| {
|
||||
quote! {
|
||||
let _ = state;
|
||||
}
|
||||
});
|
||||
visit_body = quote! {
|
||||
#ignore_state
|
||||
match self {
|
||||
#(#visit_arms)*
|
||||
}
|
||||
};
|
||||
fold_body = quote! {
|
||||
#ignore_state
|
||||
match self {
|
||||
#(#fold_arms)*
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
fold_impls.push(def_state.fold_impl(def_path, fold_body));
|
||||
visit_impls.push(def_state.visit_impl(def_path, visit_body));
|
||||
}
|
||||
Ok(prettyplease::unparse(&parse_quote! {
|
||||
pub trait Visitor {
|
||||
type Error;
|
||||
|
||||
#(#visitor_fns)*
|
||||
}
|
||||
|
||||
#(#visit_impls)*
|
||||
|
||||
pub trait Folder {
|
||||
type Error;
|
||||
|
||||
#(#folder_fns)*
|
||||
}
|
||||
|
||||
#(#fold_impls)*
|
||||
}))
|
||||
}
|
||||
|
||||
pub fn error_at_call_site<T: std::fmt::Display>(e: T) -> syn::Error {
|
||||
syn::Error::new(Span::call_site(), e)
|
||||
}
|
||||
|
||||
pub fn parse_and_generate(path: impl AsRef<std::path::Path>) -> syn::Result<String> {
|
||||
let input = fs::read_to_string(path).map_err(error_at_call_site)?;
|
||||
let ast: ast::Definitions = serde_json::from_str(&input).map_err(error_at_call_site)?;
|
||||
generate(&ast)
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue