Rust-related/RustPython
1
0
Fork 1
mirror of https://github.com/RustPython/RustPython.git synced 2026-06-02 19:39:49 +09:00
Code Issues Packages Projects Releases Wiki Activity

Enable rust2024-incompatible pat and keyword-ident lints

Browse Source
This commit is contained in:
Noa
2025-02-24 23:12:30 -06:00
parent f426348a94
commit 864e8598f8
20 changed files with 62 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Cargo.toml
View File

@@ -190,9 +190,13 @@ wasm-bindgen = "0.2.100"
[workspace.lints.rust]
unsafe_code = "allow"
unsafe_op_in_unsafe_fn = "deny"
# rust_2024_compatibility
missing_unsafe_on_extern = "deny"
unsafe_attr_outside_unsafe = "deny"
deprecated_safe_2024 = "deny"
rust_2024_incompatible_pat = "deny"
keyword_idents_2024 = "deny"
[workspace.lints.clippy]
perf = "warn"

2
common/src/int.rs
View File

@@ -50,7 +50,7 @@ pub fn bytes_to_int(lit: &[u8], mut base: u32) -> Option<BigInt> {
base = parsed;
true
} else {
if let [_first, ref others @ .., last] = lit {
if let [_first, others @ .., last] = lit {
let is_zero =
others.iter().all(|&c| c == b'0' || c == b'_') && *last == b'0';
if !is_zero {

8
compiler/codegen/src/compile.rs
View File

@@ -3302,13 +3302,13 @@ impl Compiler {
elt, generators, ..
}) => {
Self::contains_await(elt)
|| generators.iter().any(|gen| Self::contains_await(&gen.iter))
|| generators.iter().any(|jen| Self::contains_await(&jen.iter))
}
Expr::SetComp(located_ast::ExprSetComp {
elt, generators, ..
}) => {
Self::contains_await(elt)
|| generators.iter().any(|gen| Self::contains_await(&gen.iter))
|| generators.iter().any(|jen| Self::contains_await(&jen.iter))
}
Expr::DictComp(located_ast::ExprDictComp {
key,
@@ -3318,13 +3318,13 @@ impl Compiler {
}) => {
Self::contains_await(key)
|| Self::contains_await(value)
|| generators.iter().any(|gen| Self::contains_await(&gen.iter))
|| generators.iter().any(|jen| Self::contains_await(&jen.iter))
}
Expr::GeneratorExp(located_ast::ExprGeneratorExp {
elt, generators, ..
}) => {
Self::contains_await(elt)
|| generators.iter().any(|gen| Self::contains_await(&gen.iter))
|| generators.iter().any(|jen| Self::contains_await(&jen.iter))
}
Expr::Starred(expr) => Self::contains_await(&expr.value),
Expr::IfExp(located_ast::ExprIfExp {

2
derive-impl/src/pytraverse.rs
View File

@@ -70,7 +70,7 @@ fn gen_trace_code(item: &mut DeriveInput) -> Result<TokenStream> {
syn::Data::Struct(s) => {
let fields = &mut s.fields;
match fields {
syn::Fields::Named(ref mut fields) => {
syn::Fields::Named(fields) => {
let res: Vec<TokenStream> = fields
.named
.iter_mut()

2
derive-impl/src/util.rs
View File

@@ -529,7 +529,7 @@ impl AttributeExt for Attribute {
fn try_remove_name(&mut self, item_name: &str) -> Result<Option<NestedMeta>> {
self.try_meta_mut(|meta| {
let nested = match meta {
Meta::List(MetaList { ref mut nested, .. }) => Ok(nested),
Meta::List(MetaList { nested, .. }) => Ok(nested),
other => Err(syn::Error::new(
other.span(),
format!(

6
jit/src/lib.rs
View File

@@ -215,9 +215,9 @@ pub enum AbiValue {
impl AbiValue {
fn to_libffi_arg(&self) -> libffi::middle::Arg {
match self {
AbiValue::Int(ref i) => libffi::middle::Arg::new(i),
AbiValue::Float(ref f) => libffi::middle::Arg::new(f),
AbiValue::Bool(ref b) => libffi::middle::Arg::new(b),
AbiValue::Int(i) => libffi::middle::Arg::new(i),
AbiValue::Float(f) => libffi::middle::Arg::new(f),
AbiValue::Bool(b) => libffi::middle::Arg::new(b),
}
}
}

20
stdlib/src/csv.rs
View File

@@ -272,12 +272,12 @@ mod _csv {
let Some(name) = name.payload_if_subclass::<PyStr>(vm) else {
return Err(vm.new_type_error("argument 0 must be a string".to_string()));
};
let mut dialect = match dialect {
let dialect = match dialect {
OptionalArg::Present(d) => PyDialect::try_from_object(vm, d)
.map_err(|_| vm.new_type_error("argument 1 must be a dialect object".to_owned()))?,
OptionalArg::Missing => opts.result(vm)?,
};
opts.update_pydialect(&mut dialect);
let dialect = opts.update_pydialect(dialect);
GLOBAL_HASHMAP
.lock()
.insert(name.as_str().to_owned(), dialect);
@@ -665,7 +665,7 @@ mod _csv {
}
impl FormatOptions {
fn update_pydialect<'b>(&self, res: &'b mut PyDialect) -> &'b mut PyDialect {
fn update_pydialect(&self, mut res: PyDialect) -> PyDialect {
macro_rules! check_and_fill {
($res:ident, $e:ident) => {{
if let Some(t) = self.$e {
@@ -699,24 +699,18 @@ mod _csv {
DialectItem::Str(name) => {
let g = GLOBAL_HASHMAP.lock();
if let Some(dialect) = g.get(name) {
let mut dialect = *dialect;
self.update_pydialect(&mut dialect);
Ok(dialect)
Ok(self.update_pydialect(*dialect))
} else {
Err(new_csv_error(vm, format!("{} is not registed.", name)))
}
// TODO
// Maybe need to update the obj from HashMap
}
DialectItem::Obj(mut o) => {
self.update_pydialect(&mut o);
Ok(o)
}
DialectItem::Obj(o) => Ok(self.update_pydialect(*o)),
DialectItem::None => {
let g = GLOBAL_HASHMAP.lock();
let mut res = *g.get("excel").unwrap();
self.update_pydialect(&mut res);
Ok(res)
let res = *g.get("excel").unwrap();
Ok(self.update_pydialect(res))
}
}
}

2
stdlib/src/json/machinery.rs
View File

@@ -135,7 +135,7 @@ pub fn scanstring<'a>(
};
let unterminated_err = || DecodeError::new("Unterminated string starting at", end - 1);
let mut chars = s.char_indices().enumerate().skip(end).peekable();
let (_, (mut chunk_start, _)) = chars.peek().ok_or_else(unterminated_err)?;
let &(_, (mut chunk_start, _)) = chars.peek().ok_or_else(unterminated_err)?;
while let Some((char_i, (byte_i, c))) = chars.next() {
match c {
'"' => {

4
stdlib/src/mmap.rs
View File

@@ -497,8 +497,8 @@ mod mmap {
fn as_bytes(&self) -> BorrowedValue<[u8]> {
PyMutexGuard::map_immutable(self.mmap.lock(), |m| {
match m.as_ref().expect("mmap closed or invalid") {
MmapObj::Read(ref mmap) => &mmap[..],
MmapObj::Write(ref mmap) => &mmap[..],
MmapObj::Read(mmap) => &mmap[..],
MmapObj::Write(mmap) => &mmap[..],
}
})
.into()

2
stdlib/src/socket.rs
View File

@@ -1924,7 +1924,7 @@ mod _socket {
let host = opts.host.as_ref().map(|s| s.as_str());
let port = opts.port.as_ref().map(|p| -> std::borrow::Cow<str> {
match p {
Either::A(ref s) => s.as_str().into(),
Either::A(s) => s.as_str().into(),
Either::B(i) => i.to_string().into(),
}
});

2
stdlib/src/syslog.rs
View File

@@ -49,7 +49,7 @@ mod syslog {
impl GlobalIdent {
fn as_ptr(&self) -> *const c_char {
match self {
GlobalIdent::Explicit(ref cstr) => cstr.as_ptr(),
GlobalIdent::Explicit(cstr) => cstr.as_ptr(),
GlobalIdent::Implicit => std::ptr::null(),
}
}

2
vm/src/builtins/iter.rs
View File

@@ -28,7 +28,7 @@ pub enum IterStatus<T> {
unsafe impl<T: Traverse> Traverse for IterStatus<T> {
fn traverse(&self, tracer_fn: &mut TraverseFn) {
match self {
IterStatus::Active(ref r) => r.traverse(tracer_fn),
IterStatus::Active(r) => r.traverse(tracer_fn),
IterStatus::Exhausted => (),
}
}

4
vm/src/builtins/mappingproxy.rs
View File

@@ -29,8 +29,8 @@ enum MappingProxyInner {
unsafe impl Traverse for MappingProxyInner {
fn traverse(&self, tracer_fn: &mut TraverseFn) {
match self {
MappingProxyInner::Class(ref r) => r.traverse(tracer_fn),
MappingProxyInner::Mapping(ref arg) => arg.traverse(tracer_fn),
MappingProxyInner::Class(r) => r.traverse(tracer_fn),
MappingProxyInner::Mapping(arg) => arg.traverse(tracer_fn),
}
}
}

32
vm/src/coroutine.rs
View File

@@ -36,8 +36,8 @@ pub struct Coro {
exception: PyMutex<Option<PyBaseExceptionRef>>, // exc_state
}
fn gen_name(gen: &PyObject, vm: &VirtualMachine) -> &'static str {
let typ = gen.class();
fn gen_name(jen: &PyObject, vm: &VirtualMachine) -> &'static str {
let typ = jen.class();
if typ.is(vm.ctx.types.coroutine_type) {
"coroutine"
} else if typ.is(vm.ctx.types.async_generator) {
@@ -67,7 +67,7 @@ impl Coro {
fn run_with_context<F>(
&self,
gen: &PyObject,
jen: &PyObject,
vm: &VirtualMachine,
func: F,
) -> PyResult<ExecutionResult>
@@ -75,7 +75,7 @@ impl Coro {
F: FnOnce(FrameRef) -> PyResult<ExecutionResult>,
{
if self.running.compare_exchange(false, true).is_err() {
return Err(vm.new_value_error(format!("{} already executing", gen_name(gen, vm))));
return Err(vm.new_value_error(format!("{} already executing", gen_name(jen, vm))));
}
vm.push_exception(self.exception.lock().take());
@@ -90,7 +90,7 @@ impl Coro {
pub fn send(
&self,
gen: &PyObject,
jen: &PyObject,
value: PyObjectRef,
vm: &VirtualMachine,
) -> PyResult<PyIterReturn> {
@@ -102,22 +102,22 @@ impl Coro {
} else if !vm.is_none(&value) {
return Err(vm.new_type_error(format!(
"can't send non-None value to a just-started {}",
gen_name(gen, vm),
gen_name(jen, vm),
)));
} else {
None
};
let result = self.run_with_context(gen, vm, |f| f.resume(value, vm));
let result = self.run_with_context(jen, vm, |f| f.resume(value, vm));
self.maybe_close(&result);
match result {
Ok(exec_res) => Ok(exec_res.into_iter_return(vm)),
Err(e) => {
if e.fast_isinstance(vm.ctx.exceptions.stop_iteration) {
let err =
vm.new_runtime_error(format!("{} raised StopIteration", gen_name(gen, vm)));
vm.new_runtime_error(format!("{} raised StopIteration", gen_name(jen, vm)));
err.set_cause(Some(e));
Err(err)
} else if gen.class().is(vm.ctx.types.async_generator)
} else if jen.class().is(vm.ctx.types.async_generator)
&& e.fast_isinstance(vm.ctx.exceptions.stop_async_iteration)
{
let err = vm
@@ -132,7 +132,7 @@ impl Coro {
}
pub fn throw(
&self,
gen: &PyObject,
jen: &PyObject,
exc_type: PyObjectRef,
exc_val: PyObjectRef,
exc_tb: PyObjectRef,
@@ -141,16 +141,16 @@ impl Coro {
if self.closed.load() {
return Err(vm.normalize_exception(exc_type, exc_val, exc_tb)?);
}
let result = self.run_with_context(gen, vm, |f| f.gen_throw(vm, exc_type, exc_val, exc_tb));
let result = self.run_with_context(jen, vm, |f| f.gen_throw(vm, exc_type, exc_val, exc_tb));
self.maybe_close(&result);
Ok(result?.into_iter_return(vm))
}
pub fn close(&self, gen: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
pub fn close(&self, jen: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
if self.closed.load() {
return Ok(());
}
let result = self.run_with_context(gen, vm, |f| {
let result = self.run_with_context(jen, vm, |f| {
f.gen_throw(
vm,
vm.ctx.exceptions.generator_exit.to_owned().into(),
@@ -161,7 +161,7 @@ impl Coro {
self.closed.store(true);
match result {
Ok(ExecutionResult::Yield(_)) => {
Err(vm.new_runtime_error(format!("{} ignored GeneratorExit", gen_name(gen, vm))))
Err(vm.new_runtime_error(format!("{} ignored GeneratorExit", gen_name(jen, vm))))
}
Err(e) if !is_gen_exit(&e, vm) => Err(e),
_ => Ok(()),
@@ -183,10 +183,10 @@ impl Coro {
pub fn set_name(&self, name: PyStrRef) {
*self.name.lock() = name;
}
pub fn repr(&self, gen: &PyObject, id: usize, vm: &VirtualMachine) -> String {
pub fn repr(&self, jen: &PyObject, id: usize, vm: &VirtualMachine) -> String {
format!(
"<{} object {} at {:#x}>",
gen_name(gen, vm),
gen_name(jen, vm),
self.name.lock(),
id
)

18
vm/src/frame.rs
View File

@@ -426,19 +426,19 @@ impl ExecutingFrame<'_> {
exc_val: PyObjectRef,
exc_tb: PyObjectRef,
) -> PyResult<ExecutionResult> {
if let Some(gen) = self.yield_from_target() {
if let Some(jen) = self.yield_from_target() {
// borrow checker shenanigans - we only need to use exc_type/val/tb if the following
// variable is Some
let thrower = if let Some(coro) = self.builtin_coro(gen) {
let thrower = if let Some(coro) = self.builtin_coro(jen) {
Some(Either::A(coro))
} else {
vm.get_attribute_opt(gen.to_owned(), "throw")?
vm.get_attribute_opt(jen.to_owned(), "throw")?
.map(Either::B)
};
if let Some(thrower) = thrower {
let ret = match thrower {
Either::A(coro) => coro
.throw(gen, exc_type, exc_val, exc_tb, vm)
.throw(jen, exc_type, exc_val, exc_tb, vm)
.to_pyresult(vm), // FIXME:
Either::B(meth) => meth.call((exc_type, exc_val, exc_tb), vm),
};
@@ -1568,16 +1568,16 @@ impl ExecutingFrame<'_> {
fn _send(
&self,
gen: &PyObject,
jen: &PyObject,
val: PyObjectRef,
vm: &VirtualMachine,
) -> PyResult<PyIterReturn> {
match self.builtin_coro(gen) {
Some(coro) => coro.send(gen, val, vm),
match self.builtin_coro(jen) {
Some(coro) => coro.send(jen, val, vm),
// FIXME: turn return type to PyResult<PyIterReturn> then ExecutionResult will be simplified
None if vm.is_none(&val) => PyIter::new(gen).next(vm),
None if vm.is_none(&val) => PyIter::new(jen).next(vm),
None => {
let meth = gen.get_attr("send", vm)?;
let meth = jen.get_attr("send", vm)?;
PyIterReturn::from_pyresult(meth.call((val,), vm), vm)
}
}

2
vm/src/function/argument.rs
View File

@@ -497,7 +497,7 @@ where
{
fn traverse(&self, tracer_fn: &mut TraverseFn) {
match self {
OptionalArg::Present(ref o) => o.traverse(tracer_fn),
OptionalArg::Present(o) => o.traverse(tracer_fn),
OptionalArg::Missing => (),
}
}

4
vm/src/stdlib/ast.rs
View File

@@ -3,7 +3,7 @@
//! This module makes use of the parser logic, and translates all ast nodes
//! into python ast.AST objects.
mod gen;
mod r#gen;
use crate::{
builtins::{self, PyDict, PyModule, PyStrRef, PyType},
@@ -398,6 +398,6 @@ pub const PY_COMPILE_FLAGS_MASK: i32 = PY_COMPILE_FLAG_AST_ONLY
pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
let module = _ast::make_module(vm);
gen::extend_module_nodes(vm, &module);
r#gen::extend_module_nodes(vm, &module);
module
}

2
vm/src/stdlib/ctypes/base.rs
View File

@@ -176,7 +176,7 @@ impl Constructor for PyCSimple {
let attributes = cls.get_attributes();
let _type_ = attributes
.iter()
.find(|(&k, _)| k.to_object().str(vm).unwrap().to_string() == *"_type_")
.find(|(k, _)| k.to_object().str(vm).unwrap().to_string() == *"_type_")
.unwrap()
.1
.str(vm)?

4
vm/src/stdlib/os.rs
View File

@@ -380,8 +380,8 @@ pub(super) mod _os {
fn env_bytes_as_bytes(obj: &Either<PyStrRef, PyBytesRef>) -> &[u8] {
match obj {
Either::A(ref s) => s.as_str().as_bytes(),
Either::B(ref b) => b.as_bytes(),
Either::A(s) => s.as_str().as_bytes(),
Either::B(b) => b.as_bytes(),
}
}

4
wasm/lib/src/vm_class.rs
View File

@@ -233,7 +233,7 @@ impl WASMVirtualMachine {
#[wasm_bindgen(js_name = addToScope)]
pub fn add_to_scope(&self, name: String, value: JsValue) -> Result<(), JsValue> {
self.with_vm(move |vm, StoredVirtualMachine { ref scope, .. }| {
self.with_vm(move |vm, StoredVirtualMachine { scope, .. }| {
let value = convert::js_to_py(vm, value);
scope.globals.set_item(&name, value, vm).into_js(vm)
})?
@@ -335,7 +335,7 @@ impl WASMVirtualMachine {
mode: Mode,
source_path: Option<String>,
) -> Result<JsValue, JsValue> {
self.with_vm(|vm, StoredVirtualMachine { ref scope, .. }| {
self.with_vm(|vm, StoredVirtualMachine { scope, .. }| {
let source_path = source_path.unwrap_or_else(|| "<wasm>".to_owned());
let code = vm.compile(source, mode, source_path);
let code = code.map_err(convert::syntax_err)?;