chore: add an example for rust derive trait order (#24)

Author: maksym-arutyunyan

research/derive_order/Cargo.toml

@@ -0,0 +1,5 @@
+[workspace]
+members = [
+    "derive_macros",
+    "use_macros",
+]

research/derive_order/README.md

@@ -0,0 +1,34 @@
+# Rust Derive Order Example
+
+This project shows how the order of Rust derive traits can impact a struct's behavior. 
+It includes two custom procedural macros `First` and `Second`.
+
+## Structure
+
+- **derive_macros/**: Defines the `First` and `Second` macros
+- **use_macros/**: Contains tests to verify the behavior of the macros
+
+## Tests
+
+Two tests demonstrate the importance of derive order:
+
+1. **`test_first_second`**: `First` is derived before `Second`. This should pass.
+2. **`test_second_first`**: `Second` is derived before `First`. This may fail, but it actually passes. **Seems like the derive order does not matter!**
+
+### Run Tests
+
+To run the tests:
+
+```shell
+cargo test -p use_macros -- --nocapture
+```
+
+Output:
+
+```shell
+running 2 tests
+First is implemented, so Second works!
+First is implemented, so Second works!
+test tests::test_second_first ... ok
+test tests::test_first_second ... ok
+```

research/derive_order/derive_macros/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "derive_macros"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = "2.0"

research/derive_order/derive_macros/src/lib.rs

@@ -0,0 +1,36 @@
+extern crate proc_macro;
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse_macro_input, DeriveInput};
+
+#[proc_macro_derive(First)]
+pub fn derive_first(input: TokenStream) -> TokenStream {
+    let name = parse_macro_input!(input as DeriveInput).ident;
+    
+    TokenStream::from(quote! {
+        impl First for #name {
+            fn is_first_implemented() -> bool {
+                true
+            }
+        }
+    })
+}
+
+#[proc_macro_derive(Second)]
+pub fn derive_second(input: TokenStream) -> TokenStream {
+    let name = parse_macro_input!(input as DeriveInput).ident;
+
+    TokenStream::from(quote! {
+        impl Second for #name {
+            fn check_first_is_implemented() -> bool {
+                let result = <#name as First>::is_first_implemented();
+                println!(
+                    "First is {}implemented, so Second {}!",
+                    if result { "" } else { "NOT " },
+                    if result { "works" } else { "fails" }
+                );
+                result
+            }
+        }
+    })
+}

research/derive_order/use_macros/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "use_macros"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+derive_macros = { path = "../derive_macros" }

research/derive_order/use_macros/src/lib.rs

@@ -0,0 +1,32 @@
+// This test file checks if the order of Rust derive traits matters.
+// Since the keepsorted tool could reorder these traits in CI, we must ignore this file.
+// keepsorted: ignore file
+
+#[cfg(test)]
+mod tests {
+    use derive_macros::{First, Second};
+
+    trait First {
+        fn is_first_implemented() -> bool;
+    }
+
+    trait Second {
+        fn check_first_is_implemented() -> bool;
+    }
+
+    #[test]
+    fn test_first_second() {
+        #[derive(First, Second)] // <- This order should work.
+        struct MyStruct;
+
+        assert!(MyStruct::check_first_is_implemented());
+    }
+
+    #[test]
+    fn test_second_first() {
+        #[derive(Second, First)] // <- This order might not work.
+        struct MyStruct;
+
+        assert!(MyStruct::check_first_is_implemented());
+    }
+}