mirrors/RustPython
0
0 Fork 0
mirror of https://github.com/RustPython/RustPython.git synced 2026-10-28 18:59:04 +08:00
Code Activity

Add map_unwrap_or clippy rule (#7829)

Browse Source
This commit is contained in:
Shahar Naveh authored and GitHub committed 2026-05-12 00:51:23 +09:00
1 parent 949a620811
commit 4a46e84eb9
50 files changed
+208 -339
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Cargo.toml
+2 -1
View File
@@ -338,10 +338,11 @@ inefficient_to_string = "warn"
redundant_clone = "warn"
debug_assert_with_mut_call = "warn"
unused_peekable = "warn"
manual_is_variant_and = "warn"
or_fun_call = "warn"
unnested_or_patterns = "warn"
# pedantic lints to enforce gradually
cloned_instead_of_copied = "warn"
manual_is_variant_and = "warn"
map_unwrap_or = "warn"
must_use_candidate = "warn"
crates/codegen/src/compile.rs
+3 -8
View File
@@ -5412,6 +5412,7 @@ impl Compiler {
self.prepare_decorators(decorator_list)?;
let is_generic = type_params.is_some();
#[expect(clippy::map_unwrap_or, reason = "Changing this will not compile")]
let firstlineno = decorator_list
.first()
.map(|decorator| {
@@ -6882,19 +6883,13 @@ impl Compiler {
return Err(self.error(CodegenErrorType::MultipleStarArgs));
}
// star wildcard check
star_wildcard = pattern
.as_match_star()
.map(|m| m.name.is_none())
.unwrap_or(false);
star_wildcard = pattern.as_match_star().is_some_and(|m| m.name.is_none());
only_wildcard &= star_wildcard;
star = Some(i);
continue;
}
// wildcard check
only_wildcard &= pattern
.as_match_as()
.map(|m| m.name.is_none())
.unwrap_or(false);
only_wildcard &= pattern.as_match_as().is_some_and(|m| m.name.is_none());
}
// Keep the subject on top during the sequence and length checks.
crates/codegen/src/ir.rs
+9 -17
View File
@@ -8907,8 +8907,7 @@ impl CodeInfo {
if let DeoptKind::ReturnIter { tail_start_idx } = deopt_kind {
let tail_instr_idx = real_instrs
.get(tail_start_idx)
.map(|(instr_idx, _)| *instr_idx)
.unwrap_or(block_instr_len);
.map_or(block_instr_len, |(instr_idx, _)| *instr_idx);
if !tail_returns_without_store(
&self.blocks,
&is_pre_handler,
@@ -9472,8 +9471,7 @@ impl CodeInfo {
block.disable_load_fast_borrow,
block
.start_depth
.map(|depth| depth.to_string())
.unwrap_or_else(|| String::from("None")),
.map_or_else(|| String::from("None"), |depth| depth.to_string()),
);
for info in &block.instructions {
let lineno = instruction_lineno(info);
@@ -10169,8 +10167,7 @@ fn mark_cold(blocks: &mut [Block]) {
let has_fallthrough = block
.instructions
.last()
.map(|ins| !ins.instr.is_scope_exit() && !ins.instr.is_unconditional_jump())
.unwrap_or(true);
.is_none_or(|ins| !ins.instr.is_scope_exit() && !ins.instr.is_unconditional_jump());
if has_fallthrough && block.next != BlockIdx::NULL {
let next_idx = block.next.idx();
if !blocks[next_idx].except_handler && !warm[next_idx] {
@@ -10209,11 +10206,9 @@ fn push_cold_blocks_to_end(blocks: &mut Vec<Block>) {
block.cold
&& block.next != BlockIdx::NULL
&& !blocks[block.next.idx()].cold
&& block
.instructions
.last()
.map(|ins| !ins.instr.is_scope_exit() && !ins.instr.is_unconditional_jump())
.unwrap_or(true)
&& block.instructions.last().is_none_or(|ins| {
!ins.instr.is_scope_exit() && !ins.instr.is_unconditional_jump()
})
})
.map(|(idx, block)| (idx, block.next))
.collect();
@@ -13343,8 +13338,7 @@ fn duplicate_end_returns(blocks: &mut Vec<Block>, metadata: &CodeUnitMetadata) {
if current != last_block && !block.cold {
let last_ins = block.instructions.last();
let has_fallthrough = last_ins
.map(|ins| !ins.instr.is_scope_exit() && !ins.instr.is_unconditional_jump())
.unwrap_or(true);
.is_none_or(|ins| !ins.instr.is_scope_exit() && !ins.instr.is_unconditional_jump());
// Don't duplicate if block already ends with the same return pattern
let already_has_return = block.instructions.len() >= 2 && {
let n = block.instructions.len();
@@ -13518,8 +13512,7 @@ fn duplicate_named_except_cleanup_returns(blocks: &mut Vec<Block>, metadata: &Co
let fallthroughs_into_target = blocks[layout_pred.idx()]
.instructions
.last()
.map(|ins| !ins.instr.is_scope_exit() && !ins.instr.is_unconditional_jump())
.unwrap_or(true);
.is_none_or(|ins| !ins.instr.is_scope_exit() && !ins.instr.is_unconditional_jump());
if !fallthroughs_into_target || predecessors[target.idx()] < 2 {
continue;
}
@@ -13765,8 +13758,7 @@ pub(crate) fn label_exception_targets(blocks: &mut [Block]) {
let has_fallthrough = blocks[bi]
.instructions
.last()
.map(|ins| !ins.instr.is_scope_exit() && !ins.instr.is_unconditional_jump())
.unwrap_or(true); // Empty block falls through
.is_none_or(|ins| !ins.instr.is_scope_exit() && !ins.instr.is_unconditional_jump()); // Empty block falls through
if has_fallthrough {
visited[next.idx()] = true;
block_stacks[next.idx()] = Some(stack);
crates/codegen/src/symboltable.rs
+7 -11
View File
@@ -1085,17 +1085,13 @@ impl SymbolTableBuilder {
}
fn enter_scope(&mut self, name: &str, typ: CompilerScope, line_number: u32) {
let is_nested = self
.tables
.last()
.map(|table| {
table.is_nested
|| matches!(
table.typ,
CompilerScope::Function | CompilerScope::AsyncFunction
)
})
.unwrap_or(false);
let is_nested = self.tables.last().is_some_and(|table| {
table.is_nested
|| matches!(
table.typ,
CompilerScope::Function | CompilerScope::AsyncFunction
)
});
// Inherit mangled_names from parent for non-class scopes
let inherited_mangled_names = self
.tables
crates/common/src/cformat.rs
+1 -1
View File
@@ -620,7 +620,7 @@ where
let (index, c) = iter.next().ok_or_else(|| {
(
CFormatErrorType::IncompleteFormat,
iter.peek().map(|x| x.0).unwrap_or(0),
iter.peek().map_or(0, |x| x.0),
)
})?;
let format_type = match c.to_char_lossy() {
crates/derive-impl/src/pyclass.rs
+1 -2
View File
@@ -331,8 +331,7 @@ fn validate_base_field(item: &Item, base_path: &syn::Path) -> Result<Option<Toke
let base_name = base_path
.segments
.last()
.map(|s| s.ident.to_string())
.unwrap_or_else(|| quote!(#base_path).to_string());
.map_or_else(|| quote!(#base_path).to_string(), |s| s.ident.to_string());
match &item_struct.fields {
syn::Fields::Named(fields) => {
crates/jit/tests/common.rs
+6 -4
View File
@@ -116,10 +116,12 @@ fn extract_annotations_from_annotate_code(code: &CodeObject) -> HashMap<Wtf8Buf,
// Value can be a name (type ref) or a const string (forward ref)
let type_name = if val_is_const {
match code.constants.get(val_idx) {
Some(ConstantData::Str { value }) => value
.as_str()
.map(|s| s.to_owned())
.unwrap_or_else(|_| value.to_string_lossy().into_owned()),
Some(ConstantData::Str { value }) => {
value.as_str().map_or_else(
|_| value.to_string_lossy().into_owned(),
|s| s.to_owned(),
)
}
Some(other) => panic!(
"Unsupported annotation const for '{:?}' at idx {}: {:?}",
param_name, val_idx, other
crates/sre_engine/src/string.rs
+14 -35
View File
@@ -339,29 +339,20 @@ const fn is_py_ascii_whitespace(b: u8) -> bool {
#[inline]
pub(crate) fn is_word(ch: u32) -> bool {
ch == '_' as u32
|| u8::try_from(ch)
.map(|x| x.is_ascii_alphanumeric())
.unwrap_or(false)
ch == '_' as u32 || u8::try_from(ch).is_ok_and(|x| x.is_ascii_alphanumeric())
}
#[inline]
pub(crate) fn is_space(ch: u32) -> bool {
u8::try_from(ch)
.map(is_py_ascii_whitespace)
.unwrap_or(false)
u8::try_from(ch).is_ok_and(is_py_ascii_whitespace)
}
#[inline]
pub(crate) fn is_digit(ch: u32) -> bool {
u8::try_from(ch)
.map(|x| x.is_ascii_digit())
.unwrap_or(false)
u8::try_from(ch).is_ok_and(|x| x.is_ascii_digit())
}
#[inline]
pub(crate) fn is_loc_alnum(ch: u32) -> bool {
// FIXME: Ignore the locales
u8::try_from(ch)
.map(|x| x.is_ascii_alphanumeric())
.unwrap_or(false)
u8::try_from(ch).is_ok_and(|x| x.is_ascii_alphanumeric())
}
#[inline]
pub(crate) fn is_loc_word(ch: u32) -> bool {
@@ -374,9 +365,7 @@ pub(crate) const fn is_linebreak(ch: u32) -> bool {
#[inline]
#[must_use]
pub fn lower_ascii(ch: u32) -> u32 {
u8::try_from(ch)
.map(|x| x.to_ascii_lowercase() as u32)
.unwrap_or(ch)
u8::try_from(ch).map_or(ch, |x| x.to_ascii_lowercase() as u32)
}
#[inline]
pub(crate) fn lower_locate(ch: u32) -> u32 {
@@ -386,16 +375,12 @@ pub(crate) fn lower_locate(ch: u32) -> u32 {
#[inline]
pub(crate) fn upper_locate(ch: u32) -> u32 {
// FIXME: Ignore the locales
u8::try_from(ch)
.map(|x| x.to_ascii_uppercase() as u32)
.unwrap_or(ch)
u8::try_from(ch).map_or(ch, |x| x.to_ascii_uppercase() as u32)
}
#[inline]
pub(crate) fn is_uni_digit(ch: u32) -> bool {
// TODO: check with cpython
char::try_from(ch)
.map(|x| x.is_ascii_digit())
.unwrap_or(false)
char::try_from(ch).is_ok_and(|x| x.is_ascii_digit())
}
#[inline]
pub(crate) fn is_uni_space(ch: u32) -> bool {
@@ -444,13 +429,11 @@ pub(crate) const fn is_uni_linebreak(ch: u32) -> bool {
#[inline]
pub(crate) fn is_uni_alnum(ch: u32) -> bool {
// TODO: check with cpython
char::try_from(ch)
.map(|c| {
GeneralCategoryGroup::Letter
.union(GeneralCategoryGroup::Number)
.contains(GeneralCategory::for_char(c))
})
.unwrap_or(false)
char::try_from(ch).is_ok_and(|c| {
GeneralCategoryGroup::Letter
.union(GeneralCategoryGroup::Number)
.contains(GeneralCategory::for_char(c))
})
}
#[inline]
pub(crate) fn is_uni_word(ch: u32) -> bool {
@@ -460,15 +443,11 @@ pub(crate) fn is_uni_word(ch: u32) -> bool {
#[must_use]
pub fn lower_unicode(ch: u32) -> u32 {
// TODO: check with cpython
char::try_from(ch)
.map(|x| x.to_lowercase().next().unwrap() as u32)
.unwrap_or(ch)
char::try_from(ch).map_or(ch, |x| x.to_lowercase().next().unwrap() as u32)
}
#[inline]
#[must_use]
pub fn upper_unicode(ch: u32) -> u32 {
// TODO: check with cpython
char::try_from(ch)
.map(|x| x.to_uppercase().next().unwrap() as u32)
.unwrap_or(ch)
char::try_from(ch).map_or(ch, |x| x.to_uppercase().next().unwrap() as u32)
}
crates/stdlib/src/_asyncio.rs
+1 -2
View File
@@ -900,8 +900,7 @@ pub(crate) mod _asyncio {
{
let s = state
.str(vm)
.map(|s| s.as_wtf8().to_lowercase())
.unwrap_or_else(|_| Wtf8Buf::from("unknown"));
.map_or_else(|_| Wtf8Buf::from("unknown"), |s| s.as_wtf8().to_lowercase());
return Ok(s);
}
Ok(Wtf8Buf::from("state=unknown"))
crates/stdlib/src/_opcode.rs
+21 -36
View File
@@ -34,25 +34,22 @@ mod _opcode {
#[pyfunction]
fn stack_effect(args: StackEffectArgs, vm: &VirtualMachine) -> PyResult<i32> {
let oparg = args
.oparg
.map(|v| {
if !v.fast_isinstance(vm.ctx.types.int_type) {
return Err(vm.new_type_error(format!(
let oparg = args.oparg.map_or(Ok(0), |v| {
if !v.fast_isinstance(vm.ctx.types.int_type) {
return Err(vm.new_type_error(format!(
"'{}' object cannot be interpreted as an integer",
v.class().name()
)));
}
v.downcast_ref::<PyInt>()
.ok_or_else(|| {
vm.new_type_error(format!(
"'{}' object cannot be interpreted as an integer",
v.class().name()
)));
}
v.downcast_ref::<PyInt>()
.ok_or_else(|| {
vm.new_type_error(format!(
"'{}' object cannot be interpreted as an integer",
v.class().name()
))
})?
.try_to_primitive::<u32>(vm)
})
.unwrap_or(Ok(0))?;
))
})?
.try_to_primitive::<u32>(vm)
})?;
let jump: Option<bool> = match args.jump {
Some(v) => {
@@ -99,49 +96,37 @@ mod _opcode {
#[pyfunction]
fn has_arg(opcode: i32) -> bool {
try_from_i32(opcode).map(|op| op.has_arg()).unwrap_or(false)
try_from_i32(opcode).is_ok_and(|op| op.has_arg())
}
#[pyfunction]
fn has_const(opcode: i32) -> bool {
try_from_i32(opcode)
.map(|op| op.has_const())
.unwrap_or(false)
try_from_i32(opcode).is_ok_and(|op| op.has_const())
}
#[pyfunction]
fn has_name(opcode: i32) -> bool {
try_from_i32(opcode)
.map(|op| op.has_name())
.unwrap_or(false)
try_from_i32(opcode).is_ok_and(|op| op.has_name())
}
#[pyfunction]
fn has_jump(opcode: i32) -> bool {
try_from_i32(opcode)
.map(|op| op.has_jump())
.unwrap_or(false)
try_from_i32(opcode).is_ok_and(|op| op.has_jump())
}
#[pyfunction]
fn has_free(opcode: i32) -> bool {
try_from_i32(opcode)
.map(|op| op.has_free())
.unwrap_or(false)
try_from_i32(opcode).is_ok_and(|op| op.has_free())
}
#[pyfunction]
fn has_local(opcode: i32) -> bool {
try_from_i32(opcode)
.map(|op| op.has_local())
.unwrap_or(false)
try_from_i32(opcode).is_ok_and(|op| op.has_local())
}
#[pyfunction]
fn has_exc(opcode: i32) -> bool {
try_from_i32(opcode)
.map(|op| op.is_block_push())
.unwrap_or(false)
try_from_i32(opcode).is_ok_and(|op| op.is_block_push())
}
#[pyfunction]
crates/stdlib/src/bisect.rs
+5 -8
View File
@@ -44,14 +44,11 @@ mod _bisect {
) -> PyResult<(usize, usize)> {
// We only deal with positives for lo, try_from can't fail.
// Default is always a Some so we can safely unwrap.
let lo = handle_default(lo, vm)?
.map(|value| {
usize::try_from(value).map_err(|_| vm.new_value_error("lo must be non-negative"))
})
.unwrap_or(Ok(0))?;
let hi = handle_default(hi, vm)?
.map(|value| usize::try_from(value).unwrap_or(0))
.unwrap_or(seq_len);
let lo = handle_default(lo, vm)?.map_or(Ok(0), |value| {
usize::try_from(value).map_err(|_| vm.new_value_error("lo must be non-negative"))
})?;
let hi =
handle_default(hi, vm)?.map_or(seq_len, |value| usize::try_from(value).unwrap_or(0));
Ok((lo, hi))
}
crates/stdlib/src/csv.rs
+1 -5
View File
@@ -964,11 +964,7 @@ mod _csv {
#[inline]
fn trim_spaces(input: &[u8]) -> &[u8] {
let trimmed_start = input.iter().position(|&x| x != b' ').unwrap_or(input.len());
let trimmed_end = input
.iter()
.rposition(|&x| x != b' ')
.map(|i| i + 1)
.unwrap_or(0);
let trimmed_end = input.iter().rposition(|&x| x != b' ').map_or(0, |i| i + 1);
&input[trimmed_start..trimmed_end]
}
let input = if *skipinitialspace {
crates/stdlib/src/faulthandler.rs
+4 -5
View File
@@ -218,13 +218,13 @@ mod decl {
let funcname = frame.code.obj_name.as_str();
let lasti = frame.lasti();
let lineno = if lasti == 0 {
frame.code.first_line_number.map(|n| n.get()).unwrap_or(1) as u32
frame.code.first_line_number.map_or(1, |n| n.get()) as u32
} else {
let idx = (lasti as usize).saturating_sub(1);
if idx < frame.code.locations.len() {
frame.code.locations[idx].0.line.get() as u32
} else {
frame.code.first_line_number.map(|n| n.get()).unwrap_or(0) as u32
frame.code.first_line_number.map_or(0, |n| n.get()) as u32
}
};
@@ -292,7 +292,7 @@ mod decl {
let funcname = frame.code.obj_name.as_str();
let filename = frame.code.source_path().as_str();
let lineno = if frame.lasti() == 0 {
frame.code.first_line_number.map(|n| n.get()).unwrap_or(1) as u32
frame.code.first_line_number.map_or(1, |n| n.get()) as u32
} else {
frame.current_location().line.get() as u32
};
@@ -1112,8 +1112,7 @@ mod decl {
} else {
// Already registered, keep previous handler
user_signals::get_user_signal(signum)
.map(|u| u.previous)
.unwrap_or(unsafe { core::mem::zeroed() })
.map_or(unsafe { core::mem::zeroed() }, |u| u.previous)
};
user_signals::set_user_signal(
crates/stdlib/src/json.rs
+1 -2
View File
@@ -616,8 +616,7 @@ mod _json {
let end_byte_idx = wtf8
.code_point_indices()
.nth(end_char_idx as usize)
.map(|(i, _)| i)
.unwrap_or(wtf8.len());
.map_or(wtf8.len(), |(i, _)| i);
Ok((value, end_char_idx as usize, end_byte_idx))
}
Err(err) if err.fast_isinstance(vm.ctx.exceptions.stop_iteration) => {
crates/stdlib/src/math.rs
+1 -3
View File
@@ -559,9 +559,7 @@ mod math {
let mut flt_result: f64 = if let Some(ref f) = obj_float {
f.to_f64()
} else if start_is_float && let OptionalArg::Present(s) = &start {
s.downcast_ref::<PyFloat>()
.map(|f| f.to_f64())
.unwrap_or(1.0)
s.downcast_ref::<PyFloat>().map_or(1.0, |f| f.to_f64())
} else {
1.0
};
crates/stdlib/src/mmap.rs
+3 -8
View File
@@ -959,12 +959,8 @@ mod mmap {
let size = self.__len__();
let start = options
.start
.map(|start| start.saturated_at(size))
.unwrap_or_else(|| self.pos());
let end = options
.end
.map(|end| end.saturated_at(size))
.unwrap_or(size);
.map_or_else(|| self.pos(), |start| start.saturated_at(size));
let end = options.end.map_or(size, |end| end.saturated_at(size));
(start, end)
}
@@ -1121,8 +1117,7 @@ mod mmap {
let remaining = self.__len__().saturating_sub(pos);
let num_bytes = num_bytes
.filter(|&n| n >= 0 && (n as usize) <= remaining)
.map(|n| n as usize)
.unwrap_or(remaining);
.map_or(remaining, |n| n as usize);
let end_pos = pos + num_bytes;
let bytes = mmap.deref().as_ref().unwrap().as_slice()[pos..end_pos].to_vec();
crates/stdlib/src/overlapped.rs
+1 -4
View File
@@ -1949,10 +1949,7 @@ mod _overlapped {
let name_wide: Option<Vec<u16>> =
name.map(|n| n.encode_utf16().chain(core::iter::once(0)).collect());
let name_ptr = name_wide
.as_ref()
.map(|n| n.as_ptr())
.unwrap_or(core::ptr::null());
let name_ptr = name_wide.as_ref().map_or(core::ptr::null(), |n| n.as_ptr());
let event = unsafe {
windows_sys::Win32::System::Threading::CreateEventW(
crates/stdlib/src/ssl.rs
+10 -20
View File
@@ -2558,8 +2558,7 @@ mod _ssl {
.connection
.lock()
.as_ref()
.map(|conn| conn.is_session_resumed())
.unwrap_or(false);
.is_some_and(|conn| conn.is_session_resumed());
*self.session_was_reused.lock() = was_resumed;
@@ -2835,7 +2834,7 @@ mod _ssl {
}
let socket_timeout = self.get_socket_timeout(vm)?;
let is_non_blocking = socket_timeout.map(|t| t.is_zero()).unwrap_or(false);
let is_non_blocking = socket_timeout.is_some_and(|t| t.is_zero());
let mut sent_total = 0;
@@ -2918,7 +2917,7 @@ mod _ssl {
}
let timeout = self.get_socket_timeout(vm)?;
let is_non_blocking = timeout.map(|t| t.is_zero()).unwrap_or(false);
let is_non_blocking = timeout.is_some_and(|t| t.is_zero());
let mut sent_total = 0;
while sent_total < buf.len() {
@@ -2976,7 +2975,7 @@ mod _ssl {
pub(crate) fn blocking_flush_all_pending(&self, vm: &VirtualMachine) -> PyResult<()> {
// Get socket timeout to respect during flush
let timeout = self.get_socket_timeout(vm)?;
if timeout.map(|t| t.is_zero()).unwrap_or(false) {
if timeout.is_some_and(|t| t.is_zero()) {
return self.flush_pending_tls_output(vm, None);
}
@@ -3581,7 +3580,7 @@ mod _ssl {
};
let mut reader = conn.reader();
reader.fill_buf().map(|buf| buf.len()).unwrap_or(0)
reader.fill_buf().map_or(0, |buf| buf.len())
};
if pending > 0 {
let mut buf = vec![0u8; pending.min(len)];
@@ -3610,7 +3609,7 @@ mod _ssl {
};
let mut reader = conn.reader();
reader.fill_buf().map(|buf| buf.len()).unwrap_or(0)
reader.fill_buf().map_or(0, |buf| buf.len())
};
if pending > 0 {
let mut buf = vec![0u8; pending.min(len)];
@@ -4776,12 +4775,7 @@ mod _ssl {
// If name=False (default), only accept OID strings
// If name=True, accept both names and OID strings
let entry = if txt
.chars()
.next()
.map(|c| c.is_ascii_digit())
.unwrap_or(false)
{
let entry = if txt.chars().next().is_some_and(|c| c.is_ascii_digit()) {
// Looks like an OID string (starts with digit)
oid::find_by_oid_string(txt)
} else if name {
@@ -4848,13 +4842,9 @@ mod _ssl {
let tuple = vm.ctx.new_tuple(vec![
vm.ctx.new_str("SSL_CERT_FILE").into(), // openssl_cafile_env
default_cafile
.map(|s| vm.ctx.new_str(s).into())
.unwrap_or_else(|| vm.ctx.none()), // openssl_cafile
vm.ctx.new_str("SSL_CERT_DIR").into(), // openssl_capath_env
default_capath
.map(|s| vm.ctx.new_str(s).into())
.unwrap_or_else(|| vm.ctx.none()), // openssl_capath
default_cafile.map_or_else(|| vm.ctx.none(), |s| vm.ctx.new_str(s).into()), // openssl_cafile
vm.ctx.new_str("SSL_CERT_DIR").into(), // openssl_capath_env
default_capath.map_or_else(|| vm.ctx.none(), |s| vm.ctx.new_str(s).into()), // openssl_capath
]);
Ok(tuple.into())
}
crates/stdlib/src/ssl/compat.rs
+2 -4
View File
@@ -1754,8 +1754,7 @@ pub(super) fn ssl_read(
let bytes_read = data
.clone()
.try_into_value::<rustpython_vm::builtins::PyBytes>(vm)
.map(|b| b.as_bytes().len())
.unwrap_or(0);
.map_or(0, |b| b.as_bytes().len());
if bytes_read == 0 {
// No more data available - check if this is clean shutdown or unexpected EOF
@@ -2177,8 +2176,7 @@ fn ssl_ensure_data_available(
let bytes_read = data
.clone()
.try_into_value::<rustpython_vm::builtins::PyBytes>(vm)
.map(|b| b.as_bytes().len())
.unwrap_or(0);
.map_or(0, |b| b.as_bytes().len());
// Check if BIO has EOF set (incoming BIO closed)
let is_eof = if is_bio {
crates/vm/src/builtins/float.rs
+4 -3
View File
@@ -247,9 +247,10 @@ fn float_from_string(val: PyObjectRef, vm: &VirtualMachine) -> PyResult<f64> {
)));
};
crate::literal::float::parse_bytes(b).ok_or_else(|| {
val.repr(vm)
.map(|repr| vm.new_value_error(format!("could not convert string to float: {repr}")))
.unwrap_or_else(|e| e)
val.repr(vm).map_or_else(
|e| e,
|repr| vm.new_value_error(format!("could not convert string to float: {repr}")),
)
})
}
crates/vm/src/builtins/frame.rs
+2 -6
View File
@@ -474,7 +474,7 @@ impl Frame {
// If lasti is 0, execution hasn't started yet - use first line number
// Similar to PyCode_Addr2Line which returns co_firstlineno for addr_q < 0
if self.lasti() == 0 {
self.code.first_line_number.map(|n| n.get()).unwrap_or(1)
self.code.first_line_number.map_or(1, |n| n.get())
} else {
self.current_location().line.get()
}
@@ -496,11 +496,7 @@ impl Frame {
}
};
let first_line = self
.code
.first_line_number
.map(|n| n.get() as i32)
.unwrap_or(1);
let first_line = self.code.first_line_number.map_or(1, |n| n.get() as i32);
if l_new_lineno < first_line {
return Err(vm.new_value_error(format!(
crates/vm/src/builtins/function.rs
+1 -2
View File
@@ -192,8 +192,7 @@ impl PyFunction {
code.code
.constants
.first()
.map(|c| c.as_object().to_owned())
.unwrap_or_else(|| vm.ctx.none())
.map_or_else(|| vm.ctx.none(), |c| c.as_object().to_owned())
} else {
vm.ctx.none()
};
crates/vm/src/builtins/iter.rs
+4 -3
View File
@@ -188,9 +188,10 @@ impl PySequenceIterator {
let internal = self.internal.lock();
if let IterStatus::Active(obj) = &internal.status {
let seq = obj.sequence_unchecked();
seq.length(vm)
.map(|x| PyInt::from(x).into_pyobject(vm))
.unwrap_or_else(|_| vm.ctx.not_implemented())
seq.length(vm).map_or_else(
|_| vm.ctx.not_implemented(),
|x| PyInt::from(x).into_pyobject(vm),
)
} else {
PyInt::from(0).into_pyobject(vm)
}
crates/vm/src/builtins/module.rs
+1 -2
View File
@@ -185,8 +185,7 @@ impl Py<PyModule> {
let is_possibly_shadowing = origin
.as_ref()
.map(|o| is_possibly_shadowing_path(o, vm))
.unwrap_or(false);
.is_some_and(|o| is_possibly_shadowing_path(o, vm));
// Use the ORIGINAL __name__ object for stdlib check (may raise TypeError
// if __name__ is an unhashable str subclass)
let is_possibly_shadowing_stdlib = if is_possibly_shadowing {
crates/vm/src/builtins/object.rs
+2 -3
View File
@@ -756,9 +756,8 @@ fn reduce_newobj(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
// Use copyreg.__newobj_ex__
let newobj = copyreg.get_attr("__newobj_ex__", vm)?;
let args_tuple: PyObjectRef = args.into();
let kwargs_dict: PyObjectRef = kwargs
.map(|k| k.into())
.unwrap_or_else(|| vm.ctx.new_dict().into());
let kwargs_dict: PyObjectRef =
kwargs.map_or_else(|| vm.ctx.new_dict().into(), |k| k.into());
let newargs = vm
.ctx
crates/vm/src/builtins/singletons.rs
+4 -4
View File
@@ -82,10 +82,10 @@ impl Comparable for PyNone {
op: PyComparisonOp,
_vm: &VirtualMachine,
) -> PyResult<PyComparisonValue> {
Ok(op
.identical_optimization(zelf, other)
.map(PyComparisonValue::Implemented)
.unwrap_or(PyComparisonValue::NotImplemented))
Ok(op.identical_optimization(zelf, other).map_or(
PyComparisonValue::NotImplemented,
PyComparisonValue::Implemented,
))
}
}
crates/vm/src/builtins/str.rs
+2 -3
View File
@@ -452,7 +452,7 @@ impl Constructor for PyStr {
input.class().name()
)));
}
let enc_str = encoding.as_ref().map(|e| e.as_str()).unwrap_or("utf-8");
let enc_str = encoding.as_ref().map_or("utf-8", |e| e.as_str());
let s = vm
.state
.codec_registry
@@ -550,8 +550,7 @@ impl PyStr {
pub fn to_string_lossy(&self) -> Cow<'_, str> {
self.to_str()
.map(Cow::Borrowed)
.unwrap_or_else(|| self.as_wtf8().to_string_lossy())
.map_or_else(|| self.as_wtf8().to_string_lossy(), Cow::Borrowed)
}
pub const fn kind(&self) -> StrKind {
crates/vm/src/builtins/template.rs
+1 -2
View File
@@ -116,8 +116,7 @@ impl PyTemplate {
.map(|interp| {
interp
.downcast_ref::<PyInterpolation>()
.map(|i| i.value.clone())
.unwrap_or_else(|| interp.clone())
.map_or_else(|| interp.clone(), |i| i.value.clone())
})
.collect();
vm.ctx.new_tuple(values)
crates/vm/src/builtins/type.rs
+7 -11
View File
@@ -860,21 +860,17 @@ impl PyType {
if slots.flags.contains(PyTypeFlags::DISALLOW_INSTANTIATION) {
slots.new.store(None)
} else if slots.new.load().is_none() {
slots.new.store(
base.as_ref()
.map(|base| base.slots.new.load())
.unwrap_or(None),
)
slots
.new
.store(base.as_ref().and_then(|base| base.slots.new.load()))
}
}
fn set_alloc(slots: &PyTypeSlots, base: &Option<PyTypeRef>) {
if slots.alloc.load().is_none() {
slots.alloc.store(
base.as_ref()
.map(|base| base.slots.alloc.load())
.unwrap_or(None),
);
slots
.alloc
.store(base.as_ref().and_then(|base| base.slots.alloc.load()));
}
}
@@ -2072,7 +2068,7 @@ impl Constructor for PyType {
.map(|base| base.slots.member_count)
.max()
.unwrap();
let heaptype_member_count = heaptype_slots.as_ref().map(|x| x.len()).unwrap_or(0);
let heaptype_member_count = heaptype_slots.as_ref().map_or(0, |x| x.len());
let member_count: usize = base_member_count + heaptype_member_count;
let mut flags = PyTypeFlags::heap_type_flags();
crates/vm/src/exceptions.rs
+4 -6
View File
@@ -2002,8 +2002,8 @@ pub(super) mod types {
.as_ref()
.map(|s| s.str(vm))
.transpose()?
.map(|s| s.to_string())
.unwrap_or_else(|| "None".to_owned());
.map_or_else(|| "None".to_owned(), |s| s.to_string());
if let Some(ref f2) = filename2 {
return Ok(vm.ctx.new_str(format!(
"[WinError {}] {}: {} -> {}",
@@ -2034,14 +2034,12 @@ pub(super) mod types {
.as_ref()
.map(|e| e.str(vm))
.transpose()?
.map(|s| s.to_string())
.unwrap_or_else(|| "None".to_owned());
.map_or_else(|| "None".to_owned(), |s| s.to_string());
let msg = strerror
.as_ref()
.map(|s| s.str(vm))
.transpose()?
.map(|s| s.to_string())
.unwrap_or_else(|| "None".to_owned());
.map_or_else(|| "None".to_owned(), |s| s.to_string());
if let Some(ref f2) = filename2 {
return Ok(vm.ctx.new_str(format!(
"[Errno {}] {}: {} -> {}",
crates/vm/src/frame.rs
+7 -17
View File
@@ -1504,8 +1504,7 @@ impl ExecutingFrame<'_> {
let exc_value: PyObjectRef = exc.clone().into();
let exc_tb: PyObjectRef = exc
.__traceback__()
.map(|tb| -> PyObjectRef { tb.into() })
.unwrap_or_else(|| vm.ctx.none());
.map_or_else(|| vm.ctx.none(), |tb| -> PyObjectRef { tb.into() });
let tuple = vm.ctx.new_tuple(vec![exc_type, exc_value, exc_tb]).into();
vm.trace_event(crate::protocol::TraceEvent::Exception, Some(tuple))?;
}
@@ -3426,8 +3425,7 @@ impl ExecutingFrame<'_> {
let exc = self.pop_value();
let prev_exc = vm
.current_exception()
.map(|e| e.into())
.unwrap_or_else(|| vm.ctx.none());
.map_or_else(|| vm.ctx.none(), |e| e.into());
// Set exc as the current exception
if let Some(exc_ref) = exc.downcast_ref::<PyBaseException>() {
@@ -6089,13 +6087,10 @@ impl ExecutingFrame<'_> {
// because a callback may de-instrument and clear the tables.
let (real_op_byte, also_instruction) = {
let data = self.code.monitoring_data.lock();
let line_op = data.as_ref().map(|d| d.line_opcodes[idx]).unwrap_or(0);
let line_op = data.as_ref().map_or(0, |d| d.line_opcodes[idx]);
if line_op == u8::from(Instruction::InstrumentedInstruction) {
// LINE wraps INSTRUCTION: resolve the INSTRUCTION side-table too
let inst_op = data
.as_ref()
.map(|d| d.per_instruction_opcodes[idx])
.unwrap_or(0);
let inst_op = data.as_ref().map_or(0, |d| d.per_instruction_opcodes[idx]);
(inst_op, true)
} else {
(line_op, false)
@@ -6143,9 +6138,7 @@ impl ExecutingFrame<'_> {
// Get original opcode from side-table
let original_op_byte = {
let data = self.code.monitoring_data.lock();
data.as_ref()
.map(|d| d.per_instruction_opcodes[idx])
.unwrap_or(0)
data.as_ref().map_or(0, |d| d.per_instruction_opcodes[idx])
};
debug_assert!(
original_op_byte != 0,
@@ -6282,8 +6275,7 @@ impl ExecutingFrame<'_> {
let is_possibly_shadowing = origin
.as_ref()
.map(|o| is_possibly_shadowing_path(o, vm))
.unwrap_or(false);
.is_some_and(|o| is_possibly_shadowing_path(o, vm));
let is_possibly_shadowing_stdlib = if is_possibly_shadowing {
if let Some(ref mod_name) = mod_name_obj {
is_stdlib_module_name(mod_name, vm)?
@@ -9618,9 +9610,7 @@ impl ExecutingFrame<'_> {
let stack_len = self.localsplus.stack_len();
if count > stack_len {
let instr = self.code.instructions.get(self.lasti() as usize);
let op_name = instr
.map(|i| format!("{:?}", i.op))
.unwrap_or_else(|| "None".to_string());
let op_name = instr.map_or_else(|| "None".to_string(), |i| format!("{:?}", i.op));
panic!(
"Stack underflow in pop_multiple: trying to pop {} elements from stack with {} elements. lasti={}, code={}, op={}, source_path={}",
count,
crates/vm/src/getpath.rs
+4 -4
View File
@@ -145,10 +145,10 @@ pub fn init_path_config(settings: &Settings) -> Paths {
// Step 5: Set prefix and base_prefix
if venv_prefix.is_some() {
// In venv: prefix = venv directory, base_prefix = original Python's prefix
paths.prefix = venv_prefix
.as_ref()
.map(|p| p.to_string_lossy().into_owned())
.unwrap_or_else(|| calculated_prefix.clone());
paths.prefix = venv_prefix.as_ref().map_or_else(
|| calculated_prefix.clone(),
|p| p.to_string_lossy().into_owned(),
);
paths.base_prefix = calculated_prefix;
} else {
// Not in venv: prefix == base_prefix
crates/vm/src/object/ext.rs
+4 -12
View File
@@ -346,9 +346,7 @@ impl<T: PyPayload> PyAtomicRef<T> {
impl<T: PyPayload> From<Option<PyRef<T>>> for PyAtomicRef<Option<T>> {
fn from(opt_ref: Option<PyRef<T>>) -> Self {
let val = opt_ref
.map(|x| PyRef::leak(x) as *const Py<T> as *mut _)
.unwrap_or(null_mut());
let val = opt_ref.map_or(null_mut(), |x| PyRef::leak(x) as *const Py<T> as *mut _);
Self {
inner: Radium::new(val),
_phantom: Default::default(),
@@ -378,9 +376,7 @@ impl<T: PyPayload> PyAtomicRef<Option<T>> {
/// until no more reference can be used via PyAtomicRef::deref()
#[must_use]
pub unsafe fn swap(&self, opt_ref: Option<PyRef<T>>) -> Option<PyRef<T>> {
let val = opt_ref
.map(|x| PyRef::leak(x) as *const Py<T> as *mut _)
.unwrap_or(null_mut());
let val = opt_ref.map_or(null_mut(), |x| PyRef::leak(x) as *const Py<T> as *mut _);
let old = Radium::swap(&self.inner, val, Ordering::AcqRel);
unsafe { old.cast::<Py<T>>().as_ref().map(|x| PyRef::from_raw(x)) }
}
@@ -440,9 +436,7 @@ impl PyAtomicRef<PyObject> {
impl From<Option<PyObjectRef>> for PyAtomicRef<Option<PyObject>> {
fn from(obj: Option<PyObjectRef>) -> Self {
let val = obj
.map(|x| x.into_raw().as_ptr().cast())
.unwrap_or(null_mut());
let val = obj.map_or(null_mut(), |x| x.into_raw().as_ptr().cast());
Self {
inner: Radium::new(val),
_phantom: Default::default(),
@@ -472,9 +466,7 @@ impl PyAtomicRef<Option<PyObject>> {
/// until no more reference can be used via PyAtomicRef::deref()
#[must_use]
pub unsafe fn swap(&self, obj: Option<PyObjectRef>) -> Option<PyObjectRef> {
let val = obj
.map(|x| x.into_raw().as_ptr().cast())
.unwrap_or(null_mut());
let val = obj.map_or(null_mut(), |x| x.into_raw().as_ptr().cast());
let old = Radium::swap(&self.inner, val, Ordering::AcqRel);
unsafe { NonNull::new(old.cast::<PyObject>()).map(|x| PyObjectRef::from_raw(x)) }
}
crates/vm/src/stdlib/_ast/statement.rs
+20 -15
View File
@@ -191,9 +191,10 @@ impl Node for ast::StmtFunctionDef {
dict.set_item("type_comment", vm.ctx.none(), vm).unwrap();
dict.set_item(
"type_params",
type_params
.map(|tp| tp.ast_to_object(vm, source_file))
.unwrap_or_else(|| vm.ctx.new_list(vec![]).into()),
type_params.map_or_else(
|| vm.ctx.new_list(vec![]).into(),
|tp| tp.ast_to_object(vm, source_file),
),
vm,
)
.unwrap();
@@ -273,17 +274,19 @@ impl Node for ast::StmtClassDef {
.unwrap();
dict.set_item(
"bases",
bases
.map(|b| b.ast_to_object(_vm, source_file))
.unwrap_or_else(|| _vm.ctx.new_list(vec![]).into()),
bases.map_or_else(
|| _vm.ctx.new_list(vec![]).into(),
|b| b.ast_to_object(_vm, source_file),
),
_vm,
)
.unwrap();
dict.set_item(
"keywords",
keywords
.map(|k| k.ast_to_object(_vm, source_file))
.unwrap_or_else(|| _vm.ctx.new_list(vec![]).into()),
keywords.map_or_else(
|| _vm.ctx.new_list(vec![]).into(),
|k| k.ast_to_object(_vm, source_file),
),
_vm,
)
.unwrap();
@@ -297,9 +300,10 @@ impl Node for ast::StmtClassDef {
.unwrap();
dict.set_item(
"type_params",
type_params
.map(|tp| tp.ast_to_object(_vm, source_file))
.unwrap_or_else(|| _vm.ctx.new_list(vec![]).into()),
type_params.map_or_else(
|| _vm.ctx.new_list(vec![]).into(),
|tp| tp.ast_to_object(_vm, source_file),
),
_vm,
)
.unwrap();
@@ -480,9 +484,10 @@ impl Node for ast::StmtTypeAlias {
.unwrap();
dict.set_item(
"type_params",
type_params
.map(|tp| tp.ast_to_object(_vm, source_file))
.unwrap_or_else(|| _vm.ctx.new_list(Vec::new()).into()),
type_params.map_or_else(
|| _vm.ctx.new_list(Vec::new()).into(),
|tp| tp.ast_to_object(_vm, source_file),
),
_vm,
)
.unwrap();
crates/vm/src/stdlib/_codecs.rs
+9 -8
View File
@@ -62,8 +62,7 @@ mod _codecs {
let encoding = self
.encoding
.as_deref()
.map(|s| s.as_str())
.unwrap_or(codecs::DEFAULT_ENCODING);
.map_or(codecs::DEFAULT_ENCODING, |s| s.as_str());
f(
&vm.state.codec_registry,
self.obj,
@@ -392,7 +391,7 @@ mod _codecs_windows {
CP_ACP, WC_NO_BEST_FIT_CHARS, WideCharToMultiByte,
};
let errors = args.errors.as_ref().map(|s| s.as_str()).unwrap_or("strict");
let errors = args.errors.as_ref().map_or("strict", |s| s.as_str());
let s = match args.s.to_str() {
Some(s) => s,
None => {
@@ -482,7 +481,7 @@ mod _codecs_windows {
CP_ACP, MB_ERR_INVALID_CHARS, MultiByteToWideChar,
};
let _errors = args.errors.as_ref().map(|s| s.as_str()).unwrap_or("strict");
let _errors = args.errors.as_ref().map_or("strict", |s| s.as_str());
let data = args.data.borrow_buf();
let len = data.len();
@@ -578,7 +577,7 @@ mod _codecs_windows {
CP_OEMCP, WC_NO_BEST_FIT_CHARS, WideCharToMultiByte,
};
let errors = args.errors.as_ref().map(|s| s.as_str()).unwrap_or("strict");
let errors = args.errors.as_ref().map_or("strict", |s| s.as_str());
let s = match args.s.to_str() {
Some(s) => s,
None => {
@@ -668,7 +667,7 @@ mod _codecs_windows {
CP_OEMCP, MB_ERR_INVALID_CHARS, MultiByteToWideChar,
};
let _errors = args.errors.as_ref().map(|s| s.as_str()).unwrap_or("strict");
let _errors = args.errors.as_ref().map_or("strict", |s| s.as_str());
let data = args.data.borrow_buf();
let len = data.len();
@@ -1054,7 +1053,8 @@ mod _codecs_windows {
if args.code_page < 0 {
return Err(vm.new_value_error("invalid code page number"));
}
let errors = args.errors.as_ref().map(|s| s.as_str()).unwrap_or("strict");
let errors = args.errors.as_ref().map_or("strict", |s| s.as_str());
let code_page = args.code_page as u32;
let char_len = args.s.char_len();
@@ -1367,7 +1367,8 @@ mod _codecs_windows {
if args.code_page < 0 {
return Err(vm.new_value_error("invalid code page number"));
}
let errors = args.errors.as_ref().map(|s| s.as_str()).unwrap_or("strict");
let errors = args.errors.as_ref().map_or("strict", |s| s.as_str());
let code_page = args.code_page as u32;
let data = args.data.borrow_buf();
let is_final = args.r#final;
crates/vm/src/stdlib/_collections.rs
+2 -4
View File
@@ -181,8 +181,7 @@ mod _collections {
Err(vm.new_value_error(
needle
.repr(vm)
.map(|repr| format!("{repr} is not in deque"))
.unwrap_or_else(|_| String::new()),
.map_or_else(|_| String::new(), |repr| format!("{repr} is not in deque")),
))
}
}
@@ -569,8 +568,7 @@ mod _collections {
let class_name = class.name();
let closing_part = zelf
.maxlen
.map(|maxlen| format!("], maxlen={maxlen}"))
.unwrap_or_else(|| "]".to_owned());
.map_or_else(|| "]".to_owned(), |maxlen| format!("], maxlen={maxlen}"));
if zelf.__len__() == 0 {
return Ok(vm.ctx.new_str(format!("{class_name}([{closing_part})")));
crates/vm/src/stdlib/_ctypes/array.rs
+2 -8
View File
@@ -26,8 +26,7 @@ fn get_size_from_format(fmt: &str) -> usize {
.chars()
.next()
.map(|c| c.to_string());
code.map(|c| type_info(&c).map(|t| t.size).unwrap_or(1))
.unwrap_or(1)
code.map_or(1, |c| type_info(&c).map_or(1, |t| t.size))
}
/// Creates array type for (element_type, length)
@@ -770,12 +769,7 @@ impl PyCArray {
}
Some("u") => {
if let Some(s) = value.downcast_ref::<PyStr>() {
let code = s
.as_wtf8()
.code_points()
.next()
.map(|c| c.to_u32())
.unwrap_or(0);
let code = s.as_wtf8().code_points().next().map_or(0, |c| c.to_u32());
if offset + WCHAR_SIZE <= buffer.len() {
wchar_to_bytes(code, &mut buffer[offset..]);
}
crates/vm/src/stdlib/_ctypes/base.rs
+2 -2
View File
@@ -2098,7 +2098,7 @@ impl FfiArgValue {
pub(super) fn buffer_to_ffi_value(type_code: &str, buffer: &[u8]) -> FfiArgValue {
match type_code {
"c" | "b" => {
let v = buffer.first().map(|&b| b as i8).unwrap_or(0);
let v = buffer.first().map_or(0, |&b| b as i8);
FfiArgValue::I8(v)
}
"B" => {
@@ -2157,7 +2157,7 @@ pub(super) fn buffer_to_ffi_value(type_code: &str, buffer: &[u8]) -> FfiArgValue
}
"z" | "Z" | "P" | "O" => FfiArgValue::Pointer(read_ptr_from_buffer(buffer)),
"?" => {
let v = buffer.first().map(|&b| b != 0).unwrap_or(false);
let v = buffer.first().is_some_and(|&b| b != 0);
FfiArgValue::U8(if v { 1 } else { 0 })
}
"u" => {
crates/vm/src/stdlib/_ctypes/function.rs
+4 -7
View File
@@ -1760,7 +1760,7 @@ fn build_result(
// Handle OUT parameter return values
if out_buffers.is_empty() {
return result.map(Ok).unwrap_or_else(|| Ok(vm.ctx.none()));
return result.map_or_else(|| Ok(vm.ctx.none()), Ok);
}
let out_values = extract_out_values(out_buffers, vm);
@@ -1851,8 +1851,7 @@ impl AsBuffer for PyCFuncPtr {
stg_info
.format
.clone()
.map(Cow::Owned)
.unwrap_or(Cow::Borrowed("X{}")),
.map_or(Cow::Borrowed("X{}"), Cow::Owned),
stg_info.size,
)
} else {
@@ -1946,8 +1945,7 @@ impl PyCFuncPtr {
// Fallback to StgInfo for native types
zelf.class()
.stg_info_opt()
.map(|stg| stg.flags.bits())
.unwrap_or(StgInfoFlags::empty().bits())
.map_or(StgInfoFlags::empty().bits(), |stg| stg.flags.bits())
}
}
@@ -2184,8 +2182,7 @@ unsafe extern "C" fn thunk_callback(
let repr = userdata
.callable
.repr(vm)
.map(|s| s.to_string())
.unwrap_or_else(|_| "<unknown>".to_string());
.map_or_else(|_| "<unknown>".to_string(), |s| s.to_string());
let msg = format!(
"Exception ignored while calling ctypes callback function {}",
repr
crates/vm/src/stdlib/_ctypes/pointer.rs
+1 -2
View File
@@ -845,8 +845,7 @@ impl AsBuffer for PyCPointer {
let format = stg_info
.format
.clone()
.map(Cow::Owned)
.unwrap_or(Cow::Borrowed("&B"));
.map_or(Cow::Borrowed("&B"), Cow::Owned);
let itemsize = stg_info.size;
// Pointer types are scalars with ndim=0, shape=()
let desc = BufferDescriptor {
crates/vm/src/stdlib/_ctypes/simple.rs
+1 -2
View File
@@ -1424,8 +1424,7 @@ impl AsBuffer for PyCSimple {
let format = stg_info
.format
.clone()
.map(Cow::Owned)
.unwrap_or(Cow::Borrowed("B"));
.map_or(Cow::Borrowed("B"), Cow::Owned);
let itemsize = stg_info.size;
// Simple types are scalars with ndim=0, shape=()
let desc = BufferDescriptor {
crates/vm/src/stdlib/_functools.rs
+5 -4
View File
@@ -164,8 +164,7 @@ mod _functools {
fn __dict__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyDictRef {
zelf.as_object()
.instance_dict()
.map(|d| d.get_or_insert(vm))
.unwrap_or_else(|| vm.ctx.new_dict())
.map_or_else(|| vm.ctx.new_dict(), |d| d.get_or_insert(vm))
}
#[pygetset(setter)]
@@ -492,8 +491,10 @@ mod _functools {
let qualname = zelf.class().__qualname__(vm);
let qualname_wtf8 = qualname
.downcast_ref::<crate::builtins::PyStr>()
.map(|s| s.as_wtf8().to_owned())
.unwrap_or_else(|| Wtf8Buf::from(zelf.class().name().to_owned()));
.map_or_else(
|| Wtf8Buf::from(zelf.class().name().to_owned()),
|s| s.as_wtf8().to_owned(),
);
let module = zelf.class().__module__(vm);
let mut result = Wtf8Buf::new();
crates/vm/src/stdlib/_io.rs
+5 -7
View File
@@ -1856,7 +1856,7 @@ mod _io {
fn read(&self, size: OptionalSize, vm: &VirtualMachine) -> PyResult<Option<PyBytesRef>> {
let mut data = self.reader().lock(vm)?;
let raw = data.check_init(vm)?;
let n = size.size.map(|s| *s).unwrap_or(-1);
let n = size.size.map_or(-1, |s| *s);
if n < -1 {
return Err(vm.new_value_error("read length must be non-negative or -1"));
}
@@ -5968,8 +5968,7 @@ mod fileio {
if zelf.fd.load() >= 0 && zelf.closefd.load() {
let repr = source
.repr(vm)
.map(|s| s.as_wtf8().to_owned())
.unwrap_or_else(|_| Wtf8Buf::from("<file>"));
.map_or_else(|_| Wtf8Buf::from("<file>"), |s| s.as_wtf8().to_owned());
if let Err(e) = crate::stdlib::_warnings::warn(
vm.ctx.exceptions.resource_warning,
format!("unclosed file {repr}"),
@@ -6230,8 +6229,7 @@ mod winconsoleio {
let mode_str: &str = args
.mode
.as_ref()
.map(|s: &PyUtf8StrRef| s.as_str())
.unwrap_or("r");
.map_or("r", |s: &PyUtf8StrRef| s.as_str());
let mut rwa = false;
let mut readable = false;
@@ -6521,8 +6519,8 @@ mod winconsoleio {
if zelf.fd.load() >= 0 && zelf.closefd.load() {
let repr = source
.repr(vm)
.map(|s| s.as_wtf8().to_owned())
.unwrap_or_else(|_| Wtf8Buf::from("<file>"));
.map_or_else(|_| Wtf8Buf::from("<file>"), |s| s.as_wtf8().to_owned());
if let Err(e) = crate::stdlib::_warnings::warn(
vm.ctx.exceptions.resource_warning,
format!("unclosed file {repr}"),
crates/vm/src/stdlib/_sre.rs
+3 -6
View File
@@ -723,8 +723,7 @@ mod _sre {
.ok_or_else(|| vm.new_index_error("no such group"))
.map(|index| {
self.get_slice(index, str_drive, vm)
.map(|x| x.to_pyobject(vm))
.unwrap_or_else(|| vm.ctx.none())
.map_or_else(|| vm.ctx.none(), |x| x.to_pyobject(vm))
})
})
.try_collect()?;
@@ -761,8 +760,7 @@ mod _sre {
let v: Vec<PyObjectRef> = (1..self.regs.len())
.map(|i| {
self.get_slice(i, str_drive, vm)
.map(|s| s.to_pyobject(vm))
.unwrap_or_else(|| default.clone())
.map_or_else(|| default.clone(), |s| s.to_pyobject(vm))
})
.collect();
Ok(PyTuple::new_ref(v, &vm.ctx))
@@ -784,8 +782,7 @@ mod _sre {
let value = self
.get_index(index, vm)
.and_then(|x| self.get_slice(x, str_drive, vm))
.map(|x| x.to_pyobject(vm))
.unwrap_or_else(|| default.clone());
.map_or_else(|| default.clone(), |x| x.to_pyobject(vm));
dict.set_item(&*key, value, vm)?;
}
Ok(dict)
crates/vm/src/stdlib/_typing.rs
+1 -2
View File
@@ -327,8 +327,7 @@ pub(crate) mod decl {
"Expected a type param, got {}",
param
.repr(vm)
.map(|s| s.to_string())
.unwrap_or_else(|_| "?".to_owned())
.map_or_else(|_| "?".to_owned(), |s| s.to_string())
))
})?;
let is_no_default = dflt.is(no_default);
crates/vm/src/stdlib/builtins.rs
+9 -9
View File
@@ -1225,21 +1225,21 @@ mod builtins {
};
// Use downcast_exact to keep ref to old object on error.
let metaclass = kwargs
.pop_kwarg("metaclass")
.map(|metaclass| {
metaclass
.downcast_exact::<PyType>(vm)
.map(|m| m.into_pyref())
})
.unwrap_or_else(|| {
let metaclass = kwargs.pop_kwarg("metaclass").map_or_else(
|| {
// if there are no bases, use type; else get the type of the first base
Ok(if bases.is_empty() {
vm.ctx.types.type_type.to_owned()
} else {
bases.first().unwrap().class().to_owned()
})
});
},
|metaclass| {
metaclass
.downcast_exact::<PyType>(vm)
.map(|m| m.into_pyref())
},
);
let (metaclass, meta_name) = match metaclass {
Ok(mut metaclass) => {
crates/vm/src/stdlib/posix.rs
+1 -2
View File
@@ -2590,8 +2590,7 @@ pub mod module {
let headers = _extract_vec_bytes(args.headers, vm)?;
let count = headers
.as_ref()
.map(|v| v.iter().map(|s| s.len()).sum())
.unwrap_or(0) as i64
.map_or(0, |v| v.iter().map(|s| s.len()).sum()) as i64
+ args.count;
let headers = headers
crates/vm/src/types/slot.rs
+1 -2
View File
@@ -499,8 +499,7 @@ fn hash_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyHash> {
let big_int = py_int.as_bigint();
let hash = big_int
.to_i64()
.map(fix_sentinel)
.unwrap_or_else(|| hash_bigint(big_int));
.map_or_else(|| hash_bigint(big_int), fix_sentinel);
Ok(hash)
}
crates/vm/src/warn.rs
+1 -2
View File
@@ -196,8 +196,7 @@ fn already_warned(
let version_matches = version_obj.as_ref().is_some_and(|v| {
v.try_int(vm)
.map(|i| i.as_u32_mask() as usize == current_version)
.unwrap_or(false)
.is_ok_and(|i| i.as_u32_mask() as usize == current_version)
});
if version_matches {
crates/vm/src/windows.rs
+1 -3
View File
@@ -153,9 +153,7 @@ fn attribute_data_to_stat(
let mut st_mode = attributes_to_mode(info.dwFileAttributes);
let st_size = ((info.nFileSizeHigh as u64) << 32) | (info.nFileSizeLow as u64);
let st_dev = id_info
.map(|id| id.VolumeSerialNumber as u32)
.unwrap_or(info.dwVolumeSerialNumber);
let st_dev = id_info.map_or(info.dwVolumeSerialNumber, |id| id.VolumeSerialNumber as u32);
let st_nlink = info.nNumberOfLinks as i32;
// Convert FILETIME/LARGE_INTEGER to (time_t, nsec)