FromProto

Author: dlon

mullvad-management-interface/build.rs

@@ -1,3 +1,6 @@
 fn main() {
-    tonic_build::compile_protos("proto/management_interface.proto").unwrap();
+    tonic_build::configure()
+        //.type_attribute("mullvad_daemon.management_interface.UUID", "#[derive(::mullvad_proc_macro::FromProto)]")
+        .compile(&["proto/management_interface.proto"], &["proto"])
+        .unwrap();
 }

mullvad-proc-macro/src/lib.rs

@@ -162,3 +162,62 @@ mod inner2 {
         })
     }
 }
+
+#[proc_macro_derive(FromProto)]
+pub fn from_proto_derive(item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as DeriveInput);
+
+    crate::inner3::derive(input).into()
+}
+
+mod inner3 {
+
+    use proc_macro2::TokenStream;
+    use quote::{quote, TokenStreamExt};
+    use syn::{spanned::Spanned, DeriveInput, Error};
+
+    pub(crate) fn derive(input: DeriveInput) -> TokenStream {
+        if let syn::Data::Struct(data) = &input.data {
+            derive_for_struct(&input, data).unwrap_or_else(Error::into_compile_error)
+        } else {
+            syn::Error::new(
+                input.span(),
+                "Deriving `FromProto` is only supported for structs",
+            )
+                .into_compile_error()
+        }
+    }
+
+    pub(crate) fn derive_for_struct(
+        input: &DeriveInput,
+        data: &syn::DataStruct,
+    ) -> syn::Result<TokenStream> {
+        let my_type = &input.ident;
+        let mut field_conversions = quote! {};
+        for field in &data.fields {
+            let Some(name) = &field.ident else {
+                return Err(syn::Error::new(
+                    field.span(),
+                    "Tuple structs are not currently supported",
+                ));
+            };
+
+            field_conversions.append_all(quote! {
+                #name: FromProto::from_proto(other.#name),
+            })
+        }
+
+        // TODO: take proto type as argument
+        let real_type = quote! { mullvad_types::#my_type };
+
+        Ok(quote! {
+            impl FromProto<#my_type> for #real_type {
+                fn from_proto(other: #my_type) -> Self {
+                    Self {
+                        #field_conversions
+                    }
+                }
+            }
+        })
+    }
+}

mullvad-proc-macro/tests/struct.rs

@@ -2,6 +2,7 @@
 
 use chrono::DateTime;
 use mullvad_proc_macro::{IntoProto, UnwrapProto};
+use crate::proto::Timestamp;
 
 #[derive(Debug)]
 struct RelaySettings;
@@ -85,12 +86,24 @@ impl IntoProto<proto::Timestamp> for chrono::DateTime<chrono::Utc> {
     }
 }
 
+impl FromProto<proto::AppVersionInfo> for AppVersionInfo {
+    fn from_proto(other: proto::AppVersionInfo) -> Self {
+        AppVersionInfo {
+            latest_beta: other.latest_beta,
+            latest_stable: other.latest_stable,
+            suggested_upgrade: other.suggested_upgrade,
+            supported: other.supported,
+        }
+    }
+}
+
 pub type AppVersion = String;
 
 mod proto {
-    use mullvad_proc_macro::IntoProto;
+    use super::FromProto;
+    use mullvad_proc_macro::{FromProto, IntoProto};
 
-    #[derive(Debug)]
+    #[derive(Debug, FromProto)]
     pub struct AppVersionInfo {
         pub supported: bool,
         pub latest_stable: String,
@@ -108,6 +121,16 @@ mod proto {
         pub seconds: i64,
         pub nanos: i32,
     }
+
+    mod mullvad_types {
+        #[derive(Debug)]
+        pub struct AppVersionInfo {
+            pub supported: bool,
+            pub latest_stable: String,
+            pub latest_beta: String,
+            pub suggested_upgrade: Option<String>,
+        }
+    }
 }
 
 trait IntoProto<T> {
@@ -120,6 +143,16 @@ impl<T: Into<S>, S> IntoProto<S> for T {
     }
 }
 
+trait FromProto<T> {
+    fn from_proto(other: T) -> Self;
+}
+
+impl<T: From<S>, S> FromProto<S> for T {
+    fn from_proto(other: S) -> Self {
+        Self::from(other)
+    }
+}
+
 #[test]
 fn test_generate_into_proto() {
     let settings_proto = AppVersionInfo {