diff --git a/ruff_dev/src/generate_source_code.rs b/ruff_dev/src/generate_source_code.rs
index 91161543ba..a5bb53092c 100644
--- a/ruff_dev/src/generate_source_code.rs
+++ b/ruff_dev/src/generate_source_code.rs
@@ -19,7 +19,7 @@ pub fn main(cli: &Cli) -> Result<()> {
     let contents = fs::read_to_string(&cli.file)?;
     let python_ast = parser::parse_program(&contents, &cli.file.to_string_lossy())?;
     let mut generator = SourceGenerator::new();
-    generator.unparse_suite(&python_ast)?;
+    generator.unparse_suite(&python_ast);
     println!("{}", generator.generate()?);
     Ok(())
 }
diff --git a/src/code_gen.rs b/src/code_gen.rs
index e5e818566c..86ce334dfb 100644
--- a/src/code_gen.rs
+++ b/src/code_gen.rs
@@ -54,30 +54,27 @@ impl SourceGenerator {
         String::from_utf8(self.buffer)
     }
 
-    fn newline(&mut self) -> fmt::Result {
+    fn newline(&mut self) {
         if !self.initial {
             self.new_lines = std::cmp::max(self.new_lines, 1);
         }
-        Ok(())
     }
 
-    fn newlines(&mut self, extra: usize) -> fmt::Result {
+    fn newlines(&mut self, extra: usize) {
         if !self.initial {
             self.new_lines = std::cmp::max(self.new_lines, 1 + extra);
         }
-        Ok(())
     }
 
-    fn body<U>(&mut self, stmts: &[Stmt<U>]) -> fmt::Result {
+    fn body<U>(&mut self, stmts: &[Stmt<U>]) {
         self.indentation += 1;
         for stmt in stmts {
-            self.unparse_stmt(stmt)?;
+            self.unparse_stmt(stmt);
         }
         self.indentation -= 1;
-        Ok(())
     }
 
-    fn p(&mut self, s: &str) -> fmt::Result {
+    fn p(&mut self, s: &str) {
         if self.new_lines > 0 {
             for _ in 0..self.new_lines {
                 self.buffer.extend("\n".as_bytes());
@@ -85,37 +82,33 @@ impl SourceGenerator {
             self.new_lines = 0;
         }
         self.buffer.extend(s.as_bytes());
-        Ok(())
     }
 
-    fn p_if(&mut self, cond: bool, s: &str) -> fmt::Result {
+    fn p_if(&mut self, cond: bool, s: &str) {
         if cond {
-            self.p(s)?;
+            self.p(s);
         }
-        Ok(())
     }
 
-    fn p_delim(&mut self, first: &mut bool, s: &str) -> fmt::Result {
-        self.p_if(!std::mem::take(first), s)
+    fn p_delim(&mut self, first: &mut bool, s: &str) {
+        self.p_if(!std::mem::take(first), s);
     }
 
-    fn write_fmt(&mut self, f: fmt::Arguments<'_>) -> fmt::Result {
+    fn write_fmt(&mut self, f: fmt::Arguments<'_>) {
         self.buffer.extend(format!("{f}").as_bytes());
-        Ok(())
     }
 
-    pub fn unparse_suite<U>(&mut self, suite: &Suite<U>) -> fmt::Result {
+    pub fn unparse_suite<U>(&mut self, suite: &Suite<U>) {
         for stmt in suite {
-            self.unparse_stmt(stmt)?;
+            self.unparse_stmt(stmt);
         }
-        Ok(())
     }
 
-    pub fn unparse_stmt<U>(&mut self, ast: &Stmt<U>) -> fmt::Result {
+    pub fn unparse_stmt<U>(&mut self, ast: &Stmt<U>) {
         macro_rules! statement {
             ($body:block) => {{
-                self.newline()?;
-                self.p(&"    ".repeat(self.indentation))?;
+                self.newline();
+                self.p(&"    ".repeat(self.indentation));
                 $body
                 self.initial = false;
             }};
@@ -130,22 +123,22 @@ impl SourceGenerator {
                 ..
             } => {
                 // TODO(charlie): Handle decorators.
-                self.newlines(if self.indentation == 0 { 2 } else { 1 })?;
+                self.newlines(if self.indentation == 0 { 2 } else { 1 });
                 statement!({
-                    self.p("def ")?;
-                    self.p(name)?;
-                    self.p("(")?;
-                    self.unparse_args(args)?;
-                    self.p(")")?;
+                    self.p("def ");
+                    self.p(name);
+                    self.p("(");
+                    self.unparse_args(args);
+                    self.p(")");
                     if let Some(returns) = returns {
-                        self.p(" -> ")?;
-                        self.unparse_expr(returns, precedence::EXPR)?;
+                        self.p(" -> ");
+                        self.unparse_expr(returns, precedence::EXPR);
                     }
-                    self.p(":")?;
+                    self.p(":");
                 });
-                self.body(body)?;
+                self.body(body);
                 if self.indentation == 0 {
-                    self.newlines(2)?;
+                    self.newlines(2);
                 }
             }
             StmtKind::AsyncFunctionDef {
@@ -156,22 +149,22 @@ impl SourceGenerator {
                 ..
             } => {
                 // TODO(charlie): Handle decorators.
-                self.newlines(if self.indentation == 0 { 2 } else { 1 })?;
+                self.newlines(if self.indentation == 0 { 2 } else { 1 });
                 statement!({
-                    self.p("async def ")?;
-                    self.p(name)?;
-                    self.p("(")?;
-                    self.unparse_args(args)?;
-                    self.p(")")?;
+                    self.p("async def ");
+                    self.p(name);
+                    self.p("(");
+                    self.unparse_args(args);
+                    self.p(")");
                     if let Some(returns) = returns {
-                        self.p(" -> ")?;
-                        self.unparse_expr(returns, precedence::EXPR)?;
+                        self.p(" -> ");
+                        self.unparse_expr(returns, precedence::EXPR);
                     }
-                    self.p(":")?;
+                    self.p(":");
                 });
-                self.body(body)?;
+                self.body(body);
                 if self.indentation == 0 {
-                    self.newlines(2)?;
+                    self.newlines(2);
                 }
             }
             StmtKind::ClassDef {
@@ -182,68 +175,68 @@ impl SourceGenerator {
                 ..
             } => {
                 // TODO(charlie): Handle decorators.
-                self.newlines(if self.indentation == 0 { 2 } else { 1 })?;
+                self.newlines(if self.indentation == 0 { 2 } else { 1 });
                 statement!({
-                    self.p("class ")?;
-                    self.p(name)?;
+                    self.p("class ");
+                    self.p(name);
                     let mut first = true;
                     for base in bases {
-                        self.p_if(first, "(")?;
-                        self.p_delim(&mut first, ", ")?;
-                        self.unparse_expr(base, precedence::EXPR)?;
+                        self.p_if(first, "(");
+                        self.p_delim(&mut first, ", ");
+                        self.unparse_expr(base, precedence::EXPR);
                     }
                     for keyword in keywords {
-                        self.p_if(first, "(")?;
-                        self.p_delim(&mut first, ", ")?;
+                        self.p_if(first, "(");
+                        self.p_delim(&mut first, ", ");
                         if let Some(arg) = &keyword.node.arg {
-                            self.p(arg)?;
-                            self.p("=")?;
+                            self.p(arg);
+                            self.p("=");
                         } else {
-                            self.p("**")?;
+                            self.p("**");
                         }
-                        self.unparse_expr(&keyword.node.value, precedence::EXPR)?;
+                        self.unparse_expr(&keyword.node.value, precedence::EXPR);
                     }
-                    self.p_if(!first, ")")?;
-                    self.p(":")?;
+                    self.p_if(!first, ")");
+                    self.p(":");
                 });
-                self.body(body)?;
+                self.body(body);
                 if self.indentation == 0 {
-                    self.newlines(2)?;
+                    self.newlines(2);
                 }
             }
             StmtKind::Return { value } => {
                 statement!({
                     if let Some(expr) = value {
-                        self.p("return ")?;
-                        self.unparse_expr(expr, precedence::ATOM)?;
+                        self.p("return ");
+                        self.unparse_expr(expr, precedence::ATOM);
                     } else {
-                        self.p("return")?;
+                        self.p("return");
                     }
                 });
             }
             StmtKind::Delete { targets } => {
                 statement!({
-                    self.p("del ")?;
+                    self.p("del ");
                     let mut first = true;
                     for expr in targets {
-                        self.p_delim(&mut first, ", ")?;
-                        self.unparse_expr(expr, precedence::ATOM)?;
+                        self.p_delim(&mut first, ", ");
+                        self.unparse_expr(expr, precedence::ATOM);
                     }
                 });
             }
             StmtKind::Assign { targets, value, .. } => {
                 statement!({
                     for target in targets {
-                        self.unparse_expr(target, precedence::EXPR)?;
-                        self.p(" = ")?;
+                        self.unparse_expr(target, precedence::EXPR);
+                        self.p(" = ");
                     }
-                    self.unparse_expr(value, precedence::EXPR)?;
+                    self.unparse_expr(value, precedence::EXPR);
                 });
             }
             StmtKind::AugAssign { target, op, value } => {
                 statement!({
-                    self.unparse_expr(target, precedence::EXPR)?;
-                    self.p(" ")?;
+                    self.unparse_expr(target, precedence::EXPR);
+                    self.p(" ");
                     self.p(match op {
                         Operator::Add => "+",
                         Operator::Sub => "-",
@@ -258,9 +251,9 @@ impl SourceGenerator {
                         Operator::BitXor => "^",
                         Operator::BitAnd => "&",
                         Operator::FloorDiv => "//",
-                    })?;
-                    self.p("= ")?;
-                    self.unparse_expr(value, precedence::EXPR)?;
+                    });
+                    self.p("= ");
+                    self.unparse_expr(value, precedence::EXPR);
                 })
             }
             StmtKind::AnnAssign {
@@ -271,14 +264,14 @@ impl SourceGenerator {
             } => {
                 statement!({
                     let need_parens = matches!(target.node, ExprKind::Name { .. }) && simple == &0;
-                    self.p_if(need_parens, "(")?;
-                    self.unparse_expr(target, precedence::EXPR)?;
-                    self.p_if(need_parens, ")")?;
-                    self.p(": ")?;
-                    self.unparse_expr(annotation, precedence::EXPR)?;
+                    self.p_if(need_parens, "(");
+                    self.unparse_expr(target, precedence::EXPR);
+                    self.p_if(need_parens, ")");
+                    self.p(": ");
+                    self.unparse_expr(annotation, precedence::EXPR);
                     if let Some(value) = value {
-                        self.p(" = ")?;
-                        self.unparse_expr(value, precedence::EXPR)?;
+                        self.p(" = ");
+                        self.unparse_expr(value, precedence::EXPR);
                     }
                 })
             }
@@ -290,18 +283,18 @@ impl SourceGenerator {
                 ..
             } => {
                 statement!({
-                    self.p("for ")?;
-                    self.unparse_expr(target, precedence::TEST)?;
-                    self.p(" in ")?;
-                    self.unparse_expr(iter, precedence::TEST)?;
-                    self.p(":")?;
+                    self.p("for ");
+                    self.unparse_expr(target, precedence::TEST);
+                    self.p(" in ");
+                    self.unparse_expr(iter, precedence::TEST);
+                    self.p(":");
                 });
-                self.body(body)?;
+                self.body(body);
                 if !orelse.is_empty() {
                     statement!({
-                        self.p("else:")?;
+                        self.p("else:");
                     });
-                    self.body(orelse)?;
+                    self.body(orelse);
                 }
             }
             StmtKind::AsyncFor {
@@ -312,60 +305,60 @@ impl SourceGenerator {
                 ..
             } => {
                 statement!({
-                    self.p("async for ")?;
-                    self.unparse_expr(target, precedence::TEST)?;
-                    self.p(" in ")?;
-                    self.unparse_expr(iter, precedence::TEST)?;
-                    self.p(":")?;
+                    self.p("async for ");
+                    self.unparse_expr(target, precedence::TEST);
+                    self.p(" in ");
+                    self.unparse_expr(iter, precedence::TEST);
+                    self.p(":");
                 });
-                self.body(body)?;
+                self.body(body);
                 if !orelse.is_empty() {
                     statement!({
-                        self.p("else:")?;
+                        self.p("else:");
                     });
-                    self.body(orelse)?;
+                    self.body(orelse);
                 }
             }
             StmtKind::While { test, body, orelse } => {
                 statement!({
-                    self.p("while ")?;
-                    self.unparse_expr(test, precedence::TEST)?;
-                    self.p(":")?;
+                    self.p("while ");
+                    self.unparse_expr(test, precedence::TEST);
+                    self.p(":");
                 });
-                self.body(body)?;
+                self.body(body);
                 if !orelse.is_empty() {
                     statement!({
-                        self.p("else:")?;
+                        self.p("else:");
                     });
-                    self.body(orelse)?;
+                    self.body(orelse);
                 }
             }
             StmtKind::If { test, body, orelse } => {
                 statement!({
-                    self.p("if ")?;
-                    self.unparse_expr(test, precedence::TEST)?;
-                    self.p(":")?;
+                    self.p("if ");
+                    self.unparse_expr(test, precedence::TEST);
+                    self.p(":");
                 });
-                self.body(body)?;
+                self.body(body);
 
                 let mut orelse_: &Vec<Stmt<U>> = orelse;
                 loop {
                     if orelse_.len() == 1 && matches!(orelse_[0].node, StmtKind::If { .. }) {
                         if let StmtKind::If { body, test, orelse } = &orelse_[0].node {
                             statement!({
-                                self.p("elif ")?;
-                                self.unparse_expr(test, precedence::TEST)?;
-                                self.p(":")?;
+                                self.p("elif ");
+                                self.unparse_expr(test, precedence::TEST);
+                                self.p(":");
                             });
-                            self.body(body)?;
+                            self.body(body);
                             orelse_ = orelse;
                         }
                     } else {
                         if !orelse_.is_empty() {
                             statement!({
-                                self.p("else:")?;
+                                self.p("else:");
                             });
-                            self.body(orelse_)?;
+                            self.body(orelse_);
                         }
                         break;
                     }
@@ -373,39 +366,39 @@ impl SourceGenerator {
             }
             StmtKind::With { items, body, .. } => {
                 statement!({
-                    self.p("with ")?;
+                    self.p("with ");
                     let mut first = true;
                     for item in items {
-                        self.p_delim(&mut first, ", ")?;
-                        self.unparse_withitem(item)?;
+                        self.p_delim(&mut first, ", ");
+                        self.unparse_withitem(item);
                     }
-                    self.p(":")?;
+                    self.p(":");
                 });
-                self.body(body)?;
+                self.body(body);
             }
             StmtKind::AsyncWith { items, body, .. } => {
                 statement!({
-                    self.p("async with ")?;
+                    self.p("async with ");
                     let mut first = true;
                     for item in items {
-                        self.p_delim(&mut first, ", ")?;
-                        self.unparse_withitem(item)?;
+                        self.p_delim(&mut first, ", ");
+                        self.unparse_withitem(item);
                     }
-                    self.p(":")?;
+                    self.p(":");
                 });
-                self.body(body)?;
+                self.body(body);
             }
             StmtKind::Match { .. } => {}
             StmtKind::Raise { exc, cause } => {
                 statement!({
-                    self.p("raise")?;
+                    self.p("raise");
                     if let Some(exc) = exc {
-                        self.p(" ")?;
-                        self.unparse_expr(exc, precedence::EXPR)?;
+                        self.p(" ");
+                        self.unparse_expr(exc, precedence::EXPR);
                     }
                     if let Some(cause) = cause {
-                        self.p(" from ")?;
-                        self.unparse_expr(cause, precedence::EXPR)?;
+                        self.p(" from ");
+                        self.unparse_expr(cause, precedence::EXPR);
                     }
                 });
             }
@@ -416,46 +409,46 @@ impl SourceGenerator {
                 finalbody,
             } => {
                 statement!({
-                    self.p("try:")?;
+                    self.p("try:");
                 });
-                self.body(body)?;
+                self.body(body);
 
                 for handler in handlers {
                     statement!({
-                        self.unparse_excepthandler(handler)?;
+                        self.unparse_excepthandler(handler);
                     });
                 }
 
                 if !orelse.is_empty() {
                     statement!({
-                        self.p("else:")?;
+                        self.p("else:");
                     });
-                    self.body(orelse)?;
+                    self.body(orelse);
                 }
                 if !finalbody.is_empty() {
                     statement!({
-                        self.p("finally:")?;
+                        self.p("finally:");
                     });
-                    self.body(finalbody)?;
+                    self.body(finalbody);
                 }
             }
             StmtKind::Assert { test, msg } => {
                 statement!({
-                    self.p("assert ")?;
-                    self.unparse_expr(test, precedence::TEST)?;
+                    self.p("assert ");
+                    self.unparse_expr(test, precedence::TEST);
                     if let Some(msg) = msg {
-                        self.p(", ")?;
-                        self.unparse_expr(msg, precedence::TEST)?;
+                        self.p(", ");
+                        self.unparse_expr(msg, precedence::TEST);
                     }
                 })
             }
             StmtKind::Import { names } => {
                 statement!({
-                    self.p("import ")?;
+                    self.p("import ");
                     let mut first = true;
                     for alias in names {
-                        self.p_delim(&mut first, ", ")?;
-                        self.unparse_alias(alias)?;
+                        self.p_delim(&mut first, ", ");
+                        self.unparse_alias(alias);
                     }
                 });
             }
@@ -465,85 +458,83 @@ impl SourceGenerator {
                 level,
             } => {
                 statement!({
-                    self.p("from ")?;
+                    self.p("from ");
                     if let Some(level) = level {
-                        self.p(&".".repeat(*level))?;
+                        self.p(&".".repeat(*level));
                     }
                     if let Some(module) = module {
-                        self.p(module)?;
+                        self.p(module);
                     }
-                    self.p(" import ")?;
+                    self.p(" import ");
                     let mut first = true;
                     for alias in names {
-                        self.p_delim(&mut first, ", ")?;
-                        self.unparse_alias(alias)?;
+                        self.p_delim(&mut first, ", ");
+                        self.unparse_alias(alias);
                     }
                 })
             }
             StmtKind::Global { names } => {
                 statement!({
-                    self.p("global ")?;
+                    self.p("global ");
                     let mut first = true;
                     for name in names {
-                        self.p_delim(&mut first, ", ")?;
-                        self.p(name)?;
+                        self.p_delim(&mut first, ", ");
+                        self.p(name);
                     }
                 });
             }
             StmtKind::Nonlocal { names } => {
                 statement!({
-                    self.p("nonlocal ")?;
+                    self.p("nonlocal ");
                     let mut first = true;
                     for name in names {
-                        self.p_delim(&mut first, ", ")?;
-                        self.p(name)?;
+                        self.p_delim(&mut first, ", ");
+                        self.p(name);
                     }
                 });
             }
             StmtKind::Expr { value } => {
                 statement!({
-                    self.unparse_expr(value, 0)?;
+                    self.unparse_expr(value, 0);
                 });
             }
             StmtKind::Pass => {
                 statement!({
-                    self.p("pass")?;
+                    self.p("pass");
                 });
             }
             StmtKind::Break => {
                 statement!({
-                    self.p("break")?;
+                    self.p("break");
                 });
             }
             StmtKind::Continue => {
                 statement!({
-                    self.p("continue")?;
+                    self.p("continue");
                 });
             }
         }
-        Ok(())
     }
 
-    fn unparse_excepthandler<U>(&mut self, ast: &Excepthandler<U>) -> fmt::Result {
+    fn unparse_excepthandler<U>(&mut self, ast: &Excepthandler<U>) {
         match &ast.node {
             ExcepthandlerKind::ExceptHandler { type_, name, body } => {
-                self.p("except")?;
+                self.p("except");
                 if let Some(type_) = type_ {
-                    self.p(" ")?;
-                    self.unparse_expr(type_, precedence::EXPR)?;
+                    self.p(" ");
+                    self.unparse_expr(type_, precedence::EXPR);
                 }
                 if let Some(name) = name {
-                    self.p(" as ")?;
-                    self.p(name)?;
+                    self.p(" as ");
+                    self.p(name);
                 }
-                self.p(":")?;
-                self.body(body)?;
+                self.p(":");
+                self.body(body);
             }
         }
-        Ok(())
     }
 
-    pub fn unparse_expr<U>(&mut self, ast: &Expr<U>, level: u8) -> fmt::Result {
+    pub fn unparse_expr<U>(&mut self, ast: &Expr<U>, level: u8) {
         macro_rules! opprec {
             ($opty:ident, $x:expr, $enu:path, $($var:ident($op:literal, $prec:ident)),*$(,)?) => {
                 match $x {
@@ -560,9 +551,9 @@ impl SourceGenerator {
         macro_rules! group_if {
             ($lvl:expr, $body:block) => {{
                 let group = level > $lvl;
-                self.p_if(group, "(")?;
+                self.p_if(group, "(");
                 let ret = $body;
-                self.p_if(group, ")")?;
+                self.p_if(group, ")");
                 ret
             }};
         }
@@ -572,16 +563,16 @@ impl SourceGenerator {
                 group_if!(prec, {
                     let mut first = true;
                     for val in values {
-                        self.p_delim(&mut first, op)?;
-                        self.unparse_expr(val, prec + 1)?;
+                        self.p_delim(&mut first, op);
+                        self.unparse_expr(val, prec + 1);
                     }
                 })
             }
             ExprKind::NamedExpr { target, value } => {
                 group_if!(precedence::TUPLE, {
-                    self.unparse_expr(target, precedence::ATOM)?;
-                    self.p(" := ")?;
-                    self.unparse_expr(value, precedence::ATOM)?;
+                    self.unparse_expr(target, precedence::ATOM);
+                    self.p(" := ");
+                    self.unparse_expr(value, precedence::ATOM);
                 })
             }
             ExprKind::BinOp { left, op, right } => {
@@ -605,9 +596,9 @@ impl SourceGenerator {
                     FloorDiv("//", TERM),
                 );
                 group_if!(prec, {
-                    self.unparse_expr(left, prec + u8::from(rassoc))?;
-                    self.p(op)?;
-                    self.unparse_expr(right, prec + u8::from(!rassoc))?;
+                    self.unparse_expr(left, prec + u8::from(rassoc));
+                    self.p(op);
+                    self.unparse_expr(right, prec + u8::from(!rassoc));
                 })
             }
             ExprKind::UnaryOp { op, operand } => {
@@ -621,99 +612,99 @@ impl SourceGenerator {
                     USub("-", FACTOR)
                 );
                 group_if!(prec, {
-                    self.p(op)?;
-                    self.unparse_expr(operand, prec)?;
+                    self.p(op);
+                    self.unparse_expr(operand, prec);
                 })
             }
             ExprKind::Lambda { args, body } => {
                 group_if!(precedence::TEST, {
                     let npos = args.args.len() + args.posonlyargs.len();
-                    self.p(if npos > 0 { "lambda " } else { "lambda" })?;
-                    self.unparse_args(args)?;
-                    write!(self, ": {}", **body)?;
+                    self.p(if npos > 0 { "lambda " } else { "lambda" });
+                    self.unparse_args(args);
+                    write!(self, ": {}", **body);
                 })
             }
             ExprKind::IfExp { test, body, orelse } => {
                 group_if!(precedence::TEST, {
-                    self.unparse_expr(body, precedence::TEST + 1)?;
-                    self.p(" if ")?;
-                    self.unparse_expr(test, precedence::TEST + 1)?;
-                    self.p(" else ")?;
-                    self.unparse_expr(orelse, precedence::TEST)?;
+                    self.unparse_expr(body, precedence::TEST + 1);
+                    self.p(" if ");
+                    self.unparse_expr(test, precedence::TEST + 1);
+                    self.p(" else ");
+                    self.unparse_expr(orelse, precedence::TEST);
                 })
             }
             ExprKind::Dict { keys, values } => {
-                self.p("{")?;
+                self.p("{");
                 let mut first = true;
                 let (packed, unpacked) = values.split_at(keys.len());
                 for (k, v) in keys.iter().zip(packed) {
-                    self.p_delim(&mut first, ", ")?;
-                    write!(self, "{}: {}", *k, *v)?;
+                    self.p_delim(&mut first, ", ");
+                    write!(self, "{}: {}", *k, *v);
                 }
                 for d in unpacked {
-                    self.p_delim(&mut first, ", ")?;
-                    write!(self, "**{}", *d)?;
+                    self.p_delim(&mut first, ", ");
+                    write!(self, "**{}", *d);
                 }
-                self.p("}")?;
+                self.p("}");
             }
             ExprKind::Set { elts } => {
                 if elts.is_empty() {
-                    self.p("set()")?;
+                    self.p("set()");
                 } else {
-                    self.p("{")?;
+                    self.p("{");
                     let mut first = true;
                     for v in elts {
-                        self.p_delim(&mut first, ", ")?;
-                        self.unparse_expr(v, precedence::TEST)?;
+                        self.p_delim(&mut first, ", ");
+                        self.unparse_expr(v, precedence::TEST);
                     }
-                    self.p("}")?;
+                    self.p("}");
                 }
             }
             ExprKind::ListComp { elt, generators } => {
-                self.p("[")?;
-                self.unparse_expr(elt, precedence::TEST)?;
-                self.unparse_comp(generators)?;
-                self.p("]")?;
+                self.p("[");
+                self.unparse_expr(elt, precedence::TEST);
+                self.unparse_comp(generators);
+                self.p("]");
             }
             ExprKind::SetComp { elt, generators } => {
-                self.p("{")?;
-                self.unparse_expr(elt, precedence::TEST)?;
-                self.unparse_comp(generators)?;
-                self.p("}")?;
+                self.p("{");
+                self.unparse_expr(elt, precedence::TEST);
+                self.unparse_comp(generators);
+                self.p("}");
             }
             ExprKind::DictComp {
                 key,
                 value,
                 generators,
             } => {
-                self.p("{")?;
-                self.unparse_expr(key, precedence::TEST)?;
-                self.p(": ")?;
-                self.unparse_expr(value, precedence::TEST)?;
-                self.unparse_comp(generators)?;
-                self.p("}")?;
+                self.p("{");
+                self.unparse_expr(key, precedence::TEST);
+                self.p(": ");
+                self.unparse_expr(value, precedence::TEST);
+                self.unparse_comp(generators);
+                self.p("}");
             }
             ExprKind::GeneratorExp { elt, generators } => {
-                self.p("(")?;
-                self.unparse_expr(elt, precedence::TEST)?;
-                self.unparse_comp(generators)?;
-                self.p(")")?;
+                self.p("(");
+                self.unparse_expr(elt, precedence::TEST);
+                self.unparse_comp(generators);
+                self.p(")");
             }
             ExprKind::Await { value } => {
                 group_if!(precedence::AWAIT, {
-                    self.p("await ")?;
-                    self.unparse_expr(value, precedence::ATOM)?;
+                    self.p("await ");
+                    self.unparse_expr(value, precedence::ATOM);
                 })
             }
             ExprKind::Yield { value } => {
                 if let Some(value) = value {
-                    write!(self, "(yield {})", **value)?;
+                    write!(self, "(yield {})", **value);
                 } else {
-                    self.p("(yield)")?;
+                    self.p("(yield)");
                 }
             }
             ExprKind::YieldFrom { value } => {
-                write!(self, "(yield from {})", **value)?;
+                write!(self, "(yield from {})", **value);
             }
             ExprKind::Compare {
                 left,
@@ -722,7 +713,7 @@ impl SourceGenerator {
             } => {
                 group_if!(precedence::CMP, {
                     let new_lvl = precedence::CMP + 1;
-                    self.unparse_expr(left, new_lvl)?;
+                    self.unparse_expr(left, new_lvl);
                     for (op, cmp) in ops.iter().zip(comparators) {
                         let op = match op {
                             Cmpop::Eq => " == ",
@@ -736,8 +727,8 @@ impl SourceGenerator {
                             Cmpop::In => " in ",
                             Cmpop::NotIn => " not in ",
                         };
-                        self.p(op)?;
-                        self.unparse_expr(cmp, new_lvl)?;
+                        self.p(op);
+                        self.unparse_expr(cmp, new_lvl);
                     }
                 })
             }
@@ -746,8 +737,8 @@ impl SourceGenerator {
                 args,
                 keywords,
             } => {
-                self.unparse_expr(func, precedence::ATOM)?;
-                self.p("(")?;
+                self.unparse_expr(func, precedence::ATOM);
+                self.p("(");
                 if let (
                     [Expr {
                         node: ExprKind::GeneratorExp { elt, generators },
@@ -757,51 +748,51 @@ impl SourceGenerator {
                 ) = (&**args, &**keywords)
                 {
                     // make sure a single genexp doesn't get double parens
-                    self.unparse_expr(elt, precedence::TEST)?;
-                    self.unparse_comp(generators)?;
+                    self.unparse_expr(elt, precedence::TEST);
+                    self.unparse_comp(generators);
                 } else {
                     let mut first = true;
                     for arg in args {
-                        self.p_delim(&mut first, ", ")?;
-                        self.unparse_expr(arg, precedence::TEST)?;
+                        self.p_delim(&mut first, ", ");
+                        self.unparse_expr(arg, precedence::TEST);
                     }
                     for kw in keywords {
-                        self.p_delim(&mut first, ", ")?;
+                        self.p_delim(&mut first, ", ");
                         if let Some(arg) = &kw.node.arg {
-                            self.p(arg)?;
-                            self.p("=")?;
+                            self.p(arg);
+                            self.p("=");
                         } else {
-                            self.p("**")?;
+                            self.p("**");
                         }
-                        self.unparse_expr(&kw.node.value, precedence::TEST)?;
+                        self.unparse_expr(&kw.node.value, precedence::TEST);
                     }
                 }
-                self.p(")")?;
+                self.p(")");
             }
             ExprKind::FormattedValue {
                 value,
                 conversion,
                 format_spec,
-            } => self.unparse_formatted(value, *conversion, format_spec.as_deref())?,
-            ExprKind::JoinedStr { values } => self.unparse_joinedstr(values, false)?,
+            } => self.unparse_formatted(value, *conversion, format_spec.as_deref()),
+            ExprKind::JoinedStr { values } => self.unparse_joinedstr(values, false),
             ExprKind::Constant { value, kind } => {
                 if let Some(kind) = kind {
-                    self.p(kind)?;
+                    self.p(kind);
                 }
                 assert_eq!(f64::MAX_10_EXP, 308);
                 let inf_str = "1e309";
                 match value {
-                    Constant::Float(f) if f.is_infinite() => self.p(inf_str)?,
+                    Constant::Float(f) if f.is_infinite() => self.p(inf_str),
                     Constant::Complex { real, imag }
                         if real.is_infinite() || imag.is_infinite() =>
                     {
-                        self.p(&value.to_string().replace("inf", inf_str))?
+                        self.p(&value.to_string().replace("inf", inf_str));
                     }
-                    _ => self.p(&format!("{value}"))?,
+                    _ => self.p(&format!("{value}")),
                 }
             }
             ExprKind::Attribute { value, attr, .. } => {
-                self.unparse_expr(value, precedence::ATOM)?;
+                self.unparse_expr(value, precedence::ATOM);
                 let period = if let ExprKind::Constant {
                     value: Constant::Int(_),
                     ..
@@ -811,11 +802,11 @@ impl SourceGenerator {
                 } else {
                     "."
                 };
-                self.p(period)?;
-                self.p(attr)?;
+                self.p(period);
+                self.p(attr);
             }
             ExprKind::Subscript { value, slice, .. } => {
-                self.unparse_expr(value, precedence::ATOM)?;
+                self.unparse_expr(value, precedence::ATOM);
                 let mut lvl = precedence::TUPLE;
                 if let ExprKind::Tuple { elts, .. } = &slice.node {
                     if elts
@@ -825,161 +816,149 @@ impl SourceGenerator {
                         lvl += 1
                     }
                 }
-                self.p("[")?;
-                self.unparse_expr(slice, lvl)?;
-                self.p("]")?;
+                self.p("[");
+                self.unparse_expr(slice, lvl);
+                self.p("]");
             }
             ExprKind::Starred { value, .. } => {
-                self.p("*")?;
-                self.unparse_expr(value, precedence::EXPR)?;
+                self.p("*");
+                self.unparse_expr(value, precedence::EXPR);
             }
-            ExprKind::Name { id, .. } => self.p(id)?,
+            ExprKind::Name { id, .. } => self.p(id),
             ExprKind::List { elts, .. } => {
-                self.p("[")?;
+                self.p("[");
                 let mut first = true;
                 for elt in elts {
-                    self.p_delim(&mut first, ", ")?;
-                    self.unparse_expr(elt, precedence::TEST)?;
+                    self.p_delim(&mut first, ", ");
+                    self.unparse_expr(elt, precedence::TEST);
                 }
-                self.p("]")?;
+                self.p("]");
             }
             ExprKind::Tuple { elts, .. } => {
                 if elts.is_empty() {
-                    self.p("()")?;
+                    self.p("()");
                 } else {
                     group_if!(precedence::TUPLE, {
                         let mut first = true;
                         for elt in elts {
-                            self.p_delim(&mut first, ", ")?;
-                            self.unparse_expr(elt, precedence::TEST)?;
+                            self.p_delim(&mut first, ", ");
+                            self.unparse_expr(elt, precedence::TEST);
                         }
-                        self.p_if(elts.len() == 1, ",")?;
+                        self.p_if(elts.len() == 1, ",");
                     })
                 }
             }
             ExprKind::Slice { lower, upper, step } => {
                 if let Some(lower) = lower {
-                    self.unparse_expr(lower, precedence::TEST)?;
+                    self.unparse_expr(lower, precedence::TEST);
                 }
-                self.p(":")?;
+                self.p(":");
                 if let Some(upper) = upper {
-                    self.unparse_expr(upper, precedence::TEST)?;
+                    self.unparse_expr(upper, precedence::TEST);
                 }
                 if let Some(step) = step {
-                    self.p(":")?;
-                    self.unparse_expr(step, precedence::TEST)?;
+                    self.p(":");
+                    self.unparse_expr(step, precedence::TEST);
                 }
             }
         }
-        Ok(())
     }
 
-    fn unparse_args<U>(&mut self, args: &Arguments<U>) -> fmt::Result {
+    fn unparse_args<U>(&mut self, args: &Arguments<U>) {
         let mut first = true;
         let defaults_start = args.posonlyargs.len() + args.args.len() - args.defaults.len();
         for (i, arg) in args.posonlyargs.iter().chain(&args.args).enumerate() {
-            self.p_delim(&mut first, ", ")?;
-            self.unparse_arg(arg)?;
+            self.p_delim(&mut first, ", ");
+            self.unparse_arg(arg);
             if let Some(i) = i.checked_sub(defaults_start) {
-                write!(self, "={}", &args.defaults[i])?;
+                write!(self, "={}", &args.defaults[i]);
             }
-            self.p_if(i + 1 == args.posonlyargs.len(), ", /")?;
+            self.p_if(i + 1 == args.posonlyargs.len(), ", /");
         }
         if args.vararg.is_some() || !args.kwonlyargs.is_empty() {
-            self.p_delim(&mut first, ", ")?;
-            self.p("*")?;
+            self.p_delim(&mut first, ", ");
+            self.p("*");
         }
         if let Some(vararg) = &args.vararg {
-            self.unparse_arg(vararg)?;
+            self.unparse_arg(vararg);
         }
         let defaults_start = args.kwonlyargs.len() - args.kw_defaults.len();
         for (i, kwarg) in args.kwonlyargs.iter().enumerate() {
-            self.p_delim(&mut first, ", ")?;
-            self.unparse_arg(kwarg)?;
+            self.p_delim(&mut first, ", ");
+            self.unparse_arg(kwarg);
             if let Some(default) = i
                 .checked_sub(defaults_start)
                 .and_then(|i| args.kw_defaults.get(i))
             {
-                write!(self, "={default}")?;
+                write!(self, "={default}");
             }
         }
         if let Some(kwarg) = &args.kwarg {
-            self.p_delim(&mut first, ", ")?;
-            self.p("**")?;
-            self.unparse_arg(kwarg)?;
+            self.p_delim(&mut first, ", ");
+            self.p("**");
+            self.unparse_arg(kwarg);
         }
-        Ok(())
     }
 
-    fn unparse_arg<U>(&mut self, arg: &Arg<U>) -> fmt::Result {
-        self.p(&arg.node.arg)?;
+    fn unparse_arg<U>(&mut self, arg: &Arg<U>) {
+        self.p(&arg.node.arg);
         if let Some(ann) = &arg.node.annotation {
-            write!(self, ": {}", **ann)?;
+            write!(self, ": {}", **ann);
         }
-        Ok(())
     }
 
-    fn unparse_comp<U>(&mut self, generators: &[Comprehension<U>]) -> fmt::Result {
+    fn unparse_comp<U>(&mut self, generators: &[Comprehension<U>]) {
         for comp in generators {
             self.p(if comp.is_async > 0 {
                 " async for "
             } else {
                 " for "
-            })?;
-            self.unparse_expr(&comp.target, precedence::TUPLE)?;
-            self.p(" in ")?;
-            self.unparse_expr(&comp.iter, precedence::TEST + 1)?;
+            });
+            self.unparse_expr(&comp.target, precedence::TUPLE);
+            self.p(" in ");
+            self.unparse_expr(&comp.iter, precedence::TEST + 1);
             for cond in &comp.ifs {
-                self.p(" if ")?;
-                self.unparse_expr(cond, precedence::TEST + 1)?;
+                self.p(" if ");
+                self.unparse_expr(cond, precedence::TEST + 1);
             }
         }
-        Ok(())
     }
 
-    fn unparse_fstring_body<U>(&mut self, values: &[Expr<U>], is_spec: bool) -> fmt::Result {
+    fn unparse_fstring_body<U>(&mut self, values: &[Expr<U>], is_spec: bool) {
         for value in values {
-            self.unparse_fstring_elem(value, is_spec)?;
+            self.unparse_fstring_elem(value, is_spec);
         }
-        Ok(())
     }
 
-    fn unparse_formatted<U>(
-        &mut self,
-        val: &Expr<U>,
-        conversion: usize,
-        spec: Option<&Expr<U>>,
-    ) -> fmt::Result {
+    fn unparse_formatted<U>(&mut self, val: &Expr<U>, conversion: usize, spec: Option<&Expr<U>>) {
         let mut generator = SourceGenerator::default();
-        generator.unparse_expr(val, precedence::TEST + 1)?;
+        generator.unparse_expr(val, precedence::TEST + 1);
         let brace = if generator.buffer.starts_with("{".as_bytes()) {
             // put a space to avoid escaping the bracket
             "{ "
         } else {
             "{"
         };
-        self.p(brace)?;
+        self.p(brace);
         self.buffer.extend(generator.buffer);
 
         if conversion != ConversionFlag::None as usize {
-            self.p("!")?;
+            self.p("!");
             #[allow(clippy::cast_possible_truncation)]
             let buf = &[conversion as u8];
             let c = std::str::from_utf8(buf).unwrap();
-            self.p(c)?;
+            self.p(c);
         }
 
         if let Some(spec) = spec {
-            self.p(":")?;
-            self.unparse_fstring_elem(spec, true)?;
+            self.p(":");
+            self.unparse_fstring_elem(spec, true);
         }
 
-        self.p("}")?;
-
-        Ok(())
+        self.p("}");
     }
 
-    fn unparse_fstring_elem<U>(&mut self, expr: &Expr<U>, is_spec: bool) -> fmt::Result {
+    fn unparse_fstring_elem<U>(&mut self, expr: &Expr<U>, is_spec: bool) {
         match &expr.node {
             ExprKind::Constant { value, .. } => {
                 if let Constant::Str(s) = value {
@@ -998,39 +977,36 @@ impl SourceGenerator {
         }
     }
 
-    fn unparse_fstring_str(&mut self, s: &str) -> fmt::Result {
+    fn unparse_fstring_str(&mut self, s: &str) {
         let s = s.replace('{', "{{").replace('}', "}}");
-        self.p(&s)
+        self.p(&s);
     }
 
-    fn unparse_joinedstr<U>(&mut self, values: &[Expr<U>], is_spec: bool) -> fmt::Result {
+    fn unparse_joinedstr<U>(&mut self, values: &[Expr<U>], is_spec: bool) {
         if is_spec {
-            self.unparse_fstring_body(values, is_spec)?;
+            self.unparse_fstring_body(values, is_spec);
         } else {
-            self.p("f")?;
+            self.p("f");
             let mut generator = SourceGenerator::default();
-            generator.unparse_fstring_body(values, is_spec)?;
+            generator.unparse_fstring_body(values, is_spec);
             let body = std::str::from_utf8(&generator.buffer).unwrap();
-            self.p(&format!("{}", str::repr(body)))?;
+            self.p(&format!("{}", str::repr(body)));
         }
-        Ok(())
     }
 
-    fn unparse_alias<U>(&mut self, alias: &Alias<U>) -> fmt::Result {
-        self.p(&alias.node.name)?;
+    fn unparse_alias<U>(&mut self, alias: &Alias<U>) {
+        self.p(&alias.node.name);
         if let Some(asname) = &alias.node.asname {
-            self.p(" as ")?;
-            self.p(asname)?;
+            self.p(" as ");
+            self.p(asname);
         }
-        Ok(())
     }
 
-    fn unparse_withitem<U>(&mut self, withitem: &Withitem<U>) -> fmt::Result {
-        self.unparse_expr(&withitem.context_expr, precedence::EXPR)?;
+    fn unparse_withitem<U>(&mut self, withitem: &Withitem<U>) {
+        self.unparse_expr(&withitem.context_expr, precedence::EXPR);
         if let Some(optional_vars) = &withitem.optional_vars {
-            self.p(" as ")?;
-            self.unparse_expr(optional_vars, precedence::EXPR)?;
+            self.p(" as ");
+            self.unparse_expr(optional_vars, precedence::EXPR);
         }
-        Ok(())
     }
 }
diff --git a/src/directives.rs b/src/directives.rs
index 38b797fbb5..6847eb898f 100644
--- a/src/directives.rs
+++ b/src/directives.rs
@@ -121,7 +121,7 @@ mod tests {
     use crate::directives::extract_noqa_line_for;
 
     #[test]
-    fn extraction() -> Result<()> {
+    fn extraction() {
         let empty: IntMap<usize, usize> = IntMap::default();
 
         let lxr: Vec<LexResult> = lexer::make_tokenizer(
@@ -200,7 +200,5 @@ z = x + 1",
             extract_noqa_line_for(&lxr),
             IntMap::from_iter([(2, 5), (3, 5), (4, 5)])
         );
-
-        Ok(())
     }
 }
diff --git a/src/flake8_bugbear/plugins/assert_false.rs b/src/flake8_bugbear/plugins/assert_false.rs
index c6406f2a71..6d2c059b06 100644
--- a/src/flake8_bugbear/plugins/assert_false.rs
+++ b/src/flake8_bugbear/plugins/assert_false.rs
@@ -46,14 +46,13 @@ pub fn assert_false(checker: &mut Checker, stmt: &Stmt, test: &Expr, msg: Option
         let mut check = Check::new(CheckKind::DoNotAssertFalse, Range::from_located(test));
         if checker.patch(check.kind.code()) {
             let mut generator = SourceGenerator::new();
-            if let Ok(()) = generator.unparse_stmt(&assertion_error(msg)) {
-                if let Ok(content) = generator.generate() {
-                    check.amend(Fix::replacement(
-                        content,
-                        stmt.location,
-                        stmt.end_location.unwrap(),
-                    ));
-                }
+            generator.unparse_stmt(&assertion_error(msg));
+            if let Ok(content) = generator.generate() {
+                check.amend(Fix::replacement(
+                    content,
+                    stmt.location,
+                    stmt.end_location.unwrap(),
+                ));
             }
         }
         checker.add_check(check);
diff --git a/src/flake8_bugbear/plugins/duplicate_exceptions.rs b/src/flake8_bugbear/plugins/duplicate_exceptions.rs
index 37747295bc..9877f517f2 100644
--- a/src/flake8_bugbear/plugins/duplicate_exceptions.rs
+++ b/src/flake8_bugbear/plugins/duplicate_exceptions.rs
@@ -59,14 +59,13 @@ fn duplicate_handler_exceptions<'a>(
             if checker.patch(check.kind.code()) {
                 // TODO(charlie): If we have a single element, remove the tuple.
                 let mut generator = SourceGenerator::new();
-                if let Ok(()) = generator.unparse_expr(&type_pattern(unique_elts), 0) {
-                    if let Ok(content) = generator.generate() {
-                        check.amend(Fix::replacement(
-                            content,
-                            expr.location,
-                            expr.end_location.unwrap(),
-                        ))
-                    }
+                generator.unparse_expr(&type_pattern(unique_elts), 0);
+                if let Ok(content) = generator.generate() {
+                    check.amend(Fix::replacement(
+                        content,
+                        expr.location,
+                        expr.end_location.unwrap(),
+                    ))
                 }
             }
             checker.add_check(check);
diff --git a/src/flake8_bugbear/plugins/getattr_with_constant.rs b/src/flake8_bugbear/plugins/getattr_with_constant.rs
index d5754ddd0b..7700046c14 100644
--- a/src/flake8_bugbear/plugins/getattr_with_constant.rs
+++ b/src/flake8_bugbear/plugins/getattr_with_constant.rs
@@ -35,14 +35,13 @@ pub fn getattr_with_constant(checker: &mut Checker, expr: &Expr, func: &Expr, ar
                             Check::new(CheckKind::GetAttrWithConstant, Range::from_located(expr));
                         if checker.patch(check.kind.code()) {
                             let mut generator = SourceGenerator::new();
-                            if let Ok(()) = generator.unparse_expr(&attribute(obj, value), 0) {
-                                if let Ok(content) = generator.generate() {
-                                    check.amend(Fix::replacement(
-                                        content,
-                                        expr.location,
-                                        expr.end_location.unwrap(),
-                                    ));
-                                }
+                            generator.unparse_expr(&attribute(obj, value), 0);
+                            if let Ok(content) = generator.generate() {
+                                check.amend(Fix::replacement(
+                                    content,
+                                    expr.location,
+                                    expr.end_location.unwrap(),
+                                ));
                             }
                         }
                         checker.add_check(check);
diff --git a/src/flake8_bugbear/plugins/redundant_tuple_in_exception_handler.rs b/src/flake8_bugbear/plugins/redundant_tuple_in_exception_handler.rs
index f2c944d0dd..5105169bac 100644
--- a/src/flake8_bugbear/plugins/redundant_tuple_in_exception_handler.rs
+++ b/src/flake8_bugbear/plugins/redundant_tuple_in_exception_handler.rs
@@ -64,18 +64,17 @@ pub fn redundant_tuple_in_exception_handler(checker: &mut Checker, handlers: &[E
                     );
                     if checker.patch(check.kind.code()) {
                         let mut generator = SourceGenerator::new();
-                        if let Ok(()) = generator.unparse_expr(elt, 0) {
-                            if let Ok(content) = generator.generate() {
-                                match match_tuple_range(handler, checker.locator) {
-                                    Ok(range) => {
-                                        check.amend(Fix::replacement(
-                                            content,
-                                            range.location,
-                                            range.end_location,
-                                        ));
-                                    }
-                                    Err(e) => error!("Failed to locate parentheses: {}", e),
+                        generator.unparse_expr(elt, 0);
+                        if let Ok(content) = generator.generate() {
+                            match match_tuple_range(handler, checker.locator) {
+                                Ok(range) => {
+                                    check.amend(Fix::replacement(
+                                        content,
+                                        range.location,
+                                        range.end_location,
+                                    ));
                                 }
+                                Err(e) => error!("Failed to locate parentheses: {}", e),
                             }
                         }
                     }
diff --git a/src/flake8_bugbear/plugins/setattr_with_constant.rs b/src/flake8_bugbear/plugins/setattr_with_constant.rs
index c3f1292b51..24226368bc 100644
--- a/src/flake8_bugbear/plugins/setattr_with_constant.rs
+++ b/src/flake8_bugbear/plugins/setattr_with_constant.rs
@@ -1,3 +1,5 @@
+use anyhow::Result;
+use log::error;
 use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Location, Stmt, StmtKind};
 
 use crate::ast::types::Range;
@@ -8,7 +10,7 @@ use crate::code_gen::SourceGenerator;
 use crate::python::identifiers::IDENTIFIER_REGEX;
 use crate::python::keyword::KWLIST;
 
-fn assignment(obj: &Expr, name: &str, value: &Expr) -> Option<String> {
+fn assignment(obj: &Expr, name: &str, value: &Expr) -> Result<String> {
     let stmt = Stmt::new(
         Location::default(),
         Location::default(),
@@ -27,10 +29,8 @@ fn assignment(obj: &Expr, name: &str, value: &Expr) -> Option<String> {
         },
     );
     let mut generator = SourceGenerator::new();
-    match generator.unparse_stmt(&stmt) {
-        Ok(()) => generator.generate().ok(),
-        Err(_) => None,
-    }
+    generator.unparse_stmt(&stmt);
+    generator.generate().map_err(|e| e.into())
 }
 
 /// B010
@@ -47,13 +47,14 @@ pub fn setattr_with_constant(checker: &mut Checker, expr: &Expr, func: &Expr, ar
                         let mut check =
                             Check::new(CheckKind::SetAttrWithConstant, Range::from_located(expr));
                         if checker.patch(check.kind.code()) {
-                            if let Some(content) = assignment(obj, name, value) {
-                                check.amend(Fix::replacement(
+                            match assignment(obj, name, value) {
+                                Ok(content) => check.amend(Fix::replacement(
                                     content,
                                     expr.location,
                                     expr.end_location.unwrap(),
-                                ));
-                            }
+                                )),
+                                Err(e) => error!("Failed to fix invalid comparison: {}", e),
+                            };
                         }
                         checker.add_check(check);
                     }
diff --git a/src/linter.rs b/src/linter.rs
index db4175bcf5..268b379732 100644
--- a/src/linter.rs
+++ b/src/linter.rs
@@ -259,7 +259,7 @@ pub fn autoformat_path(path: &Path) -> Result<()> {
     // Generate the AST.
     let python_ast = rustpython_helpers::parse_program_tokens(tokens, "<filename>")?;
     let mut generator = SourceGenerator::default();
-    generator.unparse_suite(&python_ast)?;
+    generator.unparse_suite(&python_ast);
     write(path, generator.generate()?)?;
 
     Ok(())
diff --git a/src/main.rs b/src/main.rs
index 39458d66b4..dbac2bed81 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -79,12 +79,7 @@ fn run_once_stdin(settings: &Settings, filename: &Path, autofix: bool) -> Result
     Ok(diagnostics)
 }
 
-fn run_once(
-    files: &[PathBuf],
-    settings: &Settings,
-    cache: bool,
-    autofix: bool,
-) -> Result<Diagnostics> {
+fn run_once(files: &[PathBuf], settings: &Settings, cache: bool, autofix: bool) -> Diagnostics {
     // Collect all the files to check.
     let start = Instant::now();
     let paths: Vec<Result<DirEntry, walkdir::Error>> = files
@@ -138,10 +133,10 @@ fn run_once(
     let duration = start.elapsed();
     debug!("Checked files in: {:?}", duration);
 
-    Ok(diagnostics)
+    diagnostics
 }
 
-fn add_noqa(files: &[PathBuf], settings: &Settings) -> Result<usize> {
+fn add_noqa(files: &[PathBuf], settings: &Settings) -> usize {
     // Collect all the files to check.
     let start = Instant::now();
     let paths: Vec<Result<DirEntry, walkdir::Error>> = files
@@ -166,10 +161,10 @@ fn add_noqa(files: &[PathBuf], settings: &Settings) -> Result<usize> {
     let duration = start.elapsed();
     debug!("Added noqa to files in: {:?}", duration);
 
-    Ok(modifications)
+    modifications
 }
 
-fn autoformat(files: &[PathBuf], settings: &Settings) -> Result<usize> {
+fn autoformat(files: &[PathBuf], settings: &Settings) -> usize {
     // Collect all the files to format.
     let start = Instant::now();
     let paths: Vec<DirEntry> = files
@@ -192,7 +187,7 @@ fn autoformat(files: &[PathBuf], settings: &Settings) -> Result<usize> {
     let duration = start.elapsed();
     debug!("Auto-formatted files in: {:?}", duration);
 
-    Ok(modifications)
+    modifications
 }
 
 fn inner_main() -> Result<ExitCode> {
@@ -325,7 +320,7 @@ fn inner_main() -> Result<ExitCode> {
         printer.clear_screen()?;
         printer.write_to_user("Starting linter in watch mode...\n");
 
-        let messages = run_once(&cli.files, &settings, cache_enabled, false)?;
+        let messages = run_once(&cli.files, &settings, cache_enabled, false);
         printer.write_continuously(&messages)?;
 
         // Configure the file watcher.
@@ -343,7 +338,7 @@ fn inner_main() -> Result<ExitCode> {
                             printer.clear_screen()?;
                             printer.write_to_user("File change detected...\n");
 
-                            let messages = run_once(&cli.files, &settings, cache_enabled, false)?;
+                            let messages = run_once(&cli.files, &settings, cache_enabled, false);
                             printer.write_continuously(&messages)?;
                         }
                     }
@@ -352,12 +347,12 @@ fn inner_main() -> Result<ExitCode> {
             }
         }
     } else if cli.add_noqa {
-        let modifications = add_noqa(&cli.files, &settings)?;
+        let modifications = add_noqa(&cli.files, &settings);
         if modifications > 0 && log_level >= LogLevel::Default {
             println!("Added {modifications} noqa directives.");
         }
     } else if cli.autoformat {
-        let modifications = autoformat(&cli.files, &settings)?;
+        let modifications = autoformat(&cli.files, &settings);
         if modifications > 0 && log_level >= LogLevel::Default {
             println!("Formatted {modifications} files.");
         }
@@ -370,7 +365,7 @@ fn inner_main() -> Result<ExitCode> {
             let path = Path::new(&filename);
             run_once_stdin(&settings, path, fix_enabled)?
         } else {
-            run_once(&cli.files, &settings, cache_enabled, fix_enabled)?
+            run_once(&cli.files, &settings, cache_enabled, fix_enabled)
         };
 
         // Always try to print violations (the printer itself may suppress output),
diff --git a/src/noqa.rs b/src/noqa.rs
index d04036d10b..dc7cf6a7fd 100644
--- a/src/noqa.rs
+++ b/src/noqa.rs
@@ -57,7 +57,7 @@ pub fn add_noqa(
     noqa_line_for: &IntMap<usize, usize>,
     path: &Path,
 ) -> Result<usize> {
-    let (count, output) = add_noqa_inner(checks, contents, noqa_line_for)?;
+    let (count, output) = add_noqa_inner(checks, contents, noqa_line_for);
     fs::write(path, output)?;
     Ok(count)
 }
@@ -66,7 +66,7 @@ fn add_noqa_inner(
     checks: &[Check],
     contents: &str,
     noqa_line_for: &IntMap<usize, usize>,
-) -> Result<(usize, String)> {
+) -> (usize, String) {
     let lines: Vec<&str> = contents.lines().collect();
     let mut matches_by_line: BTreeMap<usize, BTreeSet<&CheckCode>> = BTreeMap::new();
     for lineno in 0..lines.len() {
@@ -115,7 +115,7 @@ fn add_noqa_inner(
         }
     }
 
-    Ok((count, output))
+    (count, output)
 }
 
 #[cfg(test)]
@@ -143,11 +143,11 @@ mod tests {
     }
 
     #[test]
-    fn modification() -> Result<()> {
+    fn modification() {
         let checks = vec![];
         let contents = "x = 1";
         let noqa_line_for = IntMap::default();
-        let (count, output) = add_noqa_inner(&checks, contents, &noqa_line_for)?;
+        let (count, output) = add_noqa_inner(&checks, contents, &noqa_line_for);
         assert_eq!(count, 0);
         assert_eq!(output.trim(), contents.trim());
 
@@ -160,7 +160,7 @@ mod tests {
         )];
         let contents = "x = 1";
         let noqa_line_for = IntMap::default();
-        let (count, output) = add_noqa_inner(&checks, contents, &noqa_line_for)?;
+        let (count, output) = add_noqa_inner(&checks, contents, &noqa_line_for);
         assert_eq!(count, 1);
         assert_eq!(output.trim(), "x = 1  # noqa: F841".trim());
 
@@ -182,7 +182,7 @@ mod tests {
         ];
         let contents = "x = 1  # noqa: E741";
         let noqa_line_for = IntMap::default();
-        let (count, output) = add_noqa_inner(&checks, contents, &noqa_line_for)?;
+        let (count, output) = add_noqa_inner(&checks, contents, &noqa_line_for);
         assert_eq!(count, 1);
         assert_eq!(output.trim(), "x = 1  # noqa: E741, F841".trim());
 
@@ -204,10 +204,8 @@ mod tests {
         ];
         let contents = "x = 1  # noqa";
         let noqa_line_for = IntMap::default();
-        let (count, output) = add_noqa_inner(&checks, contents, &noqa_line_for)?;
+        let (count, output) = add_noqa_inner(&checks, contents, &noqa_line_for);
         assert_eq!(count, 1);
         assert_eq!(output.trim(), "x = 1  # noqa: E741, F841".trim());
-
-        Ok(())
     }
 }
diff --git a/src/pycodestyle/plugins.rs b/src/pycodestyle/plugins.rs
index 70cee99e82..3bdfeaf6d3 100644
--- a/src/pycodestyle/plugins.rs
+++ b/src/pycodestyle/plugins.rs
@@ -24,10 +24,9 @@ fn compare(left: &Expr, ops: &[Cmpop], comparators: &[Expr]) -> Option<String> {
         },
     );
     let mut generator = SourceGenerator::new();
-    if let Ok(()) = generator.unparse_expr(&cmp, 0) {
-        if let Ok(content) = generator.generate() {
-            return Some(content);
-        }
+    generator.unparse_expr(&cmp, 0);
+    if let Ok(content) = generator.generate() {
+        return Some(content);
     }
     None
 }
@@ -287,7 +286,7 @@ fn function(name: &str, args: &Arguments, body: &Expr) -> Result<String> {
         },
     );
     let mut generator = SourceGenerator::new();
-    generator.unparse_stmt(&func)?;
+    generator.unparse_stmt(&func);
     Ok(generator.generate()?)
 }
 
diff --git a/src/pyupgrade/plugins/convert_named_tuple_functional_to_class.rs b/src/pyupgrade/plugins/convert_named_tuple_functional_to_class.rs
index b4459a5b3e..3fd5c6477d 100644
--- a/src/pyupgrade/plugins/convert_named_tuple_functional_to_class.rs
+++ b/src/pyupgrade/plugins/convert_named_tuple_functional_to_class.rs
@@ -172,7 +172,7 @@ fn convert_to_class(
     base_class: &ExprKind,
 ) -> Result<Fix> {
     let mut generator = SourceGenerator::new();
-    generator.unparse_stmt(&create_class_def_stmt(typename, body, base_class))?;
+    generator.unparse_stmt(&create_class_def_stmt(typename, body, base_class));
     let content = generator.generate()?;
     Ok(Fix::replacement(
         content,
diff --git a/src/pyupgrade/plugins/convert_typed_dict_functional_to_class.rs b/src/pyupgrade/plugins/convert_typed_dict_functional_to_class.rs
index c1de08e3ed..19b34b3724 100644
--- a/src/pyupgrade/plugins/convert_typed_dict_functional_to_class.rs
+++ b/src/pyupgrade/plugins/convert_typed_dict_functional_to_class.rs
@@ -209,7 +209,7 @@ fn convert_to_class(
         body,
         total_keyword,
         base_class,
-    ))?;
+    ));
     let content = generator.generate()?;
     Ok(Fix::replacement(
         content,
diff --git a/src/pyupgrade/plugins/use_pep604_annotation.rs b/src/pyupgrade/plugins/use_pep604_annotation.rs
index 0e367a9564..0ac82e40e0 100644
--- a/src/pyupgrade/plugins/use_pep604_annotation.rs
+++ b/src/pyupgrade/plugins/use_pep604_annotation.rs
@@ -66,14 +66,13 @@ pub fn use_pep604_annotation(checker: &mut Checker, expr: &Expr, value: &Expr, s
         let mut check = Check::new(CheckKind::UsePEP604Annotation, Range::from_located(expr));
         if checker.patch(check.kind.code()) {
             let mut generator = SourceGenerator::new();
-            if let Ok(()) = generator.unparse_expr(&optional(slice), 0) {
-                if let Ok(content) = generator.generate() {
-                    check.amend(Fix::replacement(
-                        content,
-                        expr.location,
-                        expr.end_location.unwrap(),
-                    ))
-                }
+            generator.unparse_expr(&optional(slice), 0);
+            if let Ok(content) = generator.generate() {
+                check.amend(Fix::replacement(
+                    content,
+                    expr.location,
+                    expr.end_location.unwrap(),
+                ))
             }
         }
         checker.add_check(check);
@@ -86,27 +85,25 @@ pub fn use_pep604_annotation(checker: &mut Checker, expr: &Expr, value: &Expr, s
                 }
                 ExprKind::Tuple { elts, .. } => {
                     let mut generator = SourceGenerator::new();
-                    if let Ok(()) = generator.unparse_expr(&union(elts), 0) {
-                        if let Ok(content) = generator.generate() {
-                            check.amend(Fix::replacement(
-                                content,
-                                expr.location,
-                                expr.end_location.unwrap(),
-                            ))
-                        }
+                    generator.unparse_expr(&union(elts), 0);
+                    if let Ok(content) = generator.generate() {
+                        check.amend(Fix::replacement(
+                            content,
+                            expr.location,
+                            expr.end_location.unwrap(),
+                        ))
                     }
                 }
                 _ => {
                     // Single argument.
                     let mut generator = SourceGenerator::new();
-                    if let Ok(()) = generator.unparse_expr(slice, 0) {
-                        if let Ok(content) = generator.generate() {
-                            check.amend(Fix::replacement(
-                                content,
-                                expr.location,
-                                expr.end_location.unwrap(),
-                            ));
-                        }
+                    generator.unparse_expr(slice, 0);
+                    if let Ok(content) = generator.generate() {
+                        check.amend(Fix::replacement(
+                            content,
+                            expr.location,
+                            expr.end_location.unwrap(),
+                        ));
                     }
                 }
             }