RustPython · youknowone · May 13, 2026 · May 12, 2026 · May 12, 2026 · May 12, 2026
diff --git a/Cargo.toml b/Cargo.toml
@@ -358,3 +358,4 @@ inconsistent_struct_constructor = "warn"
 manual_is_variant_and = "warn"
 map_unwrap_or = "warn"
 must_use_candidate = "warn"
+unnecessary_wraps = "warn"
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
diff --git a/crates/codegen/src/string_parser.rs b/crates/codegen/src/string_parser.rs
@@ -68,7 +68,7 @@ impl StringParser {
         self.source[self.cursor..].as_bytes().first().copied()
     }
 
-    fn parse_unicode_literal(&mut self, literal_number: usize) -> Result<CodePoint, LexicalError> {
+    fn parse_unicode_literal(&mut self, literal_number: usize) -> CodePoint {
         let mut p: u32 = 0u32;
         for i in 1..=literal_number {
             match self.next_char() {
@@ -79,7 +79,7 @@ impl StringParser {
                 None => unreachable!(),
             }
         }
-        Ok(CodePoint::from_u32(p).unwrap())
+        CodePoint::from_u32(p).unwrap()
     }
 
     fn parse_octet(&mut self, o: u8) -> char {
@@ -134,9 +134,9 @@ impl StringParser {
             't' => '\t'.into(),
             'v' => '\x0b'.into(),
             o @ '0'..='7' => self.parse_octet(o as u8).into(),
-            'x' => self.parse_unicode_literal(2)?,
-            'u' if !self.flags.is_byte_string() => self.parse_unicode_literal(4)?,
-            'U' if !self.flags.is_byte_string() => self.parse_unicode_literal(8)?,
+            'x' => self.parse_unicode_literal(2),
+            'u' if !self.flags.is_byte_string() => self.parse_unicode_literal(4),
+            'U' if !self.flags.is_byte_string() => self.parse_unicode_literal(8),
             'N' if !self.flags.is_byte_string() => self.parse_unicode_name()?.into(),
             // Special cases where the escape sequence is not a single character
             '\n' => return Ok(None),

diff --git a/crates/common/src/format.rs b/crates/common/src/format.rs
@@ -580,7 +580,13 @@ impl FormatSpec {
             },
         };
 
-        self.format_sign_and_align(&AsciiStr::new(&magnitude_str), sign_str, FormatAlign::Right)
+        Ok(
+            self.format_sign_and_align(
+                &AsciiStr::new(&magnitude_str),
+                sign_str,
+                FormatAlign::Right,
+            ),
+        )
     }
 
     /// Format a float with locale-aware 'n' format.
@@ -620,7 +626,13 @@ impl FormatSpec {
             }
         };
 
-        self.format_sign_and_align(&AsciiStr::new(&magnitude_str), sign_str, FormatAlign::Right)
+        Ok(
+            self.format_sign_and_align(
+                &AsciiStr::new(&magnitude_str),
+                sign_str,
+                FormatAlign::Right,
+            ),
+        )
     }
 
     /// Format a complex number with locale-aware 'n' format.
@@ -672,7 +684,7 @@ impl FormatSpec {
         // No parentheses for 'n' format (CPython: add_parens=0)
         let magnitude_str = format!("{grouped_re}{grouped_im}");
 
-        self.format_sign_and_align(&AsciiStr::new(&magnitude_str), "", FormatAlign::Right)
+        Ok(self.format_sign_and_align(&AsciiStr::new(&magnitude_str), "", FormatAlign::Right))
     }
 
     pub fn format_bool(&self, input: bool) -> Result<String, FormatSpecError> {
@@ -789,7 +801,13 @@ impl FormatSpec {
             }
         };
         let magnitude_str = self.add_magnitude_separators(raw_magnitude_str?, sign_str);
-        self.format_sign_and_align(&AsciiStr::new(&magnitude_str), sign_str, FormatAlign::Right)
+        Ok(
+            self.format_sign_and_align(
+                &AsciiStr::new(&magnitude_str),
+                sign_str,
+                FormatAlign::Right,
+            ),
+        )
     }
 
     #[inline]
@@ -863,11 +881,11 @@ impl FormatSpec {
         };
         let sign_prefix = format!("{sign_str}{prefix}");
         let magnitude_str = self.add_magnitude_separators(raw_magnitude_str, &sign_prefix);
-        self.format_sign_and_align(
+        Ok(self.format_sign_and_align(
             &AsciiStr::new(&magnitude_str),
             &sign_prefix,
             FormatAlign::Right,
-        )
+        ))
     }
 
     pub fn format_string<T>(&self, s: &T) -> Result<String, FormatSpecError>
@@ -883,7 +901,7 @@ impl FormatSpec {
                     Some(p) => s.deref().chars().take(p).collect(),
                     None => s.deref().to_owned(),
                 };
