Turn Resource into a macro (Astavie#1)

Author: Astavie

Cargo.lock

@@ -2,6 +2,7 @@
 name = "cardmaster"
 version = "0.1.0"
 edition = "2021"
+authors = [ "Astavie <astavie@pm.me>" ]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

Cargo.toml

@@ -2,6 +2,7 @@
 name = "discord"
 version = "0.1.0"
 edition = "2021"
+authors = [ "Astavie <astavie@pm.me>" ]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -11,7 +12,6 @@ isahc = { version = "1.7.2", features = ["serde_json", "json"] }
 serde = { version = "1.0.126", features = ["derive"] }
 serde_json = "1.0.96"
 tokio = { version = "1.27.0", features = ["full"] }
-partial_id = { path = "partial_id" }
 serde_repr = "0.1.12"
 tokio-tungstenite = { version = "0.18.0", features = ["native-tls"] }
 futures-util = "0.3.28"
@@ -21,5 +21,8 @@ async-trait = "0.1.68"
 enumset = { version = "1.1.2", features = ["serde"] }
 monostate = "0.1.6"
 
+partial_id = { path = "partial_id" }
+resource = { path = "resource" }
+
 [patch.crates-io]
 serde = { git = "https://github.com/Astavie/serde.git", branch = "integer-tags-for-enums-noprecompile" }

discord/Cargo.toml

@@ -24,13 +24,19 @@ pub fn derive_partial(input: proc_macro::TokenStream) -> proc_macro::TokenStream
     } else {
         proc_macro2::TokenStream::from_iter(derives.into_iter())
     };
-    let partial_ident = Ident::new(&format!("Partial{}", ty), Span::call_site());
+    let partial_ty = Ident::new(&format!("Partial{}", ty), Span::call_site());
 
     let fields = filter_fields(match data {
         syn::Data::Struct(ref s) => &s.fields,
         _ => panic!("Field can only be derived for structs"),
     });
 
+    let id_typ = &fields
+        .iter()
+        .find(|(_, ident, _)| ident.to_string() == "id")
+        .unwrap()
+        .2;
+
     let field_var = fields.iter().map(|(vis, ident, ty)| {
         if ident.to_string() == "id" {
             quote! {
@@ -53,60 +59,75 @@ pub fn derive_partial(input: proc_macro::TokenStream) -> proc_macro::TokenStream
             }
         }
     });
