我以为Rust没有反射...？

该crate通过类似于编译时反射的编程模型来探索如何处理自定义 derive 宏的80%用例。

动机

我的现有库 syn 和 quote 以一种非常通用的方式处理过程宏的问题空间，适用于大约95%的用例。然而，这种通用性伴随着相对较低抽象层次的代价。宏的作者需要负责放置每个单个尖括号、生命周期、类型参数、特性和幻数。涉及大量的领域知识，并且很少有人能够可靠地使用这种方法生成健壮的宏。

这里探索的设计集中在消除所有边缘案例——也就是说，如果你的宏对于最基本的情况有效，那么它也会在所有复杂的情况下有效。

编程模型

我们的想法是暴露出一个看起来很无聊、简单的运行时反射 API，就像如果你使用过Java中的反射 或 Go中的反射 一样可能会认识到的。

宏作者使用此API将宏的逻辑表达为，使用类似于reflect::Value的类型来检索函数参数、访问数据结构的字段以及调用函数等。重要的是，在此模型中不存在泛型类型或幻数数据。一切只是一个具有运行时概念上单态化的类型的reflect::Value。

同时，库正在跟踪控制流和函数调用，以构建一个完整通用且健壮的作者宏的过程实现。生成的代码将具有所有正确位置的角度符号、生命周期、界限和幻数类型，而无需宏作者考虑任何这些。

反射API仅仅是定义过程宏的一种手段。库将其全部消除，并生成干净的无任何实际运行时反射的Rust源代码。请注意，这并不是关于编译器优化的声明——我们不依赖于Rust编译器对糟糕的生成代码进行英雄般的优化。实际上，通过反射API编写的源代码将与经验丰富的宏作者仅仅使用syn和quote所生成的代码相同。

从调用宏的人的角度来看，宏的调用方式与不带反射的传统方式编写的方式完全相同，他们的代码编译速度和性能都完全一样。优势在于宏作者，对于他们来说，开发和维护一个健壮的宏变得大大简化。

演示

本项目包含了一个用于定义自定义 derive 的编译时反射API的概念验证。

tests/debug/目录展示了为具有命名字段的 struct 定义#[derive(Debug)]的可行可编译实现。相应的测试用例显示了为具有两个字段的Point struct 派生Debug时生成的代码；它与不带反射的手写derive(Debug)宏为相同数据结构生成的代码等效。

宏实现开始于运行时所需类型和函数的DSL声明。

reflect::library! {
    extern crate std {
        mod fmt {
            type Formatter;
            type Result;
            type DebugStruct;

            trait Debug {
                fn fmt(&self, &mut Formatter) -> Result;
            }

            impl Formatter {
                fn debug_struct(&mut self, &str) -> DebugStruct;
            }

            impl DebugStruct {
                fn field(&mut self, &str, &Debug) -> &mut DebugStruct;
                fn finish(&mut self) -> Result;
            }
        }
    }
}

如果需要使用标准库外的类型，这里可能会有额外的extern crate块。例如，Serde的#[derive(Serialize)]宏想要列出serde crate、Serialize和Serializer类型以及它们在运行时可能被调用的任何方法。

在宏实现的其余部分，所有类型信息都是基于在此库声明中给出的签名进行静态推断的。

接下来，宏的入口点是一个普通的proc_macro_derive函数，就像任何其他方式定义的 derive 宏一样。

再次强调，反射API只是一个定义过程宏的手段。尽管下面看起来可能不同，这里所写的所有内容都是在编译时执行的。reflect库会输出到一个输出TokenStream的生成代码，这个代码会被编译到宏用户的crate中。这个令牌流中不包含任何运行时反射的痕迹。

use proc_macro::TokenStream;

