编写Proc-Macro时，如何从父泛型提取单个Field所需泛型？

要实现从父类型Generics中提取单个字段所需的最小泛型集合，核心思路是先识别字段类型中用到的所有泛型参数/生命周期，再从父泛型中筛选出这些条目并保留其约束。可以通过syn的访问器（Visit trait）遍历字段类型语法树，收集用到的泛型标识，再匹配父泛型中的对应项。

实现步骤 #

1. 编写泛型参数收集器
   利用syn::visit::Visit trait遍历字段的类型语法树，收集所有被引用的泛型参数名和生命周期名。

2. 筛选父泛型中的相关条目
   遍历父泛型的params，只保留被字段类型引用过的参数，同时完整保留它们的约束（比如B: Bar、C: Iterator<Item=A>这类绑定）。

完整代码实现 #

use syn::{visit::Visit, Generics, Field, GenericParam, Ident, Lifetime, Type};
use quote::quote;

// 用于收集字段类型中用到的泛型参数和生命周期
struct UsedGenericsCollector {
    used_lifetimes: Vec<Lifetime>,
    used_type_params: Vec<Ident>,
}

impl<'ast> Visit<'ast> for UsedGenericsCollector {
    // 访问生命周期引用（比如'abc）
    fn visit_lifetime(&mut self, i: &'ast Lifetime) {
        self.used_lifetimes.push(i.clone());
        syn::visit::visit_lifetime(self, i);
    }

    // 访问嵌套在路径参数中的泛型（比如Vec<B::A>里的B）
    fn visit_path_arguments(&mut self, args: &'ast syn::PathArguments) {
        if let syn::PathArguments::AngleBracketed(args) = args {
            for arg in &args.args {
                if let syn::GenericArgument::Type(Type::Path(type_path)) = arg {
                    if let Some(seg) = type_path.path.segments.first() {
                        if seg.arguments.is_empty() {
                            self.used_type_params.push(seg.ident.clone());
                        }
                    }
                }
                syn::visit::visit_generic_argument(self, arg);
            }
        }
        syn::visit::visit_path_arguments(self, args);
    }

    // 访问单独的类型参数（比如字段类型直接是A）
    fn visit_type_path(&mut self, ty: &'ast syn::TypePath) {
        if ty.path.segments.len() == 1 && ty.path.segments[0].arguments.is_empty() {
            self.used_type_params.push(ty.path.segments[0].ident.clone());
        }
        syn::visit::visit_type_path(self, ty);
    }
}

fn generics_for_field(parent_generics: &Generics, field: &Field) -> Generics {
    let mut collector = UsedGenericsCollector {
        used_lifetimes: Vec::new(),
        used_type_params: Vec::new(),
    };
    // 遍历字段类型，收集用到的泛型
    collector.visit_type(&field.ty);

    // 去重，避免重复参数
    collector.used_lifetimes.dedup();
    collector.used_type_params.dedup();

    // 从父泛型中筛选出用到的参数
    let mut filtered_params = Vec::new();
    for param in &parent_generics.params {
        match param {
            GenericParam::Lifetime(lifetime_param) => {
                if collector.used_lifetimes.contains(&lifetime_param.lifetime) {
                    filtered_params.push(param.clone());
                }
            }
            GenericParam::Type(type_param) => {
                if collector.used_type_params.contains(&type_param.ident) {
                    filtered_params.push(param.clone());
                }
            }
            GenericParam::Const(_) => {
                // 如需支持const泛型，可在此添加逻辑
                continue;
            }
        }
    }

    // 构建新的Generics结构体
    Generics {
        params: filtered_params,
        ..parent_generics.clone()
    }
}

// 测试示例
#[cfg(test)]
mod tests {
    use super::*;
    use syn::parse_quote;

    #[test]
    fn test_generics_for_field() {
        let parent_generics: Generics = parse_quote!(<'abc, A, B: Bar, C: Iterator<Item=A>>);
        
        // 模拟结构体的各个字段
        let fields: Vec<Field> = parse_quote! {
            {
                foo_initial: A,
                foo_count: i32,
                unrelated: Vec<B::A>,
                some_ref: PhantomData<&'abc mut C>,
            }
        };

        // 验证第一个字段（A）
        let gen0 = generics_for_field(&parent_generics, &fields[0]);
        assert_eq!(quote!(#gen0).to_string(), quote!(<A>).to_string());

        // 验证第二个字段（i32，无泛型）
        let gen1 = generics_for_field(&parent_generics, &fields[1]);
        assert_eq!(quote!(#gen1).to_string(), quote!(<>).to_string());

        // 验证第三个字段（Vec<B::A>）
        let gen2 = generics_for_field(&parent_generics, &fields[2]);
        assert_eq!(quote!(#gen2).to_string(), quote!(<B: Bar>).to_string());

        // 验证第四个字段（PhantomData<&'abc mut C>）
        let gen3 = generics_for_field(&parent_generics, &fields[3]);
        assert_eq!(quote!(#gen3).to_string(), quote!(<'abc, C: Iterator<Item = A>>).to_string());
    }
}

说明 #

• 收集器会遍历字段类型的所有语法节点，包括嵌套在Vec、PhantomData中的泛型参数，以及生命周期引用。
• 筛选时会完整保留父泛型中该参数的所有约束（比如C: Iterator<Item=A>的约束不会丢失）。
• 代码中处理了生命周期和类型参数，如需支持const泛型，可以扩展GenericParam::Const的匹配逻辑。

内容的提问来源于stack exchange，提问作者Locke