[rustc] ICE in stability_implications: DefId::expect_local called on non-local DefId from core when using reuse with Iterator::fold under staged_api

[YuanchengJiang]

Description

rustc panics with DefId::expect_local: ... isn't local when compiling a crate that uses #![feature(staged_api)] together with #![feature(fn_delegation)] and a reuse delegation that includes Iterator::fold. The stability_implications query walks the #[unstable] implications of delegated items and calls expect_local on Iterator::fold's generic type parameter B, which is a non-local DefId from core, triggering an unconditional panic.

Reproducer

#![feature(fn_delegation)]
#![allow(incomplete_features)]
#![feature(staged_api)]
#![unstable(feature = "foo", issue = "none")]

pub mod m {
    #[unstable(feature = "foo", issue = "none")]
    pub struct W<I, F> {
        pub inner: std::iter::Map<I, F>,
    }

    #[unstable(feature = "foo", issue = "none")]
    impl<B, I: Iterator, F: FnMut(I::Item) -> B> Iterator for W<I, F> {
        type Item = B;
        reuse Iterator::{next, fold} { self.inner }
    }
}

Command

rustc reproduce.rs

Expected behavior

The compiler either compiles successfully or emits a graceful diagnostic. It should not panic when computing stability implications for delegated items that reference non-local DefIds from the standard library.

Actual behavior

thread 'rustc' panicked at compiler/rustc_passes/src/stability.rs:309:55:
DefId::expect_local: `DefId(2:10014 ~ core[18bb]::iter::traits::iterator::Iterator::fold::B)` isn't local
error: the compiler unexpectedly panicked. This is a bug

Root cause

The call chain is:

check_mod_unstable_api_usage
  → check_unused_or_stable_features
    → stability_implications (stability.rs:1059)
      → stability_implications (stability.rs:309)
        → DefId::expect_local  ← panic: non-local DefId from core

stability_implications iterates over #[unstable] feature implications in the current crate. When fn_delegation's reuse Iterator::{next, fold} is processed, the compiler associates the delegated fold item with Iterator::fold's generic type parameter B (a DefId belonging to core, not the local crate). stability_implications then calls expect_local on this DefId without first checking DefId::is_local, causing the unconditional panic. The fix should guard the expect_local call with an is_local check, or ensure that fn_delegation does not register non-local DefIds as implications of local unstable features.

Environment

• Compiler: rustc 1.95.0-nightly
• Host target: x86_64-unknown-linux-gnu
• rustc commit: 9b1f8ff42d110b0ca138116745be921df5dc97e7
• Requires: #![feature(fn_delegation, staged_api)]

[eggyal]

Not too sure if this would be T-compiler or T-types, so I'm adding both for now...

@rustbot label +A-stability +I-ICE +F-fn_delegation +F-staged_api +T-compiler +T-types -needs-triage

[TaKO8Ki]

I have confirmed that the ICE does not occur in main branch.

$ rustc +stage1 src/main.rs
warning: the feature `staged_api` is internal to the compiler or standard library
 --> src/main.rs:3:12
  |
3 | #![feature(staged_api)]
  |            ^^^^^^^^^^
  |
  = note: using it is strongly discouraged
  = note: `#[warn(internal_features)]` on by default

warning: 1 warning emitted

[TaKO8Ki]

I will add a regression test.