clippy fixes

Author: makspll

crates/bevy_mod_scripting_core/src/asset.rs

@@ -1,16 +1,14 @@
-use std::{
-    borrow::Cow,
-    path::{Path, PathBuf},
-};
-
+use crate::{prelude::ScriptError, script::ScriptId};
 use bevy::{
-    asset::{Asset, AssetId, AssetLoader, AsyncReadExt},
+    asset::{Asset, AssetId, AssetLoader},
     ecs::system::Resource,
     reflect::TypePath,
-    utils::{BoxedFuture, HashMap},
+    utils::HashMap,
+};
+use std::{
+    borrow::Cow,
+    path::{Path, PathBuf},
 };
-
-use crate::{prelude::ScriptError, script::ScriptId};
 
 /// Represents a script loaded into memory as an asset
 #[derive(Asset, TypePath, Clone)]

crates/bevy_mod_scripting_core/src/bindings/access_map.rs

@@ -1,13 +1,10 @@
-use std::{
-    sync::atomic::{AtomicBool, AtomicUsize},
-    thread::ThreadId,
-};
+use std::{sync::atomic::AtomicBool, thread::ThreadId};
 
 use bevy::{
     ecs::{component::ComponentId, world::unsafe_world_cell::UnsafeWorldCell},
     prelude::Resource,
 };
-use dashmap::{try_result::TryResult, DashMap, Entry, Map};
+use dashmap::{DashMap, Entry};
 use smallvec::SmallVec;
 
 use super::{ReflectAllocationId, ReflectBase};
@@ -49,7 +46,7 @@ impl AccessCount {
     }
 
     fn as_location(&self) -> Option<std::panic::Location<'static>> {