// Macro that is called when someone writes derive(MyDebug) on a data structure.
// It returns a fragment of Rust source code (TokenStream) containing an
// implementation of Debug for the input data structure. The macro uses
// compile-time reflection internally, but the generated Debug impl is exactly
// as if this macro were handwritten without reflection.
#[proc_macro_derive(MyDebug)]
pub fn derive(input: TokenStream) -> TokenStream {
    // Feed the tokens describing the data structure into the reflection library
    // for parsing and analysis. We provide a callback that describes what trait
    // impl(s) the reflection library will need to generate code for.
    reflect::derive(input, |ex| {
        // Instruct the library to generate an impl of Debug for the derive
        // macro's target type / Self type.
        ex.make_trait_impl(RUNTIME::std::fmt::Debug, ex.target_type(), |block| {
            // Instruct the library to compile debug_fmt (a function shown
            // below) into the source code for the impl's Debug::fmt method.
            block.make_function(RUNTIME::std::fmt::Debug::fmt, debug_fmt);
        });
    })
}

以下看起来像是一个执行运行时反射的函数。它接收类型为reflect::Value的函数参数，并且可以传递它们，提取它们的字段，检查属性，调用方法等。

use reflect::*;

// This function will get compiled into Debug::fmt, which has this signature:
//
//     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result
//
fn debug_fmt(f: MakeFunction) -> Value {
    let receiver: reflect::Value = f.arg(0);  // this is `self`
    let formatter: reflect::Value = f.arg(1);

    // The input value may be any of unit struct, tuple struct, ordinary braced
    // struct, or enum.
    match receiver.data() {
        Data::Struct(receiver) => match receiver {
            Struct::Unit(receiver) => unimplemented!(),
            Struct::Tuple(receiver) => unimplemented!(),
            Struct::Struct(receiver) => {
                /* implemented below */
            }
        },
        // For an enum, the active variant of the enum may be any of unit
        // variant, tuple variant, or struct variant.
        Data::Enum(receiver) => receiver.match_variant(|variant| match variant {
            Variant::Unit(variant) => unimplemented!(),
            Variant::Tuple(variant) => unimplemented!(),
            Variant::Struct(variant) => unimplemented!(),
        }),
    }
}

在具有命名字段的struct的情况下，我们使用反射遍历struct的字段，并调用标准库的Formatter API的方法，将每个字段的值追加到调试输出中。

有关运行时应该执行的操作，请参考标准库API文档中的DebugStruct示例代码。

以RUNTIME::开头的路径是指上面提到的library! { ... }片段中声明的库签名。

let builder = RUNTIME::std::fmt::Formatter::debug_struct
    .INVOKE(formatter, type_name)
    .reference_mut();

for field in receiver.fields() {
    RUNTIME::std::fmt::DebugStruct::field.INVOKE(
        builder,
        field.get_name(),
        field.get_value(),
    );
}

RUNTIME::std::fmt::DebugStruct::finish.INVOKE(builder)

#[derive(MyDebug)]
struct Point {
    x: i32,
    y: i32,
}

// expands to:
impl ::std::fmt::Debug for Point {
    fn fmt(&self, _arg1: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        match *self {
            Point { x: ref _v0, y: ref _v1 } => {
                let mut _v2 = ::std::fmt::Formatter::debug_struct(_arg1, "Point");
                let _ = ::std::fmt::DebugStruct::field(&mut _v2, "x", _v0);
                let _ = ::std::fmt::DebugStruct::field(&mut _v2, "y", _v1);
                let _v3 = ::std::fmt::DebugStruct::finish(&mut _v2);
                _v3
            }
        }
    }
}

let input: DeriveInput = syn::parse(...).unwrap();

// Pull out one of the field types.
let type_of_field_x: syn::Type = /* ... */;

quote! {
    // Very not robust.
    struct Wrapper<'a> {
        x: &'a #type_of_field_x,
    }

    Wrapper { x: &self.x }
}

let wrapper: reflect::Type = reflect::new_struct_type();

wrapper.instantiate(vec![input.get_field("x").reference()])

关键在于，所有剩余的工作都应在不触及我们的 Debug 派生代码的情况下完成。 reflect 的承诺是，如果宏对于最基本的案例有效（上面的代码已经做到了），那么它也将在所有边缘情况下有效。从现在起，将简单的反射样式的 reflect::Value 对象操作编译成完全通用和健壮的过程宏的责任就落在了 reflect 的身上。

许可证