Oct 17, 2026 – Oct 23, 2026

BUG: MultiIndex.rename rejects the name keyword (GH#33778)Python · 90 + / 3 −

Introduces 4 new declarations in pandas/core/indexes/multi.py.

Adds new core implementation rather than adjusting what was there. Tests changed with it, with code of their own.

pandas/core/indexes/multi.py ↗ · 4 files

@@ -5013,9 +5014,95 @@ def isin(self, values, level=None) -> npt.NDArray[np.bool_]:                 return np.zeros(len(levs), dtype=np.bool_)             return levs.isin(values) -    # error: Incompatible types in assignment (expression has type overloaded function,-    # base class "Index" defined the type as "Callable[[Index, Any, bool], Any]")-    rename = Index.set_names  # type: ignore[assignment]+    @overload+    def rename(+        self,+        name: Hashable | Sequence[Hashable] | dict[Hashable, Hashable] = ...,+        *,+        names: Hashable | Sequence[Hashable] | dict[Hashable, Hashable] = ...,+        level: Hashable | Sequence[Hashable] | None = ...,+        inplace: Literal[False] = ...,+    ) -> Self: ...++    @overload+    def rename(+        self,+        name: Hashable | Sequence[Hashable] | dict[Hashable, Hashable] = ...,+        *,+        names: Hashable | Sequence[Hashable] | dict[Hashable, Hashable] = ...,+        level: Hashable | Sequence[Hashable] | None = ...,+        inplace: Literal[True],+    ) -> None: ...++    @overload+    def rename(+        self,+        name: Hashable | Sequence[Hashable] | dict[Hashable, Hashable] = ...,+        *,+        names: Hashable | Sequence[Hashable] | dict[Hashable, Hashable] = ...,+        level: Hashable | Sequence[Hashable] | None = ...,

Add webpack utilsTypeScript · 650 + / 0 −

Introduces 14 new declarations in turbopack/crates/turbopack-node/js/src/transforms/webpack-loaders-utils.ts.

Adds new framework internals rather than adjusting what was there. Tests changed with it, with code of their own.

turbopack/crates/turbopack-node/js/src/transforms/webpack-loaders-utils.ts ↗ · 12 files

@@ -0,0 +1,648 @@+import { createHash as nodeCreateHash } from 'crypto'+import path from 'path'++const WINDOWS_ABS_PATH_REGEXP = /^[a-zA-Z]:[\\/]/++function relativePathToRequest(relativePath: string): string {+  if (relativePath === '') return './.'+  if (relativePath === '..') return '../.'+  if (relativePath.startsWith('../')) return relativePath+  return `./${relativePath}`+}++// Matches webpack's lib/util/identifier.js, including regexp-like requests.+function absoluteToRequest(context: string, request: string): string {+  const windows = WINDOWS_ABS_PATH_REGEXP.test(request)+  if (!windows && request[0] !== '/') return request+  if (!windows && request.length > 1 && request.endsWith('/')) return request++  const queryIndex = request.indexOf('?')+  const resource = queryIndex === -1 ? request : request.slice(0, queryIndex)+  let relative = windows+    ? path.win32.relative(context, resource)+    : path.posix.relative(context, resource)+  if (!windows || !WINDOWS_ABS_PATH_REGEXP.test(relative)) {+    relative = relativePathToRequest(+      windows ? relative.replace(/\\/g, '/') : relative+    )+  }+  return relative + (queryIndex === -1 ? '' : request.slice(queryIndex))+}++export function contextify(context: string, request: string): string {+  return request

Turbopack: propagate late partial namespace provenance to passthrough targetsRust · 277 + / 6 −

Introduces 25 new declarations in turbopack/crates/turbopack-core/src/module_graph/binding_usage_info.rs.

Adds new framework internals rather than adjusting what was there. Tests changed with it, with code of their own.

turbopack/crates/turbopack-core/src/module_graph/binding_usage_info.rs ↗ · 8 files

@@ -513,3 +520,267 @@ mod tests {         assert!(matches!(usage, ModuleExportUsageInfo::All));     } }++#[cfg(test)]+mod graph_tests {+    use anyhow::Result;+    use rustc_hash::FxHashMap;+    use turbo_rcstr::{RcStr, rcstr};+    use turbo_tasks::{ResolvedVc, TryJoinIterExt, Vc};+    use turbo_tasks_backend::{BackendOptions, TurboTasksBackend, noop_backing_storage};+    use turbo_tasks_fs::{FileSystem, FileSystemPath, VirtualFileSystem};++    use super::compute_binding_usage_info;+    use crate::{+        asset::{Asset, AssetContent},+        ident::AssetIdent,+        module::{Module, ModuleSideEffects},+        module_graph::{+            GraphEntries, ModuleGraph, SingleModuleGraph,+            chunk_group_info::{ChunkGroupEntry, EntryHeuristics},+        },+        reference::{ModuleReference, ModuleReferences, SingleChunkableModuleReference},+        resolve::ExportUsage,+    };++    /// Module name -> outgoing edges `(target name, export usage of the edge)`, in reference order.+    type Edges = Vec<(RcStr, Vec<(RcStr, ExportUsage)>)>;++    #[turbo_tasks::value(shared)]+    struct UsageTestRepo {+        edges: FxHashMap<RcStr, Vec<(RcStr, ExportUsage)>>,+    }

