diff --git a/.cspell.dict/cpython.txt b/.cspell.dict/cpython.txt index f7e282e4bc..1840918a4d 100644 --- a/.cspell.dict/cpython.txt +++ b/.cspell.dict/cpython.txt @@ -6,15 +6,14 @@ badsyntax basetype boolop bxor +cached_tsver cellarg cellvar cellvars cmpop -weakreflist -XXPRIME +denom dictoffset elts -xstat excepthandler fileutils finalbody @@ -30,17 +29,25 @@ linearise maxdepth mult nkwargs +numer orelse +pathconfig patma posonlyarg posonlyargs prec +PYTHREAD_NAME +SA_ONSTACK stackdepth +tok_oldval unaryop unparse unparser VARKEYWORDS varkwarg wbits +weakreflist withitem -withs \ No newline at end of file +withs +xstat +XXPRIME \ No newline at end of file diff --git a/.cspell.dict/python-more.txt b/.cspell.dict/python-more.txt index 526f5ba166..2edfe95bdf 100644 --- a/.cspell.dict/python-more.txt +++ b/.cspell.dict/python-more.txt @@ -80,6 +80,7 @@ getpip getrandom getrecursionlimit getrefcount +getsizeof getweakrefcount getweakrefs getwindowsversion @@ -90,6 +91,7 @@ hamt hostnames idfunc idiv +idxs impls indexgroup infj @@ -99,6 +101,7 @@ irepeat isabstractmethod isbytes iscased +isfinal istext itemiterator itemsize @@ -111,9 +114,11 @@ kwargs kwdefaults kwonlyargcount lastgroup +lastindex linearization linearize listcomp +longrange lvalue mappingproxy maskpri @@ -137,25 +142,39 @@ nbytes ncallbacks ndigits ndim +nldecoder nlocals +NOARGS nonbytes +Nonprintable origname +ospath +pendingcr +phello +platlibdir posixsubprocess posonly posonlyargcount +prepending profilefunc +pycache pycodecs pycs pyexpat +PYTHONBREAKPOINT PYTHONDEBUG +PYTHONHASHSEED PYTHONHOME PYTHONINSPECT PYTHONOPTIMIZE PYTHONPATH PYTHONPATH +PYTHONSAFEPATH PYTHONVERBOSE +PYTHONWARNDEFAULTENCODING PYTHONWARNINGS pytraverse +PYVENV qualname quotetabs radd @@ -164,6 +183,7 @@ rdivmod readall readbuffer reconstructor +refcnt releaselevel reverseitemiterator reverseiterator @@ -178,23 +198,37 @@ rsub rtruediv rvalue scproxy +seennl setattro setcomp +setrecursionlimit showwarnmsg signum slotnames +STACKLESS stacklevel stacksize startpos +subclassable subclasscheck subclasshook suboffset +suboffsets +SUBPATTERN sumprod surrogateescape surrogatepass +sysconf sysconfigdata sysvars +teedata +thisclass titlecased +tobytes +tolist +toreadonly +TPFLAGS +tracefunc unimportable unionable unraisablehook @@ -208,7 +242,9 @@ warningregistry warnmsg warnoptions warnopts +weaklist weakproxy +weakrefs winver withdata xmlcharrefreplace diff --git a/.cspell.dict/rust-more.txt b/.cspell.dict/rust-more.txt index d75529789f..99e87e532c 100644 --- a/.cspell.dict/rust-more.txt +++ b/.cspell.dict/rust-more.txt @@ -1,4 +1,5 @@ ahash +arrayvec bidi biguint bindgen @@ -14,6 +15,8 @@ cranelift cstring datelike deserializer +fdiv +flamescope flate2 fract getres @@ -44,16 +47,21 @@ objclass peekable powc powf +powi prepended punct puruspe replacen +rmatch +rposition rsplitn rustc rustfmt rustyline +seedable seekfrom siphash +siphasher splitn subsec thiserror @@ -63,8 +71,10 @@ trai ulonglong unic unistd +unraw unsync wasmbind +wasmtime widestring winapi winsock diff --git a/.cspell.json b/.cspell.json index 99718a6515..caa53a2879 100644 --- a/.cspell.json +++ b/.cspell.json @@ -46,6 +46,7 @@ ], // words - list of words to be always considered correct "words": [ + "RUSTPYTHONPATH", // RustPython "aiterable", "alnum", @@ -69,9 +70,11 @@ "makeunicodedata", "miri", "notrace", + "openat", "pyarg", "pyarg", "pyargs", + "pyast", "PyAttr", "pyc", "PyClass", @@ -80,6 +83,7 @@ "PyFunction", "pygetset", "pyimpl", + "pylib", "pymember", "PyMethod", "PyModule", @@ -100,6 +104,7 @@ "richcompare", "RustPython", "struc", + "sysmodule", "tracebacks", "typealiases", "Unconstructible", @@ -112,11 +117,14 @@ "CLOEXEC", "codeset", "endgrent", + "gethrvtime", "getrusage", "nanosleep", + "sigaction", "WRLCK", // win32 "birthtime", + "IFEXEC", ], // flagWords - list of words to be always considered incorrect "flagWords": [ diff --git a/common/src/format.rs b/common/src/format.rs index 75d0996796..4c1ce6c5c2 100644 --- a/common/src/format.rs +++ b/common/src/format.rs @@ -1,3 +1,4 @@ +// cspell:ignore ddfe use itertools::{Itertools, PeekingNext}; use malachite_bigint::{BigInt, Sign}; use num_traits::FromPrimitive; diff --git a/common/src/os.rs b/common/src/os.rs index 06ea1432e9..d37f28d28a 100644 --- a/common/src/os.rs +++ b/common/src/os.rs @@ -62,13 +62,13 @@ pub fn last_posix_errno() -> i32 { } #[cfg(unix)] -pub fn bytes_as_osstr(b: &[u8]) -> Result<&std::ffi::OsStr, Utf8Error> { +pub fn bytes_as_os_str(b: &[u8]) -> Result<&std::ffi::OsStr, Utf8Error> { use std::os::unix::ffi::OsStrExt; Ok(std::ffi::OsStr::from_bytes(b)) } #[cfg(not(unix))] -pub fn bytes_as_osstr(b: &[u8]) -> Result<&std::ffi::OsStr, Utf8Error> { +pub fn bytes_as_os_str(b: &[u8]) -> Result<&std::ffi::OsStr, Utf8Error> { Ok(std::str::from_utf8(b)?.as_ref()) } diff --git a/common/src/static_cell.rs b/common/src/static_cell.rs index 407b83ae0a..30e34f187f 100644 --- a/common/src/static_cell.rs +++ b/common/src/static_cell.rs @@ -76,7 +76,7 @@ mod threading { impl StaticCell { #[doc(hidden)] - pub const fn _from_oncecell(inner: OnceCell) -> Self { + pub const fn _from_once_cell(inner: OnceCell) -> Self { Self { inner } } @@ -108,7 +108,7 @@ mod threading { ($($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty;)+) => { $($(#[$attr])* $vis static $name: $crate::static_cell::StaticCell<$t> = - $crate::static_cell::StaticCell::_from_oncecell($crate::lock::OnceCell::new());)+ + $crate::static_cell::StaticCell::_from_once_cell($crate::lock::OnceCell::new());)+ }; } } diff --git a/common/src/str.rs b/common/src/str.rs index ca1723e7ef..fa26959e0b 100644 --- a/common/src/str.rs +++ b/common/src/str.rs @@ -360,8 +360,8 @@ pub fn get_chars(s: &str, range: impl RangeBounds) -> &str { } #[inline] -pub fn char_range_end(s: &str, nchars: usize) -> Option { - let i = match nchars.checked_sub(1) { +pub fn char_range_end(s: &str, n_chars: usize) -> Option { + let i = match n_chars.checked_sub(1) { Some(last_char_index) => { let (index, c) = s.char_indices().nth(last_char_index)?; index + c.len_utf8() @@ -395,8 +395,8 @@ pub fn get_codepoints(w: &Wtf8, range: impl RangeBounds) -> &Wtf8 { } #[inline] -pub fn codepoint_range_end(s: &Wtf8, nchars: usize) -> Option { - let i = match nchars.checked_sub(1) { +pub fn codepoint_range_end(s: &Wtf8, n_chars: usize) -> Option { + let i = match n_chars.checked_sub(1) { Some(last_char_index) => { let (index, c) = s.code_point_indices().nth(last_char_index)?; index + c.len_wtf8() diff --git a/src/lib.rs b/src/lib.rs index 3fa5292e94..e415d847cf 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -233,14 +233,14 @@ fn write_profile(settings: &Settings) -> Result<(), Box> enum ProfileFormat { Html, Text, - Speedscope, + SpeedScore, } let profile_output = settings.profile_output.as_deref(); let profile_format = match settings.profile_format.as_deref() { Some("html") => ProfileFormat::Html, Some("text") => ProfileFormat::Text, None if profile_output == Some("-".as_ref()) => ProfileFormat::Text, - Some("speedscope") | None => ProfileFormat::Speedscope, + Some("speedscope") | None => ProfileFormat::SpeedScore, Some(other) => { error!("Unknown profile format {}", other); // TODO: Need to change to ExitCode or Termination @@ -251,7 +251,7 @@ fn write_profile(settings: &Settings) -> Result<(), Box> let profile_output = profile_output.unwrap_or_else(|| match profile_format { ProfileFormat::Html => "flame-graph.html".as_ref(), ProfileFormat::Text => "flame.txt".as_ref(), - ProfileFormat::Speedscope => "flamescope.json".as_ref(), + ProfileFormat::SpeedScore => "flamescope.json".as_ref(), }); let profile_output: Box = if profile_output == "-" { @@ -265,7 +265,7 @@ fn write_profile(settings: &Settings) -> Result<(), Box> match profile_format { ProfileFormat::Html => flame::dump_html(profile_output)?, ProfileFormat::Text => flame::dump_text_to_writer(profile_output)?, - ProfileFormat::Speedscope => flamescope::dump(profile_output)?, + ProfileFormat::SpeedScore => flamescope::dump(profile_output)?, } Ok(()) diff --git a/stdlib/src/csv.rs b/stdlib/src/csv.rs index 39c15fd952..730d3b2feb 100644 --- a/stdlib/src/csv.rs +++ b/stdlib/src/csv.rs @@ -277,7 +277,7 @@ mod _csv { .map_err(|_| vm.new_type_error("argument 1 must be a dialect object".to_owned()))?, OptionalArg::Missing => opts.result(vm)?, }; - let dialect = opts.update_pydialect(dialect); + let dialect = opts.update_py_dialect(dialect); GLOBAL_HASHMAP .lock() .insert(name.as_str().to_owned(), dialect); @@ -665,7 +665,7 @@ mod _csv { } impl FormatOptions { - fn update_pydialect(&self, mut res: PyDialect) -> PyDialect { + fn update_py_dialect(&self, mut res: PyDialect) -> PyDialect { macro_rules! check_and_fill { ($res:ident, $e:ident) => {{ if let Some(t) = self.$e { @@ -699,18 +699,18 @@ mod _csv { DialectItem::Str(name) => { let g = GLOBAL_HASHMAP.lock(); if let Some(dialect) = g.get(name) { - Ok(self.update_pydialect(*dialect)) + Ok(self.update_py_dialect(*dialect)) } else { - Err(new_csv_error(vm, format!("{} is not registed.", name))) + Err(new_csv_error(vm, format!("{} is not registered.", name))) } // TODO // Maybe need to update the obj from HashMap } - DialectItem::Obj(o) => Ok(self.update_pydialect(*o)), + DialectItem::Obj(o) => Ok(self.update_py_dialect(*o)), DialectItem::None => { let g = GLOBAL_HASHMAP.lock(); let res = *g.get("excel").unwrap(); - Ok(self.update_pydialect(res)) + Ok(self.update_py_dialect(res)) } } } @@ -1084,8 +1084,8 @@ mod _csv { macro_rules! handle_res { ($x:expr) => {{ - let (res, nwritten) = $x; - buffer_offset += nwritten; + let (res, n_written) = $x; + buffer_offset += n_written; match res { csv_core::WriteResult::InputEmpty => break, csv_core::WriteResult::OutputFull => resize_buf(buffer), @@ -1118,10 +1118,10 @@ mod _csv { } loop { - let (res, nread, nwritten) = + let (res, n_read, n_written) = writer.field(&data[input_offset..], &mut buffer[buffer_offset..]); - input_offset += nread; - handle_res!((res, nwritten)); + input_offset += n_read; + handle_res!((res, n_written)); } } diff --git a/stdlib/src/json/machinery.rs b/stdlib/src/json/machinery.rs index 4612b5263d..a4344e363c 100644 --- a/stdlib/src/json/machinery.rs +++ b/stdlib/src/json/machinery.rs @@ -1,3 +1,4 @@ +// cspell:ignore LOJKINE // derived from https://github.com/lovasoa/json_in_type // BSD 2-Clause License diff --git a/stdlib/src/locale.rs b/stdlib/src/locale.rs index dfc6c93497..6cde173fb1 100644 --- a/stdlib/src/locale.rs +++ b/stdlib/src/locale.rs @@ -1,4 +1,4 @@ -// cspell:ignore abday abmon yesexpr +// cspell:ignore abday abmon yesexpr noexpr CRNCYSTR RADIXCHAR AMPM THOUSEP pub(crate) use _locale::make_module; diff --git a/stdlib/src/math.rs b/stdlib/src/math.rs index 93929e3566..6665ee8b49 100644 --- a/stdlib/src/math.rs +++ b/stdlib/src/math.rs @@ -652,7 +652,7 @@ mod math { partials.truncate(i); if x != 0.0 { if !x.is_finite() { - // a nonfinite x could arise either as + // a non-finite x could arise either as // a result of intermediate overflow, or // as a result of a nan or inf in the // summands diff --git a/stdlib/src/multiprocessing.rs b/stdlib/src/multiprocessing.rs index 2db922e16b..4a98c1afad 100644 --- a/stdlib/src/multiprocessing.rs +++ b/stdlib/src/multiprocessing.rs @@ -19,12 +19,12 @@ mod _multiprocessing { #[pyfunction] fn recv(socket: usize, size: usize, vm: &VirtualMachine) -> PyResult { let mut buf = vec![0; size]; - let nread = + let n_read = unsafe { WinSock::recv(socket as SOCKET, buf.as_mut_ptr() as *mut _, size as i32, 0) }; - if nread < 0 { + if n_read < 0 { Err(os::errno_err(vm)) } else { - Ok(nread) + Ok(n_read) } } diff --git a/stdlib/src/overlapped.rs b/stdlib/src/overlapped.rs index 007fa67423..6fd8a1516d 100644 --- a/stdlib/src/overlapped.rs +++ b/stdlib/src/overlapped.rs @@ -184,14 +184,14 @@ mod _overlapped { buf: buf.as_ptr() as *mut _, len: buf.len() as _, }; - let mut nread: u32 = 0; + let mut n_read: u32 = 0; // TODO: optimization with MaybeUninit let ret = unsafe { windows_sys::Win32::Networking::WinSock::WSARecv( handle as _, &wsabuf, 1, - &mut nread, + &mut n_read, &mut flags, &mut inner.overlapped, None, diff --git a/vm/src/anystr.rs b/vm/src/anystr.rs index 79b15b6a3f..03582215ba 100644 --- a/vm/src/anystr.rs +++ b/vm/src/anystr.rs @@ -167,7 +167,7 @@ pub trait AnyStr { full_obj: impl FnOnce() -> PyObjectRef, split: SP, splitn: SN, - splitw: SW, + split_whitespace: SW, ) -> PyResult> where T: TryFromObject + AnyStrWrapper, @@ -188,7 +188,7 @@ pub trait AnyStr { splitn(self, pattern, (args.maxsplit + 1) as usize, vm) } } else { - splitw(self, args.maxsplit, vm) + split_whitespace(self, args.maxsplit, vm) }; Ok(splits) } diff --git a/vm/src/builtins/bytearray.rs b/vm/src/builtins/bytearray.rs index 3d4822cf48..ce2232d8eb 100644 --- a/vm/src/builtins/bytearray.rs +++ b/vm/src/builtins/bytearray.rs @@ -9,7 +9,7 @@ use crate::{ anystr::{self, AnyStr}, atomic_func, byte::{bytes_from_object, value_from_object}, - bytesinner::{ + bytes_inner::{ ByteInnerFindOptions, ByteInnerNewOptions, ByteInnerPaddingOptions, ByteInnerSplitOptions, ByteInnerTranslateOptions, DecodeArgs, PyBytesInner, bytes_decode, }, diff --git a/vm/src/builtins/bytes.rs b/vm/src/builtins/bytes.rs index 434de6a76c..77b9f9d526 100644 --- a/vm/src/builtins/bytes.rs +++ b/vm/src/builtins/bytes.rs @@ -6,7 +6,7 @@ use crate::{ TryFromBorrowedObject, TryFromObject, VirtualMachine, anystr::{self, AnyStr}, atomic_func, - bytesinner::{ + bytes_inner::{ ByteInnerFindOptions, ByteInnerNewOptions, ByteInnerPaddingOptions, ByteInnerSplitOptions, ByteInnerTranslateOptions, DecodeArgs, PyBytesInner, bytes_decode, }, diff --git a/vm/src/builtins/dict.rs b/vm/src/builtins/dict.rs index fc2f206dd0..f78543a5f5 100644 --- a/vm/src/builtins/dict.rs +++ b/vm/src/builtins/dict.rs @@ -12,7 +12,7 @@ use crate::{ }, class::{PyClassDef, PyClassImpl}, common::ascii, - dictdatatype::{self, DictKey}, + dict_inner::{self, DictKey}, function::{ArgIterable, KwArgs, OptionalArg, PyArithmeticValue::*, PyComparisonValue}, iter::PyExactSizeIterator, protocol::{PyIterIter, PyIterReturn, PyMappingMethods, PyNumberMethods, PySequenceMethods}, @@ -27,7 +27,7 @@ use rustpython_common::lock::PyMutex; use std::fmt; use std::sync::LazyLock; -pub type DictContentType = dictdatatype::Dict; +pub type DictContentType = dict_inner::Dict; #[pyclass(module = false, name = "dict", unhashable = true, traverse)] #[derive(Default)] @@ -154,7 +154,7 @@ impl PyDict { self.entries.contains(vm, key).unwrap() } - pub fn size(&self) -> dictdatatype::DictSize { + pub fn size(&self) -> dict_inner::DictSize { self.entries.size() } } @@ -811,7 +811,7 @@ macro_rules! dict_view { #[pyclass(module = false, name = $iter_class_name)] #[derive(Debug)] pub(crate) struct $iter_name { - pub size: dictdatatype::DictSize, + pub size: dict_inner::DictSize, pub internal: PyMutex>, } @@ -884,7 +884,7 @@ macro_rules! dict_view { #[pyclass(module = false, name = $reverse_iter_class_name)] #[derive(Debug)] pub(crate) struct $reverse_iter_name { - pub size: dictdatatype::DictSize, + pub size: dict_inner::DictSize, internal: PyMutex>, } diff --git a/vm/src/builtins/float.rs b/vm/src/builtins/float.rs index 27f1f3273f..85f2a07bb9 100644 --- a/vm/src/builtins/float.rs +++ b/vm/src/builtins/float.rs @@ -1,5 +1,3 @@ -// spell-checker:ignore numer denom - use super::{ PyByteArray, PyBytes, PyInt, PyIntRef, PyStr, PyStrRef, PyType, PyTypeRef, try_bigint_to_f64, }; diff --git a/vm/src/builtins/function.rs b/vm/src/builtins/function.rs index 3181f1068f..e054ac4348 100644 --- a/vm/src/builtins/function.rs +++ b/vm/src/builtins/function.rs @@ -90,13 +90,13 @@ impl PyFunction { ) -> PyResult<()> { let code = &*self.code; let nargs = func_args.args.len(); - let nexpected_args = code.arg_count as usize; + let n_expected_args = code.arg_count as usize; let total_args = code.arg_count as usize + code.kwonlyarg_count as usize; // let arg_names = self.code.arg_names(); // This parses the arguments from args and kwargs into // the proper variables keeping into account default values - // and starargs and kwargs. + // and star-args and kwargs. // See also: PyEval_EvalCodeWithName in cpython: // https://github.com/python/cpython/blob/main/Python/ceval.c#L3681 @@ -108,7 +108,7 @@ impl PyFunction { // zip short-circuits if either iterator returns None, which is the behavior we want -- // only fill as much as there is to fill with as much as we have for (local, arg) in Iterator::zip( - fastlocals.iter_mut().take(nexpected_args), + fastlocals.iter_mut().take(n_expected_args), args_iter.by_ref().take(nargs), ) { *local = Some(arg); @@ -122,11 +122,11 @@ impl PyFunction { vararg_offset += 1; } else { // Check the number of positional arguments - if nargs > nexpected_args { + if nargs > n_expected_args { return Err(vm.new_type_error(format!( "{}() takes {} positional arguments but {} were given", self.qualname(), - nexpected_args, + n_expected_args, nargs ))); } @@ -141,7 +141,7 @@ impl PyFunction { None }; - let argpos = |range: std::ops::Range<_>, name: &str| { + let arg_pos = |range: std::ops::Range<_>, name: &str| { code.varnames .iter() .enumerate() @@ -155,7 +155,7 @@ impl PyFunction { // Handle keyword arguments for (name, value) in func_args.kwargs { // Check if we have a parameter with this name: - if let Some(pos) = argpos(code.posonlyarg_count as usize..total_args, &name) { + if let Some(pos) = arg_pos(code.posonlyarg_count as usize..total_args, &name) { let slot = &mut fastlocals[pos]; if slot.is_some() { return Err(vm.new_type_error(format!( @@ -167,7 +167,7 @@ impl PyFunction { *slot = Some(value); } else if let Some(kwargs) = kwargs.as_ref() { kwargs.set_item(&name, value, vm)?; - } else if argpos(0..code.posonlyarg_count as usize, &name).is_some() { + } else if arg_pos(0..code.posonlyarg_count as usize, &name).is_some() { posonly_passed_as_kwarg.push(name); } else { return Err(vm.new_type_error(format!( @@ -196,15 +196,15 @@ impl PyFunction { // Add missing positional arguments, if we have fewer positional arguments than the // function definition calls for - if nargs < nexpected_args { + if nargs < n_expected_args { let defaults = get_defaults!().0.as_ref().map(|tup| tup.as_slice()); let n_defs = defaults.map_or(0, |d| d.len()); - let nrequired = code.arg_count as usize - n_defs; + let n_required = code.arg_count as usize - n_defs; // Given the number of defaults available, check all the arguments for which we // _don't_ have defaults; if any are missing, raise an exception - let mut missing: Vec<_> = (nargs..nrequired) + let mut missing: Vec<_> = (nargs..n_required) .filter_map(|i| { if fastlocals[i].is_none() { Some(&code.varnames[i]) @@ -247,13 +247,13 @@ impl PyFunction { } if let Some(defaults) = defaults { - let n = std::cmp::min(nargs, nexpected_args); - let i = n.saturating_sub(nrequired); + let n = std::cmp::min(nargs, n_expected_args); + let i = n.saturating_sub(n_required); // We have sufficient defaults, so iterate over the corresponding names and use // the default if we don't already have a value for i in i..defaults.len() { - let slot = &mut fastlocals[nrequired + i]; + let slot = &mut fastlocals[n_required + i]; if slot.is_none() { *slot = Some(defaults[i].clone()); } diff --git a/vm/src/builtins/genericalias.rs b/vm/src/builtins/genericalias.rs index 549985bcfb..18649718dd 100644 --- a/vm/src/builtins/genericalias.rs +++ b/vm/src/builtins/genericalias.rs @@ -253,7 +253,7 @@ fn tuple_index(tuple: &PyTupleRef, item: &PyObjectRef) -> Option { fn subs_tvars( obj: PyObjectRef, params: &PyTupleRef, - argitems: &[PyObjectRef], + arg_items: &[PyObjectRef], vm: &VirtualMachine, ) -> PyResult { obj.get_attr(identifier!(vm, __parameters__), vm) @@ -267,7 +267,7 @@ fn subs_tvars( .iter() .map(|arg| { if let Some(idx) = tuple_index(params, arg) { - argitems[idx].clone() + arg_items[idx].clone() } else { arg.clone() } diff --git a/vm/src/builtins/int.rs b/vm/src/builtins/int.rs index 5f12f2490e..80aaae03eb 100644 --- a/vm/src/builtins/int.rs +++ b/vm/src/builtins/int.rs @@ -3,7 +3,7 @@ use crate::{ AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact, PyResult, TryFromBorrowedObject, VirtualMachine, builtins::PyStrRef, - bytesinner::PyBytesInner, + bytes_inner::PyBytesInner, class::PyClassImpl, common::{ format::FormatSpec, diff --git a/vm/src/builtins/memory.rs b/vm/src/builtins/memory.rs index 09239e3e49..801d94fb36 100644 --- a/vm/src/builtins/memory.rs +++ b/vm/src/builtins/memory.rs @@ -6,7 +6,7 @@ use crate::{ AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromBorrowedObject, TryFromObject, VirtualMachine, atomic_func, buffer::FormatSpec, - bytesinner::bytes_to_hex, + bytes_inner::bytes_to_hex, class::PyClassImpl, common::{ borrow::{BorrowedValue, BorrowedValueMut}, diff --git a/vm/src/builtins/module.rs b/vm/src/builtins/module.rs index 8c8f22cf58..2cdc13a59c 100644 --- a/vm/src/builtins/module.rs +++ b/vm/src/builtins/module.rs @@ -122,7 +122,7 @@ impl Py { name.downcast::().ok() } - // TODO: to be replaced by the commented-out dict method above once dictoffsets land + // TODO: to be replaced by the commented-out dict method above once dictoffset land pub fn dict(&self) -> PyDictRef { self.as_object().dict().unwrap() } diff --git a/vm/src/builtins/set.rs b/vm/src/builtins/set.rs index 3e10e5c6b7..43e6ee1f7d 100644 --- a/vm/src/builtins/set.rs +++ b/vm/src/builtins/set.rs @@ -11,7 +11,7 @@ use crate::{ class::PyClassImpl, common::{ascii, hash::PyHash, lock::PyMutex, rc::PyRc}, convert::ToPyResult, - dictdatatype::{self, DictSize}, + dict_inner::{self, DictSize}, function::{ArgIterable, OptionalArg, PosArgs, PyArithmeticValue, PyComparisonValue}, protocol::{PyIterReturn, PyNumberMethods, PySequenceMethods}, recursion::ReprGuard, @@ -30,7 +30,7 @@ use rustpython_common::{ use std::sync::LazyLock; use std::{fmt, ops::Deref}; -pub type SetContentType = dictdatatype::Dict<()>; +pub type SetContentType = dict_inner::Dict<()>; #[pyclass(module = false, name = "set", unhashable = true, traverse)] #[derive(Default)] @@ -460,7 +460,7 @@ impl PySetInner { hash = self.content.try_fold_keys(hash, |h, element| { Ok(h ^ _shuffle_bits(element.hash(vm)? as u64)) })?; - // Disperse patterns arising in nested frozensets + // Disperse patterns arising in nested frozen-sets hash ^= (hash >> 11) ^ (hash >> 25); hash = hash.wrapping_mul(69069).wrapping_add(907133923); // -1 is reserved as an error code diff --git a/vm/src/builtins/tuple.rs b/vm/src/builtins/tuple.rs index 1b6e281657..1dc7861071 100644 --- a/vm/src/builtins/tuple.rs +++ b/vm/src/builtins/tuple.rs @@ -332,7 +332,7 @@ impl PyTuple { #[pymethod(magic)] fn getnewargs(zelf: PyRef, vm: &VirtualMachine) -> (PyTupleRef,) { // the arguments to pass to tuple() is just one tuple - so we'll be doing tuple(tup), which - // should just return tup, or tuplesubclass(tup), which'll copy/validate (e.g. for a + // should just return tup, or tuple_subclass(tup), which'll copy/validate (e.g. for a // structseq) let tup_arg = if zelf.class().is(vm.ctx.types.tuple_type) { zelf diff --git a/vm/src/builtins/type.rs b/vm/src/builtins/type.rs index 776c777cb3..a0c7ee58ff 100644 --- a/vm/src/builtins/type.rs +++ b/vm/src/builtins/type.rs @@ -320,7 +320,7 @@ impl PyType { } } - // This is used for class initialisation where the vm is not yet available. + // This is used for class initialization where the vm is not yet available. pub fn set_str_attr>( &self, attr_name: &str, @@ -451,7 +451,7 @@ impl Py { F: Fn(&Self) -> Option, { // the hot path will be primitive types which usually hit the result from itself. - // try std::intrinsics::likely once it is stablized + // try std::intrinsics::likely once it is stabilized if let Some(r) = f(self) { Some(r) } else { diff --git a/vm/src/bytesinner.rs b/vm/src/bytes_inner.rs similarity index 99% rename from vm/src/bytesinner.rs rename to vm/src/bytes_inner.rs index 88d2b9744f..10394721e7 100644 --- a/vm/src/bytesinner.rs +++ b/vm/src/bytes_inner.rs @@ -1,3 +1,4 @@ +// cspell:ignore unchunked use crate::{ AsObject, PyObject, PyObjectRef, PyPayload, PyResult, TryFromBorrowedObject, VirtualMachine, anystr::{self, AnyStr, AnyStrContainer, AnyStrWrapper}, diff --git a/vm/src/dictdatatype.rs b/vm/src/dict_inner.rs similarity index 99% rename from vm/src/dictdatatype.rs rename to vm/src/dict_inner.rs index ab37b7dc85..c49ab752de 100644 --- a/vm/src/dictdatatype.rs +++ b/vm/src/dict_inner.rs @@ -20,7 +20,7 @@ use num_traits::ToPrimitive; use std::{fmt, mem::size_of, ops::ControlFlow}; // HashIndex is intended to be same size with hash::PyHash -// but it doesn't mean the values are compatible with actual pyhash value +// but it doesn't mean the values are compatible with actual PyHash value /// hash value of an object returned by __hash__ type HashValue = hash::PyHash; @@ -691,7 +691,7 @@ impl Dict { type LookupResult = (IndexEntry, IndexIndex); /// Types implementing this trait can be used to index -/// the dictionary. Typical usecases are: +/// the dictionary. Typical use-cases are: /// - PyObjectRef -> arbitrary python type used as key /// - str -> string reference used as key, this is often used internally pub trait DictKey { diff --git a/vm/src/function/fspath.rs b/vm/src/function/fspath.rs index 74051644e0..28145e490a 100644 --- a/vm/src/function/fspath.rs +++ b/vm/src/function/fspath.rs @@ -62,7 +62,7 @@ impl FsPath { // TODO: FS encodings match self { FsPath::Str(s) => vm.fsencode(s), - FsPath::Bytes(b) => Self::bytes_as_osstr(b.as_bytes(), vm).map(Cow::Borrowed), + FsPath::Bytes(b) => Self::bytes_as_os_str(b.as_bytes(), vm).map(Cow::Borrowed), } } @@ -84,7 +84,7 @@ impl FsPath { pub fn to_path_buf(&self, vm: &VirtualMachine) -> PyResult { let path = match self { FsPath::Str(s) => PathBuf::from(s.as_str()), - FsPath::Bytes(b) => PathBuf::from(Self::bytes_as_osstr(b, vm)?), + FsPath::Bytes(b) => PathBuf::from(Self::bytes_as_os_str(b, vm)?), }; Ok(path) } @@ -99,8 +99,8 @@ impl FsPath { .map_err(|err| err.into_pyexception(vm)) } - pub fn bytes_as_osstr<'a>(b: &'a [u8], vm: &VirtualMachine) -> PyResult<&'a std::ffi::OsStr> { - rustpython_common::os::bytes_as_osstr(b) + pub fn bytes_as_os_str<'a>(b: &'a [u8], vm: &VirtualMachine) -> PyResult<&'a std::ffi::OsStr> { + rustpython_common::os::bytes_as_os_str(b) .map_err(|_| vm.new_unicode_decode_error("can't decode path for utf-8".to_owned())) } } diff --git a/vm/src/intern.rs b/vm/src/intern.rs index bb9220d069..08e41bb5b5 100644 --- a/vm/src/intern.rs +++ b/vm/src/intern.rs @@ -281,7 +281,7 @@ impl InternableString for PyRefExact { } pub trait MaybeInternedString: - AsRef + crate::dictdatatype::DictKey + sealed::SealedMaybeInterned + AsRef + crate::dict_inner::DictKey + sealed::SealedMaybeInterned { fn as_interned(&self) -> Option<&'static PyStrInterned>; } diff --git a/vm/src/lib.rs b/vm/src/lib.rs index 2e4afa3ea1..9561a9cc23 100644 --- a/vm/src/lib.rs +++ b/vm/src/lib.rs @@ -43,14 +43,14 @@ mod anystr; pub mod buffer; pub mod builtins; pub mod byte; -mod bytesinner; +mod bytes_inner; pub mod cformat; pub mod class; mod codecs; pub mod compiler; pub mod convert; mod coroutine; -mod dictdatatype; +mod dict_inner; #[cfg(feature = "rustpython-compiler")] pub mod eval; pub mod exceptions; diff --git a/vm/src/object/core.rs b/vm/src/object/core.rs index bbe900f7cd..a6049884d8 100644 --- a/vm/src/object/core.rs +++ b/vm/src/object/core.rs @@ -370,11 +370,11 @@ impl PyWeak { let dealloc = { let mut guard = unsafe { self.parent.as_ref().lock() }; let offset = std::mem::offset_of!(PyInner, payload); - let pyinner = (self as *const Self) + let py_inner = (self as *const Self) .cast::() .wrapping_sub(offset) .cast::>(); - let node_ptr = unsafe { NonNull::new_unchecked(pyinner as *mut Py) }; + let node_ptr = unsafe { NonNull::new_unchecked(py_inner as *mut Py) }; // the list doesn't have ownership over its PyRef! we're being dropped // right now so that should be obvious!! std::mem::forget(unsafe { guard.list.remove(node_ptr) }); diff --git a/vm/src/object/traverse.rs b/vm/src/object/traverse.rs index 9ff0f88343..c105d23feb 100644 --- a/vm/src/object/traverse.rs +++ b/vm/src/object/traverse.rs @@ -26,7 +26,7 @@ pub unsafe trait Traverse { /// If some field is not called, the worst results is just memory leak, /// but if some field is called repeatedly, panic and deadlock can happen. /// - /// - _**DO NOT**_ clone a `PyObjectRef` or `Pyef` in `traverse()` + /// - _**DO NOT**_ clone a `PyObjectRef` or `PyRef` in `traverse()` fn traverse(&self, traverse_fn: &mut TraverseFn<'_>); } diff --git a/vm/src/protocol/object.rs b/vm/src/protocol/object.rs index 256baa0fdf..1e972eb540 100644 --- a/vm/src/protocol/object.rs +++ b/vm/src/protocol/object.rs @@ -7,10 +7,10 @@ use crate::{ PyAsyncGen, PyBytes, PyDict, PyDictRef, PyGenericAlias, PyInt, PyList, PyStr, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef, pystr::AsPyStr, }, - bytesinner::ByteInnerNewOptions, + bytes_inner::ByteInnerNewOptions, common::{hash::PyHash, str::to_ascii}, convert::{ToPyObject, ToPyResult}, - dictdatatype::DictKey, + dict_inner::DictKey, function::{Either, OptionalArg, PyArithmeticValue, PySetterValue}, object::PyPayload, protocol::{PyIter, PyMapping, PySequence}, diff --git a/vm/src/protocol/sequence.rs b/vm/src/protocol/sequence.rs index 5d5622c156..0681c3e664 100644 --- a/vm/src/protocol/sequence.rs +++ b/vm/src/protocol/sequence.rs @@ -118,7 +118,7 @@ impl PySequence<'_> { return f(self, other, vm); } - // if both arguments apear to be sequences, try fallback to __add__ + // if both arguments appear to be sequences, try fallback to __add__ if self.check() && other.to_sequence().check() { let ret = vm.binary_op1(self.obj, other, PyNumberBinaryOp::Add)?; if let PyArithmeticValue::Implemented(ret) = PyArithmeticValue::from_object(vm, ret) { @@ -156,7 +156,7 @@ impl PySequence<'_> { return f(self, other, vm); } - // if both arguments apear to be sequences, try fallback to __iadd__ + // if both arguments appear to be sequences, try fallback to __iadd__ if self.check() && other.to_sequence().check() { let ret = vm._iadd(self.obj, other)?; if let PyArithmeticValue::Implemented(ret) = PyArithmeticValue::from_object(vm, ret) { diff --git a/vm/src/py_io.rs b/vm/src/py_io.rs index c50f09e2bf..87df9a73d8 100644 --- a/vm/src/py_io.rs +++ b/vm/src/py_io.rs @@ -70,12 +70,12 @@ pub fn file_readline(obj: &PyObject, size: Option, vm: &VirtualMachine) - }; let ret = match_class!(match ret { s @ PyStr => { - let sval = s.as_str(); - if sval.is_empty() { + let s_val = s.as_str(); + if s_val.is_empty() { return Err(eof_err()); } - if let Some(nonl) = sval.strip_suffix('\n') { - vm.ctx.new_str(nonl).into() + if let Some(no_nl) = s_val.strip_suffix('\n') { + vm.ctx.new_str(no_nl).into() } else { s.into() } diff --git a/vm/src/scope.rs b/vm/src/scope.rs index e01209857c..7515468d78 100644 --- a/vm/src/scope.rs +++ b/vm/src/scope.rs @@ -141,7 +141,7 @@ impl Scope { // impl Sealed for super::PyStrRef {} // } // pub trait PyName: -// sealed::Sealed + crate::dictdatatype::DictKey + Clone + ToPyObject +// sealed::Sealed + crate::dict_inner::DictKey + Clone + ToPyObject // { // } // impl PyName for str {} diff --git a/vm/src/stdlib/ast/python.rs b/vm/src/stdlib/ast/python.rs index 50f8294c76..74c4db888a 100644 --- a/vm/src/stdlib/ast/python.rs +++ b/vm/src/stdlib/ast/python.rs @@ -19,8 +19,8 @@ pub(crate) mod _ast { fn init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> { let fields = zelf.get_attr("_fields", vm)?; let fields: Vec = fields.try_to_value(vm)?; - let numargs = args.args.len(); - if numargs > fields.len() { + let n_args = args.args.len(); + if n_args > fields.len() { return Err(vm.new_type_error(format!( "{} constructor takes at most {} positional argument{}", zelf.class().name(), @@ -33,7 +33,7 @@ pub(crate) mod _ast { } for (key, value) in args.kwargs { if let Some(pos) = fields.iter().position(|f| f.as_str() == key) { - if pos < numargs { + if pos < n_args { return Err(vm.new_type_error(format!( "{} got multiple values for argument '{}'", zelf.class().name(), diff --git a/vm/src/stdlib/io.rs b/vm/src/stdlib/io.rs index 6f13e0878d..3e1979e3d0 100644 --- a/vm/src/stdlib/io.rs +++ b/vm/src/stdlib/io.rs @@ -1360,7 +1360,7 @@ mod _io { }) } - pub fn repr_fileobj_name(obj: &PyObject, vm: &VirtualMachine) -> PyResult> { + pub fn repr_file_obj_name(obj: &PyObject, vm: &VirtualMachine) -> PyResult> { let name = match obj.get_attr("name", vm) { Ok(name) => Some(name), Err(e) @@ -1549,7 +1549,7 @@ mod _io { #[pyslot] fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult { - let name_repr = repr_fileobj_name(zelf, vm)?; + let name_repr = repr_file_obj_name(zelf, vm)?; let cls = zelf.class(); let slot_name = cls.slot_name(); let repr = if let Some(name_repr) = name_repr { @@ -4293,7 +4293,7 @@ mod fileio { if fd < 0 { return Ok("<_io.FileIO [closed]>".to_owned()); } - let name_repr = repr_fileobj_name(zelf.as_object(), vm)?; + let name_repr = repr_file_obj_name(zelf.as_object(), vm)?; let mode = zelf.mode(); let closefd = if zelf.closefd.load() { "True" } else { "False" }; let repr = if let Some(name_repr) = name_repr { diff --git a/vm/src/stdlib/itertools.rs b/vm/src/stdlib/itertools.rs index 18641ac3b6..addfc991ff 100644 --- a/vm/src/stdlib/itertools.rs +++ b/vm/src/stdlib/itertools.rs @@ -87,7 +87,7 @@ mod decl { fn setstate(zelf: PyRef, state: PyTupleRef, vm: &VirtualMachine) -> PyResult<()> { let args = state.as_slice(); if args.is_empty() { - let msg = String::from("function takes at leat 1 arguments (0 given)"); + let msg = String::from("function takes at least 1 arguments (0 given)"); return Err(vm.new_type_error(msg)); } if args.len() > 2 { @@ -1892,14 +1892,14 @@ mod decl { return Ok(PyIterReturn::StopIteration(None)); } let mut result: Vec = Vec::new(); - let mut numactive = zelf.iterators.len(); + let mut num_active = zelf.iterators.len(); for idx in 0..zelf.iterators.len() { let next_obj = match zelf.iterators[idx].next(vm)? { PyIterReturn::Return(obj) => obj, PyIterReturn::StopIteration(v) => { - numactive -= 1; - if numactive == 0 { + num_active -= 1; + if num_active == 0 { return Ok(PyIterReturn::StopIteration(v)); } zelf.fillvalue.read().clone() diff --git a/vm/src/stdlib/marshal.rs b/vm/src/stdlib/marshal.rs index 564ee5bf6c..17d8ccd3e1 100644 --- a/vm/src/stdlib/marshal.rs +++ b/vm/src/stdlib/marshal.rs @@ -1,3 +1,4 @@ +// cspell:ignore pyfrozen pycomplex pub(crate) use decl::make_module; #[pymodule(name = "marshal")] diff --git a/vm/src/stdlib/operator.rs b/vm/src/stdlib/operator.rs index 38f931b0e7..fbb8147e9f 100644 --- a/vm/src/stdlib/operator.rs +++ b/vm/src/stdlib/operator.rs @@ -532,9 +532,9 @@ mod _operator { fn reduce(zelf: PyRef, vm: &VirtualMachine) -> PyResult { // With no kwargs, return (type(obj), (name, *args)) tuple. if zelf.args.kwargs.is_empty() { - let mut pargs = vec![zelf.name.as_object().to_owned()]; - pargs.append(&mut zelf.args.args.clone()); - Ok(vm.new_tuple((zelf.class().to_owned(), vm.ctx.new_tuple(pargs)))) + let mut py_args = vec![zelf.name.as_object().to_owned()]; + py_args.append(&mut zelf.args.args.clone()); + Ok(vm.new_tuple((zelf.class().to_owned(), vm.ctx.new_tuple(py_args)))) } else { // If we have kwargs, create a partial function that contains them and pass back that // along with the args. diff --git a/vm/src/stdlib/os.rs b/vm/src/stdlib/os.rs index 48e16ad41f..08a5051fe7 100644 --- a/vm/src/stdlib/os.rs +++ b/vm/src/stdlib/os.rs @@ -120,8 +120,8 @@ pub(super) struct FollowSymlinks( #[pyarg(named, name = "follow_symlinks", default = true)] pub bool, ); -fn bytes_as_osstr<'a>(b: &'a [u8], vm: &VirtualMachine) -> PyResult<&'a ffi::OsStr> { - rustpython_common::os::bytes_as_osstr(b) +fn bytes_as_os_str<'a>(b: &'a [u8], vm: &VirtualMachine) -> PyResult<&'a ffi::OsStr> { + rustpython_common::os::bytes_as_os_str(b) .map_err(|_| vm.new_unicode_decode_error("can't decode path for utf-8".to_owned())) } @@ -393,8 +393,8 @@ pub(super) mod _os { if key.is_empty() || key.contains(&b'=') { return Err(vm.new_value_error("illegal environment variable name".to_string())); } - let key = super::bytes_as_osstr(key, vm)?; - let value = super::bytes_as_osstr(value, vm)?; + let key = super::bytes_as_os_str(key, vm)?; + let value = super::bytes_as_os_str(value, vm)?; // SAFETY: requirements forwarded from the caller unsafe { env::set_var(key, value) }; Ok(()) @@ -415,7 +415,7 @@ pub(super) mod _os { ), )); } - let key = super::bytes_as_osstr(key, vm)?; + let key = super::bytes_as_os_str(key, vm)?; // SAFETY: requirements forwarded from the caller unsafe { env::remove_var(key) }; Ok(()) diff --git a/vm/src/stdlib/sre.rs b/vm/src/stdlib/sre.rs index fd41aa2b7d..fdb48c7524 100644 --- a/vm/src/stdlib/sre.rs +++ b/vm/src/stdlib/sre.rs @@ -228,7 +228,7 @@ mod _sre { } #[pymethod(name = "match")] - fn pymatch( + fn py_match( zelf: PyRef, string_args: StringArgs, vm: &VirtualMachine, @@ -242,7 +242,7 @@ mod _sre { let req = x.create_request(&zelf, pos, endpos); let mut state = State::default(); Ok(state - .pymatch(&req) + .py_match(&req) .then(|| Match::new(&mut state, zelf.clone(), string).into_ref(&vm.ctx))) }) } @@ -257,7 +257,7 @@ mod _sre { let mut req = x.create_request(&zelf, string_args.pos, string_args.endpos); req.match_all = true; let mut state = State::default(); - Ok(state.pymatch(&req).then(|| { + Ok(state.py_match(&req).then(|| { Match::new(&mut state, zelf.clone(), string_args.string).into_ref(&vm.ctx) })) }) @@ -346,11 +346,11 @@ mod _sre { #[pymethod] fn sub(zelf: PyRef, sub_args: SubArgs, vm: &VirtualMachine) -> PyResult { - Self::subx(zelf, sub_args, false, vm) + Self::sub_impl(zelf, sub_args, false, vm) } #[pymethod] fn subn(zelf: PyRef, sub_args: SubArgs, vm: &VirtualMachine) -> PyResult { - Self::subx(zelf, sub_args, true, vm) + Self::sub_impl(zelf, sub_args, true, vm) } #[pymethod] @@ -407,7 +407,7 @@ mod _sre { self.pattern.clone() } - fn subx( + fn sub_impl( zelf: PyRef, sub_args: SubArgs, subn: bool, @@ -860,12 +860,12 @@ mod _sre { } #[pymethod(name = "match")] - fn pymatch(&self, vm: &VirtualMachine) -> PyResult>> { + fn py_match(&self, vm: &VirtualMachine) -> PyResult>> { with_sre_str!(self.pattern, &self.string.clone(), vm, |s| { let mut req = s.create_request(&self.pattern, self.start.load(), self.end); let mut state = State::default(); req.must_advance = self.must_advance.load(); - let has_matched = state.pymatch(&req); + let has_matched = state.py_match(&req); self.must_advance .store(state.cursor.position == state.start); diff --git a/vm/src/stdlib/sys.rs b/vm/src/stdlib/sys.rs index fdfe2faf69..befa0f8dff 100644 --- a/vm/src/stdlib/sys.rs +++ b/vm/src/stdlib/sys.rs @@ -513,19 +513,19 @@ mod sys { } // Get the size of the version information block - let verblock_size = + let ver_block_size = GetFileVersionInfoSizeW(kernel32_path.as_ptr(), std::ptr::null_mut()); - if verblock_size == 0 { + if ver_block_size == 0 { return Err(std::io::Error::last_os_error()); } // Allocate a buffer to hold the version information - let mut verblock = vec![0u8; verblock_size as usize]; + let mut ver_block = vec![0u8; ver_block_size as usize]; if GetFileVersionInfoW( kernel32_path.as_ptr(), 0, - verblock_size, - verblock.as_mut_ptr() as *mut _, + ver_block_size, + ver_block.as_mut_ptr() as *mut _, ) == 0 { return Err(std::io::Error::last_os_error()); @@ -540,7 +540,7 @@ mod sys { let mut ffi_ptr: *mut VS_FIXEDFILEINFO = std::ptr::null_mut(); let mut ffi_len: u32 = 0; if VerQueryValueW( - verblock.as_ptr() as *const _, + ver_block.as_ptr() as *const _, sub_block.as_ptr(), &mut ffi_ptr as *mut *mut VS_FIXEDFILEINFO as *mut *mut _, &mut ffi_len as *mut u32, @@ -572,10 +572,10 @@ mod sys { let mut version: OSVERSIONINFOEXW = unsafe { std::mem::zeroed() }; version.dwOSVersionInfoSize = std::mem::size_of::() as u32; let result = unsafe { - let osvi = &mut version as *mut OSVERSIONINFOEXW as *mut OSVERSIONINFOW; + let os_vi = &mut version as *mut OSVERSIONINFOEXW as *mut OSVERSIONINFOW; // SAFETY: GetVersionExW accepts a pointer of OSVERSIONINFOW, but windows-sys crate's type currently doesn't allow to do so. // https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-getversionexw#parameters - GetVersionExW(osvi) + GetVersionExW(os_vi) }; if result == 0 { diff --git a/vm/src/stdlib/thread.rs b/vm/src/stdlib/thread.rs index ad80f1f1e1..0ee087e5e4 100644 --- a/vm/src/stdlib/thread.rs +++ b/vm/src/stdlib/thread.rs @@ -334,8 +334,8 @@ pub(crate) mod _thread { ); } } - SENTINELS.with(|sents| { - for lock in sents.replace(Default::default()) { + SENTINELS.with(|sentinels| { + for lock in sentinels.replace(Default::default()) { if lock.mu.is_locked() { unsafe { lock.mu.unlock() }; } @@ -360,7 +360,7 @@ pub(crate) mod _thread { #[pyfunction] fn _set_sentinel(vm: &VirtualMachine) -> PyRef { let lock = Lock { mu: RawMutex::INIT }.into_ref(&vm.ctx); - SENTINELS.with(|sents| sents.borrow_mut().push(lock.clone())); + SENTINELS.with(|sentinels| sentinels.borrow_mut().push(lock.clone())); lock } @@ -385,7 +385,7 @@ pub(crate) mod _thread { #[pyclass(with(GetAttr, SetAttr), flags(BASETYPE))] impl Local { - fn ldict(&self, vm: &VirtualMachine) -> PyDictRef { + fn l_dict(&self, vm: &VirtualMachine) -> PyDictRef { self.data.get_or(|| vm.ctx.new_dict()).clone() } @@ -401,12 +401,12 @@ pub(crate) mod _thread { impl GetAttr for Local { fn getattro(zelf: &Py, attr: &Py, vm: &VirtualMachine) -> PyResult { - let ldict = zelf.ldict(vm); + let l_dict = zelf.l_dict(vm); if attr.as_str() == "__dict__" { - Ok(ldict.into()) + Ok(l_dict.into()) } else { zelf.as_object() - .generic_getattr_opt(attr, Some(ldict), vm)? + .generic_getattr_opt(attr, Some(l_dict), vm)? .ok_or_else(|| { vm.new_attribute_error(format!( "{} has no attribute '{}'", @@ -431,7 +431,7 @@ pub(crate) mod _thread { zelf.class().name() ))) } else { - let dict = zelf.ldict(vm); + let dict = zelf.l_dict(vm); if let PySetterValue::Assign(value) = value { dict.set_item(attr, value, vm)?; } else { diff --git a/vm/src/stdlib/time.rs b/vm/src/stdlib/time.rs index 5f41304c19..cc543e9249 100644 --- a/vm/src/stdlib/time.rs +++ b/vm/src/stdlib/time.rs @@ -243,8 +243,8 @@ mod decl { let timestamp = match value { Either::A(float) => { let secs = float.trunc() as i64; - let nsecs = (float.fract() * 1e9) as u32; - DateTime::::from_timestamp(secs, nsecs) + let nano_secs = (float.fract() * 1e9) as u32; + DateTime::::from_timestamp(secs, nano_secs) } Either::B(int) => DateTime::::from_timestamp(int, 0), }; diff --git a/vm/src/types/slot.rs b/vm/src/types/slot.rs index 2d8c825817..e2121973ec 100644 --- a/vm/src/types/slot.rs +++ b/vm/src/types/slot.rs @@ -390,7 +390,7 @@ impl PyType { }}; } - macro_rules! toggle_subslot { + macro_rules! toggle_sub_slot { ($group:ident, $name:ident, $func:expr) => { self.slots .$group @@ -520,90 +520,90 @@ impl PyType { toggle_slot!(del, del_wrapper); } _ if name == identifier!(ctx, __int__) => { - toggle_subslot!(as_number, int, number_unary_op_wrapper!(__int__)); + toggle_sub_slot!(as_number, int, number_unary_op_wrapper!(__int__)); } _ if name == identifier!(ctx, __index__) => { - toggle_subslot!(as_number, index, number_unary_op_wrapper!(__index__)); + toggle_sub_slot!(as_number, index, number_unary_op_wrapper!(__index__)); } _ if name == identifier!(ctx, __float__) => { - toggle_subslot!(as_number, float, number_unary_op_wrapper!(__float__)); + toggle_sub_slot!(as_number, float, number_unary_op_wrapper!(__float__)); } _ if name == identifier!(ctx, __add__) => { - toggle_subslot!(as_number, add, number_binary_op_wrapper!(__add__)); + toggle_sub_slot!(as_number, add, number_binary_op_wrapper!(__add__)); } _ if name == identifier!(ctx, __radd__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, right_add, number_binary_right_op_wrapper!(__radd__) ); } _ if name == identifier!(ctx, __iadd__) => { - toggle_subslot!(as_number, inplace_add, number_binary_op_wrapper!(__iadd__)); + toggle_sub_slot!(as_number, inplace_add, number_binary_op_wrapper!(__iadd__)); } _ if name == identifier!(ctx, __sub__) => { - toggle_subslot!(as_number, subtract, number_binary_op_wrapper!(__sub__)); + toggle_sub_slot!(as_number, subtract, number_binary_op_wrapper!(__sub__)); } _ if name == identifier!(ctx, __rsub__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, right_subtract, number_binary_right_op_wrapper!(__rsub__) ); } _ if name == identifier!(ctx, __isub__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, inplace_subtract, number_binary_op_wrapper!(__isub__) ); } _ if name == identifier!(ctx, __mul__) => { - toggle_subslot!(as_number, multiply, number_binary_op_wrapper!(__mul__)); + toggle_sub_slot!(as_number, multiply, number_binary_op_wrapper!(__mul__)); } _ if name == identifier!(ctx, __rmul__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, right_multiply, number_binary_right_op_wrapper!(__rmul__) ); } _ if name == identifier!(ctx, __imul__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, inplace_multiply, number_binary_op_wrapper!(__imul__) ); } _ if name == identifier!(ctx, __mod__) => { - toggle_subslot!(as_number, remainder, number_binary_op_wrapper!(__mod__)); + toggle_sub_slot!(as_number, remainder, number_binary_op_wrapper!(__mod__)); } _ if name == identifier!(ctx, __rmod__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, right_remainder, number_binary_right_op_wrapper!(__rmod__) ); } _ if name == identifier!(ctx, __imod__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, inplace_remainder, number_binary_op_wrapper!(__imod__) ); } _ if name == identifier!(ctx, __divmod__) => { - toggle_subslot!(as_number, divmod, number_binary_op_wrapper!(__divmod__)); + toggle_sub_slot!(as_number, divmod, number_binary_op_wrapper!(__divmod__)); } _ if name == identifier!(ctx, __rdivmod__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, right_divmod, number_binary_right_op_wrapper!(__rdivmod__) ); } _ if name == identifier!(ctx, __pow__) => { - toggle_subslot!(as_number, power, |a, b, c, vm| { + toggle_sub_slot!(as_number, power, |a, b, c, vm| { let args = if vm.is_none(c) { vec![b.to_owned()] } else { @@ -613,7 +613,7 @@ impl PyType { }); } _ if name == identifier!(ctx, __rpow__) => { - toggle_subslot!(as_number, right_power, |a, b, c, vm| { + toggle_sub_slot!(as_number, right_power, |a, b, c, vm| { let args = if vm.is_none(c) { vec![a.to_owned()] } else { @@ -623,141 +623,141 @@ impl PyType { }); } _ if name == identifier!(ctx, __ipow__) => { - toggle_subslot!(as_number, inplace_power, |a, b, _, vm| { + toggle_sub_slot!(as_number, inplace_power, |a, b, _, vm| { vm.call_special_method(a, identifier!(vm, __ipow__), (b.to_owned(),)) }); } _ if name == identifier!(ctx, __lshift__) => { - toggle_subslot!(as_number, lshift, number_binary_op_wrapper!(__lshift__)); + toggle_sub_slot!(as_number, lshift, number_binary_op_wrapper!(__lshift__)); } _ if name == identifier!(ctx, __rlshift__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, right_lshift, number_binary_right_op_wrapper!(__rlshift__) ); } _ if name == identifier!(ctx, __ilshift__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, inplace_lshift, number_binary_op_wrapper!(__ilshift__) ); } _ if name == identifier!(ctx, __rshift__) => { - toggle_subslot!(as_number, rshift, number_binary_op_wrapper!(__rshift__)); + toggle_sub_slot!(as_number, rshift, number_binary_op_wrapper!(__rshift__)); } _ if name == identifier!(ctx, __rrshift__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, right_rshift, number_binary_right_op_wrapper!(__rrshift__) ); } _ if name == identifier!(ctx, __irshift__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, inplace_rshift, number_binary_op_wrapper!(__irshift__) ); } _ if name == identifier!(ctx, __and__) => { - toggle_subslot!(as_number, and, number_binary_op_wrapper!(__and__)); + toggle_sub_slot!(as_number, and, number_binary_op_wrapper!(__and__)); } _ if name == identifier!(ctx, __rand__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, right_and, number_binary_right_op_wrapper!(__rand__) ); } _ if name == identifier!(ctx, __iand__) => { - toggle_subslot!(as_number, inplace_and, number_binary_op_wrapper!(__iand__)); + toggle_sub_slot!(as_number, inplace_and, number_binary_op_wrapper!(__iand__)); } _ if name == identifier!(ctx, __xor__) => { - toggle_subslot!(as_number, xor, number_binary_op_wrapper!(__xor__)); + toggle_sub_slot!(as_number, xor, number_binary_op_wrapper!(__xor__)); } _ if name == identifier!(ctx, __rxor__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, right_xor, number_binary_right_op_wrapper!(__rxor__) ); } _ if name == identifier!(ctx, __ixor__) => { - toggle_subslot!(as_number, inplace_xor, number_binary_op_wrapper!(__ixor__)); + toggle_sub_slot!(as_number, inplace_xor, number_binary_op_wrapper!(__ixor__)); } _ if name == identifier!(ctx, __or__) => { - toggle_subslot!(as_number, or, number_binary_op_wrapper!(__or__)); + toggle_sub_slot!(as_number, or, number_binary_op_wrapper!(__or__)); } _ if name == identifier!(ctx, __ror__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, right_or, number_binary_right_op_wrapper!(__ror__) ); } _ if name == identifier!(ctx, __ior__) => { - toggle_subslot!(as_number, inplace_or, number_binary_op_wrapper!(__ior__)); + toggle_sub_slot!(as_number, inplace_or, number_binary_op_wrapper!(__ior__)); } _ if name == identifier!(ctx, __floordiv__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, floor_divide, number_binary_op_wrapper!(__floordiv__) ); } _ if name == identifier!(ctx, __rfloordiv__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, right_floor_divide, number_binary_right_op_wrapper!(__rfloordiv__) ); } _ if name == identifier!(ctx, __ifloordiv__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, inplace_floor_divide, number_binary_op_wrapper!(__ifloordiv__) ); } _ if name == identifier!(ctx, __truediv__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, true_divide, number_binary_op_wrapper!(__truediv__) ); } _ if name == identifier!(ctx, __rtruediv__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, right_true_divide, number_binary_right_op_wrapper!(__rtruediv__) ); } _ if name == identifier!(ctx, __itruediv__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, inplace_true_divide, number_binary_op_wrapper!(__itruediv__) ); } _ if name == identifier!(ctx, __matmul__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, matrix_multiply, number_binary_op_wrapper!(__matmul__) ); } _ if name == identifier!(ctx, __rmatmul__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, right_matrix_multiply, number_binary_right_op_wrapper!(__rmatmul__) ); } _ if name == identifier!(ctx, __imatmul__) => { - toggle_subslot!( + toggle_sub_slot!( as_number, inplace_matrix_multiply, number_binary_op_wrapper!(__imatmul__) diff --git a/vm/src/vm/mod.rs b/vm/src/vm/mod.rs index 752943319d..4b1cece8c5 100644 --- a/vm/src/vm/mod.rs +++ b/vm/src/vm/mod.rs @@ -648,7 +648,7 @@ impl VirtualMachine { list_borrow = value.payload::().unwrap().borrow_vec(); &list_borrow } else { - return self.map_pyiter(value, func); + return self.map_py_iter(value, func); }; slice.iter().map(|obj| func(obj.clone())).collect() } @@ -682,12 +682,12 @@ impl VirtualMachine { ref t @ PyTuple => Ok(t.iter().cloned().map(f).collect()), // TODO: put internal iterable type obj => { - Ok(self.map_pyiter(obj, f)) + Ok(self.map_py_iter(obj, f)) } }) } - fn map_pyiter(&self, value: &PyObject, mut f: F) -> PyResult> + fn map_py_iter(&self, value: &PyObject, mut f: F) -> PyResult> where F: FnMut(PyObjectRef) -> PyResult, { diff --git a/vm/sre_engine/benches/benches.rs b/vm/sre_engine/benches/benches.rs index ee49b036de..e2372d783e 100644 --- a/vm/sre_engine/benches/benches.rs +++ b/vm/sre_engine/benches/benches.rs @@ -92,20 +92,20 @@ fn basic(c: &mut Criterion) { let (req, mut state) = p.state(s); assert!(state.search(req)); let (req, mut state) = p.state(s); - assert!(state.pymatch(&req)); + assert!(state.py_match(&req)); let (mut req, mut state) = p.state(s); req.match_all = true; - assert!(state.pymatch(&req)); + assert!(state.py_match(&req)); let s2 = format!("{}{}{}", " ".repeat(10000), s, " ".repeat(10000)); let (req, mut state) = p.state_range(s2.as_str(), 0..usize::MAX); assert!(state.search(req)); let (req, mut state) = p.state_range(s2.as_str(), 10000..usize::MAX); - assert!(state.pymatch(&req)); + assert!(state.py_match(&req)); let (req, mut state) = p.state_range(s2.as_str(), 10000..10000 + s.len()); - assert!(state.pymatch(&req)); + assert!(state.py_match(&req)); let (mut req, mut state) = p.state_range(s2.as_str(), 10000..10000 + s.len()); req.match_all = true; - assert!(state.pymatch(&req)); + assert!(state.py_match(&req)); }); }); } diff --git a/vm/sre_engine/src/engine.rs b/vm/sre_engine/src/engine.rs index 9b27f55031..1e0b15fd01 100644 --- a/vm/sre_engine/src/engine.rs +++ b/vm/sre_engine/src/engine.rs @@ -129,7 +129,7 @@ impl State { req.string.adjust_cursor(&mut self.cursor, start); } - pub fn pymatch(&mut self, req: &Request<'_, S>) -> bool { + pub fn py_match(&mut self, req: &Request<'_, S>) -> bool { self.start = req.start; req.string.adjust_cursor(&mut self.cursor, self.start); diff --git a/vm/sre_engine/tests/tests.rs b/vm/sre_engine/tests/tests.rs index 5499afa281..0ada32e5db 100644 --- a/vm/sre_engine/tests/tests.rs +++ b/vm/sre_engine/tests/tests.rs @@ -1,3 +1,4 @@ +// cspell:disable use rustpython_sre_engine::{Request, State, StrDrive}; struct Pattern { @@ -21,7 +22,7 @@ fn test_2427() { #[rustfmt::skip] let lookbehind = Pattern { pattern: "(?x)++x", code: &[14, 4, 0, 2, 4294967295, 28, 8, 1, 4294967295, 27, 4, 16, 120, 1, 1, 16, 120, 1] }; // END GENERATED let (req, mut state) = p.state("xxx"); - assert!(!state.pymatch(&req)); + assert!(!state.py_match(&req)); } #[test] @@ -162,7 +163,7 @@ fn test_bug_20998() { // END GENERATED let (mut req, mut state) = p.state("ABC"); req.match_all = true; - assert!(state.pymatch(&req)); + assert!(state.py_match(&req)); assert_eq!(state.cursor.position, 3); } @@ -173,7 +174,7 @@ fn test_bigcharset() { #[rustfmt::skip] let p = Pattern { pattern: "[a-z]*", code: &[14, 4, 0, 0, 4294967295, 24, 97, 0, 4294967295, 39, 92, 10, 3, 33685760, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 33686018, 0, 0, 0, 134217726, 0, 0, 0, 0, 0, 131072, 0, 2147483648, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1] }; // END GENERATED let (req, mut state) = p.state("x "); - assert!(state.pymatch(&req)); + assert!(state.py_match(&req)); assert_eq!(state.cursor.position, 1); } diff --git a/wasm/lib/src/convert.rs b/wasm/lib/src/convert.rs index 4f6e4db35c..bccf5564fa 100644 --- a/wasm/lib/src/convert.rs +++ b/wasm/lib/src/convert.rs @@ -33,8 +33,8 @@ extern "C" { } pub fn py_err_to_js_err(vm: &VirtualMachine, py_err: &PyBaseExceptionRef) -> JsValue { - let jserr = vm.try_class("_js", "JSError").ok(); - let js_arg = if jserr.is_some_and(|jserr| py_err.fast_isinstance(&jserr)) { + let js_err = vm.try_class("_js", "JSError").ok(); + let js_arg = if js_err.is_some_and(|js_err| py_err.fast_isinstance(&js_err)) { py_err.get_arg(0) } else { None @@ -116,7 +116,7 @@ pub fn py_to_js(vm: &VirtualMachine, py_obj: PyObjectRef) -> JsValue { } } let result = py_obj.call(py_func_args, vm); - pyresult_to_jsresult(vm, result) + pyresult_to_js_result(vm, result) }) }; let closure = Closure::wrap(Box::new(closure) @@ -164,7 +164,7 @@ pub fn object_entries(obj: &Object) -> impl Iterator Result { +pub fn pyresult_to_js_result(vm: &VirtualMachine, result: PyResult) -> Result { result .map(|value| py_to_js(vm, value)) .map_err(|err| py_err_to_js_err(vm, &err)) diff --git a/wasm/lib/src/js_module.rs b/wasm/lib/src/js_module.rs index a5b7281481..f159c467d0 100644 --- a/wasm/lib/src/js_module.rs +++ b/wasm/lib/src/js_module.rs @@ -326,7 +326,7 @@ mod _js { .map(|arg| PyJsValue::new(arg).into_pyobject(vm)), ); let res = py_obj.call(pyargs, vm); - convert::pyresult_to_jsresult(vm, res) + convert::pyresult_to_js_result(vm, res) }) }; let closure: ClosureType = if once { @@ -500,7 +500,7 @@ mod _js { Some(on_fulfill) => stored_vm.interp.enter(move |vm| { let val = convert::js_to_py(vm, val); let res = on_fulfill.invoke((val,), vm); - convert::pyresult_to_jsresult(vm, res) + convert::pyresult_to_js_result(vm, res) }), None => Ok(val), }, @@ -508,7 +508,7 @@ mod _js { Some(on_reject) => stored_vm.interp.enter(move |vm| { let err = new_js_error(vm, err); let res = on_reject.invoke((err,), vm); - convert::pyresult_to_jsresult(vm, res) + convert::pyresult_to_js_result(vm, res) }), None => Err(err), }, diff --git a/wasm/lib/src/vm_class.rs b/wasm/lib/src/vm_class.rs index c04877f7e3..d84603e986 100644 --- a/wasm/lib/src/vm_class.rs +++ b/wasm/lib/src/vm_class.rs @@ -340,7 +340,7 @@ impl WASMVirtualMachine { let code = vm.compile(source, mode, source_path); let code = code.map_err(convert::syntax_err)?; let result = vm.run_code_obj(code, scope.clone()); - convert::pyresult_to_jsresult(vm, result) + convert::pyresult_to_js_result(vm, result) })? }