-
-    let get_field = fields.iter().map(|(vis, ident, ty)| {
+    let convert_none_branch = fields.iter().map(|(_vis, ident, _ty)| {
         if ident.to_string() == "id" {
-            quote!{}
+            quote! {
+                #ident: src
+            }
         } else {
-            let get_ident = Ident::new(&format!("get_{}", ident), ident.span());
-            let get_ident_mut = Ident::new(&format!("get_{}_mut", ident), ident.span());
             quote! {
-                #vis async fn #get_ident(&mut self, client: &crate::request::Discord) -> crate::request::Result<&#ty> {
-                    crate::request::Result::Ok(match self.#ident {
-                        ::core::option::Option::Some(ref v) => v,
-                        ::core::option::Option::None => {
-                            crate::resource::Updatable::update(self, client).await?;
-                            self.#ident.as_ref().unwrap()
-                        }
-                    })
-                }
-                #vis async fn #get_ident_mut(&mut self, client: &crate::request::Discord) -> crate::request::Result<&mut #ty> {
-                    crate::request::Result::Ok(match self.#ident {
-                        ::core::option::Option::Some(ref mut v) => v,
-                        ::core::option::Option::None => {
-                            crate::resource::Updatable::update(self, client).await?;
-                            self.#ident.as_mut().unwrap()
-                        }
-                    })
-                }
+                #ident: ::core::option::Option::None
             }
         }
     });
 
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
 
     let tokens = quote! {
+
         #derive
-        #vis struct #partial_ident #ty_generics
-            #where_clause
-        {
+        #vis struct #partial_ty #generics {
             #(#field_var),*
         }
 
-        impl #impl_generics ::core::convert::From<#ty #ty_generics> for #partial_ident #ty_generics
+        impl #impl_generics ::core::convert::From<#ty #ty_generics> for #partial_ty #ty_generics
             #where_clause
         {
-            fn from(src: #ty #ty_generics) -> #partial_ident #ty_generics {
-                #partial_ident {
+            fn from(src: #ty #ty_generics) -> Self {
+                Self {
                     #(#convert_branch),*
                 }
             }
         }
 
-        impl #impl_generics #partial_ident #ty_generics
+        impl #impl_generics ::core::convert::From<#id_typ> for #partial_ty #ty_generics
             #where_clause
         {
-            #(#get_field)*
+            fn from(src: #id_typ) -> Self {
+                Self {
+                    #(#convert_none_branch),*
+                }
+            }
+        }
+
+        impl #impl_generics #ty #ty_generics
+            #where_clause
+        {
+            #vis async fn update(&mut self, client: &crate::request::Discord) -> crate::request::Result<()> {
+                *self = crate::request::Request::request(crate::request::HttpRequest::get(crate::resource::Endpoint::uri(&self.id)), client).await?;
+                crate::request::Result::Ok(())
+            }
+        }
+
+        impl #impl_generics #partial_ty #ty_generics
+            #where_clause
+        {
+            #vis async fn update(&mut self, client: &crate::request::Discord) -> crate::request::Result<()> {
+                let full: #ty = crate::request::Request::request(crate::request::HttpRequest::get(crate::resource::Endpoint::uri(&self.id)), client).await?;
+                *self = full.into();
+                crate::request::Result::Ok(())
+            }
+            #vis async fn get_field<T>(&mut self, client: &crate::request::Discord, f: fn(&Self) -> &::core::option::Option<T>) -> crate::request::Result<&T> {
+                crate::request::Result::Ok(match f(self) {
+                    ::core::option::Option::Some(_) => {
+                        f(self).as_ref().unwrap()
+                    }
+                    ::core::option::Option::None => {
+                        self.update(client).await?;
+                        f(self).as_ref().unwrap()
+                    }
+                })
+            }
         }
     };
     tokens.into()

discord/partial_id/src/lib.rs

@@ -0,0 +1,16 @@
+[package]
+name = "resource"
+version = "0.1.0"
+edition = "2021"
+authors = [ "Astavie <astavie@pm.me>" ]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "~1.0", features = ["full"] }
+quote = "~1.0"
+proc-macro2 = "~1.0"
+
+[dev-dependencies]
+trybuild = "~1.0"

discord/resource/Cargo.toml

