youknowone · Nov 13, 2026 · Nov 13, 2026 · Nov 13, 2026
diff --git a/crates/capi/src/ceval.rs b/crates/capi/src/ceval.rs
@@ -72,8 +72,7 @@ pub extern "C" fn PyEval_GetBuiltins() -> *mut PyObject {
 pub extern "C" fn PyEval_GetFrame() -> *mut PyFrameObject {
     with_vm(|vm| -> *mut PyObject {
         vm.current_frame()
-            .map(|frame| frame.as_object().as_raw().cast_mut())
-            .unwrap_or_default()
+            .map_or_default(|frame| frame.as_object().as_raw().cast_mut())
     })
     .cast()
 }
@@ -91,17 +90,15 @@ pub extern "C" fn PyEval_GetFrameBuiltins() -> *mut PyObject {
 #[unsafe(no_mangle)]
 pub extern "C" fn PyEval_GetFrameGlobals() -> *mut PyObject {
     with_vm(|vm| {
-        vm.current_frame()
-            .map(|frame| {
-                frame
-                    .iframe()
-                    .globals()
-                    .as_object()
-                    .to_owned()
-                    .into_raw()
-                    .as_ptr()
-            })
-            .unwrap_or_default()
+        vm.current_frame().map_or_default(|frame| {
+            frame
+                .iframe()
+                .globals()
+                .as_object()
+                .to_owned()
+                .into_raw()
+                .as_ptr()
+        })
     })
 }
 
@@ -120,8 +117,7 @@ pub extern "C" fn PyEval_GetFrameLocals() -> *mut PyObject {
 pub extern "C" fn PyEval_GetGlobals() -> *mut PyObject {
     with_vm(|vm| {
         vm.current_frame()
-            .map(|frame| frame.iframe().globals().as_object().as_raw())
-            .unwrap_or_default()
+            .map_or_default(|frame| frame.iframe().globals().as_object().as_raw())
     })
 }
 

diff --git a/crates/capi/src/methodobject.rs b/crates/capi/src/methodobject.rs
@@ -184,13 +184,11 @@ unsafe fn call_function<A: Into<FuncArgs>>(
 
     let slf_ptr = slf
         .as_ref()
-        .map(|obj| obj.as_object().as_raw().cast_mut())
-        .unwrap_or_default();
+        .map_or_default(|obj| obj.as_object().as_raw().cast_mut());
 
     let arg_ptr = arg_tuple
         .as_ref()
-        .map(|tuple| tuple.as_object().as_raw().cast_mut())
-        .unwrap_or_default();
+        .map_or_default(|tuple| tuple.as_object().as_raw().cast_mut());
 
     unsafe { f(slf_ptr, arg_ptr).assume_owned_or_err(vm) }
 }
@@ -205,8 +203,7 @@ unsafe fn call_function_with_keywords(
     let slf = take_self_arg(&mut args, has_self);
     let slf_ptr = slf
         .as_ref()
-        .map(|obj| obj.as_object().as_raw().cast_mut())
-        .unwrap_or_default();
+        .map_or_default(|obj| obj.as_object().as_raw().cast_mut());
     let (arg_tuple, kwargs) = split_args(vm, args)?;
     unsafe {
         f(
@@ -228,8 +225,7 @@ unsafe fn call_fast_function_with_keywords(
     let slf = take_self_arg(&mut args, has_self);
     let slf_ptr = slf
         .as_ref()
-        .map(|obj| obj.as_object().as_raw().cast_mut())
-        .unwrap_or_default();
+        .map_or_default(|obj| obj.as_object().as_raw().cast_mut());
     let nargs = args.args.len();
     let mut fastcall_args = args.args;
     let kwnames_tuple = if !args.kwargs.is_empty() {
@@ -244,8 +240,7 @@ unsafe fn call_fast_function_with_keywords(
     };
     let kwnames_ptr = kwnames_tuple
         .as_ref()
-        .map(|tuple| tuple.as_object().as_raw().cast_mut())
-        .unwrap_or_default();
+        .map_or_default(|tuple| tuple.as_object().as_raw().cast_mut());
     // SAFETY: PyObjectRef is repr(transparent) over a pointer to PyObject, so a
     // Vec<PyObjectRef> has a layout-compatible contiguous backing buffer. The
     // vector is kept alive for the duration of the call.
@@ -264,8 +259,7 @@ unsafe fn call_fast_function(
     let slf = take_self_arg(&mut args, has_self);
     let slf_ptr = slf
         .as_ref()
-        .map(|obj| obj.as_object().as_raw().cast_mut())
-        .unwrap_or_default();
+        .map_or_default(|obj| obj.as_object().as_raw().cast_mut());
     // SAFETY: PyObjectRef is repr(transparent) over a pointer to PyObject, so a
     // Vec<PyObjectRef> has a layout-compatible contiguous backing buffer. The
     // vector is kept alive for the duration of the call.

diff --git a/crates/capi/src/pycapsule.rs b/crates/capi/src/pycapsule.rs
@@ -38,7 +38,7 @@ pub unsafe extern "C" fn PyCapsule_GetName(capsule: *mut PyObject) -> *const c_c
         let capsule = unsafe { capsule.assume_borrowed() }
             .downcast_ref_if_exact::<PyCapsule>(vm)
             .ok_or_else(|| vm.new_value_error("Invalid capsule"))?;
-        Ok(capsule.name().map(CStr::as_ptr).unwrap_or_default())
+        Ok(capsule.name().map_or_default(CStr::as_ptr))
     })
 }
 
@@ -135,7 +135,7 @@ fn checked_capsule<'a>(
         .downcast_ref_if_exact::<PyCapsule>(vm)
         .ok_or_else(|| vm.new_value_error("Invalid capsule"))?;
 
-    if !names_match(capsule.name().map(CStr::as_ptr).unwrap_or_default(), name) {
+    if !names_match(capsule.name().map_or_default(CStr::as_ptr), name) {
         return Err(vm.new_value_error("Capsule name does not match"));
     }
 

diff --git a/crates/capi/src/pyerrors.rs b/crates/capi/src/pyerrors.rs
@@ -102,17 +102,15 @@ define_py_check!(fn PyExceptionInstance_Check, exceptions.base_exception_type);
 pub extern "C" fn PyErr_Occurred() -> *mut PyObject {
     with_vm(|vm| {
         vm.raised_exception()
-            .map(|exc| exc.class().as_object().as_raw())
-            .unwrap_or_default()
+            .map_or_default(|exc| exc.class().as_object().as_raw())
     })
 }
 
 #[unsafe(no_mangle)]
 pub extern "C" fn PyErr_GetRaisedException() -> *mut PyObject {
     with_vm(|vm| {
         vm.take_raised_exception()
-            .map(|exc| exc.into_object().into_raw().as_ptr())
-            .unwrap_or_default()
+            .map_or_default(|exc| exc.into_object().into_raw().as_ptr())
     })
 }
 
@@ -268,8 +266,7 @@ pub unsafe extern "C" fn PyException_GetTraceback(exc: *mut PyObject) -> *mut Py
         let exc = unsafe { exc.assume_borrowed_and_cast::<PyBaseException>(vm) }?;
         let tb = exc
             .traceback()
-            .map(|tb| tb.into_object().into_raw().as_ptr())
-            .unwrap_or_default();
+            .map_or_default(|tb| tb.into_object().into_raw().as_ptr());
         Ok(tb)
     })
 }
@@ -280,8 +277,7 @@ pub unsafe extern "C" fn PyException_GetCause(exc: *mut PyObject) -> *mut PyObje
         let exc = unsafe { exc.assume_borrowed_and_cast::<PyBaseException>(vm) }?;
         let cause = exc
             .__cause__()
-            .map(|cause| cause.into_object().into_raw().as_ptr())
-            .unwrap_or_default();
+            .map_or_default(|cause| cause.into_object().into_raw().as_ptr());
         Ok(cause)
     })
 }
@@ -292,8 +288,7 @@ pub unsafe extern "C" fn PyException_GetContext(exc: *mut PyObject) -> *mut PyOb
         let exc = unsafe { exc.assume_borrowed_and_cast::<PyBaseException>(vm) }?;
         let context = exc
             .__context__()
-            .map(|context| context.into_object().into_raw().as_ptr())
-            .unwrap_or_default();
+            .map_or_default(|context| context.into_object().into_raw().as_ptr());
         Ok(context)
     })
 }

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
@@ -2107,18 +2107,15 @@ impl<'warnings> Compiler<'warnings> {
 
         // Build freevars using dictbytype (FREE scope, offset by cellvars size)
         let mut freevar_cache = IndexSet::default();
-        let annotation_free_names: IndexSet<Name> = ste
-            .annotation_block
-            .as_ref()
-            .map(|annotation| {
+        let annotation_free_names: IndexSet<Name> =
+            ste.annotation_block.as_ref().map_or_default(|annotation| {
                 annotation
                     .symbols
                     .iter()
                     .filter(|(_, s)| s.scope == SymbolScope::Free)
                     .map(|(name, _)| name.clone())
                     .collect()
-            })
-            .unwrap_or_default();
+            });
         let mut free_names: Vec<_> = ste
             .symbols
             .iter()
@@ -6253,8 +6250,7 @@ impl<'warnings> Compiler<'warnings> {
                 .unwrap()
                 .static_attributes
                 .as_ref()
-                .map(|s| s.iter().cloned().collect())
-                .unwrap_or_default();
+                .map_or_default(|s| s.iter().cloned().collect());
             attrs.sort();
             self.emit_load_const(ConstantData::Tuple {
                 elements: attrs

diff --git a/crates/host_env/Cargo.toml b/crates/host_env/Cargo.toml
@@ -37,7 +37,6 @@ getrandom = { workspace = true }
 libc = { workspace = true }
 num-traits = { workspace = true }
 parking_lot = { workspace = true }
-paste = { workspace = true }
 pkcs8 = { workspace = true, features = ["encryption", "pkcs5", "pem"], optional = true }
 rustls = { workspace = true, default-features = false, features = ["std", "tls12"], optional = true }
 rustls-pemfile = { workspace = true, optional = true }
@@ -84,6 +83,7 @@ system-configuration = { workspace = true }
 object = { workspace = true }
 
 [target.'cfg(windows)'.dependencies]
+paste = { workspace = true }
 memchr.workspace = true
 junction = { workspace = true }
 schannel = { workspace = true }

diff --git a/crates/host_env/src/ctypes.rs b/crates/host_env/src/ctypes.rs
@@ -874,8 +874,7 @@ pub fn read_array_element(
         Some("u") => {
             let value = wchar_from_bytes(rest)
                 .and_then(char::from_u32)
-                .map(|c| c.to_string())
-                .unwrap_or_default();
+                .map_or_default(|c| c.to_string());
             DecodedValue::String(value)
         }
         Some("z") => {

diff --git a/crates/stdlib/src/_datetime.rs b/crates/stdlib/src/_datetime.rs
@@ -1131,9 +1131,7 @@ mod _datetime {
         arg: &PyObject,
         vm: &VirtualMachine,
     ) -> PyResult<String> {
-        Ok(call_utcoffset(tzinfo, arg, vm)?
-            .map(|offset| format_offset(&offset, sep))
-            .unwrap_or_default())
+        Ok(call_utcoffset(tzinfo, arg, vm)?.map_or_default(|offset| format_offset(&offset, sep)))
     }
 
     fn append_keyword_tzinfo(

diff --git a/crates/stdlib/src/elementtree.rs b/crates/stdlib/src/elementtree.rs
@@ -2217,8 +2217,7 @@ pub(crate) mod _elementtree {
             let info: Vec<PyObjectRef> = expat.get_attr("version_info", vm)?.try_to_value(vm)?;
             let part = |i: usize| -> String {
                 info.get(i)
-                    .map(|o| o.str(vm).map(|s| s.to_string()).unwrap_or_default())
-                    .unwrap_or_default()
+                    .map_or_default(|o| o.str(vm).map_or_default(|s| s.to_string()))
             };
             Ok(format!("Expat {}.{}.{}", part(0), part(1), part(2)))
         }
@@ -2310,8 +2309,7 @@ pub(crate) mod _elementtree {
             let tag = zelf.make_universal(tag, vm)?;
             let items = attr_list
                 .downcast_ref::<PyList>()
-                .map(|l| l.borrow_vec().to_vec())
-                .unwrap_or_default();
+                .map_or_default(|l| l.borrow_vec().to_vec());
             let attrib = if items.is_empty() {
                 None
             } else {

diff --git a/crates/stdlib/src/pyexpat.rs b/crates/stdlib/src/pyexpat.rs
@@ -2112,7 +2112,7 @@ mod _errors {
         for (index, &(name, message)) in ERRORS.iter().enumerate() {
             let code = vm.ctx.new_int(index + 1);
             module.set_attr(name, vm.ctx.new_str(message), vm)?;
-            codes.set_item(message, code.clone().into(), vm)?;
+            codes.set_item(message, code.into(), vm)?;
             messages.set_item(&(index + 1), vm.ctx.new_str(message).into(), vm)?;
         }
         extend_module!(vm, module, {

diff --git a/crates/unicode/src/data.rs b/crates/unicode/src/data.rs
@@ -382,10 +382,7 @@ impl Ucd {
             lookup_table(BIDI_CLASS_DIFF, c)
                 .or_else(|| membership_3_2(c as u32).then(|| BidiClass::for_char(c)))
         };
-        class
-            .as_ref()
-            .map(BidiClass::short_name)
-            .unwrap_or_default()
+        class.as_ref().map_or_default(BidiClass::short_name)
     }
 
     #[must_use]
@@ -474,10 +471,7 @@ impl Ucd {
             // have to do it manually for now.
             let tag = DECOMP_COMPAT[i].1.type_tag();
             let end = DECOMP_COMPAT[i].2;
-            let start = i
-                .checked_sub(1)
-                .map(|i| DECOMP_COMPAT[i].2)
-                .unwrap_or_default();
+            let start = i.checked_sub(1).map_or_default(|i| DECOMP_COMPAT[i].2);
 
             let decomp = &DECOMP_RANGE[start..end];
             let cap = decomp.len() * 10 + decomp.len() + tag.len() + 1;

diff --git a/crates/vm/Cargo.toml b/crates/vm/Cargo.toml
@@ -59,7 +59,6 @@ indexmap = { workspace = true }
 itertools = { workspace = true }
 itoa = { workspace = true }
 is-macro = { workspace = true }
-jiff = { workspace = true }
 libc = { workspace = true }
 log = { workspace = true }
 malachite-bigint = { workspace = true }
@@ -93,6 +92,9 @@ widestring = { workspace = true }
 [target.'cfg(all(target_arch = "wasm32", target_os = "unknown"))'.dependencies]
 wasm-bindgen = { workspace = true, optional = true }
 
+[target.'cfg(not(unix))'.dependencies]
+jiff = { workspace = true }
+
 [build-dependencies]
 glob = { workspace = true }
 jiff = { workspace = true }

diff --git a/crates/vm/src/builtins/set.rs b/crates/vm/src/builtins/set.rs
@@ -686,7 +686,11 @@ impl PySetInner {
                 elements
             } else {
                 // We want to remove duplicates in iterable
-                iterable_set = Self::from_object(iterable.clone(), vm)?;
+                // Keep the source alive through toggle_entries: its finalizer may mutate the set.
+                #[allow(clippy::redundant_clone)]
+                {
+                    iterable_set = Self::from_object(iterable.clone(), vm)?;
+                }
                 iterable_set.content.keys_with_hashes()
             };
             self.toggle_entries(elements, vm)?;

diff --git a/crates/vm/src/getpath.rs b/crates/vm/src/getpath.rs
@@ -240,8 +240,7 @@ pub fn init_path_config(settings: &Settings) -> Paths {
     let executable = get_executable_path();
     let real_executable = executable
         .as_ref()
-        .map(|p| p.to_string_lossy().into_owned())
-        .unwrap_or_default();
+        .map_or_default(|p| p.to_string_lossy().into_owned());
 
     // Step 1: Check for PYTHONEXECUTABLE / __PYVENV_LAUNCHER__
     // When set, these are used as sys.executable and when searching for venvs.
@@ -536,9 +535,7 @@ fn calculate_base_executable(executable: Option<&PathBuf>, home_dir: Option<&Pat
     }
 
     // Otherwise, base_executable == executable
-    executable
-        .map(|p| p.to_string_lossy().into_owned())
-        .unwrap_or_default()
+    executable.map_or_default(|p| p.to_string_lossy().into_owned())
 }
 
 /// Calculate stdlib_dir (sys._stdlib_dir)

diff --git a/crates/vm/src/import.rs b/crates/vm/src/import.rs
@@ -813,8 +813,7 @@ fn calc_package(globals: Option<&PyObject>, vm: &VirtualMachine) -> PyResult<PyS
         {
             let parent_repr = parent
                 .repr_utf8(vm)
-                .map(|s| s.as_str().to_owned())
-                .unwrap_or_default();
+                .map_or_default(|s| s.as_str().to_owned());
             let msg = format!(
                 "__package__ != __spec__.parent ('{}' != {})",
                 pkg_str.as_wtf8(),

diff --git a/crates/vm/src/stdlib/_ast/type_parameters.rs b/crates/vm/src/stdlib/_ast/type_parameters.rs
@@ -45,8 +45,7 @@ fn type_params_from_values(
     let runtime_type_params = values.iter().any(Option::is_none).then(|| values.clone());
     let type_params = lower_nullable_type_params(&values);
     let range = Option::zip(type_params.first(), type_params.last())
-        .map(|(first, last)| first.range().cover(last.range()))
-        .unwrap_or_default();
+        .map_or_default(|(first, last)| first.range().cover(last.range()));
     ast::TypeParams {
         node_index: Default::default(),
         type_params,

diff --git a/crates/vm/src/stdlib/_ctypes/base.rs b/crates/vm/src/stdlib/_ctypes/base.rs
@@ -1234,8 +1234,7 @@ impl CDataValue {
                         .as_slice()
                         .first()
                         .and_then(|arg| arg.downcast_ref::<PyStr>())
-                        .map(|s| s.to_string())
-                        .unwrap_or_default();
+                        .map_or_default(|s| s.to_string());
                     vm.new_runtime_error(format!(
                         "({}) {}: {message}",
                         proto.name(),

diff --git a/crates/vm/src/stdlib/_ctypes/function.rs b/crates/vm/src/stdlib/_ctypes/function.rs
@@ -975,16 +975,14 @@ impl Constructor for PyCFuncPtr {
         // Check if first argument is a Python callable (callback creation)
         if first_arg.is_callable() {
             // Get argument types and result type from the class
-            let (class_argtypes, class_restype, class_checker) = cls
-                .stg_info_opt()
-                .map(|info| {
+            let (class_argtypes, class_restype, class_checker) =
+                cls.stg_info_opt().map_or_default(|info| {
                     (
                         info.argtypes.clone(),
                         info.restype.clone(),
                         info.checker.clone(),
                     )
-                })
-                .unwrap_or_default();
+                });
             if class_argtypes.is_none() {
                 return Err(
                     vm.new_type_error("cannot construct instance of this class: no argtypes")