-                self.format_sign_and_align(&truncated, "", FormatAlign::Left)
+                Ok(self.format_sign_and_align(&truncated, "", FormatAlign::Left))
             }
             _ => {
                 let ch = char::from(self.format_type.as_ref().unwrap());
@@ -905,7 +923,11 @@ impl FormatSpec {
         }
         match &self.fill.unwrap_or_else(|| ' '.into()).to_char() {
             Some('0') => Err(FormatSpecError::ZeroPadding),
-            _ => self.format_sign_and_align(&AsciiStr::new(&magnitude_str), "", FormatAlign::Right),
+            _ => Ok(self.format_sign_and_align(
+                &AsciiStr::new(&magnitude_str),
+                "",
+                FormatAlign::Right,
+            )),
         }
     }
 
@@ -1017,7 +1039,7 @@ impl FormatSpec {
         magnitude_str: &T,
         sign_str: &str,
         default_align: FormatAlign,
-    ) -> Result<String, FormatSpecError>
+    ) -> String
     where
         T: CharLen + Deref<Target = str>,
     {
@@ -1030,7 +1052,7 @@ impl FormatSpec {
         });
 
         let magnitude_str = magnitude_str.deref();
-        Ok(match align {
+        match align {
             FormatAlign::Left => format!(
                 "{}{}{}",
                 sign_str,
@@ -1057,7 +1079,7 @@ impl FormatSpec {
                     Self::compute_fill_string(fill_char, right_fill_chars_needed);
                 format!("{left_fill_string}{sign_str}{magnitude_str}{right_fill_string}")
             }
-        })
+        }
     }
 }
 

diff --git a/crates/derive-impl/src/lib.rs b/crates/derive-impl/src/lib.rs
@@ -53,7 +53,7 @@ pub fn pyclass(attr: PunctuatedNestedMeta, item: Item) -> TokenStream {
 #[must_use]
 pub fn pyexception(attr: PunctuatedNestedMeta, item: Item) -> TokenStream {
     if matches!(item, syn::Item::Impl(_)) {
-        result_to_tokens(pyclass::impl_pyexception_impl(attr, item))
+        pyclass::impl_pyexception_impl(attr, item)
     } else {
         result_to_tokens(pyclass::impl_pyexception(attr, item))
     }
@@ -84,7 +84,7 @@ pub fn py_freeze(input: TokenStream, compiler: &dyn Compiler) -> TokenStream {
 
 #[must_use]
 pub fn pypayload(input: DeriveInput) -> TokenStream {
-    result_to_tokens(pypayload::impl_pypayload(input))
+    pypayload::impl_pypayload(input)
 }
 
 #[must_use]

diff --git a/crates/derive-impl/src/pyclass.rs b/crates/derive-impl/src/pyclass.rs
@@ -644,8 +644,8 @@ pub(crate) fn impl_pyclass(attr: PunctuatedNestedMeta, item: Item) -> Result<Tok
     // 1. no `clear`: HAS_CLEAR = HAS_TRAVERSE (default: same as traverse)
     // 2. `clear` or `clear = true`: HAS_CLEAR = true, try_clear calls Traverse::clear
     // 3. `clear = false`: HAS_CLEAR = false (rare: traverse without clear)
-    let has_traverse = class_meta.inner()._has_key("traverse")?;
-    let has_clear = if class_meta.inner()._has_key("clear")? {
+    let has_traverse = class_meta.inner()._has_key("traverse");
+    let has_clear = if class_meta.inner()._has_key("clear") {
         // If clear attribute is present, use its value
         class_meta.inner()._bool("clear")?
     } else {
@@ -804,9 +804,9 @@ pub(crate) fn impl_pyexception(attr: PunctuatedNestedMeta, item: Item) -> Result
     Ok(ret)
 }
 
-pub(crate) fn impl_pyexception_impl(attr: PunctuatedNestedMeta, item: Item) -> Result<TokenStream> {
+pub(crate) fn impl_pyexception_impl(attr: PunctuatedNestedMeta, item: Item) -> TokenStream {
     let Item::Impl(imp) = item else {
-        return Ok(item.into_token_stream());
+        return item.into_token_stream();
     };
 
     // Check if with(Constructor) is specified. If Constructor trait is used, don't generate slot_new
@@ -878,15 +878,15 @@ pub(crate) fn impl_pyexception_impl(attr: PunctuatedNestedMeta, item: Item) -> R
         quote!(, #(#extra_attrs),*)
     };
 
-    Ok(quote! {
+    quote! {
         #[pyclass(flags(BASETYPE, HAS_DICT), with(#(#with_items),*) #extra_attrs_tokens)]
         impl #generics #self_ty {
             #(#items)*
         }
 
         #slot_new
         #slot_init
-    })
+    }
 }
 
 macro_rules! define_content_item {
@@ -1189,7 +1189,7 @@ where
             args.cfgs.to_vec(),
             tokens,
             2,
-        )?;
+        );
 
         Ok(())
     }
@@ -1235,7 +1235,7 @@ where
 
         args.context
             .attribute_items
-            .add_item(ident.clone(), vec![py_name], cfgs, tokens, 1)?;
+            .add_item(ident.clone(), vec![py_name], cfgs, tokens, 1);
 
         Ok(())
     }
@@ -1944,12 +1944,12 @@ fn extract_impl_attrs(attr: PunctuatedNestedMeta, item: &Ident) -> Result<Extrac
 fn impl_item_new<Item>(
     index: usize,
     attr_name: AttrName,
-) -> Result<Box<dyn ImplItem<Item, AttrName = AttrName>>>
+) -> Box<dyn ImplItem<Item, AttrName = AttrName>>
 where
     Item: ItemLike + ToTokens + GetIdent,
 {
     use AttrName::*;
-    Ok(match attr_name {
+    match attr_name {
         attr_name @ (Method | ClassMethod | StaticMethod) => Box::new(MethodItem {
             inner: ContentItemInner { index, attr_name },
         }),
@@ -1968,15 +1968,15 @@ where
         Member => Box::new(MemberItem {
             inner: ContentItemInner { index, attr_name },
         }),
-    })
+    }
 }
 
 fn attrs_to_content_items<F, R>(
     attrs: &[Attribute],
     item_new: F,
 ) -> Result<(Vec<R>, Vec<Attribute>)>
 where
