serde-aco-derive/src/help.rs - f5bf11a

help.rs90.98%

// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
use std::cmp::Ordering;
use std::iter::zip;
 
use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use syn::meta::ParseNestedMeta;
use syn::punctuated::Punctuated;
use syn::{
    Attribute, Data, DataEnum, DataStruct, DeriveInput, Expr, ExprLit, Fields, FieldsNamed,
    FieldsUnnamed, Ident, Lit, Meta, MetaNameValue, Token, parse_macro_input,
};
 
fn get_doc_from_attrs(attrs: &[Attribute]) -> String {275x
    let mut lines = vec![];275x
    for attr in attrs.iter() {518x
        let Meta::NameValue(MetaNameValue {
            path,313x
            value: Expr::Lit(ExprLit {
                lit: Lit::Str(s), ..313x
            }),
            ..
        }) = &attr.meta313x
        else {
            continue;205x
        };
        if path.is_ident("doc") {313x
            let v = s.value();313x
            let mut trimmed = v.trim_end();313x
            if let Some(t) = trimmed.strip_prefix(' ') {313x
                trimmed = t;305x
            }305x
            if !trimmed.is_empty() {313x
                lines.push(trimmed.to_string());305x
            }305x
        }
    }
    lines.join("\n")275x
}275x
 
fn get_serde_aliases_from_attrs(ident: &Ident, attrs: &[Attribute]) -> Vec<String> {273x
    let mut aliases = vec![];273x
    for attr in attrs.iter() {514x
        if !attr.path().is_ident("serde") {514x
            continue;362x
        }152x
        let Ok(nested) = attr.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)152x
        else {
            continue;
        };
        for meta in nested {166x
            let Meta::NameValue(MetaNameValue {
                path,86x
                value:
                    Expr::Lit(ExprLit {
                        lit: Lit::Str(s), ..86x
                    }),
                ..
            }) = meta86x
            else {
                continue;80x
            };
            if !path.is_ident("alias") {86x
                continue;12x
            }74x
            aliases.push(s.value());74x
        }
    }
    aliases.push(ident.to_string());273x
    aliases.sort_by(|l, r| {273x
        if l.len() != r.len() {80x
            l.len().cmp(&r.len())34x
        } else {
            for (a, b) in zip(l.chars(), r.chars()) {46x
                if a == b {46x
                    continue;
                }46x
                if a.is_lowercase() == b.is_lowercase() {46x
                    return a.cmp(&b);
                } else if a.is_lowercase() {46x
                    return Ordering::Less;
                } else {
                    return Ordering::Greater;46x
                }
            }
            Ordering::Equal
        }
    });80x
    aliases273x
}273x
 
fn has_aco_attr(attrs: &[Attribute], name: &str) -> bool {499x
    for attr in attrs.iter() {893x
        if !attr.path().is_ident("serde_aco") {893x
            continue;881x
        }12x
        let mut found = false;12x
        let has_name = |meta: ParseNestedMeta| {12x
            if meta.path.is_ident(name) {12x
                found = true;10x
            }10x
            Ok(())12x
        };12x
        if attr.parse_nested_meta(has_name).is_err() {12x
            continue;
        }12x
        if found {12x
            return true;10x
        }2x
    }
    false489x
}499x
 
fn is_hidden(attrs: &[Attribute]) -> bool {283x
    has_aco_attr(attrs, "hide")283x
}283x
 
fn is_flattened(attrs: &[Attribute]) -> bool {216x
    has_aco_attr(attrs, "flatten")216x
}216x
 
fn derive_named_struct_help(name: &Ident, fields: &FieldsNamed) -> TokenStream2 {96x
    let mut field_docs = Vec::new();96x
    for field in &fields.named {219x
        if is_hidden(&field.attrs) {219x
            continue;3x
        }216x
        let aliases;
        let ident = if is_flattened(&field.attrs) {216x
            ""2x
        } else {
            aliases = get_serde_aliases_from_attrs(field.ident.as_ref().unwrap(), &field.attrs);214x
            &aliases[0]214x
        };
        let ty = &field.ty;216x
        let doc = get_doc_from_attrs(&field.attrs);216x
        field_docs.push(quote! {216x
            FieldHelp {
                ident: #ident,
                doc: #doc,
                ty: <#ty as Help>::HELP,
            }
        })
    }
 
    quote! {96x
        TypedHelp::Struct{
            name: stringify!(#name),
            fields: &[#(#field_docs,)*],
        }
    }
}96x
 
fn derive_unnamed_struct_help(fields: &FieldsUnnamed) -> TokenStream2 {36x
    if let Some(first) = fields.unnamed.first() {36x
        let ty = &first.ty;36x
        quote! { <#ty as Help>::HELP }36x
    } else if fields.unnamed.is_empty() {
        quote! { TypedHelp::Unit }
    } else {
        panic!("Unnamed struct must have only one field")
    }
}36x
 
fn derive_struct_help(name: &Ident, data: &DataStruct) -> TokenStream2 {95x
    match &data.fields {95x
        Fields::Named(fields) => derive_named_struct_help(name, fields),89x
        Fields::Unnamed(fields) => derive_unnamed_struct_help(fields),6x
        Fields::Unit => quote! { TypedHelp::Unit },
    }
}95x
 
fn derive_enum_help(name: &Ident, data: &DataEnum) -> TokenStream2 {41x
    let mut variant_docs = vec![];41x
    for variant in data.variants.iter() {65x
        if is_hidden(&variant.attrs) {64x
            continue;5x
        }59x
        let doc = get_doc_from_attrs(&variant.attrs);59x
        let ty = match &variant.fields {59x
            Fields::Unit => quote! {TypedHelp::Unit},22x
            Fields::Named(fields) => derive_named_struct_help(name, fields),7x
            Fields::Unnamed(fields) => derive_unnamed_struct_help(fields),30x
        };
        let aliases = get_serde_aliases_from_attrs(&variant.ident, &variant.attrs);59x
        let ident = &aliases[0];59x
        variant_docs.push(quote! {59x
            FieldHelp {
                ident: #ident,
                doc: #doc,
                ty: #ty,
            }
        })
    }
    quote! {41x
        TypedHelp::Enum {
            name: stringify!(#name),
            variants: &[#(#variant_docs,)*],
        }
    }
}41x
 
pub fn derive_help(input: TokenStream) -> TokenStream {136x
    let input = parse_macro_input!(input as DeriveInput);136x
    let ty_name = &input.ident;136x
    let body = match &input.data {136x
        Data::Struct(data) => derive_struct_help(ty_name, data),95x
        Data::Enum(data) => derive_enum_help(ty_name, data),41x
        Data::Union(_) => unimplemented!("Data::Union not supported"),
    };
    TokenStream::from(quote! {136x
        const _:() = {
            use ::serde_aco::{Help, TypedHelp, FieldHelp};
            impl Help for #ty_name {
                const HELP: TypedHelp = #body;
            }
        };
    })
}136x
 