fix clippy

Signed-off-by: Ashwin Naren <arihant2math@gmail.com>

Author: arihant2math

compiler/codegen/src/compile.rs

@@ -41,8 +41,8 @@ use rustpython_compiler_core::{
 };
 use rustpython_compiler_source::SourceCode;
 // use rustpython_parser_core::source_code::{LineNumber, SourceLocation};
-use std::borrow::Cow;
 use crate::error::InternalError;
+use std::borrow::Cow;
 
 pub(crate) type InternalResult<T> = Result<T, InternalError>;
 type CompileResult<T> = Result<T, CodegenError>;
@@ -213,27 +213,38 @@ macro_rules! emit {
 }
 
 fn eprint_location(zelf: &Compiler<'_>) {
-    let start = zelf.source_code.source_location(zelf.current_source_range.start());
-    let end = zelf.source_code.source_location(zelf.current_source_range.end());
-    eprintln!("LOCATION: {} from {}:{} to {}:{}", zelf.source_code.path.to_owned(), start.row, start.column, end.row, end.column);
+    let start = zelf
+        .source_code
+        .source_location(zelf.current_source_range.start());
+    let end = zelf
+        .source_code
+        .source_location(zelf.current_source_range.end());
+    eprintln!(
+        "LOCATION: {} from {}:{} to {}:{}",
+        zelf.source_code.path.to_owned(),
+        start.row,
+        start.column,
+        end.row,
+        end.column
+    );
 }
 
 /// Better traceback for internal error
 fn unwrap_internal<T>(zelf: &Compiler<'_>, r: InternalResult<T>) -> T {
     if let Err(ref r_err) = r {
         eprintln!("=== CODEGEN PANIC INFO ===");
         eprintln!("This IS an internal error: {}", r_err);
-        print_location(zelf);
+        eprint_location(zelf);
         eprintln!("=== END PANIC INFO ===");
     }
     r.unwrap()
 }
 
 fn compiler_unwrap_option<T>(zelf: &Compiler<'_>, o: Option<T>) -> T {
-    if let None = o {
+    if o.is_none() {
         eprintln!("=== CODEGEN PANIC INFO ===");
         eprintln!("This IS an internal error, an option was unwrapped during codegen");
-        print_location(zelf);
+        eprint_location(zelf);
         eprintln!("=== END PANIC INFO ===");
     }
     o.unwrap()
@@ -243,7 +254,7 @@ fn compiler_unwrap_option<T>(zelf: &Compiler<'_>, o: Option<T>) -> T {
 //     if result.is_err() {
 //         eprintln!("=== CODEGEN PANIC INFO ===");
 //         eprintln!("This IS an internal error, an result was unwrapped during codegen");
-//         print_location(zelf);
+//         eprint_location(zelf);
 //         eprintln!("=== END PANIC INFO ===");
 //     }
 //     result.unwrap()
@@ -579,9 +590,12 @@ impl Compiler<'_> {
         self.check_forbidden_name(&name, usage)?;
 
         let symbol_table = self.symbol_table_stack.last().unwrap();
-        let symbol = unwrap_internal(self, symbol_table.lookup(name.as_ref()).ok_or_else(||
-            InternalError::MissingSymbol(name.to_string())
-        ));
+        let symbol = unwrap_internal(
+            self,
+            symbol_table
+                .lookup(name.as_ref())
+                .ok_or_else(|| InternalError::MissingSymbol(name.to_string())),
+        );
         let info = self.code_stack.last_mut().unwrap();
         let mut cache = &mut info.name_cache;
         enum NameOpType {
@@ -1515,9 +1529,12 @@ impl Compiler<'_> {
         }
         for var in &*code.freevars {
             let table = self.symbol_table_stack.last().unwrap();
-            let symbol = unwrap_internal(self, table.lookup(var).ok_or_else(|| {
-                InternalError::MissingSymbol(var.to_owned())
-            }));
+            let symbol = unwrap_internal(
+                self,
+                table
+                    .lookup(var)
+                    .ok_or_else(|| InternalError::MissingSymbol(var.to_owned())),
+            );
             let parent_code = self.code_stack.last().unwrap();
             let vars = match symbol.scope {
                 SymbolScope::Free => &parent_code.freevar_cache,
@@ -1600,7 +1617,12 @@ impl Compiler<'_> {
 
         // Check if the class is declared global
         let symbol_table = self.symbol_table_stack.last().unwrap();
-        let symbol = unwrap_internal(self, symbol_table.lookup(name.as_ref()).ok_or_else(|| InternalError::MissingSymbol(name.to_owned())));
+        let symbol = unwrap_internal(
+            self,
+            symbol_table
+                .lookup(name.as_ref())
+                .ok_or_else(|| InternalError::MissingSymbol(name.to_owned())),
+        );
         let mut global_path_prefix = Vec::new();
         if symbol.scope == SymbolScope::GlobalExplicit {
             global_path_prefix.append(&mut self.qualified_path);

compiler/codegen/src/error.rs

@@ -47,7 +47,10 @@ impl Display for InternalError {
         match self {
             Self::StackOverflow => write!(f, "stack overflow"),
             Self::StackUnderflow => write!(f, "stack underflow"),
-            Self::MissingSymbol(s) => write!(f, "The symbol '{s}' must be present in the symbol table, even when it is undefined in python.")
+            Self::MissingSymbol(s) => write!(
+                f,
+                "The symbol '{s}' must be present in the symbol table, even when it is undefined in python."
+            ),
         }
     }
 }

compiler/codegen/src/ir.rs

@@ -1,11 +1,11 @@
 use std::ops;
 
 use crate::IndexSet;
+use crate::error::InternalError;
 use ruff_source_file::{OneIndexed, SourceLocation};
 use rustpython_compiler_core::bytecode::{
     CodeFlags, CodeObject, CodeUnit, ConstantData, InstrDisplayContext, Instruction, Label, OpArg,
 };
-use crate::error::InternalError;
 // use rustpython_parser_core::source_code::{LineNumber, SourceLocation};
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
@@ -245,10 +245,7 @@ impl CodeInfo {
                     let instr_display = instr.display(display_arg, self);
                     eprint!("{instr_display}: {depth} {effect:+} => ");
                 }
-                if effect < 0 && depth < effect.unsigned_abs() {
-                    panic!("The stack will underflow at {depth} with {effect} effect on {instr:?}");
-                }
-                let new_depth = depth.checked_add_signed(effect).ok_or_else(|| {
+                let new_depth = depth.checked_add_signed(effect).ok_or({
                     if effect < 0 {
                         InternalError::StackUnderflow
                     } else {
@@ -271,7 +268,7 @@ impl CodeInfo {
                     )
                 {
                     let effect = instr.stack_effect(ins.arg, true);
-                    let target_depth = depth.checked_add_signed(effect).ok_or_else(|| {
+                    let target_depth = depth.checked_add_signed(effect).ok_or({
                         if effect < 0 {
                             InternalError::StackUnderflow
                         } else {