cargo clippy

jongiddy · jongiddy · commit 64944f87ba58 · 2025-12-16T20:52:02.000Z
diff --git a/README.md b/README.md
@@ -62,7 +62,7 @@ struct MultipleHandlers<T> {
 #[typle(Tuple for 0..=3)]
 impl<T> HandleStuff for MultipleHandlers<T>
 where
-    T: Tuple,           // `T`` is a tuple with 0 to 3 components.
+    T: Tuple,           // `T` is a tuple with 0 to 3 components.
     T<_>: HandleStuff,  // All components implement `HandleStuff`.
 {
     type Output = (typle! {i in .. => T<{i}>::Output});
diff --git a/src/constant.rs b/src/constant.rs
@@ -77,30 +77,22 @@ pub fn evaluate_range(
             }
         }
         Expr::Range(range) => {
-            let start = range
-                .start
-                .as_ref()
-                .map(|start_expr| {
-                    Bound::Included(
-                        evaluate_usize(start_expr)
-                            .map(Ok)
-                            .unwrap_or_else(|| Err(start_expr.span())),
-                    )
-                })
-                .unwrap_or(Bound::Unbounded);
-            let end = range
-                .end
-                .as_ref()
-                .map(|end_expr| {
-                    let end = evaluate_usize(end_expr)
+            let start = range.start.as_ref().map_or(Bound::Unbounded, |start_expr| {
+                Bound::Included(
+                    evaluate_usize(start_expr)
                         .map(Ok)
-                        .unwrap_or_else(|| Err(end_expr.span()));
-                    match range.limits {
-                        syn::RangeLimits::HalfOpen(_) => Bound::Excluded(end),
-                        syn::RangeLimits::Closed(_) => Bound::Included(end),
-                    }
-                })
-                .unwrap_or(Bound::Unbounded);
+                        .unwrap_or_else(|| Err(start_expr.span())),
+                )
+            });
+            let end = range.end.as_ref().map_or(Bound::Unbounded, |end_expr| {
+                let end = evaluate_usize(end_expr)
+                    .map(Ok)
+                    .unwrap_or_else(|| Err(end_expr.span()));
+                match range.limits {
+                    syn::RangeLimits::HalfOpen(_) => Bound::Excluded(end),
+                    syn::RangeLimits::Closed(_) => Bound::Included(end),
+                }
+            });
             return Some((start, end));
         }
         _ => {}
diff --git a/src/context.rs b/src/context.rs
@@ -30,15 +30,15 @@ use crate::TypleMacro;
 #[derive(Clone)]
 pub enum Typle {
     // `Typle<C>`: the name C of the type for all components (concrete or generic)
-    Specific(Type),
+    Specific(Box<Type>),
     // `Typle`: the invented name for each component
     Generic(Rc<Vec<String>>),
 }
 
 impl Typle {
     pub fn get(&self, i: usize, span: Span) -> Type {
         match self {
-            Typle::Specific(r#type) => r#type.clone(),
+            Typle::Specific(r#type) => (**r#type).clone(),
             Typle::Generic(v) => Type::Path(syn::TypePath {
                 qself: None,
                 path: ident_to_path(Ident::new(&v[i], span)),
@@ -222,7 +222,7 @@ impl TypleContext {
                                             )
                                         );
                                     }
-                                    result = Some(Typle::Specific(ty.clone()));
+                                    result = Some(Typle::Specific(Box::new(ty.clone())));
                                     continue;
                                 }
                                 PathArguments::Parenthesized(arguments) => {
diff --git a/src/context/expr.rs b/src/context/expr.rs
@@ -110,7 +110,7 @@ impl TypleContext {
                             };
                             if let Some(tt) = tokens.next() {
                                 abort!(tt, "unexpected token in typle_index");
-                            };
+                            }
                             let Some((start, end)) = evaluate_range(&for_loop.expr) else {
                                 abort!(for_loop.expr, "expected range");
                             };
diff --git a/src/context/generic_param.rs b/src/context/generic_param.rs
@@ -80,7 +80,7 @@ fn handle_type(
                                 bounds: Punctuated::new(),
                                 eq_token: None,
                                 default: None,
-                            }))
+                            }));
                         }
                         GenericParam::Const(_) => {
                             output.push(param.clone());
@@ -95,7 +95,7 @@ fn handle_type(
         Type::Reference(type_reference) => {
             if let Some(lifetime) = &type_reference.lifetime {
                 if let Some(param) = param_map.lifetimes.remove(&lifetime.ident) {
-                    output.push(GenericParam::Lifetime(param.clone()))
+                    output.push(GenericParam::Lifetime(param.clone()));
                 }
             }
             handle_type(&type_reference.elem, param_map, output);
diff --git a/src/context/pat.rs b/src/context/pat.rs
@@ -116,6 +116,7 @@ impl TypleContext {
         mut pat: Pat,
     ) -> Replacements<impl Iterator<Item = syn::Result<Pat>>> {
         let mut state = BlockState::default();
+        #[allow(clippy::single_match)]
         match &mut pat {
             Pat::Macro(syn::PatMacro { mac, .. }) => {
                 if let Some(ident) = mac.path.get_ident() {
diff --git a/src/context/shared.rs b/src/context/shared.rs
@@ -262,7 +262,7 @@ impl TypleContext {
                         let ty_segment = ty_path.segments.first().unwrap();
                         let segment = path.segments.first_mut().unwrap();
                         *segment = ty_segment.clone();
-                        *qself = ty_qself.clone();
+                        qself.clone_from(ty_qself);
                         path.leading_colon = ty_path.leading_colon;
                     }
                     _ => {
diff --git a/src/context/type.rs b/src/context/type.rs
@@ -127,9 +127,8 @@ impl TypleContext {
                             (iter.next(), iter.next())
                         {
                             let mut state = BlockState::default();
-                            match self.replace_expr(expr, &mut state) {
-                                Ok(_) => {}
-                                Err(e) => return Replacements::Singleton(Err(e)),
+                            if let Err(err) = self.replace_expr(expr, &mut state) {
+                                return Replacements::Singleton(Err(err));
                             }
                             if let Some((start, end)) = evaluate_range(expr) {
                                 // T<{..}>
diff --git a/src/lib.rs b/src/lib.rs
@@ -120,9 +120,9 @@
 //! - `T<0>: Clone` - the first component of the tuple implements the `Clone` trait.
 //! - `T<{1..=2}>: Clone` - the second and third components implement the `Clone` trait.
 //! - `typle!(j in .. => I<{j}>: Iterator<Item=T<{j}>>): Tuple::Bounds` - the most
-//!    general way to bound components, allowing typle index expressions on both
-//!    sides of the colon. Note that the suffix `: Tuple::Bounds` is required after
-//!    the macro, where `Tuple` is the name of the typle trait.
+//!   general way to bound components, allowing typle index expressions on both
+//!   sides of the colon. Note that the suffix `: Tuple::Bounds` is required after
+//!   the macro, where `Tuple` is the name of the typle trait.
 //!
 //! ```rust
 //! # use typle::typle;
@@ -351,12 +351,8 @@
 //!     T<_>: Extract,
 //! {
 //!     // The output of all previous components plus the state of the current component.
-//!     S = typle_variant!(
-//!         curr in ..T::MAX => (
-//!             typle! {
-//!                 prev in ..curr => T::<{prev}>::Output
-//!             }
-//!         ),
+//!     S = typle_variant!(curr in ..T::MAX =>
+//!         (typle! {prev in ..curr => T::<{prev}>::Output}),
 //!         Option<T<{curr}>::State>
 //!     ),
 //! }
@@ -408,8 +404,9 @@
 //! #     T: Tuple,
 //! #     T<_>: Extract,
 //! # {
-//! #     S = typle_variant!(i in ..T::MAX =>
-//! #         (typle!(j in ..i => T::<{j}>::Output)), Option<T<{i}>::State>
+//! #     S = typle_variant!(curr in ..T::MAX =>
+//! #         (typle! {prev in ..curr => T::<{prev}>::Output}),
+//! #         Option<T<{curr}>::State>
 //! #     ),
 //! # }
 //! // Relevant traits may need to be implemented for the never type.
@@ -591,7 +588,7 @@
 //! }
 //! ```
 //! - Typle index variables can be shadowed by inner typle index variables
-//! but cannot be shadowed by standard variables:
+//!   but cannot be shadowed by standard variables:
 //! ```rust
 //! # use typle::typle;
 //! # #[typle(Tuple for 1..=1)]
@@ -631,7 +628,6 @@
 //! }
 //! test_macro((0, 1, 2));
 //! ```
-//!
 
 mod constant;
 mod context;
diff --git a/tests/compile/doc_typle.rs b/tests/compile/doc_typle.rs
@@ -62,12 +62,8 @@ mod tuple {
         T: Tuple,
         T<_>: Extract,
     {
-        S = typle_variant!(
-            curr in ..T::MAX => (
-                typle! {
-                    prev in ..curr => T::<{prev}>::Output
-                }
-            ),
+        S = typle_variant!(curr in ..T::MAX =>
+            (typle! {prev in ..curr => T::<{prev}>::Output}),
             Option<T<{curr}>::State>
         ),
     }

Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ struct MultipleHandlers<T> {`
`62`	`62`	`#[typle(Tuple for 0..=3)]`
`63`	`63`	`impl<T> HandleStuff for MultipleHandlers<T>`
`64`	`64`	`where`
`65`		- T: Tuple, // `T`` is a tuple with 0 to 3 components.
	`65`	+ T: Tuple, // `T` is a tuple with 0 to 3 components.
`66`	`66`	T<_>: HandleStuff, // All components implement `HandleStuff`.
`67`	`67`	`{`
`68`	`68`	`type Output = (typle! {i in .. => T<{i}>::Output});`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ fn handle_type(`
`80`	`80`	`bounds: Punctuated::new(),`
`81`	`81`	`eq_token: None,`
`82`	`82`	`default: None,`
`83`		`- }))`
	`83`	`+ }));`
`84`	`84`	`}`
`85`	`85`	`GenericParam::Const(_) => {`
`86`	`86`	`output.push(param.clone());`
`@@ -95,7 +95,7 @@ fn handle_type(`
`95`	`95`	`Type::Reference(type_reference) => {`
`96`	`96`	`if let Some(lifetime) = &type_reference.lifetime {`
`97`	`97`	`if let Some(param) = param_map.lifetimes.remove(&lifetime.ident) {`
`98`		`- output.push(GenericParam::Lifetime(param.clone()))`
	`98`	`+ output.push(GenericParam::Lifetime(param.clone()));`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`	`handle_type(&type_reference.elem, param_map, output);`
Original file line number	Diff line number	Diff line change
`@@ -262,7 +262,7 @@ impl TypleContext {`
`262`	`262`	`let ty_segment = ty_path.segments.first().unwrap();`
`263`	`263`	`let segment = path.segments.first_mut().unwrap();`
`264`	`264`	`*segment = ty_segment.clone();`
`265`		`- *qself = ty_qself.clone();`
	`265`	`+ qself.clone_from(ty_qself);`
`266`	`266`	`path.leading_colon = ty_path.leading_colon;`
`267`	`267`	`}`
`268`	`268`	`_ => {`
Original file line number	Diff line number	Diff line change
`@@ -127,9 +127,8 @@ impl TypleContext {`
`127`	`127`	`(iter.next(), iter.next())`
`128`	`128`	`{`
`129`	`129`	`let mut state = BlockState::default();`
`130`		`- match self.replace_expr(expr, &mut state) {`
`131`		`- Ok(_) => {}`
`132`		`- Err(e) => return Replacements::Singleton(Err(e)),`
	`130`	`+ if let Err(err) = self.replace_expr(expr, &mut state) {`
	`131`	`+ return Replacements::Singleton(Err(err));`
`133`	`132`	`}`
`134`	`133`	`if let Some((start, end)) = evaluate_range(expr) {`
`135`	`134`	`// T<{..}>`