single_line_macro 0.2.2

A macro to create methods and functions on a single line in a more readable way.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! Single_line_macro
//!
//! A procedural macro for writing one-line functions and methods
//! using `=> expr` syntax. Doc comments (`///`) are captured
//! and re-emitted so that `cargo doc` shows them.

extern crate proc_macro;
use proc_macro::TokenStream;
use quote::quote;
use syn::parenthesized;
use syn::parse::{Parse, ParseStream};
use syn::punctuated::Punctuated;
use syn::token::{Comma, Paren};
use syn::{parse_macro_input, Attribute, Expr, FnArg, Ident, Result, Token, Type, Visibility};

struct SingleLine {
    attrs: Vec<Attribute>,
    vis: Visibility,
    _fn_token: Option<Token![fn]>,
    async_token: Option<Token![async]>,
    name: Ident,
    args: Vec<FnArg>,
    ret_ty: Option<Type>,
    expr: Expr,
}

impl Parse for SingleLine {
    fn parse(input: ParseStream) -> Result<Self> {
        // 1. Capture doc comments and other outer attributes
        let attrs = input.call(Attribute::parse_outer)?;

        // 2. Visibility (`pub`, `pub(crate)`, or nothing)
        let vis: Visibility = input.parse()?;


        // 3. Optional `async` keyword
        let async_token = if input.peek(Token!(async)) {
            Some(input.parse()?)
        } else {
            None
        };
        
        // 4. Optional `fn` keyword
        let fn_token = if input.peek(Token![fn]) {
            Some(input.parse()?)
        } else {
            None
        };
        
        // 5. Function name
        let name: Ident = input.parse()?;

        // 6. Argument list: parse `( ... )` if present
        let mut args = Vec::new();
        if input.peek(Paren) {
            let content;
            parenthesized!(content in input);
            let punct: Punctuated<FnArg, Comma> = content.parse_terminated(FnArg::parse, Comma)?;
            args.extend(punct);
        }

        // 7. Optional return type: parse `-> ...` if present
        let ret_ty = if input.peek(Token![->]) {
            input.parse::<Token![->]>()?;
            Some(input.parse()?)
        } else {
            None
        };

        // 8. Body expression: parse `=> ...`
        input.parse::<Token![=>]>()?;
        let expr: Expr = input.parse()?;

        Ok(SingleLine {
            attrs,
            vis,
            _fn_token: fn_token,
            async_token,
            name,
            args,
            ret_ty,
            expr,
        })
    }
}

#[proc_macro]
pub fn single_line(item: TokenStream) -> TokenStream {
    let input = parse_macro_input!(item as SingleLine);

    let attrs = input.attrs;
    let vis = input.vis;
    let name = input.name;
    let expr = input.expr;
    let args = input.args;
    let async_token = input.async_token;

    let ret_ty = input.ret_ty.unwrap_or_else(|| syn::parse_quote! { () });

    // Detect if this is a method (has &self or &mut self)
    let is_method = args.iter().any(|arg| matches!(arg, FnArg::Receiver(_)));

    // If method and a single bare identifier, rewrite `x` to `self.x`
    let body = if is_method {
        if let Expr::Path(ref path) = expr {
            if path.path.segments.len() == 1 {
                let field = &path.path.segments[0].ident;
                quote! { self.#field }
            } else {
                quote! { #expr }
            }
        } else {
            quote! { #expr }
        }
    } else {
        quote! { #expr }
    };

    // build the function signature
    let args_quote = if !args.is_empty() {
        quote! { ( #(#args),* ) }
    } else {
        quote! { () }
    };

    let expanded = quote! {
        #(#attrs)*
        #vis #async_token fn #name #args_quote -> #ret_ty {
            #body
        }
    };
    expanded.into()
}