BUG: str regex \w, \d, \s and \b only matching ASCII for pyarrow-backed stringsPython · 79 + / 44 −

Introduces 5 new declarations in pandas/core/arrays/_arrow_string_mixins.py.

Adds new core implementation rather than adjusting what was there. Tests changed with it, with code of their own.

pandas/core/arrays/_arrow_string_mixins.py ↗ · 5 files

@@ -64,48 +77,72 @@ def _has_unsupported_regex(pat: str | re.Pattern[str]) -> bool:          Returns         --------        bool-            Whether `pat` contains a lookahead or lookbehind.+        list[tuple[Any, Any]]+            The nodes of `pat`, or an empty list if Python's ``re`` cannot+            parse it.         """-        try:-            # error: Module "re" has no attribute "_parser"-            from re import _parser  # type: ignore[attr-defined]+        _parser = ArrowStringArrayMixin._re_parser()+        repeats = {_parser.MAX_REPEAT, _parser.MIN_REPEAT, _parser.POSSESSIVE_REPEAT} -            regex_parser = _parser.parse-        except Exception as err:-            raise type(err)(-                "Incompatible version for regex; you will need to upgrade pandas "-                "or downgrade Python"-            ) from err--        def has_unsupported_code(tokens):-            # For certain op codes we need to recurse.+        def walk(tokens):             for op_code, argument in tokens:-                if (-                    (-                        op_code == _parser.SUBPATTERN-                        and has_unsupported_code(argument[3])-                    )-                    or (-                        op_code == _parser.BRANCH

suggest named lifetimes instead of `'_` in `use<...>` for E0700Rust · 247 + / 69 −

Introduces 13 new declarations in compiler/rustc_trait_selection/src/error_reporting/infer/region.rs.

Adds new language design rather than adjusting what was there. Tests changed with it, with code of their own.

compiler/rustc_trait_selection/src/error_reporting/infer/region.rs ↗ · 8 files

