format

Author: makspll

crates/bevy_mod_scripting_core/src/private/mod.rs

@@ -11,5 +11,4 @@ macro_rules! export_all_in_modules {
     };
 }
 
-
 pub(crate) use export_all_in_modules;

crates/bevy_mod_scripting_derive/src/derive/get_type_dependencies.rs

@@ -2,22 +2,19 @@ use proc_macro2::TokenStream;
 use quote::{quote_spanned, ToTokens};
 use syn::{parse_quote, parse_quote_spanned, DeriveInput, WhereClause};
 
-
-
-
 /// Generate a GetTypeDependencies impl like below:
 /// For type:
-/// 
+///
 /// ```rust,ignore
 /// #[derive(GetTypeDependencies)]
 /// #[get_type_dependencies(remote)]
 /// struct TargetType<T1: CustomBoundsT1, T2: CustomBoundsT2>{
 ///     ...
 /// }
 /// ```
-/// 
+///
 /// ```rust,ignore
-/// impl <T1,T2> GetTypeDependencies for TargetType 
+/// impl <T1,T2> GetTypeDependencies for TargetType
 /// where
 ///     T1: GetTypeDependencies,
 ///     T2: GetTypeDependencies,
@@ -28,7 +25,7 @@ use syn::{parse_quote, parse_quote_spanned, DeriveInput, WhereClause};
 ///     pub fn get_type_dependencies(registry: &mut bevy::reflect::TypeRegistry) {
 ///         T1::get_type_dependencies(registry);
 ///         T2::get_type_dependencies(registry);
-/// 
+///
 ///         registry.register::<TargetType<T1::Underlying, T2::Underlying>>();
 ///     }  
 /// }
@@ -41,15 +38,15 @@ fn get_type_dependencies_from_input(derive_input: DeriveInput) -> TokenStream {
 
     let bms_core = &args.bms_core_path;
 
-    
-    
     let (impl_generics, type_generics, impl_where) = derive_input.generics.split_for_impl();
-    
 
     let name = &derive_input.ident;
-    
-    
-    let generic_names = derive_input.generics.type_params().map(|param| &param.ident).collect::<Vec<_>>();
+
+    let generic_names = derive_input
+        .generics
+        .type_params()
+        .map(|param| &param.ident)
+        .collect::<Vec<_>>();
 
     let type_generics_underlying = if generic_names.is_empty() {
         Default::default()
@@ -67,20 +64,18 @@ fn get_type_dependencies_from_input(derive_input: DeriveInput) -> TokenStream {
         }
     };
 
-    let mut impl_where: WhereClause = impl_where.cloned().unwrap_or_else(|| parse_quote!{where});
+    let mut impl_where: WhereClause = impl_where.cloned().unwrap_or_else(|| parse_quote! {where});
     let mut recursive_registrations = Vec::default();
     for param in derive_input.generics.type_params() {
         let param_name = &param.ident;
         if !args.dont_recurse {
-            impl_where.predicates.push(
-                parse_quote_spanned!(param.ident.span()=> #param_name: GetTypeDependencies),
-            );
-            recursive_registrations.push(
-                quote_spanned! {param.ident.span()=>
-                    <#param_name as GetTypeDependencies>::register_type_dependencies(registry);
-                }
-            );
-        
+            impl_where
+                .predicates
+                .push(parse_quote_spanned!(param.ident.span()=> #param_name: GetTypeDependencies));
+            recursive_registrations.push(quote_spanned! {param.ident.span()=>
+                <#param_name as GetTypeDependencies>::register_type_dependencies(registry);
+            });
+
             impl_where.predicates.push(
                 parse_quote_spanned!(param.ident.span()=> #param_name::Underlying: bevy::reflect::GetTypeRegistration),
             );
@@ -90,8 +85,7 @@ fn get_type_dependencies_from_input(derive_input: DeriveInput) -> TokenStream {
             )
         }
     }
-    
-    
+
     quote_spanned! {derive_input.ident.span()=>
         #[automatically_derived]
         #[allow(clippy::needless_lifetimes)]
@@ -112,12 +106,9 @@ pub fn get_type_dependencies(input: TokenStream) -> TokenStream {
         Ok(input) => input,
         Err(e) => return e.into_compile_error(),
     };
-    
-   get_type_dependencies_from_input(derive_input)
-}
-
-
 
+    get_type_dependencies_from_input(derive_input)
+}
 
 struct Args {
     bms_core_path: syn::Path,
@@ -151,12 +142,19 @@ impl Args {
                         dont_recurse = true;
                         Ok(())
                     } else {
-                        Err(syn::Error::new_spanned(meta.path, "unknown attribute, allowed: bms_core_path, underlying"))
+                        Err(syn::Error::new_spanned(
+                            meta.path,
+                            "unknown attribute, allowed: bms_core_path, underlying",
+                        ))
                     }
                 })?;
             }
         }
 
-        Ok(Self { bms_core_path, underlying, dont_recurse })
+        Ok(Self {
+            bms_core_path,
+            underlying,
+            dont_recurse,
+        })
     }
-}
+}

crates/bevy_mod_scripting_derive/src/derive/mod.rs

@@ -1,17 +1,16 @@
+mod get_type_dependencies;
 mod into_script;
 mod script_bindings;
 mod script_globals;
 mod typed_through;
-mod get_type_dependencies;
 
 use proc_macro2::{Span, TokenStream};
 use quote::{quote_spanned, ToTokens};
 use syn::{Ident, ImplItemFn, ItemImpl};
 
 pub use self::{
-    into_script::into_script, script_bindings::script_bindings, script_globals::script_globals,
-    typed_through::typed_through,
-    get_type_dependencies::get_type_dependencies
+    get_type_dependencies::get_type_dependencies, into_script::into_script,
+    script_bindings::script_bindings, script_globals::script_globals, typed_through::typed_through,
 };
 
 pub(crate) fn impl_fn_to_namespace_builder_registration(fun: &ImplItemFn) -> TokenStream {

crates/bevy_mod_scripting_derive/src/lib.rs

@@ -2,8 +2,6 @@
 
 mod derive;
 
-
-
 #[proc_macro_derive(TypedThrough)]
 /// Default implementation for the `TypedThrough` trait
 pub fn typed_through(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
@@ -54,17 +52,13 @@ pub fn script_globals(
 
 /// Derive macro for generating `GetTypeDependencies` implementations.
 #[proc_macro_derive(GetTypeDependencies, attributes(get_type_dependencies))]
-pub fn get_type_dependencies(
-    input: proc_macro::TokenStream,
-) -> proc_macro::TokenStream {
+pub fn get_type_dependencies(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     derive::get_type_dependencies(input.into()).into()
 }
 
 /// Proc macro equivalent of `GetTypeDependencies` which does not generate a type, purely the impl.
 /// Useful for generating implementations against remote types.
 #[proc_macro]
-pub fn impl_get_type_dependencies(
-    input: proc_macro::TokenStream,
-) -> proc_macro::TokenStream {
+pub fn impl_get_type_dependencies(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     derive::get_type_dependencies(input.into()).into()
 }