type-history-codegen 0.3.2

Shared type history parsing, authority, and Rust generation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

//! Preserve authored lint scope across generated copies of one declaration.

use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use syn::spanned::Spanned;
use syn::visit_mut::{self, VisitMut};
use syn::{Attribute, File, Ident, Path, Result, Type};

/// The supported lint attributes, in their authored order.
pub fn lint_attributes(attributes: &[Attribute]) -> impl Iterator<Item = &Attribute> {
    attributes.iter().filter(|attribute| {
        ["allow", "warn", "deny"]
            .iter()
            .any(|name| attribute.path().is_ident(name))
    })
}

/// Reuse a field type without moving its lint allowance onto neighboring fields.
pub fn scoped_field_type(
    record: &Ident,
    index: usize,
    ty: &Type,
    attributes: &[Attribute],
) -> (Type, TokenStream) {
    scoped_field_type_for_owner(record, record, index, ty, attributes)
}

// Historical helper names remain distinct while `Self` keeps its authored owner.
pub(crate) fn scoped_field_type_for_owner(
    record: &Ident,
    owner: &Ident,
    index: usize,
    ty: &Type,
    attributes: &[Attribute],
) -> (Type, TokenStream) {
    // Helpers have a different `Self`; preserve the authored field's owner.
    let authored_span = ty.span();
    let mut ty = ty.clone();
    FieldOwner(owner).visit_type_mut(&mut ty);
    let lints = lint_attributes(attributes).collect::<Vec<_>>();
    if lints.is_empty() {
        return (ty, TokenStream::new());
    }
    let name = format_ident!(
        "__TypeHistory{}Field{}Type",
        record,
        index,
        span = authored_span
    );
    (
        syn::parse_quote!(#name),
        quote!(#(#lints)* type #name = #ty;),
    )
}

struct FieldOwner<'a>(&'a Ident);

impl VisitMut for FieldOwner<'_> {
    fn visit_path_mut(&mut self, path: &mut Path) {
        if path.leading_colon.is_none() {
            if let Some(first) = path.segments.first_mut() {
                if first.ident == "Self" {
                    first.ident = self.0.clone();
                }
            }
        }
        visit_mut::visit_path_mut(self, path);
    }
}

/// Apply a declaration's lint scope to every emitted item that replaces it.
pub fn with_lints(attributes: &[Attribute], tokens: TokenStream) -> Result<TokenStream> {
    let lints = lint_attributes(attributes).collect::<Vec<_>>();
    if lints.is_empty() {
        return Ok(tokens);
    }
    let file: File = syn::parse2(tokens)?;
    Ok(file
        .items
        .iter()
        .map(|item| quote!(#(#lints)* #item))
        .collect())
}