From 6ca8ba9b0a6561c3472c8f82d7348088b4c68beb Mon Sep 17 00:00:00 2001 From: Filipe Rodrigues Date: Thu, 5 Jun 2025 09:38:50 +0100 Subject: [PATCH] Added a blanket `restriction` lint. --- Cargo.toml | 60 +++++++++++++++++++++- dynatos-builder-macros/src/lib.rs | 1 + dynatos-builder/src/lib.rs | 2 +- dynatos-context/src/lib.rs | 58 ++++++++++----------- dynatos-context/src/world.rs | 9 ++-- dynatos-context/src/world/context_stack.rs | 3 ++ dynatos-html/src/event_listener.rs | 3 +- dynatos-html/src/lib.rs | 2 +- dynatos-loadable/src/loadable.rs | 4 +- dynatos-reactive/src/async_signal.rs | 4 +- dynatos-reactive/src/effect.rs | 17 +++--- dynatos-reactive/src/enum_split.rs | 8 +-- dynatos-reactive/src/mapped_signal.rs | 4 +- dynatos-reactive/src/signal.rs | 12 ++--- dynatos-reactive/src/trigger.rs | 15 +++--- dynatos-reactive/tests/run-queue.rs | 4 +- dynatos-reactive/tests/unsized.rs | 1 + dynatos-world/src/imut.rs | 11 ++-- dynatos-world/src/rc.rs | 21 ++++---- dynatos/src/element_dyn_attr.rs | 1 + dynatos/src/node_dyn_child.rs | 1 + dynatos/src/object_dyn_prop.rs | 1 + 22 files changed, 159 insertions(+), 83 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 6d8c63e..ca326b8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -71,12 +71,18 @@ web-sys = "0.3.77" [workspace.lints] -clippy.nursery = { level = "warn", priority = -1 } -clippy.pedantic = { level = "warn", priority = -1 } +clippy.nursery = { level = "warn", priority = -1 } +clippy.pedantic = { level = "warn", priority = -1 } +clippy.restriction = { level = "warn", priority = -1 } + +# We enable restriction group and then allow any we don't care +clippy.blanket_clippy_restriction_lints = "allow" # Styling +clippy.implicit_return = "allow" clippy.match_bool = "allow" clippy.option_if_let_else = "allow" +clippy.ref_patterns = "allow" clippy.single_match_else = "allow" # It's easier to define them before their first usage @@ -88,9 +94,59 @@ clippy.future_not_send = "allow" # Most times, the panics are internal assertions that the user can't trigger clippy.missing_panics_doc = "allow" +clippy.unwrap_in_result = "allow" + +# Shadowing is fine +# TODO: Turn off `unrelated` every once in a while? +clippy.shadow_reuse = "allow" +clippy.shadow_same = "allow" +clippy.shadow_unrelated = "allow" + +# We want to use match ergonomics +clippy.pattern_type_mismatch = "allow" + +# We sometimes need to explicitly panic +clippy.panic = "allow" +clippy.unreachable = "allow" + +# Misc. +clippy.arbitrary_source_item_ordering = "allow" +clippy.arithmetic_side_effects = "allow" +clippy.exhaustive_enums = "allow" +clippy.exhaustive_structs = "allow" +clippy.expect_used = "allow" +clippy.impl_trait_in_params = "allow" +clippy.indexing_slicing = "allow" +clippy.mem_forget = "allow" +clippy.min_ident_chars = "allow" +clippy.missing_docs_in_private_items = "allow" +clippy.module_name_repetitions = "allow" +clippy.pub_use = "allow" +clippy.pub_with_shorthand = "allow" +clippy.question_mark_used = "allow" +clippy.self_named_module_files = "allow" +clippy.separated_literal_suffix = "allow" +clippy.single_call_fn = "allow" +clippy.single_char_lifetime_names = "allow" +clippy.string_slice = "allow" +clippy.unused_trait_names = "allow" +clippy.wildcard_enum_match_arm = "allow" + +# False positives for tests in `tests/`. +clippy.tests_outside_test_module = "allow" # TODO: Should we document all errors? clippy.missing_errors_doc = "allow" +# TODO: Should we mark all of them as inline +clippy.missing_inline_in_public_items = "allow" + +# TODO: Should we turn this off every once a while to check if we're missing any +# default items we can implement better? +clippy.missing_trait_methods = "allow" + +# TODO: Should we move to `alloc`? +clippy.std_instead_of_alloc = "allow" + # Until `wasm_bindgen` themselves fix it upstream, we can't fix ourselves rust.wasm_c_abi = "allow" diff --git a/dynatos-builder-macros/src/lib.rs b/dynatos-builder-macros/src/lib.rs index 468ecd3..ff6359e 100644 --- a/dynatos-builder-macros/src/lib.rs +++ b/dynatos-builder-macros/src/lib.rs @@ -363,6 +363,7 @@ impl Prop { let ident = name_value.path.get_ident().expect("Expected identifier"); match ident.to_string().as_str() { "name" => match name_value.value { + #[expect(clippy::shadow_unrelated, reason = "It's related")] syn::Expr::Path(ref path) if let Some(ident) = path.path.get_ident() => { prop_ident = Some(ident.clone()); }, diff --git a/dynatos-builder/src/lib.rs b/dynatos-builder/src/lib.rs index 22c3c20..c29918c 100644 --- a/dynatos-builder/src/lib.rs +++ b/dynatos-builder/src/lib.rs @@ -5,4 +5,4 @@ pub use dynatos_builder_macros::builder; /// Missing prop #[derive(Clone, Copy, Default, Debug)] -pub struct MissingProp; +pub struct MissingProp(()); diff --git a/dynatos-context/src/lib.rs b/dynatos-context/src/lib.rs index ad7bea3..a3bb586 100644 --- a/dynatos-context/src/lib.rs +++ b/dynatos-context/src/lib.rs @@ -285,76 +285,76 @@ mod test { #[test] fn simple() { - let handle = crate::provide::(5); + let handle = crate::provide::(5); - assert_eq!(crate::get::(), Some(5)); + assert_eq!(crate::get::(), Some(5)); assert_eq!(handle.take(), 5); - assert_eq!(crate::get::(), None); + assert_eq!(crate::get::(), None); } #[test] fn stacked() { - let handle1 = crate::provide::(5); - let handle2 = crate::provide::(4); + let handle1 = crate::provide::(5); + let handle2 = crate::provide::(4); - assert_eq!(crate::get::(), Some(4)); + assert_eq!(crate::get::(), Some(4)); assert_eq!(handle2.take(), 4); - assert_eq!(crate::get::(), Some(5)); + assert_eq!(crate::get::(), Some(5)); assert_eq!(handle1.take(), 5); - assert_eq!(crate::get::(), None); + assert_eq!(crate::get::(), None); } #[test] fn stacked_swapped() { - let handle1 = crate::provide::(5); - let handle2 = crate::provide::(4); + let handle1 = crate::provide::(5); + let handle2 = crate::provide::(4); - assert_eq!(crate::get::(), Some(4)); + assert_eq!(crate::get::(), Some(4)); assert_eq!(handle1.take(), 5); - assert_eq!(crate::get::(), Some(4)); + assert_eq!(crate::get::(), Some(4)); assert_eq!(handle2.take(), 4); - assert_eq!(crate::get::(), None); + assert_eq!(crate::get::(), None); } #[test] fn stacked_triple() { - let handle1 = crate::provide::(5); - let handle2 = crate::provide::(4); - let handle3 = crate::provide::(3); + let handle1 = crate::provide::(5); + let handle2 = crate::provide::(4); + let handle3 = crate::provide::(3); - assert_eq!(crate::get::(), Some(3)); + assert_eq!(crate::get::(), Some(3)); assert_eq!(handle2.take(), 4); assert_eq!(handle3.take(), 3); - assert_eq!(crate::get::(), Some(5)); + assert_eq!(crate::get::(), Some(5)); assert_eq!(handle1.take(), 5); - assert_eq!(crate::get::(), None); + assert_eq!(crate::get::(), None); } #[test] fn opaque() { - let handle1 = crate::provide::(5).into_opaque(); - let handle2 = crate::provide::(4).into_opaque(); + let handle1 = crate::provide::(5).into_opaque(); + let handle2 = crate::provide::(4).into_opaque(); - assert_eq!(crate::get::(), Some(4)); - assert_eq!(*handle2.take().downcast::().expect("Handle had wrong type"), 4); - assert_eq!(crate::get::(), Some(5)); - assert_eq!(*handle1.take().downcast::().expect("Handle had wrong type"), 5); - assert_eq!(crate::get::(), None); + assert_eq!(crate::get::(), Some(4)); + assert_eq!(*handle2.take().downcast::().expect("Handle had wrong type"), 4); + assert_eq!(crate::get::(), Some(5)); + assert_eq!(*handle1.take().downcast::().expect("Handle had wrong type"), 5); + assert_eq!(crate::get::(), None); } #[test] fn stress() { let handles_len = 100; - let mut handles = (0..handles_len).map(crate::provide::).collect::>(); + let mut handles = (0..handles_len).map(crate::provide::).collect::>(); for value in (0..handles_len).rev() { - assert_eq!(crate::get::(), Some(value)); + assert_eq!(crate::get::(), Some(value)); let handle = handles.pop().expect("Should have handle"); assert_eq!(handle.get(), value); assert_eq!(handle.take(), value); } - assert_eq!(crate::get::(), None); + assert_eq!(crate::get::(), None); } // Type and value to test for the accesses diff --git a/dynatos-context/src/world.rs b/dynatos-context/src/world.rs index 4fd35f1..c5ff399 100644 --- a/dynatos-context/src/world.rs +++ b/dynatos-context/src/world.rs @@ -13,7 +13,10 @@ pub mod context_stack; pub use self::context_stack::{ContextStack, ContextStackGlobal, ContextStackOpaque, ContextStackThreadLocal}; // Imports -use dynatos_world::{World, WorldGlobal, WorldThreadLocal}; +use { + core::any::Any as StdAny, + dynatos_world::{World, WorldGlobal, WorldThreadLocal}, +}; /// Context world pub trait ContextWorld: World { @@ -26,12 +29,12 @@ pub trait ContextWorld: World { impl ContextWorld for WorldThreadLocal { type ContextStack = ContextStackThreadLocal; - type ContextStackOpaque = ContextStackThreadLocal; + type ContextStackOpaque = ContextStackThreadLocal; } impl ContextWorld for WorldGlobal { type ContextStack = ContextStackGlobal; - type ContextStackOpaque = ContextStackGlobal; + type ContextStackOpaque = ContextStackGlobal; } /// Handle type for the world's context stack diff --git a/dynatos-context/src/world/context_stack.rs b/dynatos-context/src/world/context_stack.rs index 48fbe60..7d17a24 100644 --- a/dynatos-context/src/world/context_stack.rs +++ b/dynatos-context/src/world/context_stack.rs @@ -1,5 +1,8 @@ //! Context stack +// Lints +#![expect(clippy::as_conversions, reason = "We need to unsize items and there's no other way")] + // Imports use { crate::ContextWorld, diff --git a/dynatos-html/src/event_listener.rs b/dynatos-html/src/event_listener.rs index d094ef5..693416f 100644 --- a/dynatos-html/src/event_listener.rs +++ b/dynatos-html/src/event_listener.rs @@ -5,6 +5,7 @@ use { crate::WeakRef, dynatos_util::TryOrReturnExt, wasm_bindgen::{closure::Closure, convert::FromWasmAbi, JsCast}, + web_sys::js_sys, }; /// Extension trait to define an event listener on an event target with a closure @@ -21,7 +22,7 @@ where // Build the closure let closure = Closure::::new(f) .into_js_value() - .dyn_into::() + .dyn_into::() .expect("Should be a valid function"); // Then add it diff --git a/dynatos-html/src/lib.rs b/dynatos-html/src/lib.rs index f8864ba..3e87169 100644 --- a/dynatos-html/src/lib.rs +++ b/dynatos-html/src/lib.rs @@ -16,9 +16,9 @@ pub use self::{ // Imports use { + core::fmt, itertools::Itertools, js_sys::Reflect, - std::fmt, wasm_bindgen::{JsCast, JsValue}, }; diff --git a/dynatos-loadable/src/loadable.rs b/dynatos-loadable/src/loadable.rs index cb4384c..44c47c8 100644 --- a/dynatos-loadable/src/loadable.rs +++ b/dynatos-loadable/src/loadable.rs @@ -425,8 +425,8 @@ where type Signal = Loadable, Signal>; type SignalsStorage = SplitValueStorage; - fn get_signal(storage: &Self::SignalsStorage, cur: &Self::SigKind) -> Option { - let signal = match cur { + fn get_signal(storage: &Self::SignalsStorage, kind: &Self::SigKind) -> Option { + let signal = match kind { Loadable::Empty => Loadable::Empty, Loadable::Err(()) => Loadable::Err(storage.err.as_ref()?.signal()), Loadable::Loaded(()) => Loadable::Loaded(storage.loaded.as_ref()?.signal()), diff --git a/dynatos-reactive/src/async_signal.rs b/dynatos-reactive/src/async_signal.rs index bb10c3e..85c3187 100644 --- a/dynatos-reactive/src/async_signal.rs +++ b/dynatos-reactive/src/async_signal.rs @@ -26,7 +26,7 @@ use { ops::{Deref, DerefMut}, }, dynatos_world::{IMut, IMutLike, IMutRef, IMutRefMut, IMutRefMutLike, Rc, RcLike, WorldDefault}, - futures::stream::AbortHandle, + futures::{future, stream::AbortHandle}, tokio::sync::Notify, }; @@ -87,7 +87,7 @@ impl> Inner { // Then spawn the future // TODO: Allow using something other than `wasm_bindgen_futures`? - let (fut, handle) = futures::future::abortable(self.loader.load()); + let (fut, handle) = future::abortable(self.loader.load()); wasm_bindgen_futures::spawn_local(async move { // Load the value // Note: If we get aborted, just remove the handle diff --git a/dynatos-reactive/src/effect.rs b/dynatos-reactive/src/effect.rs index 42d4c7c..df8bbe3 100644 --- a/dynatos-reactive/src/effect.rs +++ b/dynatos-reactive/src/effect.rs @@ -17,9 +17,10 @@ use { }, core::{ fmt, - hash::Hash, + hash::{Hash, Hasher}, marker::{PhantomData, Unsize}, ops::CoerceUnsized, + ptr, sync::atomic::{self, AtomicBool}, }, dynatos_world::{IMut, IMutLike, Rc, RcLike, Weak, WeakLike, WorldDefault}, @@ -288,7 +289,7 @@ impl Effect { impl PartialEq> for Effect { fn eq(&self, other: &Effect) -> bool { - core::ptr::eq(self.inner_ptr(), other.inner_ptr()) + ptr::eq(self.inner_ptr(), other.inner_ptr()) } } @@ -303,7 +304,7 @@ impl Clone for Effect { } impl Hash for Effect { - fn hash(&self, state: &mut H) { + fn hash(&self, state: &mut H) { Rc::<_, W>::as_ptr(&self.inner).hash(state); } } @@ -367,7 +368,7 @@ impl WeakEffect { impl PartialEq> for WeakEffect { fn eq(&self, other: &WeakEffect) -> bool { - core::ptr::eq(self.inner_ptr(), other.inner_ptr()) + ptr::eq(self.inner_ptr(), other.inner_ptr()) } } @@ -383,7 +384,7 @@ impl Clone for WeakEffect { impl Hash for WeakEffect { - fn hash(&self, state: &mut H) { + fn hash(&self, state: &mut H) { self.inner_ptr().hash(state); } } @@ -539,7 +540,7 @@ mod test { #[bench] fn get_running_100_none(bencher: &mut Bencher) { bencher.iter(|| { - for _ in 0..100 { + for _ in 0_usize..100 { let effect = effect::running(); test::black_box(effect); } @@ -552,7 +553,7 @@ mod test { effect.gather_dependencies(|| { bencher.iter(|| { - for _ in 0..100 { + for _ in 0_usize..100 { let effect = effect::running(); test::black_box(effect); } @@ -563,7 +564,7 @@ mod test { #[bench] fn create_10(bencher: &mut Bencher) { bencher.iter(|| { - for _ in 0..10 { + for _ in 0_usize..10 { let effect = Effect::new(move || ()); test::black_box(&effect); mem::forget(effect); diff --git a/dynatos-reactive/src/enum_split.rs b/dynatos-reactive/src/enum_split.rs index 6472492..744d4e0 100644 --- a/dynatos-reactive/src/enum_split.rs +++ b/dynatos-reactive/src/enum_split.rs @@ -239,8 +239,8 @@ where type Signal = Option>; type SignalsStorage = Option>; - fn get_signal(storage: &Self::SignalsStorage, cur: &Self::SigKind) -> Option { - let signal = match cur { + fn get_signal(storage: &Self::SignalsStorage, kind: &Self::SigKind) -> Option { + let signal = match kind { Some(()) => Some(storage.as_ref()?.signal()), None => None, }; @@ -288,7 +288,7 @@ mod tests { #[test] fn exec() { - let input = Signal::new(Either2::::T2(())); + let input = Signal::new(Either2::::T2(())); #[cloned(input)] let signal = EnumSplitSignal::new(input); @@ -363,7 +363,7 @@ mod tests { #[test] fn write_back() { // Start with `T1` - let outer = Signal::new(Either2::::T1(5)); + let outer = Signal::new(Either2::::T1(5)); #[thread_local] static TIMES_RUN_OUTER: Cell = Cell::new(0); #[cloned(outer)] diff --git a/dynatos-reactive/src/mapped_signal.rs b/dynatos-reactive/src/mapped_signal.rs index 8aeea11..30d8fdf 100644 --- a/dynatos-reactive/src/mapped_signal.rs +++ b/dynatos-reactive/src/mapped_signal.rs @@ -364,7 +364,7 @@ mod test { #[test] fn basic() { - let outer = Signal::new(Ok::<_, ()>(5)); + let outer = Signal::new(Ok::(5)); // Counts the number of times that `outer` was written to #[thread_local] @@ -407,7 +407,7 @@ mod test { #[test] fn effects() { - let outer = Signal::new(Ok::<_, i32>(5)); + let outer = Signal::new(Ok::(5)); let mapped = TryMappedSignal::new(outer.clone(), |opt| *opt, |opt, &value| *opt = Ok(value)); // Counts the times that the mapped signal was run diff --git a/dynatos-reactive/src/signal.rs b/dynatos-reactive/src/signal.rs index 0d95659..6364fa8 100644 --- a/dynatos-reactive/src/signal.rs +++ b/dynatos-reactive/src/signal.rs @@ -221,7 +221,7 @@ impl fmt::Debug for Signal { mod test { // Imports extern crate test; - use {super::*, crate::Effect, test::Bencher, zutil_cloned::cloned}; + use {super::*, crate::Effect, core::array, test::Bencher, zutil_cloned::cloned}; #[test] fn multiple_mut() { @@ -240,7 +240,7 @@ mod test { #[bench] fn clone_100(bencher: &mut Bencher) { - let signals = core::array::from_fn::<_, 100, _>(|_| Signal::new(0_i32)); + let signals = array::from_fn::<_, 100, _>(|_| Signal::new(0_i32)); bencher.iter(|| { for signal in &signals { let signal = test::black_box(signal.clone()); @@ -252,7 +252,7 @@ mod test { /// Reference for [`access_100`] #[bench] fn access_100_value(bencher: &mut Bencher) { - let values = core::array::from_fn::<_, 100, _>(|_| 123_usize); + let values = array::from_fn::<_, 100, _>(|_| 123_usize); bencher.iter(|| { for value in &values { test::black_box(*value); @@ -262,7 +262,7 @@ mod test { #[bench] fn access_100(bencher: &mut Bencher) { - let signals = core::array::from_fn::<_, 100, _>(|_| Signal::new(123_usize)); + let signals = array::from_fn::<_, 100, _>(|_| Signal::new(123_usize)); bencher.iter(|| { for signal in &signals { test::black_box(signal.get()); @@ -273,7 +273,7 @@ mod test { /// Reference for `update_100_*` #[bench] fn update_100_value(bencher: &mut Bencher) { - let mut values = core::array::from_fn::<_, 100, _>(|_| 123_usize); + let mut values = array::from_fn::<_, 100, _>(|_| 123_usize); bencher.iter(|| { for value in &mut values { *value += 1; @@ -284,7 +284,7 @@ mod test { #[bench] fn update_100_empty(bencher: &mut Bencher) { - let signals = core::array::from_fn::<_, 100, _>(|_| Signal::new(123_usize)); + let signals = array::from_fn::<_, 100, _>(|_| Signal::new(123_usize)); bencher.iter(|| { for signal in &signals { signal.update(|value| *value += 1); diff --git a/dynatos-reactive/src/trigger.rs b/dynatos-reactive/src/trigger.rs index e7a8530..c547d8e 100644 --- a/dynatos-reactive/src/trigger.rs +++ b/dynatos-reactive/src/trigger.rs @@ -10,8 +10,9 @@ use { borrow::Borrow, fmt, hash::{Hash, Hasher}, - marker::PhantomData, + marker::{PhantomData, Unsize}, ops::CoerceUnsized, + ptr, }, dynatos_world::{IMut, IMutLike, Rc, RcLike, Weak, WeakLike, WorldDefault}, std::collections::{hash_map, HashMap}, @@ -304,7 +305,7 @@ impl Default for Trigger { impl PartialEq for Trigger { fn eq(&self, other: &Self) -> bool { - core::ptr::eq(Rc::<_, W>::as_ptr(&self.inner), Rc::<_, W>::as_ptr(&other.inner)) + ptr::eq(Rc::<_, W>::as_ptr(&self.inner), Rc::<_, W>::as_ptr(&other.inner)) } } @@ -348,7 +349,7 @@ impl WeakTrigger { impl PartialEq for WeakTrigger { fn eq(&self, other: &Self) -> bool { - core::ptr::eq(Weak::<_, W>::as_ptr(&self.inner), Weak::<_, W>::as_ptr(&other.inner)) + ptr::eq(Weak::<_, W>::as_ptr(&self.inner), Weak::<_, W>::as_ptr(&other.inner)) } } @@ -402,7 +403,7 @@ impl IntoSubscriber for Subscriber { )] impl IntoSubscriber for T where - F: ?Sized + core::marker::Unsize, + F: ?Sized + Unsize, W: ReactiveWorld, WeakEffect: CoerceUnsized>, { @@ -472,7 +473,7 @@ mod test { extern crate test; use { super::*, - core::{cell::Cell, mem}, + core::{array, cell::Cell, mem}, test::Bencher, }; @@ -568,7 +569,7 @@ mod test { #[bench] fn clone_100(bencher: &mut Bencher) { - let triggers = core::array::from_fn::(|_| Trigger::new()); + let triggers = array::from_fn::(|_| Trigger::new()); bencher.iter(|| { for trigger in &triggers { let trigger = test::black_box(trigger.clone()); @@ -580,7 +581,7 @@ mod test { /// Benches triggering a trigger with `N` no-op effects. fn trigger_noop_n(bencher: &mut Bencher) { let trigger = Trigger::new(); - let effects = core::array::from_fn::<_, N, _>(|_| Effect::new(|| ())); + let effects = array::from_fn::<_, N, _>(|_| Effect::new(|| ())); for effect in &effects { trigger.add_subscriber(effect); } diff --git a/dynatos-reactive/tests/run-queue.rs b/dynatos-reactive/tests/run-queue.rs index 4178a9f..5c8a920 100644 --- a/dynatos-reactive/tests/run-queue.rs +++ b/dynatos-reactive/tests/run-queue.rs @@ -13,8 +13,8 @@ use { /// Ensures that the run queue is breadth-first #[test] fn breadth_first() { - let a = Signal::new(5); - let b = Signal::new(6); + let a = Signal::new(5_usize); + let b = Signal::new(6_usize); #[thread_local] static ORDER: RefCell> = RefCell::new(vec![]); diff --git a/dynatos-reactive/tests/unsized.rs b/dynatos-reactive/tests/unsized.rs index fa68bec..8fd04a4 100644 --- a/dynatos-reactive/tests/unsized.rs +++ b/dynatos-reactive/tests/unsized.rs @@ -9,6 +9,7 @@ use { #[test] fn create_unsized() { let value: i32 = 5; + #[expect(clippy::as_conversions, reason = "We need to unsize it")] let sig = Signal::::new(value) as Signal; sig.with(|dyn_value| { diff --git a/dynatos-world/src/imut.rs b/dynatos-world/src/imut.rs index dd7fa77..82a340b 100644 --- a/dynatos-world/src/imut.rs +++ b/dynatos-world/src/imut.rs @@ -1,7 +1,10 @@ //! Inner-mutability types // Imports -use core::{cell::RefCell, ops}; +use core::{ + cell::{self, RefCell}, + ops, +}; /// Inner mutability family pub trait IMutFamily: Sized { @@ -65,7 +68,7 @@ impl IMutFamily for StdRefcell { impl IMutLike for RefCell { type Ref<'a> - = core::cell::Ref<'a, T> + = cell::Ref<'a, T> where Self: 'a; type RefMut<'a> @@ -103,7 +106,7 @@ impl IMutLike for RefCell { } } -impl<'a, T: ?Sized> IMutRefLike<'a, T> for core::cell::Ref<'a, T> { +impl<'a, T: ?Sized> IMutRefLike<'a, T> for cell::Ref<'a, T> { type IMut = RefCell; } @@ -114,7 +117,7 @@ pub struct RefCellRefMut<'a, T: ?Sized> { /// Borrow #[deref(forward)] #[deref_mut] - borrow: core::cell::RefMut<'a, T>, + borrow: cell::RefMut<'a, T>, /// Original refcell // Note: This field is necessary for downgrading. diff --git a/dynatos-world/src/rc.rs b/dynatos-world/src/rc.rs index 1bc7f04..4a496ac 100644 --- a/dynatos-world/src/rc.rs +++ b/dynatos-world/src/rc.rs @@ -1,7 +1,10 @@ //! Reference-counted pointer // Imports -use core::ops; +use { + core::ops, + std::{rc, sync}, +}; /// Reference-counted pointer family pub trait RcFamily: Sized { @@ -51,11 +54,11 @@ pub trait WeakLike: Clone { pub struct StdArc; impl RcFamily for StdArc { - type Rc = std::sync::Arc; - type Weak = std::sync::Weak; + type Rc = sync::Arc; + type Weak = sync::Weak; } -impl RcLike for std::sync::Arc { +impl RcLike for sync::Arc { type Family = StdArc; fn new(value: T) -> Self @@ -82,7 +85,7 @@ impl RcLike for std::sync::Arc { } } -impl WeakLike for std::sync::Weak { +impl WeakLike for sync::Weak { type Family = StdArc; fn upgrade(&self) -> Option<::Rc> { @@ -98,11 +101,11 @@ impl WeakLike for std::sync::Weak { pub struct StdRc; impl RcFamily for StdRc { - type Rc = std::rc::Rc; - type Weak = std::rc::Weak; + type Rc = rc::Rc; + type Weak = rc::Weak; } -impl RcLike for std::rc::Rc { +impl RcLike for rc::Rc { type Family = StdRc; fn new(value: T) -> Self @@ -129,7 +132,7 @@ impl RcLike for std::rc::Rc { } } -impl WeakLike for std::rc::Weak { +impl WeakLike for rc::Weak { type Family = StdRc; fn upgrade(&self) -> Option<::Rc> { diff --git a/dynatos/src/element_dyn_attr.rs b/dynatos/src/element_dyn_attr.rs index 59c2b21..4d4027d 100644 --- a/dynatos/src/element_dyn_attr.rs +++ b/dynatos/src/element_dyn_attr.rs @@ -207,6 +207,7 @@ impl DynAttrPred for bool { impl DynAttrPred for Ty { fn eval(&self) -> bool { #[allow( + clippy::allow_attributes, clippy::redundant_closure_for_method_calls, reason = "In some branches it isn't redundant" )] diff --git a/dynatos/src/node_dyn_child.rs b/dynatos/src/node_dyn_child.rs index b35ca7c..c324f80 100644 --- a/dynatos/src/node_dyn_child.rs +++ b/dynatos/src/node_dyn_child.rs @@ -179,6 +179,7 @@ where impl ToDynNode for Ty { fn to_node(&self) -> Option { #[allow( + clippy::allow_attributes, clippy::redundant_closure_for_method_calls, reason = "In some branches it isn't redundant" )] diff --git a/dynatos/src/object_dyn_prop.rs b/dynatos/src/object_dyn_prop.rs index 1b80f63..9cb580b 100644 --- a/dynatos/src/object_dyn_prop.rs +++ b/dynatos/src/object_dyn_prop.rs @@ -156,6 +156,7 @@ impl ToDynProp for Ty { impl ToDynProp for Ty { fn to_prop(&self) -> Option { #[allow( + clippy::allow_attributes, clippy::redundant_closure_for_method_calls, reason = "In some branches it isn't redundant" )]