Merge pull request #2 from Tsukuba-Programming-Lab/#1_SetupProject

#1 基礎を整えた

Author: Yuta1004

Cargo.lock

@@ -1,6 +1,26 @@
 [package]
 name = "mymodifer"
-version = "0.1.0"
 edition = "2024"
+version.workspace = true
 
 [dependencies]
+# TODO
+
+[workspace]
+resovler = "2"
+members = [
+    # crates
+    "crates/core",
+    "crates/macros",
+
+    # examples
+    "examples/simple",
+]
+exclude = []
+
+[workspace.package]
+version = "0.1.0"
+
+[workspace.dependencies]
+anyhow = "1.0.96"
+thiserror = "2.0.11"

Cargo.toml

@@ -0,0 +1,30 @@
+# My Modifier
+
+```rust
+#[modifier]
+trait Dev {}
+
+#[modifier_callee]
+fn for_developper() {
+    // ...
+}
+
+fn main() {
+    // Ok
+    dev! {{
+        for_developper();
+    }}
+
+    // Compile error
+    for_developper();
+}
+```
+
+## Examples
+
+- [simple](examples/simple)
+
+```
+$ cargo run -p example_simple
+Hello, World!
+```

README.md

@@ -0,0 +1,9 @@
+[package]
+name = "mymodifier_core"
+edition = "2024"
+version.workspace = true
+
+[dependencies]
+anyhow = { workspace = true }
+thiserror = { workspace = true }
+mymodifier_macros = { path = "../macros" }

crates/core/Cargo.toml

@@ -0,0 +1,5 @@
+pub use mymodifier_macros::{
+    modifier,
+    modifier_caller,
+    modifier_callee,
+};

crates/core/src/lib.rs

@@ -0,0 +1,12 @@
+[package]
+name = "mymodifier_macros"
+edition = "2024"
+version.workspace = true
+
+[dependencies]
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = { version = "2.0", features = ["full", "extra-traits"] }
+
+[lib]
+proc-macro = true

crates/macros/Cargo.toml

@@ -0,0 +1,3 @@
+pub mod modifier;
+pub mod modifier_caller;
+pub mod modifier_callee;

crates/macros/src/impl.rs

@@ -0,0 +1,58 @@
+use proc_macro2::{TokenStream, Ident};
+use quote::quote;
+use syn::ItemTrait;
+
+/// 対象: トレイト
+/// 動作: 文脈導入用の宣言型マクロを生成
+pub fn proc_macro_impl(_args: TokenStream, ast: ItemTrait) -> TokenStream {
+    let trait_name = &ast.ident;
+    let macro_ident = as_macro_ident(trait_name);
+
+    quote! {
+        // トレイト本体
+        #ast
+
+        // 文脈マクロ
+        #[macro_export]
+        macro_rules! #macro_ident {
+            ({ $($body:tt)* }) => {
+                // 文脈を用意
+                struct Ctx;
+
+                // 文脈付き呼び出しへの変換 (関数定義ではなくブロックに変換される)
+                #[modifier_caller(#trait_name)]
+                fn __mymodifier_caller() {
+                    $($body)*
+                }
+            };
+
+            ($($body:tt)*) => {{
+                // 文脈付き呼び出しへの変換 (関数定義ではなくブロックに変換される)
+                #[modifier_caller(#trait_name)]
+                fn __mymodifier_caller() {
+                    $($body)*
+                }
+            }};
+        }
+    }
+}
+
+fn as_macro_ident(ident: &Ident) -> TokenStream {
+    let mut result = String::new();
+    for c in ident.to_string().chars() {
+        if c.is_uppercase() {
+            result.push('_');
+            result.push(c.to_ascii_lowercase());
+        } else {
+            result.push(c);
+        }
+    }
+
+    let result = if result.starts_with('_') {
+        &result[1..]
+    } else {
+        &result
+    };
+
+    result.parse().unwrap()
+}

crates/macros/src/impl/modifier.rs

