Merge pull request RustPython#4223 from youknowone/nightly-clippy

youknowone · web-flow · commit 6d140fb0e7e9 · 2022-10-17T13:28:53.000+09:00
Fix nightly clippy warnings
diff --git a/benches/microbenchmarks.rs b/benches/microbenchmarks.rs
@@ -115,7 +115,7 @@ fn bench_rustpy_code(group: &mut BenchmarkGroup<WallTime>, bench: &MicroBenchmar
     settings.no_user_site = true;
 
     Interpreter::with_init(settings, |vm| {
-        for (name, init) in rustpython_stdlib::get_module_inits().into_iter() {
+        for (name, init) in rustpython_stdlib::get_module_inits() {
             vm.add_native_module(name, init);
         }
     })
diff --git a/compiler/codegen/src/compile.rs b/compiler/codegen/src/compile.rs
@@ -342,7 +342,7 @@ impl Compiler {
             self.emit(Instruction::StoreGlobal(doc))
         }
 
-        if self.find_ann(statements) {
+        if Self::find_ann(statements) {
             self.emit(Instruction::SetupAnnotation);
         }
 
@@ -1229,22 +1229,22 @@ impl Compiler {
     }
 
     // Python/compile.c find_ann
-    fn find_ann(&self, body: &[ast::Stmt]) -> bool {
+    fn find_ann(body: &[ast::Stmt]) -> bool {
         use ast::StmtKind::*;
 
         for statement in body {
             let res = match &statement.node {
                 AnnAssign { .. } => true,
-                For { body, orelse, .. } => self.find_ann(body) || self.find_ann(orelse),
-                If { body, orelse, .. } => self.find_ann(body) || self.find_ann(orelse),
-                While { body, orelse, .. } => self.find_ann(body) || self.find_ann(orelse),
-                With { body, .. } => self.find_ann(body),
+                For { body, orelse, .. } => Self::find_ann(body) || Self::find_ann(orelse),
+                If { body, orelse, .. } => Self::find_ann(body) || Self::find_ann(orelse),
+                While { body, orelse, .. } => Self::find_ann(body) || Self::find_ann(orelse),
+                With { body, .. } => Self::find_ann(body),
                 Try {
                     body,
                     orelse,
                     finalbody,
                     ..
-                } => self.find_ann(body) || self.find_ann(orelse) || self.find_ann(finalbody),
+                } => Self::find_ann(body) || Self::find_ann(orelse) || Self::find_ann(finalbody),
                 _ => false,
             };
             if res {
@@ -1295,7 +1295,7 @@ impl Compiler {
         let doc = self.name("__doc__");
         self.emit(Instruction::StoreLocal(doc));
         // setup annotations
-        if self.find_ann(body) {
+        if Self::find_ann(body) {
             self.emit(Instruction::SetupAnnotation);
         }
         self.compile_statements(body)?;
diff --git a/compiler/core/src/bytecode.rs b/compiler/core/src/bytecode.rs
@@ -996,20 +996,8 @@ impl Instruction {
             | SetupFinally { .. }
             | EnterFinally
             | EndFinally => 0,
-            SetupExcept { .. } => {
-                if jump {
-                    1
-                } else {
-                    0
-                }
-            }
-            SetupWith { .. } => {
-                if jump {
-                    0
-                } else {
-                    1
-                }
-            }
+            SetupExcept { .. } => jump as i32,
+            SetupWith { .. } => (!jump) as i32,
             WithCleanupStart => 0,
             WithCleanupFinish => -1,
             PopBlock => 0,
diff --git a/derive/src/pyclass.rs b/derive/src/pyclass.rs
@@ -782,12 +782,12 @@ impl ToTokens for GetSetNursery {
             .iter()
             .map(|((name, cfgs), (getter, setter, deleter))| {
                 let setter = match setter {
-                    Some(setter) => quote_spanned! { setter.span() => .with_set(&Self::#setter)},
+                    Some(setter) => quote_spanned! { setter.span() => .with_set(Self::#setter)},
                     None => quote! {},
                 };
                 let deleter = match deleter {
                     Some(deleter) => {
-                        quote_spanned! { deleter.span() => .with_delete(&Self::#deleter)}
+                        quote_spanned! { deleter.span() => .with_delete(Self::#deleter)}
                     }
                     None => quote! {},
                 };
@@ -797,7 +797,7 @@ impl ToTokens for GetSetNursery {
                         #name,
                         ::rustpython_vm::PyRef::new_ref(
                             ::rustpython_vm::builtins::PyGetSet::new(#name.into(), class)
-                                .with_get(&Self::#getter)
+                                .with_get(Self::#getter)
                                 #setter #deleter,
                                 ctx.types.getset_type.to_owned(), None),
                         ctx
@@ -1372,12 +1372,12 @@ fn parse_vec_ident(
     Ok(attr
         .get(index)
         .ok_or_else(|| {
-            syn::Error::new_spanned(&item, format!("We require {} argument to be set", &message))
+            syn::Error::new_spanned(item, format!("We require {} argument to be set", &message))
         })?
         .get_ident()
         .ok_or_else(|| {
             syn::Error::new_spanned(
-                &item,
+                item,
                 format!("We require {} argument to be ident or string", &message),
             )
         })?
diff --git a/examples/generator.rs b/examples/generator.rs
@@ -10,7 +10,7 @@ fn py_main(interp: &Interpreter) -> vm::PyResult<()> {
     let generator = interp.enter(|vm| {
         let scope = vm.new_scope_with_builtins();
         let generator = vm.run_block_expr(
-            scope.clone(),
+            scope,
             r#"
 def gen():
     for i in range(10):
diff --git a/examples/package_embed.rs b/examples/package_embed.rs
@@ -19,9 +19,8 @@ fn main() -> ExitCode {
         vm.add_native_modules(rustpython_stdlib::get_module_inits());
     });
     let result = py_main(&interp);
-    let result = result.and_then(|result| {
+    let result = result.map(|result| {
         println!("name: {}", result);
-        Ok(())
     });
     ExitCode::from(interp.run(|_vm| result))
 }
diff --git a/examples/parse_folder.rs b/examples/parse_folder.rs
@@ -34,7 +34,7 @@ fn main() {
     if folder.exists() && folder.is_dir() {
         println!("Parsing folder of python code: {:?}", folder);
         let t1 = Instant::now();
-        let parsed_files = parse_folder(&folder).unwrap();
+        let parsed_files = parse_folder(folder).unwrap();
         let t2 = Instant::now();
         let results = ScanResult {
             t1,
@@ -83,7 +83,7 @@ fn parse_python_file(filename: &Path) -> ParsedFile {
             result: Err(e.to_string()),
         },
         Ok(source) => {
-            let num_lines = source.to_string().lines().count();
+            let num_lines = source.lines().count();
             let result = parser::parse_program(&source, &filename.to_string_lossy())
                 .map_err(|e| e.to_string());
             ParsedFile {
diff --git a/stdlib/src/mmap.rs b/stdlib/src/mmap.rs
@@ -755,10 +755,10 @@ mod mmap {
                 .map(|n| n as usize)
                 .unwrap_or(remaining);
 
-            let end_pos = (pos + num_bytes) as usize;
+            let end_pos = pos + num_bytes;
             let bytes = match mmap.deref().as_ref().unwrap() {
-                MmapObj::Read(mmap) => mmap[pos as usize..end_pos].to_vec(),
-                MmapObj::Write(mmap) => mmap[pos as usize..end_pos].to_vec(),
+                MmapObj::Read(mmap) => mmap[pos..end_pos].to_vec(),
+                MmapObj::Write(mmap) => mmap[pos..end_pos].to_vec(),
             };
 
             let result = PyBytes::from(bytes).into_ref(vm);
@@ -776,8 +776,8 @@ mod mmap {
             }
 
             let b = match self.check_valid(vm)?.deref().as_ref().unwrap() {
-                MmapObj::Read(mmap) => mmap[pos as usize],
-                MmapObj::Write(mmap) => mmap[pos as usize],
+                MmapObj::Read(mmap) => mmap[pos],
+                MmapObj::Write(mmap) => mmap[pos],
             };
 
             self.advance_pos(1);
@@ -809,8 +809,8 @@ mod mmap {
             };
 
             let bytes = match mmap.deref().as_ref().unwrap() {
-                MmapObj::Read(mmap) => mmap[pos as usize..end_pos].to_vec(),
-                MmapObj::Write(mmap) => mmap[pos as usize..end_pos].to_vec(),
+                MmapObj::Read(mmap) => mmap[pos..end_pos].to_vec(),
+                MmapObj::Write(mmap) => mmap[pos..end_pos].to_vec(),
             };
 
             let result = PyBytes::from(bytes).into_ref(vm);
@@ -895,7 +895,7 @@ mod mmap {
             }
 
             let len = self.try_writable(vm, |mmap| {
-                (&mut mmap[pos as usize..(pos as usize + data.len())])
+                (&mut mmap[pos..(pos + data.len())])
                     .write(&data)
                     .map_err(|e| vm.new_os_error(e.to_string()))?;
                 Ok(data.len())
@@ -918,7 +918,7 @@ mod mmap {
             }
 
             self.try_writable(vm, |mmap| {
-                mmap[pos as usize] = b;
+                mmap[pos] = b;
             })?;
 
             self.advance_pos(1);
@@ -932,8 +932,8 @@ mod mmap {
                 .ok_or_else(|| vm.new_index_error("mmap index out of range".to_owned()))?;
 
             let b = match self.check_valid(vm)?.deref().as_ref().unwrap() {
-                MmapObj::Read(mmap) => mmap[i as usize],
-                MmapObj::Write(mmap) => mmap[i as usize],
+                MmapObj::Read(mmap) => mmap[i],
+                MmapObj::Write(mmap) => mmap[i],
             };
 
             Ok(PyInt::from(b).into_ref(vm).into())
@@ -1009,14 +1009,14 @@ mod mmap {
             value: PyObjectRef,
             vm: &VirtualMachine,
         ) -> PyResult<()> {
-            let i = i
+            let i: usize = i
                 .wrapped_at(zelf.len())
                 .ok_or_else(|| vm.new_index_error("mmap index out of range".to_owned()))?;
 
             let b = value_from_object(vm, &value)?;
 
             zelf.try_writable(vm, |mmap| {
-                mmap[i as usize] = b;
+                mmap[i] = b;
             })?;
 
             Ok(())
diff --git a/stdlib/src/pystruct.rs b/stdlib/src/pystruct.rs
@@ -84,7 +84,7 @@ pub(crate) mod _struct {
                     bytes at offset {offset} (actual buffer size is {buffer_len})",
                     op = op,
                     op_action = op_action,
-                    required = needed + offset as usize,
+                    required = needed + offset,
                     needed = needed,
                     offset = offset,
                     buffer_len = buffer_len
diff --git a/stdlib/src/select.rs b/stdlib/src/select.rs
@@ -205,11 +205,11 @@ mod decl {
             return Ok((empty.clone(), empty.clone(), empty));
         }
 
-        let nfds = [&mut r, &mut w, &mut x]
+        let nfds: i32 = [&mut r, &mut w, &mut x]
             .iter_mut()
             .filter_map(|set| set.highest())
             .max()
-            .map_or(0, |n| n + 1) as i32;
+            .map_or(0, |n| n + 1) as _;
 
         loop {
             let mut tv = timeout.map(sec_to_timeval);
diff --git a/stdlib/src/socket.rs b/stdlib/src/socket.rs
@@ -1118,7 +1118,7 @@ mod _socket {
                 }
             } else {
                 if family == -1 {
-                    family = c::AF_INET as i32
+                    family = c::AF_INET as _
                 }
                 if socket_kind == -1 {
                     socket_kind = c::SOCK_STREAM
diff --git a/stdlib/src/termios.rs b/stdlib/src/termios.rs
@@ -175,7 +175,7 @@ mod termios {
             .enumerate()
             .map(|(i, &c)| match i {
                 termios::VMIN | termios::VTIME if noncanon => vm.ctx.new_int(c).into(),
-                _ => vm.ctx.new_bytes(vec![c as u8]).into(),
+                _ => vm.ctx.new_bytes(vec![c as _]).into(),
             })
             .collect::<Vec<_>>();
         let out = vec![
diff --git a/vm/src/anystr.rs b/vm/src/anystr.rs
@@ -379,7 +379,7 @@ pub trait AnyStr<'s>: 's {
     where
         FW: Fn(&Self) -> W,
     {
-        let keep = if options.keepends { 1 } else { 0 };
+        let keep = options.keepends as usize;
         let mut elements = Vec::new();
         let mut last_i = 0;
         let mut enumerated = self.as_bytes().iter().enumerate().peekable();
diff --git a/vm/src/builtins/complex.rs b/vm/src/builtins/complex.rs
@@ -352,7 +352,7 @@ impl PyComplex {
             float_ops::to_string(re)
         };
         let mut result = String::with_capacity(
-            re_part.len() + im_part.len() + 2 + if im.is_sign_positive() { 1 } else { 0 },
+            re_part.len() + im_part.len() + 2 + im.is_sign_positive() as usize,
         );
         result.push('(');
         result.push_str(&re_part);
diff --git a/vm/src/builtins/str.rs b/vm/src/builtins/str.rs
@@ -1164,7 +1164,7 @@ impl PyStr {
                                     "character mapping must be in range(0x110000)".to_owned(),
                                 )
                             })?;
-                        translated.push(ch as char);
+                        translated.push(ch);
                     } else if !vm.is_none(&value) {
                         return Err(vm.new_type_error(
                             "character mapping must return integer, None or str".to_owned(),
diff --git a/vm/src/builtins/tuple.rs b/vm/src/builtins/tuple.rs
@@ -281,13 +281,7 @@ impl PyTuple {
         vm: &VirtualMachine,
     ) -> PyResult<usize> {
         let (start, stop) = range.saturate(self.len(), vm)?;
-        for (index, element) in self
-            .elements
-            .iter()
-            .enumerate()
-            .take(stop as usize)
-            .skip(start as usize)
-        {
+        for (index, element) in self.elements.iter().enumerate().take(stop).skip(start) {
             if vm.identical_or_equal(element, &needle)? {
                 return Ok(index);
             }
diff --git a/vm/src/builtins/type.rs b/vm/src/builtins/type.rs
@@ -1234,7 +1234,7 @@ mod tests {
             PyAttributes::default(),
             Default::default(),
             type_type.clone(),
-            &context,
+            context,
         )
         .unwrap();
         let b = PyType::new_ref(
@@ -1243,7 +1243,7 @@ mod tests {
             PyAttributes::default(),
             Default::default(),
             type_type,
-            &context,
+            context,
         )
         .unwrap();
 
diff --git a/vm/src/stdlib/io.rs b/vm/src/stdlib/io.rs
@@ -1299,7 +1299,7 @@ mod _io {
 
             let mut remaining = buf_len - written;
             while remaining > 0 {
-                let n = if remaining as usize > self.buffer.len() {
+                let n = if remaining > self.buffer.len() {
                     self.raw_read(Either::B(buf.clone()), written..written + remaining, vm)?
                 } else if !(readinto1 && written != 0) {
                     let n = self.fill_buffer(vm)?;
@@ -4012,7 +4012,7 @@ mod fileio {
             }
             let mut handle = self.get_fd(vm)?;
             let bytes = if let Some(read_byte) = read_byte.to_usize() {
-                let mut bytes = vec![0; read_byte as usize];
+                let mut bytes = vec![0; read_byte];
                 let n = handle
                     .read(&mut bytes)
                     .map_err(|err| err.to_pyexception(vm))?;
diff --git a/vm/src/stdlib/itertools.rs b/vm/src/stdlib/itertools.rs
diff --git a/vm/src/vm/mod.rs b/vm/src/vm/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ fn bench_rustpy_code(group: &mut BenchmarkGroup<WallTime>, bench: &MicroBenchmar`
`115`	`115`	`settings.no_user_site = true;`
`116`	`116`
`117`	`117`	`Interpreter::with_init(settings, \|vm\| {`
`118`		`- for (name, init) in rustpython_stdlib::get_module_inits().into_iter() {`
	`118`	`+ for (name, init) in rustpython_stdlib::get_module_inits() {`
`119`	`119`	`vm.add_native_module(name, init);`
`120`	`120`	`}`
`121`	`121`	`})`