如何在Rust过程宏中存储类型type_code以实现编译期字段排序？

定义的Trait #

trait XrlpType<T> {
    pub fn type_code() -> u16;
}

需求 #

每个实现XrlpType<T>的类型对应一个由T决定的u16类型码。需要在结构体序列化的derive过程宏中，按字段类型的type_code从小到大排序字段，且排序必须在编译期完成。

尝试的宏代码 #

let fields_data = fields.named.into_iter().map(|field| {
    // ... 其他逻辑
    return Some((field.ty, nth, field.ident));
    // ... 其他逻辑
});

// ... 其他逻辑

let fields_data = fields_data.flatten()
    .sorted_by(|a, b| Ord::cmp(&(a.0::type_code(), a.1), &(b.0::type_code(), b.1)));

遇到的问题 #

宏展开阶段，a.0和b.0仅仅是类型标识符，并非实际可调用方法的类型实例，因此无法直接调用type_code()获取对应的类型码值。

当前构想的方案 #

编写另一个过程宏，在编译时将类型T与对应的type_code写入toml格式数据库，但希望找到更优方案。

更优解决方案推荐 #

方案1：将关联函数改为关联常量 #

修改原trait定义，把type_code()关联函数换成TYPE_CODE关联常量：

trait XrlpType<T> {
    const TYPE_CODE: u16;
}

这样在过程宏中，只要能解析出字段的类型路径，就可以直接生成#ty::TYPE_CODE的代码，在编译期获取常量值。结合编译期排序逻辑，就能完成字段排序。

方案2：利用Rust编译期const求值实现排序 #

不需要修改原trait，通过生成包含编译期排序逻辑的代码来实现需求。核心思路是：

1. 为每个字段生成包含type_code、原始索引、字段标识的编译期条目
2. 在const块中对这些条目按type_code（以及原始索引作为次要键）排序
3. 根据排序后的索引重新排列字段

示例代码片段：

use quote::quote;
use syn::{DataStruct, FieldsNamed};

fn generate_sorted_fields(fields: &FieldsNamed) -> proc_macro2::TokenStream {
    let field_count = fields.named.len();
    let field_entries = fields.named.iter().enumerate().map(|(idx, field)| {
        let ty = &field.ty;
        let ident = &field.ident;
        // 生成包含类型码、索引、字段名的条目
        quote! {
            (<#ty as XrlpType<_>>::type_code(), #idx, #ident)
        }
    });

    quote! {
        // 定义包含所有字段信息的常量数组
        const FIELD_INFO: [(u16, usize, Option<&'static str>); #field_count] = [
            #(#field_entries),*
        ];

        // 编译期排序，生成排序后的索引数组
        const SORTED_INDICES: [usize; #field_count] = {
            let mut indices = [0; #field_count];
            let mut codes = [0; #field_count];
            // 初始化索引和类型码数组
            let mut i = 0;
            while i < #field_count {
                indices[i] = FIELD_INFO[i].1;
                codes[i] = FIELD_INFO[i].0;
                i += 1;
            }
            // 编译期冒泡排序（稳定排序，相同类型码保留原始顺序）
            let mut i = 0;
            while i < #field_count - 1 {
                let mut j = 0;
                while j < #field_count - i - 1 {
                    if codes[j] > codes[j+1] || (codes[j] == codes[j+1] && indices[j] > indices[j+1]) {
                        // 交换索引和类型码
                        let temp_idx = indices[j];
                        indices[j] = indices[j+1];
                        indices[j+1] = temp_idx;
                        let temp_code = codes[j];
                        codes[j] = codes[j+1];
                        codes[j+1] = temp_code;
                    }
                    j += 1;
                }
                i += 1;
            }
            indices
        };

        // 根据排序后的索引获取字段
        let sorted_fields = [
            #(FIELD_INFO[SORTED_INDICES[#]].2),*
        ];
        sorted_fields
    }
}

这段代码会在编译期完成排序逻辑，完全符合需求，不需要额外的外部工具或数据库。

方案3：过程宏中预验证类型并生成排序代码 #

在过程宏中，先通过syn验证每个字段的类型确实实现了XrlpType，然后生成调用type_code()的代码片段，将这些片段嵌入到编译期计算的排序逻辑中。这种方式保持原trait不变，同时利用编译器的类型检查确保每个字段都符合要求。

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