@@ -0,0 +1,115 @@
+use proc_macro::TokenStream;
+use proc_macro2::{Ident, TokenStream as TokenStream2};
+use quote::quote;
+use syn::{
+    parse::{Parse, ParseStream},
+    parse_quote,
+    spanned::Spanned,
+    FnArg, ItemFn, ReturnType, Token, Type,
+};
+
+struct ResourceParams {
+    result: Type,
+    client: Option<Type>,
+}
+
+impl Parse for ResourceParams {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let result = input.parse()?;
+        let client = if input.peek(Token![,]) {
+            input.parse::<Token![,]>()?;
+
+            let ident: Ident = input.parse()?;
+            if ident.to_string() != "client" {
+                return Err(syn::Error::new(ident.span(), "invalid resource property"));
+            }
+
+            input.parse::<Token![=]>()?;
+            Some(input.parse()?)
+        } else {
+            None
+        };
+
+        Ok(Self { result, client })
+    }
+}
+
+fn resource_impl(attr: TokenStream, item: TokenStream) -> syn::Result<TokenStream2> {
+    let params: ResourceParams = syn::parse(attr)?;
+    let return_type = params.result;
+    let client_type = match params.client {
+        Some(t) => t,
+        None => parse_quote!(crate::request::Discord),
+    };
+
+    let result_type = parse_quote!(
+        ::std::pin::Pin<::std::boxed::Box<dyn ::futures_util::Future<Output = crate::request::Result<#return_type>> + ::std::marker::Send + 'resource>>
+    );
+
+    let mut get_request_fn: ItemFn = syn::parse(item)?;
+
+    // get immediate fn signature
+    let vis = get_request_fn.vis.clone();
+
+    let mut sig = get_request_fn.sig.clone();
+    let generic_params = sig.generics.params;
+    sig.generics = parse_quote!(<'resource, #generic_params>);
+    match &mut sig.output {
+        ReturnType::Default => panic!(),
+        ReturnType::Type(_, typ) => **typ = result_type,
+    }
+
+    // remove pattern matching from inputs and get names
+    let inputs = sig
+        .inputs
+        .iter_mut()
+        .skip(1) // skip self
+        .enumerate()
+        .map(|(n, arg)| match arg {
+            FnArg::Receiver(_) => panic!(),
+            FnArg::Typed(pt) => {
+                let ty = &*pt.ty;
+                match &*pt.pat {
+                    syn::Pat::Ident(ident) => {
+                        let id = &ident.ident;
+                        let id_cloned = id.clone();
+                        *arg = parse_quote!(#id: #ty);
+                        id_cloned
+                    }
+                    _ => {
+                        let id = Ident::new(&format!("arg__{}", n), pt.pat.span());
+                        let id_cloned = id.clone();
+                        *arg = parse_quote!(#id: #ty);
+                        id_cloned
+                    }
+                }
+            }
+        })
+        .collect::<Vec<_>>();
+
+    // insert client as input
+    sig.inputs
+        .insert(1, parse_quote!(client: &'resource #client_type));
+
+    // set original fn name to {}_request
+    let get_ident = get_request_fn.sig.ident;
+    let get_request_ident = Ident::new(&format!("{}_request", get_ident), get_ident.span());
+    get_request_fn.sig.ident = get_request_ident.clone();
+
+    // return functions
+    let tokens = quote! {
+        #get_request_fn
+        #vis #sig {
+            crate::request::Request::request(self.#get_request_ident(#(#inputs),*), client)
+        }
+    };
+    Ok(tokens)
+}
+
+#[proc_macro_attribute]
+pub fn resource(attr: TokenStream, item: TokenStream) -> TokenStream {
+    match resource_impl(attr, item) {
+        Ok(params) => params.into(),
+        Err(e) => return e.into_compile_error().into(),
+    }
+}

discord/resource/src/lib.rs

@@ -1,8 +1,9 @@
 use partial_id::Partial;
 use serde::Deserialize;
 
-use crate::guild::Guild;
-use crate::resource::{Endpoint, Resource};
+use crate::guild::GuildResource;
+use crate::request::HttpRequest;
+use crate::resource::{resource, Endpoint};
 
 use super::{command::Commands, resource::Snowflake};
 
@@ -18,7 +19,7 @@ pub trait ApplicationResource {
     fn global_commands(&self) -> Commands {
         Commands::new(self.endpoint().clone(), None)
     }
-    fn guild_commands(&self, guild: &impl Resource<Endpoint = Snowflake<Guild>>) -> Commands {
+    fn guild_commands(&self, guild: &impl GuildResource) -> Commands {
         Commands::new(self.endpoint().clone(), Some(guild.endpoint().clone()))
     }
 }
@@ -34,11 +35,18 @@ impl ApplicationResource for Application {
     }
 }
 
+impl Endpoint for Snowflake<Application> {
+    fn uri(&self) -> String {
+        // you can only ever get your own application data
+        "/applications/@me".into()
+    }
+}
+
 pub struct Me;
 
-impl Endpoint for Me {
-    type Result = Application;
-    fn uri(&self) -> String {
-        "/oauth2/applications/@me".into()
+impl Me {
+    #[resource(Application)]
+    pub fn get(&self) -> HttpRequest<Application> {
+        HttpRequest::get("/applications/@me")
     }
 }