-        self.read_by.first().map(|o| o.location.clone())
+        self.read_by.first().map(|o| o.location)
     }
 
     fn readers(&self) -> usize {
@@ -372,6 +369,7 @@ macro_rules! with_global_access {
                 )
             );
         } else {
+            #[allow(clippy::redundant_closure_call)]
             let result = (|| $body)();
             $access_map.release_global_access();
             result

crates/bevy_mod_scripting_core/src/bindings/allocator.rs

@@ -1,15 +1,14 @@
-use bevy::ecs::system::Resource;
-use bevy::reflect::{PartialReflect, Reflect};
+use bevy::{ecs::system::Resource, reflect::PartialReflect};
 use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
-use std::any::{Any, TypeId};
-use std::cell::UnsafeCell;
-use std::cmp::Ordering;
-use std::collections::HashMap;
-use std::fmt::{Display, Formatter};
-use std::hash::Hasher;
-use std::io::Read;
-use std::sync::atomic::{AtomicU64, AtomicUsize};
-use std::sync::Arc;
+use std::{
+    any::TypeId,
+    cell::UnsafeCell,
+    cmp::Ordering,
+    collections::HashMap,
+    fmt::{Display, Formatter},
+    hash::Hasher,
+    sync::{atomic::AtomicU64, Arc},
+};
 
 #[derive(Clone, Debug)]
 pub struct ReflectAllocationId(pub(crate) Arc<u64>);

crates/bevy_mod_scripting_core/src/bindings/function/from.rs

@@ -34,7 +34,7 @@ impl FromScript for ScriptValue {
 
 impl FromScript for () {
     type This<'w> = Self;
-    fn from_script(value: ScriptValue, _world: WorldGuard) -> Result<Self, InteropError> {
+    fn from_script(_value: ScriptValue, _world: WorldGuard) -> Result<Self, InteropError> {
         Ok(())
     }
 }

crates/bevy_mod_scripting_core/src/bindings/function/into.rs

@@ -1,10 +1,10 @@
 use std::{
     borrow::Cow,
     ffi::OsString,
-    path::{Path, PathBuf},
+    path::PathBuf,
 };
 
-use bevy::reflect::{GetTypeRegistration, PartialReflect, ReflectRef};
+use bevy::reflect::PartialReflect;
 
 use crate::{
     bindings::{ReflectReference, WorldGuard},

crates/bevy_mod_scripting_core/src/bindings/function/into_ref.rs

@@ -1,4 +1,4 @@
-use std::{any::TypeId, ffi::OsString, path::PathBuf};
+use std::{ffi::OsString, path::PathBuf};
 
 use bevy::reflect::{ParsedPath, PartialReflect};
 

crates/bevy_mod_scripting_core/src/bindings/function/mod.rs

@@ -1,28 +1,16 @@
-use std::{any::TypeId, borrow::Cow, ops::Deref, sync::Arc};
 
 pub mod from;
 pub mod from_ref;
 pub mod into;
 pub mod into_ref;
 pub mod script_function;
 
-use bevy::reflect::{
-    func::{
-        args::{Arg, ArgInfo, Ownership},
-        ArgList, ArgValue, DynamicFunction, FunctionInfo, FunctionResult, Return,
-    },
-    PartialReflect,
-};
 use script_function::{CallerContext, DynamicScriptFunction, DynamicScriptFunctionMut};
 
-use crate::{
-    error::{FlattenError, InteropError, InteropErrorInner, ScriptError, ScriptResult},
-    reflection_extensions::{PartialReflectExt, ReturnValExt},
-};
+use crate::error::InteropError;
 
 use super::{
-    access_map::ReflectAccessId, pretty_print::DisplayWithWorld, script_value::ScriptValue,
-    ReflectBase, ReflectReference, WorldAccessGuard, WorldCallbackAccess, WorldGuard,
+    pretty_print::DisplayWithWorld, script_value::ScriptValue, WorldCallbackAccess, WorldGuard,
 };
 
 /// Can be implemented for callables which require dynamic access to the world to be called.

crates/bevy_mod_scripting_core/src/bindings/function/script_function.rs

@@ -8,11 +8,10 @@ use crate::{
     prelude::{ScriptValue, WorldCallbackAccess},
 };
 use bevy::{
-    prelude::{AppFunctionRegistry, IntoFunction, Reflect, Resource, World},
+    prelude::{Reflect, Resource},
     reflect::{
-        func::{args::GetOwnership, DynamicFunction, FunctionError, FunctionInfo, TypedFunction},
-        FromReflect, GetTypeRegistration, PartialReflect, TypePath, TypeRegistration, TypeRegistry,
-        Typed,
+        func::{args::GetOwnership, FunctionError},
+        FromReflect, GetTypeRegistration, TypePath, TypeRegistry, Typed,
     },
 };
 use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
@@ -531,28 +530,6 @@ macro_rules! assert_is_script_function {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::bindings::function::script_function::ScriptFunction;
-    use crate::prelude::AppReflectAllocator;
-    use bevy::reflect::func::{ArgList, ArgValue, Return};
-    use test_utils::test_data::*;
-
-    fn test_setup_world() -> World {
-        setup_world(|w, _| w.insert_resource(AppReflectAllocator::default()))
-    }
-
-    fn assert_function_info_eq(a: &FunctionInfo, b: &FunctionInfo) {
-        assert_eq!(a.name(), b.name(), "Function names do not match");
-        assert_eq!(
-            a.args().len(),
-            b.args().len(),
-            "Function arg count does not match"
-        );
-        for (a, b) in a.args().iter().zip(b.args().iter()) {
-            assert_eq!(a.type_id(), b.type_id(), "Function arg types do not match");
-            assert_eq!(a.name(), b.name(), "Function arg names do not match");
-        }
-    }
-
     #[test]
     fn test_register_script_function() {
         let mut registry = ScriptFunctionRegistry::default();

crates/bevy_mod_scripting_core/src/bindings/query.rs

@@ -1,9 +1,5 @@
 use super::{ReflectReference, WorldAccessGuard, WorldCallbackAccess};
-use crate::{
-    bindings::{CONCURRENT_WORLD_ACCESS_MSG, STALE_WORLD_MSG},
-    error::InteropError,
-    with_global_access,
-};
+use crate::{error::InteropError, with_global_access};
 use bevy::{
     ecs::{component::ComponentId, entity::Entity},
     prelude::{EntityRef, QueryBuilder},
@@ -133,7 +129,7 @@ impl WorldCallbackAccess {
     }
 }
 
-impl<'w> WorldAccessGuard<'w> {
+impl WorldAccessGuard<'_> {
     pub fn query(
         &self,
         query: ScriptQueryBuilder,
@@ -203,18 +199,3 @@ impl<'w> WorldAccessGuard<'w> {
         })
     }
 }
-
-#[cfg(test)]
-mod test {
-    use test_utils::test_data::setup_world;
-
-    use super::*;
-
-    // #[test]
-    // fn test_simple_query() {
-    //     let world = setup_world(|w,r|{
-    //         w.spawn(TestComponent::init())
-    //         w.spawn(Te)
-    //     })
-    // }
-}

crates/bevy_mod_scripting_core/src/bindings/reference.rs

@@ -4,14 +4,11 @@
 //! reflection gives us access to `dyn PartialReflect` objects via their type name,
 //! Scripting languages only really support `Clone` objects so if we want to support references,
 //! we need wrapper types which have owned and ref variants.
-use super::{
-    access_map::{AccessMapKey, ReflectAccessId},
-    WorldAccessGuard, WorldCallbackAccess, WorldGuard,
-};
+use super::{access_map::ReflectAccessId, WorldGuard};
 use crate::{
-    bindings::{pretty_print::DisplayWithWorld, ReflectAllocationId},
+    bindings::ReflectAllocationId,
     error::InteropError,
-    prelude::{ReflectAllocator, ScriptResult},
+    prelude::ReflectAllocator,
     reflection_extensions::{PartialReflectExt, TypeIdExtensions},
     with_access_read, with_access_write,
 };
@@ -22,14 +19,9 @@ use bevy::{
     },
     prelude::{Component, ReflectDefault, Resource},
     ptr::Ptr,
-    reflect::{
-        func::{args::ArgInfo, ArgValue},
-        ParsedPath, PartialReflect, Reflect, ReflectFromPtr, ReflectFromReflect, ReflectMut,
-        ReflectPath, ReflectPathError, ReflectRef, TypeData,
-    },
+    reflect::{ParsedPath, PartialReflect, Reflect, ReflectFromPtr, ReflectPath},
 };
-use itertools::Either;
-use std::{any::TypeId, fmt::Debug, sync::Arc};
+use std::{any::TypeId, fmt::Debug};
 
 /// An accessor to a `dyn PartialReflect` struct, stores a base ID of the type and a reflection path
 /// safe to build but to reflect on the value inside you need to ensure aliasing rules are upheld
@@ -464,25 +456,6 @@ impl ReflectBase {
     }
 }
 
-fn map_key_to_concrete(key: &str, key_type_id: TypeId) -> Option<Box<dyn PartialReflect>> {
-    match key_type_id {
-        _ if key_type_id == std::any::TypeId::of::<String>() => Some(Box::new(key.to_owned())),
-        _ if key_type_id == std::any::TypeId::of::<usize>() => key
-            .parse::<usize>()
-            .ok()
-            .map(|u| Box::new(u) as Box<dyn PartialReflect>),
-        _ if key_type_id == std::any::TypeId::of::<f32>() => key
-            .parse::<f32>()
-            .ok()
-            .map(|f| Box::new(f) as Box<dyn PartialReflect>),
-        _ if key_type_id == std::any::TypeId::of::<bool>() => key
-            .parse::<bool>()
-            .ok()
-            .map(|b| Box::new(b) as Box<dyn PartialReflect>),
-        _ => None,
-    }
-}
-
 pub trait ReflectionPathExt {
     fn convert_to_0_indexed(&mut self);
 

crates/bevy_mod_scripting_core/src/bindings/script_value/mod.rs

@@ -1,25 +1,10 @@
-use std::{
-    any::{type_name, TypeId},
-    borrow::Cow,
-    ffi::{CStr, CString, OsStr, OsString},
-    path::{Path, PathBuf},
-};
-
-use bevy::reflect::{
-    Access, DynamicEnum, DynamicList, DynamicTuple, DynamicVariant, OffsetAccess, ParsedPath,
-    PartialReflect, Reflect, ReflectFromReflect, TypeData,
-};
-
-use crate::{
-    error::{InteropError, InteropErrorInner, ScriptError, ScriptResult},
-    reflection_extensions::{PartialReflectExt, TypeIdExtensions, TypeInfoExtensions},
-};
-
-use super::{
-    function::script_function::{DynamicScriptFunction, DynamicScriptFunctionMut},
-    pretty_print::DisplayWithWorld,
-    ReflectReference, WorldGuard,
-};
+use std::borrow::Cow;
+
+use bevy::reflect::{OffsetAccess, ParsedPath, Reflect};
+
+use crate::error::InteropError;
+
+use super::{function::script_function::DynamicScriptFunctionMut, ReflectReference};
 
 /// An abstraction of values that can be passed to and from scripts.
 /// This allows us to re-use logic between scripting languages.
@@ -148,7 +133,7 @@ impl TryFrom<ScriptValue> for ParsedPath {
                 access: bevy::reflect::Access::ListIndex(i as usize),
                 offset: Some(1),
             }]),
-            ScriptValue::Float(v) => {
+            ScriptValue::Float(_) => {
                 return Err(InteropError::invalid_index(
                     value,
                     "Floating point numbers cannot be used to index into reflected values"