clean up imports and useless allow attributes

Author: youknowone

benches/execution.rs

@@ -4,8 +4,7 @@ use criterion::{
 };
 use rustpython_compiler::Mode;
 use rustpython_parser::parser::parse_program;
-use rustpython_vm::Interpreter;
-use rustpython_vm::PyResult;
+use rustpython_vm::{Interpreter, PyResult};
 use std::collections::HashMap;
 use std::path::Path;
 

benches/microbenchmarks.rs

@@ -1,13 +1,15 @@
-use criterion::measurement::WallTime;
 use criterion::{
-    criterion_group, criterion_main, BatchSize, BenchmarkGroup, BenchmarkId, Criterion, Throughput,
+    criterion_group, criterion_main, measurement::WallTime, BatchSize, BenchmarkGroup, BenchmarkId,
+    Criterion, Throughput,
 };
 use rustpython_compiler::Mode;
 use rustpython_vm::{
     common::ascii, InitParameter, Interpreter, PyObjectWrap, PyResult, PySettings,
 };
-use std::path::{Path, PathBuf};
-use std::{ffi, fs, io};
+use std::{
+    ffi, fs, io,
+    path::{Path, PathBuf},
+};
 
 pub struct MicroBenchmark {
     name: String,

bytecode/src/lib.rs

@@ -10,8 +10,7 @@ use itertools::Itertools;
 use num_bigint::BigInt;
 use num_complex::Complex64;
 use serde::{Deserialize, Serialize};
-use std::collections::BTreeSet;
-use std::{fmt, hash};
+use std::{collections::BTreeSet, fmt, hash};
 
 /// Sourcecode location.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]

common/src/boxvec.rs

@@ -1,9 +1,13 @@
 //! An unresizable vector backed by a `Box<[T]>`
 
-use std::borrow::{Borrow, BorrowMut};
-use std::mem::{self, MaybeUninit};
-use std::ops::{Bound, Deref, DerefMut, RangeBounds};
-use std::{alloc, cmp, fmt, ptr, slice};
+use std::{
+    alloc,
+    borrow::{Borrow, BorrowMut},
+    cmp, fmt,
+    mem::{self, MaybeUninit},
+    ops::{Bound, Deref, DerefMut, RangeBounds},
+    ptr, slice,
+};
 
 pub struct BoxVec<T> {
     xs: Box<[MaybeUninit<T>]>,
@@ -501,9 +505,7 @@ impl<T> Drop for Drain<'_, T> {
     fn drop(&mut self) {
         // len is currently 0 so panicking while dropping will not cause a double drop.
 
-        // exhaust self first, clippy warning here is seemingly a fluke.
-        #[allow(clippy::while_let_on_iterator)]
-        while let Some(_) = self.next() {}
+        for _ in self.by_ref() {}
 
         if self.tail_len > 0 {
             unsafe {

common/src/hash.rs

@@ -2,8 +2,10 @@ use num_bigint::BigInt;
 use num_complex::Complex64;
 use num_traits::ToPrimitive;
 use siphasher::sip::SipHasher24;
-use std::hash::{BuildHasher, Hash, Hasher};
-use std::num::Wrapping;
+use std::{
+    hash::{BuildHasher, Hash, Hasher},
+    num::Wrapping,
+};
 
 pub type PyHash = i64;
 pub type PyUHash = u64;

common/src/lock/cell_lock.rs

@@ -2,8 +2,7 @@ use lock_api::{
     GetThreadId, RawMutex, RawRwLock, RawRwLockDowngrade, RawRwLockRecursive, RawRwLockUpgrade,
     RawRwLockUpgradeDowngrade,
 };
-use std::cell::Cell;
-use std::num::NonZeroUsize;
+use std::{cell::Cell, num::NonZeroUsize};
 
 pub struct RawCellMutex {
     locked: Cell<bool>,

common/src/lock/immutable_mutex.rs

@@ -1,8 +1,5 @@
-use std::fmt;
-use std::marker::PhantomData;
-use std::ops::Deref;
-
 use lock_api::{MutexGuard, RawMutex};
+use std::{fmt, marker::PhantomData, ops::Deref};
 
 /// A mutex guard that has an exclusive lock, but only an immutable reference; useful if you
 /// need to map a mutex guard with a function that returns an `&T`. Construct using the

common/src/lock/thread_mutex.rs

@@ -1,11 +1,12 @@
-use std::cell::UnsafeCell;
-use std::fmt;
-use std::marker::PhantomData;
-use std::ops::{Deref, DerefMut};
-use std::ptr::NonNull;
-use std::sync::atomic::{AtomicUsize, Ordering};
-
 use lock_api::{GetThreadId, GuardNoSend, RawMutex};
+use std::{
+    cell::UnsafeCell,
+    fmt,
+    marker::PhantomData,
+    ops::{Deref, DerefMut},
+    ptr::NonNull,
+    sync::atomic::{AtomicUsize, Ordering},
+};
 
 // based off ReentrantMutex from lock_api
 

common/src/str.rs

@@ -1,7 +1,9 @@
 use ascii::AsciiString;
 use once_cell::unsync::OnceCell;
-use std::fmt;
-use std::ops::{Bound, RangeBounds};
+use std::{
+    fmt,
+    ops::{Bound, RangeBounds},
+};
 
 #[cfg(not(target_arch = "wasm32"))]
 #[allow(non_camel_case_types)]
@@ -99,8 +101,7 @@ pub const fn bytes_is_ascii(x: &str) -> bool {
 }
 
 pub mod levenshtein {
-    use std::cell::RefCell;
-    use std::thread_local;
+    use std::{cell::RefCell, thread_local};
 
     pub const MOVE_COST: usize = 2;
     const CASE_COST: usize = 1;

compiler/src/compile.rs

@@ -88,7 +88,6 @@ struct CompileContext {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
-#[allow(clippy::enum_variant_names)]
 enum FunctionContext {
     NoFunction,
     Function,

compiler/src/error.rs

@@ -1,7 +1,6 @@
 use rustpython_ast::Location;
 
-use std::error::Error;
-use std::fmt;
+use std::{error::Error, fmt};
 
 #[derive(Debug)]
 pub struct CompileError {

compiler/src/symboltable.rs

@@ -7,11 +7,12 @@ load and store instructions for names.
 Inspirational file: https://github.com/python/cpython/blob/main/Python/symtable.c
 */
 
-use crate::error::{CompileError, CompileErrorType};
-use crate::IndexMap;
+use crate::{
+    error::{CompileError, CompileErrorType},
+    IndexMap,
+};
 use rustpython_ast::{self as ast, Location};
-use std::borrow::Cow;
-use std::fmt;
+use std::{borrow::Cow, fmt};
 
 pub fn make_symbol_table(program: &[ast::Stmt]) -> SymbolTableResult<SymbolTable> {
     let mut builder = SymbolTableBuilder::new();

jit/src/lib.rs

@@ -1,16 +1,11 @@
-#![allow(clippy::unnecessary_wraps)]
-use std::fmt;
+mod instructions;
 
 use cranelift::prelude::*;
 use cranelift_jit::{JITBuilder, JITModule};
 use cranelift_module::{FuncId, Linkage, Module, ModuleError};
-
-use rustpython_bytecode as bytecode;
-
-mod instructions;
-
 use instructions::FunctionCompiler;
-use std::mem::ManuallyDrop;
+use rustpython_bytecode as bytecode;
+use std::{fmt, mem::ManuallyDrop};
 
 #[derive(Debug, thiserror::Error)]
 #[non_exhaustive]
@@ -292,7 +287,6 @@ impl UnTypedAbiValue {
 
 // we don't actually ever touch CompiledCode til we drop it, it should be safe.
 // TODO: confirm with wasmtime ppl that it's not unsound?
-#[allow(clippy::non_send_fields_in_send_ty)]
 unsafe impl Send for CompiledCode {}
 unsafe impl Sync for CompiledCode {}
 

parser/src/fstring.rs

@@ -1,12 +1,10 @@
-use std::iter;
-use std::mem;
-use std::str;
-
-use crate::ast::{Constant, ConversionFlag, Expr, ExprKind, Location};
-use crate::error::{FStringError, FStringErrorType, ParseError};
-use crate::parser::parse_expression;
-
 use self::FStringErrorType::*;
+use crate::{
+    ast::{Constant, ConversionFlag, Expr, ExprKind, Location},
+    error::{FStringError, FStringErrorType, ParseError},
+    parser::parse_expression,
+};
+use std::{iter, mem, str};
 
 struct FStringParser<'a> {
     chars: iter::Peekable<str::Chars<'a>>,

src/lib.rs

@@ -35,7 +35,7 @@
 //!
 //! The binary will have all the standard arguments of a python interpreter (including a REPL!) but
 //! it will have your modules loaded into the vm.
-#![allow(clippy::needless_doctest_main, clippy::unnecessary_wraps)]
+#![allow(clippy::needless_doctest_main)]
 
 #[macro_use]
 extern crate clap;

src/shell/helper.rs

@@ -55,7 +55,6 @@ impl<'vm> ShellHelper<'vm> {
         ShellHelper { vm, globals }
     }
 
-    #[allow(clippy::type_complexity)]
     fn get_available_completions<'w>(
         &self,
         words: &'w [String],

stdlib/src/array.rs

@@ -49,7 +49,6 @@ mod array {
                 $($n(Vec<$t>),)*
             }
 
-            #[allow(clippy::naive_bytecount, clippy::float_cmp)]
             impl ArrayContentType {
                 fn from_char(c: char) -> Result<Self, String> {
                     match c {

stdlib/src/binascii.rs

@@ -111,7 +111,7 @@ mod decl {
 
     #[pyfunction]
     fn b2a_base64(data: ArgBytesLike, NewlineArg { newline }: NewlineArg) -> Vec<u8> {
-        #[allow(clippy::redundant_closure)] // https://stackoverflow.com/questions/63916821
+        // https://stackoverflow.com/questions/63916821
         let mut encoded = data.with_ref(|b| base64::encode(b)).into_bytes();
         if newline {
             encoded.push(b'\n');

stdlib/src/math.rs

@@ -72,7 +72,6 @@ mod math {
         abs_tol: OptionalArg<ArgIntoFloat>,
     }
 
-    #[allow(clippy::float_cmp)]
     #[pyfunction]
     fn isclose(args: IsCloseArgs, vm: &VirtualMachine) -> PyResult<bool> {
         let a = args.a.to_f64();
@@ -628,7 +627,6 @@ mod math {
                 // digit to two instead of down to zero (the 1e-16 makes the 1
                 // slightly closer to two).  With a potential 1 ULP rounding
                 // error fixed-up, math.fsum() can guarantee commutativity.
-                #[allow(clippy::float_cmp)]
                 if y == x - hi {
                     hi = x;
                 }

stdlib/src/socket.rs

@@ -24,12 +24,12 @@ mod _socket {
     use crossbeam_utils::atomic::AtomicCell;
     use num_traits::ToPrimitive;
     use socket2::{Domain, Protocol, Socket, Type as SocketType};
-    use std::mem::MaybeUninit;
-    use std::net::{self, Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr, ToSocketAddrs};
-    use std::time::{Duration, Instant};
     use std::{
         ffi,
         io::{self, Read, Write},
+        mem::MaybeUninit,
+        net::{self, Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr, ToSocketAddrs},
+        time::{Duration, Instant},
     };
 
     #[cfg(unix)]

vm/build.rs

@@ -1,8 +1,5 @@
 use itertools::Itertools;
-use std::env;
-use std::io::prelude::*;
-use std::path::PathBuf;
-use std::process::Command;
+use std::{env, io::prelude::*, path::PathBuf, process::Command};
 
 fn main() {
     println!("cargo:rustc-env=RUSTPYTHON_GIT_HASH={}", git_hash());

vm/src/builtins/bytes.rs

@@ -25,8 +25,7 @@ use crate::{
     VirtualMachine,
 };
 use bstr::ByteSlice;
-use std::ops::Deref;
-use std::{borrow::Cow, mem::size_of};
+use std::{borrow::Cow, mem::size_of, ops::Deref};
 
 #[pyclass(module = false, name = "bytes")]
 #[derive(Clone, Debug)]

vm/src/builtins/code.rs

@@ -10,8 +10,7 @@ use crate::{
     StaticType, TypeProtocol, VirtualMachine,
 };
 use num_traits::Zero;
-use std::fmt;
-use std::ops::Deref;
+use std::{fmt, ops::Deref};
 
 #[derive(Clone)]
 pub struct PyConstant(pub PyObjectRef);

vm/src/builtins/dict.rs

@@ -19,7 +19,6 @@ use crate::{
     PyObjectView, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol,
 };
 use rustpython_common::lock::PyMutex;
-use std::mem::size_of;
 use std::{borrow::Cow, fmt};
 
 pub type DictContentType = dictdatatype::Dict;
@@ -221,7 +220,7 @@ impl PyDict {
 
     #[pymethod(magic)]
     fn sizeof(&self) -> usize {
-        size_of::<Self>() + self.entries.sizeof()
+        std::mem::size_of::<Self>() + self.entries.sizeof()
     }
 
     #[pymethod(magic)]
@@ -679,7 +678,6 @@ where
         self.dict().len()
     }
 
-    #[allow(clippy::redundant_closure_call)]
     #[pymethod(magic)]
     fn repr(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<String> {
         let s = if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {

vm/src/builtins/int.rs

@@ -14,7 +14,6 @@ use num_bigint::{BigInt, BigUint, Sign};
 use num_integer::Integer;
 use num_traits::{One, Pow, PrimInt, Signed, ToPrimitive, Zero};
 use std::fmt;
-use std::mem::size_of;
 
 /// int(x=0) -> integer
 /// int(x, base=10) -> integer
@@ -583,7 +582,7 @@ impl PyInt {
 
     #[pymethod(magic)]
     fn sizeof(&self) -> usize {
-        size_of::<Self>() + (((self.value.bits() + 7) & !7) / 8) as usize
+        std::mem::size_of::<Self>() + (((self.value.bits() + 7) & !7) / 8) as usize
     }
 
     #[pymethod]

vm/src/builtins/list.rs

@@ -17,10 +17,7 @@ use crate::{
     PyClassImpl, PyComparisonValue, PyContext, PyObject, PyObjectRef, PyObjectView, PyObjectWrap,
     PyRef, PyResult, PyValue, TypeProtocol,
 };
-use std::borrow::Cow;
-use std::fmt;
-use std::mem::size_of;
-use std::ops::DerefMut;
+use std::{borrow::Cow, fmt, ops::DerefMut};
 
 /// Built-in mutable sequence.
 ///
@@ -176,7 +173,8 @@ impl PyList {
 
     #[pymethod(magic)]
     fn sizeof(&self) -> usize {
-        size_of::<Self>() + self.elements.read().capacity() * size_of::<PyObjectRef>()
+        std::mem::size_of::<Self>()
+            + self.elements.read().capacity() * std::mem::size_of::<PyObjectRef>()
     }
 
     #[pymethod]