use proc_macro2::{Delimiter, TokenStream, TokenTree};
use syn::parse::{Parse, ParseStream};
use syn::punctuated::Punctuated;
use syn::{
AttrStyle, Attribute, Expr, ExprLit, ExprPath, Item, Lit, Meta, MetaNameValue, PathArguments,
Token,
};
use template_quote::quote;
pub const INTERNAL_PREFIX: &str = "__subcrate_";
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Args {
pub proc_macro: bool,
pub edition: Option<String>,
pub deps: Vec<Dependency>,
pub ui: UiExpectations,
}
impl Args {
pub fn is_ui_test(&self) -> bool {
self.ui.is_ui_test()
}
pub fn expects_error(&self) -> bool {
self.ui.expects_error()
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct UiExpectations {
pub should_errors: Vec<Option<String>>,
pub should_warns: Vec<Option<String>>,
pub should_spanned: Vec<String>,
}
impl UiExpectations {
pub fn is_ui_test(&self) -> bool {
!self.should_errors.is_empty()
|| !self.should_warns.is_empty()
|| !self.should_spanned.is_empty()
}
pub fn expects_error(&self) -> bool {
!self.should_errors.is_empty()
}
fn fingerprint(&self) -> String {
format!(
"e:{}|w:{}|s:{}",
fingerprint_opts(&self.should_errors),
fingerprint_opts(&self.should_warns),
self.should_spanned.join("\u{1f}"),
)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Dependency {
pub alias: String,
pub path: Vec<String>,
pub external: bool,
}
impl Dependency {
pub fn path_display(&self) -> String {
format!(
"{}{}",
if self.external { "::" } else { "" },
self.path.join("::")
)
}
}
impl Args {
fn fingerprint(&self) -> String {
let mut deps: Vec<String> = self
.deps
.iter()
.map(|dep| format!("{}={}", dep.alias, dep.path_display()))
.collect();
deps.sort();
format!(
"{}|{}|{}|{}",
self.proc_macro,
self.edition.as_deref().unwrap_or(""),
deps.join(","),
self.ui.fingerprint(),
)
}
}
fn fingerprint_opts(opts: &[Option<String>]) -> String {
opts.iter()
.map(|opt| match opt {
Some(text) => format!("S{}", text),
None => "N".to_string(),
})
.collect::<Vec<_>>()
.join("\u{1f}")
}
impl Parse for Args {
fn parse(input: ParseStream) -> syn::Result<Self> {
let mut args = Args::default();
let metas = Punctuated::<Meta, Token![,]>::parse_terminated(input)?;
for meta in metas {
match &meta {
Meta::Path(path) => {
if path.is_ident("proc_macro") {
args.proc_macro = true;
} else if path.is_ident("should_error") {
args.ui.should_errors.push(None);
} else if path.is_ident("should_warn") {
args.ui.should_warns.push(None);
} else if path.is_ident("should_spanned") {
return Err(syn::Error::new_spanned(
path,
"`should_spanned` needs the code to match: \
`should_spanned = \"…\"`",
));
} else {
args.deps.push(parse_dependency(None, path)?);
}
}
Meta::NameValue(MetaNameValue { path, value, .. }) => {
let key = match path.get_ident() {
Some(ident) => ident.to_string(),
None => return Err(unknown_argument(path)),
};
match value {
Expr::Path(ExprPath {
qself: None,
path: target,
..
}) => {
if key == "proc_macro" {
return Err(syn::Error::new_spanned(
path,
"`proc_macro` is reserved and cannot name a dependency",
));
}
args.deps.push(parse_dependency(Some(key), target)?);
}
_ if key == "proc_macro" => args.proc_macro = parse_bool(value)?,
_ if key == "edition" => args.edition = Some(parse_string(value)?),
_ if key == "should_error" => {
args.ui.should_errors.push(Some(parse_string(value)?))
}
_ if key == "should_warn" => {
args.ui.should_warns.push(Some(parse_string(value)?))
}
_ if key == "should_spanned" => {
args.ui.should_spanned.push(parse_string(value)?)
}
_ => return Err(unknown_argument(path)),
}
}
Meta::List(list) => return Err(unknown_argument(&list.path)),
}
}
Ok(args)
}
}
fn unknown_argument(path: &syn::Path) -> syn::Error {
syn::Error::new_spanned(
path,
"unknown `#[subcrate]` argument (expected `proc_macro`, `edition = \"…\"`, a \
dependency: `path::to::subcrate`, `::crate_name`, or either with an `alias = `, or a \
UI-test assertion: `should_error`, `should_warn` (each optionally `= \"…\"`), or \
`should_spanned = \"…\"`)",
)
}
fn parse_dependency(alias: Option<String>, path: &syn::Path) -> syn::Result<Dependency> {
let external = path.leading_colon.is_some();
let mut segments = Vec::new();
for segment in &path.segments {
if !matches!(segment.arguments, PathArguments::None) {
return Err(syn::Error::new_spanned(
segment,
"a subcrate dependency path cannot have generic arguments",
));
}
segments.push(segment.ident.to_string());
}
if !external && segments.first().map(String::as_str) == Some("crate") {
segments.remove(0);
}
if segments
.iter()
.any(|s| matches!(s.as_str(), "crate" | "self" | "super" | "Self"))
{
return Err(syn::Error::new_spanned(
path,
"a subcrate dependency path must name a module from the crate root, \
like `outer::inner` (`self`, `super` and `Self` are not allowed)",
));
}
let last = match segments.last() {
Some(last) => last.clone(),
None => {
return Err(syn::Error::new_spanned(
path,
"expected the path of a subcrate",
))
}
};
Ok(Dependency {
alias: alias.unwrap_or(last),
path: segments,
external,
})
}
fn parse_bool(expr: &Expr) -> syn::Result<bool> {
if let Expr::Lit(ExprLit {
lit: Lit::Bool(b), ..
}) = expr
{
Ok(b.value)
} else {
Err(syn::Error::new_spanned(expr, "expected a boolean literal"))
}
}
fn parse_string(expr: &Expr) -> syn::Result<String> {
if let Expr::Lit(ExprLit {
lit: Lit::Str(s), ..
}) = expr
{
Ok(s.value())
} else {
Err(syn::Error::new_spanned(expr, "expected a string literal"))
}
}
pub fn inner_attrs(attrs: &[Attribute]) -> Vec<Attribute> {
attrs
.iter()
.filter(|attr| matches!(attr.style, AttrStyle::Inner(_)))
.cloned()
.collect()
}
pub fn is_subcrate_attr(attr: &Attribute) -> bool {
attr.path()
.segments
.last()
.map(|seg| seg.ident == "subcrate")
.unwrap_or(false)
}
pub fn parse_attr_args(attr: &Attribute) -> syn::Result<Args> {
match &attr.meta {
Meta::Path(_) => Ok(Args::default()),
Meta::List(list) => syn::parse2::<Args>(list.tokens.clone()),
Meta::NameValue(nv) => Err(syn::Error::new_spanned(
nv,
"`#[subcrate]` does not take a `= value` form",
)),
}
}
pub type ResolvedDep = (String, Vec<String>);
pub const SKIPPED_MARKER: &str = "!skipped";
pub enum ManifestEntry {
Built(Vec<ResolvedDep>),
Skipped,
}
pub fn manifest_line(internal: &str, deps: &[ResolvedDep]) -> String {
let mut line = internal.to_string();
for (alias, path) in deps {
line.push('\t');
line.push_str(alias);
line.push('=');
line.push_str(&path.join("::"));
}
line
}
pub fn skipped_manifest_line(internal: &str) -> String {
format!("{}\t{}", internal, SKIPPED_MARKER)
}
pub fn manifest_lookup(manifest: &str, internal: &str) -> Option<ManifestEntry> {
manifest.lines().find_map(|line| {
let mut fields = line.trim().split('\t');
if fields.next()? != internal {
return None;
}
let rest = fields.collect::<Vec<&str>>();
if rest.first() == Some(&SKIPPED_MARKER) {
return Some(ManifestEntry::Skipped);
}
Some(ManifestEntry::Built(
rest.into_iter()
.filter_map(|field| {
let (alias, path) = field.split_once('=')?;
let path = path.split("::").map(str::to_string).collect();
Some((alias.to_string(), path))
})
.collect(),
))
})
}
pub fn canonical_body(attrs: &[Attribute], items: &[Item]) -> String {
let tokens: TokenStream = quote! { #(#attrs)* #(#items)* };
let mut out = String::new();
write_canonical(&tokens, &mut out);
out
}
fn write_canonical(tokens: &TokenStream, out: &mut String) {
for tt in tokens.clone() {
match tt {
TokenTree::Group(group) => {
let (open, close) = match group.delimiter() {
Delimiter::Parenthesis => ('(', ')'),
Delimiter::Brace => ('{', '}'),
Delimiter::Bracket => ('[', ']'),
Delimiter::None => ('\u{2039}', '\u{203a}'),
};
out.push(open);
write_canonical(&group.stream(), out);
out.push(close);
}
TokenTree::Ident(ident) => {
out.push(' ');
out.push_str(&ident.to_string());
out.push(' ');
}
TokenTree::Punct(punct) => out.push(punct.as_char()),
TokenTree::Literal(lit) => {
out.push('\u{2045}');
out.push_str(&canonical_literal(&lit.to_string()));
out.push('\u{2046}');
}
}
}
}
fn canonical_literal(text: &str) -> String {
match syn::parse_str::<Lit>(text) {
Ok(Lit::Str(s)) => format!("s\u{1f}{}", s.value()),
Ok(Lit::ByteStr(s)) => format!("b\u{1f}{:?}", s.value()),
Ok(Lit::Char(c)) => format!("c\u{1f}{}", c.value()),
Ok(Lit::Byte(b)) => format!("y\u{1f}{}", b.value()),
_ => text.to_string(),
}
}
pub fn internal_crate_name(
ident: &str,
args: &Args,
inner_attrs: &[Attribute],
items: &[Item],
) -> String {
let body = canonical_body(inner_attrs, items);
let mut hasher = Fnv1a::new();
hasher.write(ident.as_bytes());
hasher.write(&[0x1f]);
hasher.write(args.fingerprint().as_bytes());
hasher.write(&[0x1f]);
hasher.write(body.as_bytes());
format!(
"{}{}_{:016x}",
INTERNAL_PREFIX,
sanitize_ident(ident),
hasher.finish()
)
}
fn sanitize_ident(ident: &str) -> String {
let mut result = String::new();
let mut gap = false;
for ch in ident.chars() {
if ch.is_ascii_alphanumeric() {
if gap && !result.is_empty() {
result.push('_');
}
result.push(ch.to_ascii_lowercase());
gap = false;
} else {
gap = true;
}
}
if result.is_empty() {
"anon".to_string()
} else {
result
}
}
struct Fnv1a(u64);
impl Fnv1a {
const OFFSET: u64 = 0xcbf2_9ce4_8422_2325;
const PRIME: u64 = 0x0000_0100_0000_01b3;
fn new() -> Self {
Fnv1a(Self::OFFSET)
}
fn write(&mut self, bytes: &[u8]) {
for &b in bytes {
self.0 ^= u64::from(b);
self.0 = self.0.wrapping_mul(Self::PRIME);
}
}
fn finish(&self) -> u64 {
self.0
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn literals_canonicalize_by_value_not_spelling() {
let raw: Item = syn::parse_str(r##"fn f() -> &'static str { r"a\b" }"##).unwrap();
let escaped: Item = syn::parse_str(r#"fn f() -> &'static str { "a\\b" }"#).unwrap();
assert_eq!(
canonical_body(&[], std::slice::from_ref(&raw)),
canonical_body(&[], std::slice::from_ref(&escaped)),
);
assert_eq!(
internal_crate_name("m", &Args::default(), &[], std::slice::from_ref(&raw)),
internal_crate_name("m", &Args::default(), &[], std::slice::from_ref(&escaped)),
);
}
#[test]
fn a_skipped_subcrate_round_trips_through_the_manifest() {
let built = manifest_line(
"__subcrate_a",
&[("dep".into(), vec!["x".into(), "y".into()])],
);
let skipped = skipped_manifest_line("__subcrate_b");
let manifest = format!("{}\n{}\n", built, skipped);
match manifest_lookup(&manifest, "__subcrate_a") {
Some(ManifestEntry::Built(deps)) => {
assert_eq!(
deps,
vec![("dep".to_string(), vec!["x".to_string(), "y".to_string()])]
);
}
_ => panic!("expected a built entry"),
}
assert!(matches!(
manifest_lookup(&manifest, "__subcrate_b"),
Some(ManifestEntry::Skipped)
));
assert!(manifest_lookup(&manifest, "__subcrate_missing").is_none());
}
}