From 9bb2a999326b73e2f811df32320e3b62cdc5b47c Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Tue, 16 Aug 2022 08:11:49 +0900 Subject: [PATCH 1/2] Fix nightly build --- vm/src/exceptions.rs | 32 +++++++++++++++++++++++++------- 1 file changed, 25 insertions(+), 7 deletions(-) diff --git a/vm/src/exceptions.rs b/vm/src/exceptions.rs index edbc3afdb..0d404e6a8 100644 --- a/vm/src/exceptions.rs +++ b/vm/src/exceptions.rs @@ -910,18 +910,30 @@ fn system_exit_code(exc: PyBaseExceptionRef) -> Option { }) } -pub struct SerializeException<'s> { - vm: &'s VirtualMachine, +pub struct SerializeException<'vm, 's> { + vm: &'vm VirtualMachine, exc: &'s PyBaseExceptionRef, } -impl<'s> SerializeException<'s> { - pub fn new(vm: &'s VirtualMachine, exc: &'s PyBaseExceptionRef) -> Self { +impl<'vm, 's> SerializeException<'vm, 's> { + pub fn new(vm: &'vm VirtualMachine, exc: &'s PyBaseExceptionRef) -> Self { SerializeException { vm, exc } } } -impl serde::Serialize for SerializeException<'_> { +pub struct SerializeExceptionOwned<'vm> { + vm: &'vm VirtualMachine, + exc: PyBaseExceptionRef, +} + +impl serde::Serialize for SerializeExceptionOwned<'_> { + fn serialize(&self, s: S) -> Result { + let Self { vm, exc } = self; + SerializeException::new(vm, exc).serialize(s) + } +} + +impl serde::Serialize for SerializeException<'_, '_> { fn serialize(&self, s: S) -> Result { use serde::ser::*; @@ -943,11 +955,17 @@ impl serde::Serialize for SerializeException<'_> { struc.serialize_field("traceback", &tbs)?; struc.serialize_field( "cause", - &self.exc.cause().as_ref().map(|e| Self::new(self.vm, e)), + &self + .exc + .cause() + .map(|exc| SerializeExceptionOwned { vm: self.vm, exc }), )?; struc.serialize_field( "context", - &self.exc.context().as_ref().map(|e| Self::new(self.vm, e)), + &self + .exc + .context() + .map(|exc| SerializeExceptionOwned { vm: self.vm, exc }), )?; struc.serialize_field("suppress_context", &self.exc.get_suppress_context())?; From 27040c01b0e4c36559bff4e01e4553864a991e83 Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Tue, 16 Aug 2022 08:49:14 +0900 Subject: [PATCH 2/2] Fix nightly clippy --- common/src/linked_list.rs | 2 +- stdlib/src/array.rs | 10 +++++----- stdlib/src/bisect.rs | 2 +- stdlib/src/fcntl.rs | 2 +- vm/src/builtins/bytearray.rs | 2 +- vm/src/builtins/bytes.rs | 2 +- vm/src/builtins/list.rs | 4 ++-- vm/src/function/buffer.rs | 8 ++++---- vm/src/object/core.rs | 2 +- vm/src/stdlib/io.rs | 4 ++-- vm/src/stdlib/itertools.rs | 2 +- 11 files changed, 20 insertions(+), 20 deletions(-) diff --git a/common/src/linked_list.rs b/common/src/linked_list.rs index ac4f01343..3941d2c83 100644 --- a/common/src/linked_list.rs +++ b/common/src/linked_list.rs @@ -152,7 +152,7 @@ impl LinkedList { pub fn push_front(&mut self, val: L::Handle) { // The value should not be dropped, it is being inserted into the list let val = ManuallyDrop::new(val); - let ptr = L::as_raw(&*val); + let ptr = L::as_raw(&val); assert_ne!(self.head, Some(ptr)); unsafe { L::pointers(ptr).as_mut().set_next(self.head); diff --git a/stdlib/src/array.rs b/stdlib/src/array.rs index a92b5ae71..ca4c8f6a8 100644 --- a/stdlib/src/array.rs +++ b/stdlib/src/array.rs @@ -725,7 +725,7 @@ mod array { if zelf.is(&obj) { w.imul(2, vm) } else if let Some(array) = obj.payload::() { - w.iadd(&*array.read(), vm) + w.iadd(&array.read(), vm) } else { let iter = ArgIterable::try_from_object(vm, obj)?; // zelf.extend_from_iterable(iter, vm) @@ -1029,7 +1029,7 @@ mod array { fn add(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult> { if let Some(other) = other.payload::() { self.read() - .add(&*other.read(), vm) + .add(&other.read(), vm) .map(|array| PyArray::from(array).into_ref(vm)) } else { Err(vm.new_type_error(format!( @@ -1048,7 +1048,7 @@ mod array { if zelf.is(&other) { zelf.try_resizable(vm)?.imul(2, vm)?; } else if let Some(other) = other.payload::() { - zelf.try_resizable(vm)?.iadd(&*other.read(), vm)?; + zelf.try_resizable(vm)?.iadd(&other.read(), vm)?; } else { return Err(vm.new_type_error(format!( "can only extend array with array (not \"{}\")", @@ -1104,7 +1104,7 @@ mod array { let array_b = other.read(); // fast path for same ArrayContentType type - if let Ok(ord) = array_a.cmp(&*array_b) { + if let Ok(ord) = array_a.cmp(&array_b) { return Ok(ord == Some(Ordering::Equal)); } @@ -1187,7 +1187,7 @@ mod array { let array_a = zelf.read(); let array_b = other.read(); - let res = match array_a.cmp(&*array_b) { + let res = match array_a.cmp(&array_b) { // fast path for same ArrayContentType type Ok(partial_ord) => partial_ord.map_or(false, |ord| op.eval_ord(ord)), Err(()) => { diff --git a/stdlib/src/bisect.rs b/stdlib/src/bisect.rs index 0caab7c1d..e77107938 100644 --- a/stdlib/src/bisect.rs +++ b/stdlib/src/bisect.rs @@ -116,7 +116,7 @@ mod _bisect { } else { a_mid }; - if x.rich_compare_bool(&*comp, PyComparisonOp::Lt, vm)? { + if x.rich_compare_bool(&comp, PyComparisonOp::Lt, vm)? { hi = mid; } else { lo = mid + 1; diff --git a/stdlib/src/fcntl.rs b/stdlib/src/fcntl.rs index 8f94a9319..1e5ce5ef7 100644 --- a/stdlib/src/fcntl.rs +++ b/stdlib/src/fcntl.rs @@ -69,7 +69,7 @@ mod fcntl { arg_len = s.len(); buf.get_mut(..arg_len) .ok_or_else(|| vm.new_value_error("fcntl string arg too long".to_owned()))? - .copy_from_slice(&*s) + .copy_from_slice(&s) } let ret = unsafe { libc::fcntl(fd, cmd, buf.as_mut_ptr()) }; if ret < 0 { diff --git a/vm/src/builtins/bytearray.rs b/vm/src/builtins/bytearray.rs index 4c1f9715c..920237d2a 100644 --- a/vm/src/builtins/bytearray.rs +++ b/vm/src/builtins/bytearray.rs @@ -146,7 +146,7 @@ impl PyByteArray { #[pymethod(magic)] fn add(&self, other: ArgBytesLike) -> Self { - self.inner().add(&*other.borrow_buf()).into() + self.inner().add(&other.borrow_buf()).into() } #[pymethod(magic)] diff --git a/vm/src/builtins/bytes.rs b/vm/src/builtins/bytes.rs index 88f77f1df..c2130c565 100644 --- a/vm/src/builtins/bytes.rs +++ b/vm/src/builtins/bytes.rs @@ -151,7 +151,7 @@ impl PyBytes { #[pymethod(magic)] fn add(&self, other: ArgBytesLike) -> Vec { - self.inner.add(&*other.borrow_buf()) + self.inner.add(&other.borrow_buf()) } #[pymethod(magic)] diff --git a/vm/src/builtins/list.rs b/vm/src/builtins/list.rs index 3633ae375..43e31cb6e 100644 --- a/vm/src/builtins/list.rs +++ b/vm/src/builtins/list.rs @@ -150,7 +150,7 @@ impl PyList { #[pymethod(magic)] fn iadd(zelf: PyRef, other: PyObjectRef, vm: &VirtualMachine) -> PyResult> { - let mut seq = extract_cloned(&*other, Ok, vm)?; + let mut seq = extract_cloned(&other, Ok, vm)?; zelf.borrow_vec_mut().append(&mut seq); Ok(zelf) } @@ -213,7 +213,7 @@ impl PyList { match SequenceIndex::try_from_borrowed_object(vm, needle, "list")? { SequenceIndex::Int(index) => self.borrow_vec_mut().setitem_by_index(vm, index, value), SequenceIndex::Slice(slice) => { - let sec = extract_cloned(&*value, Ok, vm)?; + let sec = extract_cloned(&value, Ok, vm)?; self.borrow_vec_mut().setitem_by_slice(vm, slice, &sec) } } diff --git a/vm/src/function/buffer.rs b/vm/src/function/buffer.rs index fd7c20c9d..81e5e104c 100644 --- a/vm/src/function/buffer.rs +++ b/vm/src/function/buffer.rs @@ -18,7 +18,7 @@ impl PyObject { f: impl FnOnce(&[u8]) -> R, ) -> PyResult { let buffer = PyBuffer::try_from_borrowed_object(vm, self)?; - buffer.as_contiguous().map(|x| f(&*x)).ok_or_else(|| { + buffer.as_contiguous().map(|x| f(&x)).ok_or_else(|| { vm.new_type_error("non-contiguous buffer is not a bytes-like object".to_owned()) }) } @@ -31,7 +31,7 @@ impl PyObject { let buffer = PyBuffer::try_from_borrowed_object(vm, self)?; buffer .as_contiguous_mut() - .map(|mut x| f(&mut *x)) + .map(|mut x| f(&mut x)) .ok_or_else(|| { vm.new_type_error("buffer is not a read-write bytes-like object".to_owned()) }) @@ -47,7 +47,7 @@ impl ArgBytesLike { where F: FnOnce(&[u8]) -> R, { - f(&*self.borrow_buf()) + f(&self.borrow_buf()) } pub fn len(&self) -> usize { @@ -89,7 +89,7 @@ impl ArgMemoryBuffer { where F: FnOnce(&mut [u8]) -> R, { - f(&mut *self.borrow_buf_mut()) + f(&mut self.borrow_buf_mut()) } pub fn len(&self) -> usize { diff --git a/vm/src/object/core.rs b/vm/src/object/core.rs index 8868a68e9..42e76df5c 100644 --- a/vm/src/object/core.rs +++ b/vm/src/object/core.rs @@ -837,7 +837,7 @@ impl fmt::Debug for PyObjectRef { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { // SAFETY: the vtable contains functions that accept payload types that always match up // with the payload of the object - unsafe { ((*self).0.vtable.debug)(self, f) } + unsafe { (self.0.vtable.debug)(self, f) } } } diff --git a/vm/src/stdlib/io.rs b/vm/src/stdlib/io.rs index d747d8034..1c94d065f 100644 --- a/vm/src/stdlib/io.rs +++ b/vm/src/stdlib/io.rs @@ -2989,7 +2989,7 @@ mod _io { if let Some((dec_buffer, dec_flags)) = dec_state { // TODO: inplace append to bytes when refcount == 1 let mut next_input = dec_buffer.as_bytes().to_vec(); - next_input.extend_from_slice(&*buf.borrow_buf()); + next_input.extend_from_slice(&buf.borrow_buf()); self.snapshot = Some((dec_flags, PyBytes::from(next_input).into_ref(vm))); } @@ -3298,7 +3298,7 @@ mod _io { let mut buf = self.buffer(vm)?; let ret = buf .cursor - .read(&mut *obj.borrow_buf_mut()) + .read(&mut obj.borrow_buf_mut()) .map_err(|_| vm.new_value_error("Error readinto from Take".to_owned()))?; Ok(ret) diff --git a/vm/src/stdlib/itertools.rs b/vm/src/stdlib/itertools.rs index 7dba83646..9ccdb2c39 100644 --- a/vm/src/stdlib/itertools.rs +++ b/vm/src/stdlib/itertools.rs @@ -235,7 +235,7 @@ mod decl { let mut cur = zelf.cur.write(); let step = zelf.step.clone(); let result = cur.clone(); - *cur = vm._iadd(&*cur, step.as_object())?; + *cur = vm._iadd(&cur, step.as_object())?; Ok(PyIterReturn::Return(result.to_pyobject(vm))) } }