@@ -0,0 +1,35 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{FnArg, ItemFn};
+
+/// 対象: 関数
+/// 動作: 文脈への制約を追加
+pub fn proc_macro_impl(args: TokenStream, ast: ItemFn) -> TokenStream {
+    let target_trait = args;
+
+    let fn_visibility = ast.vis;
+    let fn_ident = ast.sig.ident;
+    let fn_ret_type = ast.sig.output;
+    let fn_body = ast.block;
+
+    let fn_args = ast.sig.inputs;
+    let fn_args = if let Some(FnArg::Receiver(..)) = fn_args.first() {
+        let receiver = &fn_args[0];
+        let remains = fn_args.iter().skip(1).collect::<Vec<_>>();
+        quote! { #receiver, ctx: Ctx, #(#remains),*}
+    } else {
+        quote! { ctx: Ctx, #fn_args }
+    };
+
+    quote! {
+        // マクロ適用関数
+        #fn_visibility fn #fn_ident <Ctx> (#fn_args) #fn_ret_type
+        where
+            // 制約
+            Ctx: #target_trait,
+        {
+            // 関数本体
+            #fn_body
+        }
+    }
+}

crates/macros/src/impl/modifier_callee.rs

@@ -0,0 +1,47 @@
+use proc_macro2::TokenStream;
+use quote::{quote, ToTokens};
+use syn::{Expr, ItemFn, Stmt};
+
+/// 対象: 関数
+/// 動作: 文脈付き呼び出しを行うための前準備を生成 & 文脈付き呼び出しへの変換
+pub fn proc_macro_impl(args: TokenStream, ast: ItemFn) -> TokenStream {
+    let target_trait = args;
+
+    let stmts = &ast
+        .block
+        .stmts
+        .iter()
+        .map(append_ctx_if_calling)
+        .collect::<Vec<_>>();
+
+    quote! {
+        // 前準備
+        #[allow(non_local_definitions)]
+        impl #target_trait for Ctx {}
+
+        // 関数本体
+        #(#stmts);*
+    }
+}
+
+fn append_ctx_if_calling(stmt: &Stmt) -> TokenStream {
+    let append_ctx = |expr: &Expr| {
+        if let Expr::Call(call) = expr {
+            let func = call.func.to_token_stream();
+            let args = call.args.to_token_stream();
+            quote! { #func (Ctx, #args) }
+        } else if let Expr::MethodCall(call) = expr {
+            let receiver = call.receiver.to_token_stream();
+            let method = call.method.to_token_stream();
+            let args = call.args.to_token_stream();
+            quote! { #receiver . #method (Ctx, #args) }
+        } else {
+            stmt.to_token_stream()
+        }
+    };
+
+    match stmt {
+        Stmt::Expr(expr, _) => append_ctx(expr),
+        _ => stmt.to_token_stream(),
+    }
+}

crates/macros/src/impl/modifier_caller.rs

@@ -0,0 +1,34 @@
+mod r#impl;
+
+use proc_macro2::TokenStream;
+use syn::{parse_macro_input, ItemFn, ItemTrait};
+
+#[proc_macro_attribute]
+pub fn modifier(
+    attr: proc_macro::TokenStream,
+    item: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    let args: TokenStream = attr.into();
+    let ast = parse_macro_input!(item as ItemTrait);
+    r#impl::modifier::proc_macro_impl(args, ast).into()
+}
+
+#[proc_macro_attribute]
+pub fn modifier_caller(
+    attr: proc_macro::TokenStream,
+    item: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    let args: TokenStream = attr.into();
+    let ast = parse_macro_input!(item as ItemFn);
+    r#impl::modifier_caller::proc_macro_impl(args, ast).into()
+}
+
+#[proc_macro_attribute]
+pub fn modifier_callee(
+    attr: proc_macro::TokenStream,
+    item: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    let args: TokenStream = attr.into();
+    let ast = parse_macro_input!(item as ItemFn);
+    r#impl::modifier_callee::proc_macro_impl(args, ast).into()
+}

crates/macros/src/lib.rs

@@ -0,0 +1,13 @@
+use mymodifier_macros::*;
+
+#[modifier]
+pub trait A {}
+
+#[modifier]
+pub trait B {}
+
+#[modifier]
+pub trait C {}
+
+#[test]
+fn check_compile() {}