misc: Do a lot of code cleanup

Author: caseif

engine/libs/argus_util/src/math/vector.rs

@@ -27,9 +27,9 @@ macro_rules! create_vector2_ops {
             }
         }
 
-        impl Into<[$el_type; 2]> for $vec_type {
-            fn into(self) -> [$el_type; 2] {
-                [self.x, self.y]
+        impl From<$vec_type> for [$el_type; 2] {
+            fn from(v: $vec_type) -> Self {
+                [v.x, v.y]
             }
         }
 
@@ -222,9 +222,9 @@ macro_rules! create_vector2_signed_ops {
 
 macro_rules! create_vector3_ops {
     ($vec_type: ty, $el_type: ty) => {
-        impl Into<[$el_type; 3]> for $vec_type {
-            fn into(self) -> [$el_type; 3] {
-                [self.x, self.y, self.z]
+        impl From<$vec_type> for [$el_type; 3] {
+            fn from(v: $vec_type) -> Self {
+                [v.x, v.y, v.z]
             }
         }
 
@@ -347,9 +347,9 @@ macro_rules! create_vector3_signed_ops {
 
 macro_rules! create_vector4_ops {
     ($vec_type: ty, $el_type: ty) => {
-        impl Into<[$el_type; 4]> for $vec_type {
-            fn into(self) -> [$el_type; 4] {
-                [self.x, self.y, self.z, self.w]
+        impl From<$vec_type> for [$el_type; 4] {
+            fn from(v: $vec_type) -> Self {
+                [v.x, v.y, v.z, v.w]
             }
         }
 

engine/libs/argus_util/src/semaphore.rs

@@ -12,15 +12,6 @@ struct SemaphoreInner {
 }
 
 impl Semaphore {
-    fn new() -> Self {
-        Self {
-            inner: Arc::new(SemaphoreInner {
-                mutex: Mutex::new(false),
-                cv: Condvar::new(),
-            }),
-        }
-    }
-    
     pub fn is_signaled(&self) -> bool {
         *self.inner.mutex.lock().unwrap()
     }

engine/libs/build_util/src/rerun.rs

@@ -33,7 +33,7 @@ fn did_file_change(path: &Path, timestamp_file: &Path) -> bool {
     if !path.exists() {
         panic!(
             "No file exists at path {}",
-            path.to_string_lossy().to_string()
+            path.to_string_lossy()
         );
     }
 
@@ -54,7 +54,7 @@ fn did_file_change(path: &Path, timestamp_file: &Path) -> bool {
             ),
         };
 
-        let prev_modified_time = match fs::metadata(&timestamp_file).and_then(|meta| meta.modified()) {
+        let prev_modified_time = match fs::metadata(timestamp_file).and_then(|meta| meta.modified()) {
             Ok(modified_time) => modified_time,
             Err(e) => panic!(
                 "Failed to read metadata of timestamp file at path {} ({e})",

engine/libs/build_util/src/resource.rs

@@ -1,7 +1,7 @@
-use std::{env, fs};
-use std::path::{Path, PathBuf};
-use arp::{create_arp_from_fs, CompressionType, PackingOptions};
 use crate::rerun::run_if_changed;
+use arp::{create_arp_from_fs, CompressionType, PackingOptions};
+use std::path::PathBuf;
+use std::{env, fs};
 
 const RES_MAPPINGS_PATH: &str = "../../../res/arp_custom_mappings.csv";
 

engine/libs/logging/src/manager.rs

@@ -23,7 +23,7 @@ pub struct LogManager {
 
 impl LogManager {
     pub fn instance() -> &'static Self {
-        &MANAGER.get().unwrap()
+        MANAGER.get().unwrap()
     }
 
     pub fn initialize(settings: LogSettings) -> Result<(), ()> {
@@ -191,7 +191,7 @@ fn emit_log_entry(mgr: &LogManager, message: StagedMessage) {
         .collect::<Vec<_>>()
         .join(" ");
 
-    let final_msg = if prelude.len() > 0 {
+    let final_msg = if !prelude.is_empty() {
         format!("{} {}\n", prelude, message.message)
     } else {
         format!("{}\n", message.message)

engine/libs/scripting_bind_macros/src/lib.rs

@@ -65,7 +65,7 @@ pub fn script_bind(args: TokenStream, input: TokenStream) -> TokenStream {
     if meta_list.iter().any(|meta| match meta {
         Meta::Path(path) => {
             path.segments.len() == 1 &&
-                path.segments.first().unwrap().ident.to_string() == UNIV_ARG_IGNORE
+                path.segments.first().unwrap().ident == UNIV_ARG_IGNORE
         }
         _ => false,
     }) {
@@ -287,6 +287,7 @@ fn handle_struct(item: &ItemStruct, args: Vec<&Meta>) -> Result<TokenStream2, Co
                         name: #field_name,
                         type_serial: #field_type_serial,
                         size: size_of::<#field_type>(),
+                        #[allow(clippy::clone_on_copy, clippy::needless_borrow)]
                         accessor: #field_accessor_tokens,
                         #[allow(clippy::clone_on_copy, clippy::needless_borrow)]
                         mutator: #field_mutator_tokens,
@@ -301,7 +302,6 @@ fn handle_struct(item: &ItemStruct, args: Vec<&Meta>) -> Result<TokenStream2, Co
         Ok(quote! {
             #item
             const _: () = {
-                use ::argus_scripting_bind::Wrappable;
                 #ctor_dtor_proxies_tokens
                 #script_bound_impl_tokens
                 #wrappable_impl_tokens
@@ -313,7 +313,6 @@ fn handle_struct(item: &ItemStruct, args: Vec<&Meta>) -> Result<TokenStream2, Co
         Ok(quote! {
             #item
             const _: () = {
-                use ::argus_scripting_bind::Wrappable;
                 #script_bound_impl_tokens
                 #register_struct_tokens
                 #(#field_regs)*
@@ -483,7 +482,6 @@ fn handle_enum(item: &ItemEnum, args: Vec<&Meta>) -> Result<TokenStream2, Compil
     Ok(quote! {
         #item
         const _: () = {
-            use ::argus_scripting_bind::Wrappable;
             #script_bound_impl_tokens
             #wrappable_impl_tokens
             const _: () = {
@@ -632,9 +630,9 @@ fn gen_fn_binding_code(
                         Type::Path(assoc_type.expect("Associated type was missing").clone());
                     match &self_type.reference {
                         Some((and_token, lifetime)) => Ok(Type::Reference(TypeReference {
-                            and_token: and_token.clone(),
+                            and_token: *and_token,
                             lifetime: lifetime.clone(),
-                            mutability: self_type.mutability.clone(),
+                            mutability: self_type.mutability,
                             elem: Box::new(assoc_type_path),
                         })),
                         None => Ok(assoc_type_path),
@@ -649,7 +647,7 @@ fn gen_fn_binding_code(
         Vec<(ObjectType, Vec<Type>)> =
         param_types.iter()
             .map(|ty| {
-                parse_type(&ty, ValueFlowDirection::FromScript)
+                parse_type(ty, ValueFlowDirection::FromScript)
             })
             .collect::<Result<_, _>>()?;
 
@@ -684,7 +682,7 @@ fn gen_fn_binding_code(
     for i in 0..param_obj_types.len() {
         let syn_type = &param_types[i];
         let param_type_tokens: TokenStream2;
-        let boxed_trait_obj_opt = try_as_boxed_trait_object(&syn_type);
+        let boxed_trait_obj_opt = try_as_boxed_trait_object(syn_type);
         if let Some(trait_obj) = boxed_trait_obj_opt {
             //TODO: only allow 1 bound (?)
             let Some(paren_args) = trait_obj.bounds.iter().find_map(|bound| match bound {
@@ -1052,9 +1050,9 @@ fn handle_impl(impl_block: &ItemImpl, _args: Vec<&Meta>) -> Result<TokenStream2,
                 if let Some(pos) = f.attrs.iter().position(|attr| {
                     if attr.path().segments.len() != 1 { return false; }
                     let seg = attr.path().segments.first().expect("First path segment was missing");
-                    seg.ident.to_string() == ATTR_SCRIPT_BIND
+                    seg.ident == ATTR_SCRIPT_BIND
                 }) {
-                    fns_to_bind.push((&f, f.attrs[pos].meta.clone()));
+                    fns_to_bind.push((f, f.attrs[pos].meta.clone()));
                     let mut f_clone = f.clone();
                     // remove script_bind attribute since it's being handled as
                     // part of the impl block
@@ -1117,7 +1115,7 @@ fn handle_impl(impl_block: &ItemImpl, _args: Vec<&Meta>) -> Result<TokenStream2,
 }
 
 fn handle_impl_fn(ty: &TypePath, f: &ImplItemFn, args: Meta) -> Result<TokenStream2, CompileError> {
-    let fn_attr_span = args.span().clone();
+    let fn_attr_span = args.span();
     let meta_list = match args {
         Meta::List(meta_list) => {
             let args_tokens = TokenStream::from(meta_list.tokens);
@@ -1185,6 +1183,7 @@ enum ValueFlowDirection {
 }
 
 #[derive(Clone, Copy, PartialEq, PartialOrd)]
+#[allow(unused)]
 enum OuterTypeType {
     None,
     Reference,
@@ -1223,7 +1222,7 @@ fn parse_type_internal(
     let ty = if let Type::Group(group) = ty {
         group.elem.as_ref()
     } else {
-        &base_ty
+        base_ty
     };
 
     if let Some(trait_obj) = try_as_boxed_trait_object(ty) {
@@ -1258,7 +1257,7 @@ fn parse_type_internal(
         };
         let (out_type, out_syn_types) = match &paren_args.output {
             ReturnType::Type(_, ty) => {
-                parse_type_internal(&ty, flow_direction, OuterTypeType::None)?
+                parse_type_internal(ty, flow_direction, OuterTypeType::None)?
             },
             ReturnType::Default => (ObjectType::empty(), vec![]),
         };
@@ -1294,32 +1293,32 @@ fn parse_type_internal(
             all_syn_types,
         ))
     } else if let Type::Path(path) = ty {
-        if path.path.segments.len() == 0 {
+        if path.path.segments.is_empty() {
             return Err(CompileError::new(path.span(), "Type path does not contain any segments"));
         }
 
         let parsed_opt = first_some!(
-            resolve_i8(&path),
-            resolve_i16(&path),
-            resolve_i32(&path),
-            resolve_i64(&path),
-            resolve_i128(&path),
-            resolve_u8(&path),
-            resolve_u16(&path),
-            resolve_u32(&path),
-            resolve_u64(&path),
-            resolve_u128(&path),
-            resolve_f32(&path),
-            resolve_f64(&path),
-            resolve_bool(&path),
-            resolve_string(&path),
+            resolve_i8(path),
+            resolve_i16(path),
+            resolve_i32(path),
+            resolve_i64(path),
+            resolve_i128(path),
+            resolve_u8(path),
+            resolve_u16(path),
+            resolve_u32(path),
+            resolve_u64(path),
+            resolve_u128(path),
+            resolve_f32(path),
+            resolve_f64(path),
+            resolve_bool(path),
+            resolve_string(path),
         );
 
         if let Some(res) = parsed_opt {
             return Ok((res, vec![]));
         }
 
-        if let Some(res) = resolve_vec(&path, flow_direction)? {
+        if let Some(res) = resolve_vec(path, flow_direction)? {
             if outer_type != OuterTypeType::None &&
                 outer_type != OuterTypeType::Reference {
                 return Err(CompileError::new(path.span(), "Vec may not be used as an inner type"));
@@ -1329,22 +1328,22 @@ fn parse_type_internal(
             return Ok((res.0, resolved_inner_type));
         }
 
-        if let Some(res) = resolve_result(&path, flow_direction)? {
+        if let Some(res) = resolve_result(path, flow_direction)? {
             if outer_type != OuterTypeType::None {
-                if outer_type == OuterTypeType::Reference {
-                    return Err(CompileError::new(
+                return if outer_type == OuterTypeType::Reference {
+                    Err(CompileError::new(
                         path.span(),
                         "Result may not be passed as references in bound symbol"
-                    ));
+                    ))
                 } else {
-                    return Err(CompileError::new(
+                    Err(CompileError::new(
                         path.span(), "Result may not be used as an inner type"
-                    ));
+                    ))
                 }
             }
 
             let resolved_inner_types = [res.1, res.2].into_iter()
-                .filter_map(|opt| opt)
+                .flatten()
                 .collect();
             return Ok((res.0, resolved_inner_types));
         }
@@ -1426,7 +1425,7 @@ fn parse_type_internal(
     } else if let Type::Ptr(_) = ty {
         Err(CompileError::new(ty.span(), "Pointer is not allowed in bound symbol"))
     } else if let Type::Tuple(tuple) = ty {
-        if tuple.elems.len() == 0 {
+        if tuple.elems.is_empty() {
             Ok((
                 ObjectType::empty(),
                 vec![],
@@ -1449,8 +1448,8 @@ fn match_path(subject: &Path, needle: Vec<&'static str>) -> bool {
         needle[needle.len() - subject.segments.len()..]
             .iter()
             .enumerate()
-            .map(|(i, seg)| subject.segments[i].ident.to_string() == *seg)
-            .fold(true, |a, b| a && b)
+            .map(|(i, seg)| subject.segments[i].ident == seg)
+            .all(|b| b)
     }
 }
 
@@ -1528,7 +1527,7 @@ fn resolve_vec(ty: &TypePath, flow_direction: ValueFlowDirection)
     else { return Err(CompileError::new(ty.span(), "Invalid Vec argument syntax")); };
 
     let (inner_obj_type, resolved_inner_types) =
-        parse_type_internal(&inner_type, flow_direction, OuterTypeType::Vec)?;
+        parse_type_internal(inner_type, flow_direction, OuterTypeType::Vec)?;
     assert!(resolved_inner_types.len() <= 1,
             "Parsing Vec type returned too many resolved types for inner type");
 

engine/libs/scripting_types/src/lib.rs

@@ -256,10 +256,8 @@ impl ObjectType {
     pub fn get_is_refable(&self) -> Option<bool> {
         if let Some(refable) = self.is_refable {
             Some(refable)
-        } else if let Some(getter) = self.is_refable_getter {
-            Some((getter.fn_ptr)())
         } else {
-            None
+            self.is_refable_getter.map(|getter| (getter.fn_ptr)())
         }
     }
 }
@@ -403,7 +401,7 @@ impl Wrappable for String {
     }
 }
 
-impl<'a> ScriptBound for &'a str {
+impl ScriptBound for &str {
     fn get_object_type() -> ObjectType {
         ObjectType {
             ty: IntegralType::String,
@@ -422,7 +420,7 @@ impl<'a> ScriptBound for &'a str {
     }
 }
 
-impl<'a> Wrappable for &'a str {
+impl Wrappable for &str {
     type InternalFormat = ffi::c_char;
 
     fn wrap_into(self, wrapper: &mut WrappedObject) {
@@ -560,6 +558,8 @@ impl<T: ScriptBound> Wrappable for &mut T {
 
 const WRAPPED_OBJ_BUF_CAP: usize = 64;
 
+pub type EnumValueGetter = fn() -> i64;
+
 pub struct WrappedObject {
     pub ty: ObjectType,
     pub data: [u8; WRAPPED_OBJ_BUF_CAP],
@@ -648,7 +648,7 @@ impl WrappedObject {
     }
 
     pub fn unwrap<T: Wrappable>(&self) -> T {
-        <T as Wrappable>::unwrap_as_value(&self)
+        <T as Wrappable>::unwrap_as_value(self)
     }
 
     fn initialize_buffer(&mut self, size: usize) {
@@ -818,7 +818,7 @@ pub struct BoundEnumInfo {
     pub name: &'static str,
     pub type_id: fn() -> TypeId,
     pub width: usize,
-    pub values: &'static [(&'static str, fn() -> i64)],
+    pub values: &'static [(&'static str, EnumValueGetter)],
 }
 
 pub unsafe extern "C" fn copy_string(dst: *mut (), src: *const ()) {