Fix a bunch of clippy warnings

Author: skinnyBat

vm/src/compile.rs

@@ -871,8 +871,8 @@ impl Compiler {
         vals: &[ast::Expression],
         ops: &[ast::Comparison],
     ) -> Result<(), CompileError> {
-        assert!(ops.len() > 0);
-        assert!(vals.len() == ops.len() + 1);
+        assert!(!ops.is_empty());
+        assert_eq!(vals.len(), ops.len() + 1);
 
         let to_operator = |op: &ast::Comparison| match op {
             ast::Comparison::Equal => bytecode::ComparisonOperator::Equal,

vm/src/frame.rs

@@ -1215,9 +1215,9 @@ impl Frame {
 
     fn get_exception(&self, vm: &VirtualMachine, none_allowed: bool) -> PyResult {
         let exception = self.pop_value();
-        if none_allowed && vm.get_none().is(&exception) {
-            Ok(exception)
-        } else if objtype::isinstance(&exception, &vm.ctx.exceptions.base_exception_type) {
+        if none_allowed && vm.get_none().is(&exception)
+            || objtype::isinstance(&exception, &vm.ctx.exceptions.base_exception_type)
+        {
             Ok(exception)
         } else if let Ok(exception) = PyClassRef::try_from_object(vm, exception) {
             if objtype::issubclass(&exception, &vm.ctx.exceptions.base_exception_type) {

vm/src/function.rs

@@ -286,7 +286,7 @@ pub struct Args<T = PyObjectRef>(Vec<T>);
 impl<T: PyValue> Args<PyRef<T>> {
     pub fn into_tuple(self, vm: &VirtualMachine) -> PyObjectRef {
         vm.ctx
-            .new_tuple(self.0.into_iter().map(|obj| obj.into_object()).collect())
+            .new_tuple(self.0.into_iter().map(PyRef::into_object).collect())
     }
 }
 

vm/src/obj/objbyteinner.rs

@@ -356,8 +356,7 @@ impl PyByteInner {
             .collect::<Vec<char>>()
             .chunks(2)
             .map(|x| x.to_vec().iter().collect::<String>())
-            .map(|x| u8::from_str_radix(&x, 16))
-            .map(|x| x.unwrap())
+            .map(|x| u8::from_str_radix(&x, 16).unwrap())
             .collect::<Vec<u8>>())
     }
 

vm/src/obj/objdict.rs

@@ -118,7 +118,7 @@ impl PyDictRef {
                 }
             }
         }
-        return Ok(true);
+        Ok(true)
     }
 
     fn eq(self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {

vm/src/obj/objint.rs

@@ -518,7 +518,7 @@ pub fn to_int(vm: &VirtualMachine, obj: &PyObjectRef, base: u32) -> PyResult<Big
         f @ PyFloat => Ok(f.to_f64().to_bigint().unwrap()),
         s @ PyString => {
             i32::from_str_radix(s.as_str(), base)
-                .map(|i| BigInt::from(i))
+                .map(BigInt::from)
                 .map_err(|_|vm.new_value_error(format!(
                     "invalid literal for int() with base {}: '{}'",
                     base, s

vm/src/obj/objrange.rs

@@ -144,8 +144,8 @@ impl PyRange {
         vm: &VirtualMachine,
     ) -> PyResult<PyRangeRef> {
         PyRange {
-            start: start,
-            stop: stop,
+            start,
+            stop,
             step: step
                 .into_option()
                 .unwrap_or_else(|| PyInt::new(BigInt::one()).into_ref(vm)),

vm/src/obj/objset.rs

@@ -262,7 +262,7 @@ impl PySetInner {
         perform_action_with_hash(vm, &mut self.elements, &item, &discard)
     }
 
-    fn clear(&mut self) -> () {
+    fn clear(&mut self) {
         self.elements.clear();
     }
 
@@ -449,11 +449,11 @@ impl PySetRef {
     fn repr(self, vm: &VirtualMachine) -> PyResult {
         let inner = self.inner.borrow();
         let s = if inner.len() == 0 {
-            format!("set()")
+            "set()".to_string()
         } else if let Some(_guard) = ReprGuard::enter(self.as_object()) {
             inner.repr(vm)?
         } else {
-            format!("set(...)")
+            "set(...)".to_string()
         };
         Ok(vm.new_str(s))
     }
@@ -470,7 +470,7 @@ impl PySetRef {
         self.inner.borrow_mut().discard(&item, vm)
     }
 
-    fn clear(self, _vm: &VirtualMachine) -> () {
+    fn clear(self, _vm: &VirtualMachine) {
         self.inner.borrow_mut().clear()
     }
 
@@ -656,11 +656,11 @@ impl PyFrozenSetRef {
     fn repr(self, vm: &VirtualMachine) -> PyResult {
         let inner = &self.inner;
         let s = if inner.len() == 0 {
-            format!("frozenset()")
+            "frozenset()".to_string()
         } else if let Some(_guard) = ReprGuard::enter(self.as_object()) {
             format!("frozenset({})", inner.repr(vm)?)
         } else {
-            format!("frozenset(...)")
+            "frozenset(...)".to_string()
         };
         Ok(vm.new_str(s))
     }

vm/src/obj/objslice.rs

@@ -63,7 +63,7 @@ fn slice_new(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
         step: step.map(|x| objint::get_value(x).clone()),
     }
     .into_ref_with_type(vm, cls.clone().downcast().unwrap())
-    .map(|x| x.into_object())
+    .map(PyRef::into_object)
 }
 
 fn get_property_value(vm: &VirtualMachine, value: &Option<BigInt>) -> PyObjectRef {

vm/src/obj/objtype.rs

@@ -235,7 +235,7 @@ pub fn type_new(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
         Ok(args.args[1].class().into_object())
     } else if args.args.len() == 4 {
         let (typ, name, bases, dict) = args.bind(vm)?;
-        type_new_class(vm, typ, name, bases, dict).map(|x| x.into_object())
+        type_new_class(vm, typ, name, bases, dict).map(PyRef::into_object)
     } else {
         Err(vm.new_type_error(format!(": type_new: {:?}", args)))
     }

vm/src/pyobject.rs

@@ -87,7 +87,6 @@ pub type PyAttributes = HashMap<String, PyObjectRef>;
 
 impl fmt::Display for PyObject<dyn PyObjectPayload> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use self::TypeProtocol;
         if let Some(PyClass { ref name, .. }) = self.payload::<PyClass>() {
             let type_name = self.class().name.clone();
             // We don't have access to a vm, so just assume that if its parent's name
@@ -698,7 +697,7 @@ impl PyContext {
     pub fn new_instance(&self, class: PyClassRef, dict: Option<PyDictRef>) -> PyObjectRef {
         PyObject {
             typ: class,
-            dict: dict,
+            dict,
             payload: objobject::PyInstance,
         }
         .into_ref()
@@ -1065,7 +1064,7 @@ where
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
         if let Ok(method) = vm.get_method(obj.clone(), "__iter__") {
             Ok(PyIterable {
-                method: method,
+                method,
                 _item: std::marker::PhantomData,
             })
         } else if vm.get_method(obj.clone(), "__getitem__").is_ok() {
@@ -1170,12 +1169,7 @@ where
     T: Sized + PyObjectPayload,
 {
     pub fn new(payload: T, typ: PyClassRef, dict: Option<PyDictRef>) -> PyObjectRef {
-        PyObject {
-            typ,
-            dict: dict,
-            payload,
-        }
-        .into_ref()
+        PyObject { typ, dict, payload }.into_ref()
     }
 
     // Move this object into a reference object, transferring ownership.

vm/src/stdlib/os.rs

@@ -174,11 +174,11 @@ fn os_listdir(path: PyStringRef, vm: &VirtualMachine) -> PyResult {
     }
 }
 
-fn os_putenv(key: PyStringRef, value: PyStringRef, _vm: &VirtualMachine) -> () {
+fn os_putenv(key: PyStringRef, value: PyStringRef, _vm: &VirtualMachine) {
     env::set_var(&key.value, &value.value)
 }
 
-fn os_unsetenv(key: PyStringRef, _vm: &VirtualMachine) -> () {
+fn os_unsetenv(key: PyStringRef, _vm: &VirtualMachine) {
     env::remove_var(&key.value)
 }