-    F: Fn(usize, AttrName) -> Result<R>,
+    F: Fn(usize, AttrName) -> R,
 {
     let mut cfgs: Vec<Attribute> = Vec::new();
     let mut result = Vec::new();
@@ -2018,7 +2018,7 @@ where
             }
         };
 
-        result.push(item_new(i, attr_name)?);
+        result.push(item_new(i, attr_name));
     }
     Ok((result, cfgs))
 }

diff --git a/crates/derive-impl/src/pymodule.rs b/crates/derive-impl/src/pymodule.rs
@@ -816,7 +816,7 @@ impl ModuleItem for ClassItem {
                 #set_attr
             },
             0,
-        )?;
+        );
         Ok(())
     }
 }
@@ -910,7 +910,7 @@ impl ModuleItem for StructSequenceItem {
                 #set_attr
             },
             0,
-        )?;
+        );
         Ok(())
     }
 }
@@ -995,9 +995,9 @@ impl ModuleItem for AttributeItem {
                         cfgs.clone(),
                         tokens,
                         1,
-                    )?;
+                    );
                     Ok(())
-                })?;
+                });
                 return Ok(());
             }
             other => {
@@ -1053,7 +1053,7 @@ impl ModuleItem for AttributeItem {
 
         args.context
             .attribute_items
-            .add_item(ident, py_names, cfgs, tokens, 1)?;
+            .add_item(ident, py_names, cfgs, tokens, 1);
 
         Ok(())
     }

diff --git a/crates/derive-impl/src/pypayload.rs b/crates/derive-impl/src/pypayload.rs
@@ -1,17 +1,16 @@
 use proc_macro2::TokenStream;
 use quote::quote;
-use syn::{DeriveInput, Result};
+use syn::DeriveInput;
 
-pub(crate) fn impl_pypayload(input: DeriveInput) -> Result<TokenStream> {
+pub(crate) fn impl_pypayload(input: DeriveInput) -> TokenStream {
     let ty = &input.ident;
 
-    let ret = quote! {
+    quote! {
         impl ::rustpython_vm::PyPayload for #ty {
             #[inline]
             fn class(_ctx: &::rustpython_vm::vm::Context) -> &'static rustpython_vm::Py<::rustpython_vm::builtins::PyType> {
                 <Self as ::rustpython_vm::class::StaticType>::static_type()
             }
         }
-    };
-    Ok(ret)
+    }
 }
diff --git a/crates/derive-impl/src/util.rs b/crates/derive-impl/src/util.rs
@@ -45,15 +45,14 @@ impl ItemNursery {
         cfgs: Vec<Attribute>,
         tokens: TokenStream,
         sort_order: usize,
-    ) -> Result<()> {
+    ) {
         self.0.push(NurseryItem {
             attr_name,
             py_names,
             cfgs,
             tokens,
             sort_order,
         });
-        Ok(())
     }
 
     pub(crate) fn validate(self) -> Result<ValidatedItemNursery> {
@@ -216,8 +215,8 @@ impl ItemMetaInner {
         Ok(value)
     }
 
-    pub(crate) fn _has_key(&self, key: &str) -> Result<bool> {
-        Ok(matches!(self.meta_map.get(key), Some((_, _))))
+    pub(crate) fn _has_key(&self, key: &str) -> bool {
+        matches!(self.meta_map.get(key), Some((_, _)))
     }
 
     pub(crate) fn _bool(&self, key: &str) -> Result<bool> {