@@ -1169,6 +1110,101 @@ pub(super) fn note_and_explain_region<'tcx>(     emit_msg_span(err, prefix, description, span, suffix); } +fn suggest_name_regions<'tcx>(+    tcx: TyCtxt<'tcx>,+    generic_param_scope: LocalDefId,+    lifetimes: &[Region<'tcx>],+    add_lt_suggs: &mut Vec<(Span, String)>,+) -> Option<Vec<String>> {+    struct LifetimeReplaceVisitor<'a> {+        new_lts: &'a [(LocalDefId, String)],+        add_lt_suggs: &'a mut Vec<(Span, String)>,+    }++    impl<'hir> hir::intravisit::Visitor<'hir> for LifetimeReplaceVisitor<'_> {+        fn visit_lifetime(&mut self, lt: &'hir hir::Lifetime) {+            if let hir::LifetimeKind::Param(def_id) = lt.kind+                && let Some((_, new_lt)) = self.new_lts.iter().find(|(id, _)| *id == def_id)+            {+                self.add_lt_suggs.push(lt.suggestion(new_lt));+            }+        }+    }++    let mut lifetime_scope = None;+    let mut used_names = vec![];+    let mut new_lts: Vec<(LocalDefId, String)> = vec![];+    let names: Vec<_> = lifetimes+        .iter()+        .map(|&lifetime| {+            let (lifetime_def_id, scope) =+                match tcx.is_suitable_region(generic_param_scope, lifetime) {+                    Some(info) if !lifetime.is_named(tcx) => {

MIR move elimination [4/6]: MoveEliminationRust · 959 + / 36 −

Introduces 41 new declarations in compiler/rustc_mir_transform/src/move_elimination.rs.

Adds new language design rather than adjusting what was there. Tests changed with it, with code of their own.

compiler/rustc_mir_transform/src/move_elimination.rs ↗ · 36 files

@@ -0,0 +1,911 @@+//! Eliminates copies and moves by unifying MIR places whose allocation ranges+//! are disjoint.+//!+//! See RFC 3943 for the local-lifetime semantics that make this optimization+//! possible.+//!+//! # Motivation+//!+//! MIR building can insert a lot of redundant copies, and Rust code in general+//! often tends to move values around a lot. The result is a lot of assignments+//! of the form `dest = {move} src;` in MIR. MIR building for constants in+//! particular tends to create additional locals that are only used inside a+//! single block to shuffle a value around unnecessarily.+//!+//! Additionally, Rust constructs nested aggregates by repeatedly moving values+//! into fields. For example, a function may build an inner value in a local,+//! move it into an outer aggregate, then move that aggregate into the caller's+//! destination. If these intermediate source and destination places have+//! different addresses, each layer needs an actual copy or move of the bytes.+//!+//! LLVM cannot remove these copies when both the source and destination+//! addresses are observed because merging the allocations would be an+//! observable change: the program could see that two addresses which were+//! previously distinct have become the same. This pass removes the copies+//! earlier, while MIR still has the information needed to prove that the two+//! allocation ranges do not overlap.+//!+//! # Optimization+//!+//! The basis of this optimization is place unification. If the source and+//! destination of an assignment have the same address, then the assignment is a+//! no-op. The same idea applies to aggregate construction: if a field operand+//! is already located at the corresponding field of the destination, then the

Only disable the compiler on the offload path in AlignDevicesHookPython · 64 + / 58 −

Introduces 9 new declarations in src/accelerate/hooks.py.

Adds new language design rather than adjusting what was there. Tests changed with it, with code of their own.

src/accelerate/hooks.py ↗ · 2 files

@@ -356,76 +356,82 @@ def _maybe_get_fp16_statistics(self, name, value):         return None      @_compiler_disable-    def pre_forward(self, module, *args, **kwargs):-        if self.io_same_device:-            self.input_device = find_device([args, kwargs])-        if self.offload:-            self.tied_pointers_to_remove = set()+    def _onload_weights(self, module):+        self.tied_pointers_to_remove = set() -            for name, _ in named_module_tensors(-                module,-                include_buffers=self.offload_buffers,-                recurse=self.place_submodules,-                remove_non_persistent=True,+        for name, _ in named_module_tensors(+            module,+            include_buffers=self.offload_buffers,+            recurse=self.place_submodules,+            remove_non_persistent=True,+        ):+            value = self.weights_map[name]+            fp16_statistics = self._maybe_get_fp16_statistics(name, value)++            # In case we are using offloading with tied weights, we need to keep track of the offloaded weights+            # that are loaded on device at this point, as we will need to remove them as well from the dictionary+            # self.tied_params_map in order to allow to free memory.+            if name in self.tied_params_names and value.data_ptr() not in self.tied_params_map:+                self.tied_params_map[value.data_ptr()] = {}++            if (+                value is not None

🚨Add an FP8 backend to `QuantizedCache`Python · 144 + / 27 −

Introduces 14 new declarations in src/transformers/cache_utils.py.

Adds new framework internals rather than adjusting what was there. Tests changed with it, with code of their own.

src/transformers/cache_utils.py ↗ · 6 files

@@ -919,6 +941,76 @@ def _dequantize(self, qtensor):         return tensor  +class Fp8QuantizedLayer(BaseQuantizedLayer):+    """+    A quantized layer storing the key and value states in 8-bit floating point. The per-tensor scale is frozen+    after the first `update`, so new states are appended as-is: no residual cache, no re-quantization.++    A finer-grained variant belongs here rather than under `QuantizedLayer`, as grouping along the head+    dimension keeps states appendable and only turns the stored scale into a tensor.+    """++    fp8_dtype = torch.float8_e4m3fn+    fp8_max = torch.finfo(fp8_dtype).max++    def lazy_initialization(self, key_states: torch.Tensor, value_states: torch.Tensor) -> None:+        super().lazy_initialization(key_states, value_states)+        self._quantized_keys = self._quantize(key_states)+        self._quantized_values = self._quantize(value_states)++    def _quantize(self, tensor, scale=None):+        """Quantize `tensor` to FP8, calibrating the scale on its amplitude if it is not provided."""+        if scale is None:+            # `clamp` guards against an all-zeros tensor, which would give a null scale+            scale = (tensor.abs().amax().float() / self.fp8_max).clamp(min=torch.finfo(torch.float32).tiny)+        return (tensor.float() / scale).to(self.fp8_dtype), scale++    def _dequantize(self, qtensor):+        quant_tensor, scale = qtensor+        return (quant_tensor.float() * scale).to(self.dtype)++    def update(+        self, key_states: torch.Tensor, value_states: torch.Tensor, *args, **kwargs

Reland debug impl for fieldless enums with concatenated string without using discriminant_valueRust · 108 + / 0 −

Introduces 3 new declarations in compiler/rustc_builtin_macros/src/deriving/debug.rs.

Adds new language design rather than adjusting what was there. Tests changed with it, with code of their own.

compiler/rustc_builtin_macros/src/deriving/debug.rs ↗ · 6 files

@@ -256,3 +259,94 @@ fn show_fieldless_enum(     let fn_path_write_str = cx.std_path(span, &[sym::fmt, sym::Formatter, sym::write_str]);     BlockOrExpr::new_expr(cx.expr_call_global(span, fn_path_write_str, thin_vec![fmt, name])) }++/// Special case for large enums with no fields. Builds:+/// ```text+/// impl ::core::fmt::Debug for A {+///     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {+///         ::core::fmt::Formatter::debug_c_like_enum_write_str(f,+///             "A B C D E F",+///             match self {+///                 A::A => 0usize,+///                 A::B => 2usize,+///                 A::C => 4usize,+///                 A::D => 6usize,+///                 A::E => 8usize,+///                 A::F => 10usize,+///             })+///     }+/// }+/// ```+fn show_fieldless_enum_concat_str(+    cx: &ExtCtxt<'_>,+    span: Span,+    def: &EnumDef,+    type_ident: Ident,+) -> Option<Box<ast::Expr>> {+    // Minimum variant count where this optimization starts to pay off.+    // Initial value of 10 came from https://github.com/rust-lang/rust/pull/155452.+    // Refined with the new impl in https://github.com/rust-lang/rust/pull/162535.+    // Tested with thresholds 10,5,2 on rustc-perf+    // and by comparing MIR sizes for various enums in GodBolt.+    //

turbo-tasks-backend: restore invalidated tasks with batched optional readsRust · 418 + / 38 −

Introduces 25 new declarations in turbopack/crates/turbo-tasks-backend/src/backend/operation/mod.rs.

Adds new framework internals rather than adjusting what was there. Tests changed with it, with code of their own.

turbopack/crates/turbo-tasks-backend/src/backend/operation/mod.rs ↗ · 4 files

@@ -2104,6 +2202,280 @@ mod must_exist_tests {             assert!(!tt.backend().storage.access_mut(id).flags.meta_restored());         }     }++    /// Runs [`ExecuteContext::for_each_try_task_all`] and returns the ids handed to the callback.+    fn try_tasks(tt: &TurboTasks<TurboTasksBackend>, ids: &[TaskId]) -> Vec<TaskId> {+        let mut ctx = ExecuteContext::new(tt.backend(), tt);+        let mut seen = Vec::new();+        ctx.for_each_try_task_all(ids.iter().copied(), "try tasks", |guard, _| {+            seen.push(guard.id())+        });+        seen+    }++    fn has_entry(tt: &TurboTasks<TurboTasksBackend>, id: TaskId) -> bool {+        tt.backend().storage.with_task(id, |_| ()).is_some()+    }++    fn assert_unpinned(tt: &TurboTasks<TurboTasksBackend>, id: TaskId) {+        assert_eq!(+            tt.backend()+                .storage+                .with_task(id, |t| t.gc_transient_ref_count()),+            Some(0)+        );+    }++    #[tokio::test(flavor = "multi_thread")]+    async fn try_tasks_resident_handed_off() {+        let tt = backend();+        let present = persistent(1);+        let transient = TaskId::new(TRANSIENT_TASK_BIT | 2).unwrap();+        resident(&tt, present, TaskDataCategory::All);

models: Add Flint model (FlintForCausalLM)C++ · 234 + / 5 −

Introduces 3 new declarations in src/models/flint.cpp.

Adds new runtime rather than adjusting what was there. Tests changed with it, with code of their own.

src/models/flint.cpp ↗ · 18 files

@@ -0,0 +1,194 @@+#include "models.h"++void llama_model_flint::load_arch_hparams(llama_model_loader & ml) {+    ml.get_key(LLM_KV_ATTENTION_LAYERNORM_RMS_EPS, hparams.f_norm_rms_eps);+    ml.get_key(LLM_KV_LEADING_DENSE_BLOCK_COUNT,   hparams.n_layer_dense_lead);+    ml.get_key_or_arr(LLM_KV_EXPERT_FEED_FORWARD_LENGTH, hparams.n_ff_exp_arr, hparams.n_layer_all);+    ml.get_key(LLM_KV_EXPERT_SHARED_COUNT,         hparams.n_expert_shared);+    ml.get_key(LLM_KV_EXPERT_WEIGHTS_SCALE,        hparams.expert_weights_scale, false);+    ml.get_key(LLM_KV_EXPERT_WEIGHTS_NORM,         hparams.expert_weights_norm);+    ml.get_key(LLM_KV_EXPERT_GATING_FUNC,          hparams.expert_gating_func);++    ml.get_key(LLM_KV_EXPERT_SHARED_FEED_FORWARD_LENGTH, hparams.n_ff_shexp);+    ml.get_arr(LLM_KV_ATTENTION_SLIDING_WINDOW_PATTERN, hparams.is_swa_impl);+    ml.get_arr(LLM_KV_ATTENTION_ROPE_PATTERN, hparams.rope_pattern);+    ml.get_key(LLM_KV_ATTENTION_SLIDING_WINDOW, hparams.n_swa);+    hparams.swa_type = LLAMA_SWA_TYPE_STANDARD;+    type = LLM_TYPE_UNKNOWN;+}++void llama_model_flint::load_arch_tensors(llama_model_loader &) {+    LLAMA_LOAD_LOCALS;++    const int64_t n_ff_exp        = hparams.n_ff_exp();++    tok_embd = create_tensor(tn(LLM_TENSOR_TOKEN_EMBD, "weight"), {n_embd, n_vocab}, 0);++    output_norm = create_tensor(tn(LLM_TENSOR_OUTPUT_NORM, "weight"), {n_embd}, 0);+    output      = create_tensor(tn(LLM_TENSOR_OUTPUT,      "weight"), {n_embd, n_vocab}, 0);++    for (int i = 0; i < n_layer; ++i) {+        auto & layer = layers[i];++        layer.attn_norm = create_tensor(tn(LLM_TENSOR_ATTN_NORM, "weight", i), {n_embd}, 0);

Align non-recursive responses between cacher and etcdGo · 72 + / 167 −

Introduces 3 new declarations in staging/src/k8s.io/apiserver/pkg/storage/testing/watcher_tests.go.

Adds new framework internals rather than adjusting what was there. Tests changed with it, with code of their own.

staging/src/k8s.io/apiserver/pkg/storage/testing/watcher_tests.go ↗ · 9 files

@@ -1516,64 +1498,34 @@ func RunTestNamespaceScopedWatch(ctx context.Context, t *testing.T, store storag 			name:          "namespaced watch, non-recursive, request without name, request without namespace, without field selector", 			recursive:     false, 			fieldSelector: fields.Everything(),-			watchTests: func() []*testWatchStruct {-				if isWatchCache {-					return []*testWatchStruct{-						{baseNamespacedPod("t43-foo1", "t43-ns1"), true, watch.Added},-						{baseNamespacedPod("t43-foo2", "t43-ns2"), true, watch.Added},-						{baseNamespacedPodUpdated("t43-foo1", "t43-ns1"), true, watch.Modified},-						{baseNamespacedPodUpdated("t43-foo2", "t43-ns2"), true, watch.Modified},-					}-				}-				return []*testWatchStruct{-					{baseNamespacedPod("t43-foo1", "t43-ns1"), false, ""},-					{baseNamespacedPod("t43-foo2", "t43-ns2"), false, ""},-					{baseNamespacedPodUpdated("t43-foo1", "t43-ns1"), false, ""},-					{baseNamespacedPodUpdated("t43-foo2", "t43-ns2"), false, ""},-				}-			}(),+			watchTests: []*testWatchStruct{+				{baseNamespacedPod("t43-foo1", "t43-ns1"), false, ""},+				{baseNamespacedPod("t43-foo2", "t43-ns2"), false, ""},+				{baseNamespacedPodUpdated("t43-foo1", "t43-ns1"), false, ""},+				{baseNamespacedPodUpdated("t43-foo2", "t43-ns2"), false, ""},+			}, 		}, 		{ 			name:          "namespaced watch, non-recursive, request without name, request without namespace, field selector with metadata.namespace", 			recursive:     false, 			fieldSelector: fields.ParseSelectorOrDie("metadata.namespace=t44-ns1"),-			watchTests: func() []*testWatchStruct {-				if isWatchCache {-					return []*testWatchStruct{