rust-lang/rust · error · bridge::Error

Expected a static item, but found

Error message

Expected a static item, but found: {value:?}

What it means

Thrown by `impl TryFrom<CrateItem> for StaticDef` (mono.rs:284) when a crate item that is not a `Static` is converted into a `StaticDef`. Only items whose `ItemKind` is `Static` are accepted, since a static definition needs a corresponding static DefKind.

Solutions

1. Check `matches!(item.kind(), ItemKind::Static)` before converting.
2. Separate items by kind using `crate_statics()` instead of `crate_items()` when you only want statics.
3. Handle non-static kinds in a separate branch.

Example fix

// before
let s: StaticDef = crate_item.try_into()?;

// after
let s: StaticDef = if matches!(crate_item.kind(), ItemKind::Static) {
    crate_item.try_into()?
} else {
    continue;
};

// Only attempt the conversion on items known to be statics.
if !matches!(item.kind(), ItemKind::Static) {
    return Err("not a static item".into());
}
StaticDef::try_from(item)

fn is_static_item(item: &CrateItem) -> bool {
    matches!(item.kind(), ItemKind::Static)
}

When it happens

Trigger: Calling `StaticDef::try_from(crate_item)` / `crate_item.try_into()` on a `CrateItem` whose kind is `Fn`, `Const`, `Trait`, etc.

Common situations: Filtering crate items into typed handles without first checking `item.kind()`; processing a mixed list of functions and statics through a single conversion path.

Related errors

• Item kind ` ` cannot be converted
• Failed to resolve ` ` with
• Item requires monomorphization
• {self:?}

AI-assisted analysis of rust-lang/rust@7088e4b63a (2026-08-10). Data as JSON: /api/errors/5d08e30f79a70227. Report an issue: GitHub.

Appendix: source

Thrown at compiler/rustc_public/src/mir/mono.rs:284

    fn def_id(&self) -> DefId {
        with(|context| context.instance_def_id(*self))
    }
}

crate_def! {
    /// Holds information about a static variable definition.
    #[derive(Serialize)]
    pub StaticDef;
}

impl TryFrom<CrateItem> for StaticDef {
    type Error = crate::Error;

    fn try_from(value: CrateItem) -> Result<Self, Self::Error> {
        if matches!(value.kind(), ItemKind::Static) {
            Ok(StaticDef(value.0))
        } else {
            Err(bridge::Error::new(format!("Expected a static item, but found: {value:?}")))
        }
    }
}

impl TryFrom<Instance> for StaticDef {
    type Error = crate::Error;

    fn try_from(value: Instance) -> Result<Self, Self::Error> {
        StaticDef::try_from(CrateItem::try_from(value)?)
    }
}

impl From<StaticDef> for Instance {
    fn from(value: StaticDef) -> Self {
        // A static definition should always be convertible to an instance.
        with(|cx| cx.mono_instance(value.def_id()))
    }
}

View on GitHub (pinned to 7088e4b63a)