{"id":"306f4b828da0d2db","repo":"rust-lang/rust","slug":"item-requires-monomorphization","errorCode":null,"errorMessage":"Item requires monomorphization","messagePattern":"Item requires monomorphization","errorType":"exception","errorClass":"bridge::Error","httpStatus":null,"severity":"error","filePath":"compiler/rustc_public/src/mir/mono.rs","lineNumber":221,"sourceCode":"            .field(\"kind\", &self.kind)\n            .field(\"def\", &self.mangled_name())\n            .field(\"args\", &self.args())\n            .finish()\n    }\n}\n\n/// Try to convert a crate item into an instance.\n/// The item cannot be generic in order to be converted into an instance.\nimpl TryFrom<CrateItem> for Instance {\n    type Error = crate::Error;\n\n    fn try_from(item: CrateItem) -> Result<Self, Self::Error> {\n        with(|context| {\n            let def_id = item.def_id();\n            if !context.requires_monomorphization(def_id) {\n                Ok(context.mono_instance(def_id))\n            } else {\n                Err(bridge::Error::new(\"Item requires monomorphization\".to_string()))\n            }\n        })\n    }\n}\n\n/// Try to convert an instance into a crate item.\n/// Only user defined instances can be converted.\nimpl TryFrom<Instance> for CrateItem {\n    type Error = crate::Error;\n\n    fn try_from(value: Instance) -> Result<Self, Self::Error> {\n        with(|context| {\n            if value.kind == InstanceKind::Item && context.has_body(value.def.def_id()) {\n                Ok(CrateItem(context.instance_def_id(value.def)))\n            } else {\n                Err(bridge::Error::new(format!(\"Item kind `{:?}` cannot be converted\", value.kind)))\n            }\n        })","sourceCodeStart":203,"sourceCodeEnd":239,"githubUrl":"https://github.com/rust-lang/rust/blob/22057b88b091743bc0fd8d592a9264f0a6951403/compiler/rustc_public/src/mir/mono.rs#L203-L239","documentation":"Thrown by the `TryFrom<CrateItem> for Instance` impl in compiler/rustc_public/src/mir/mono.rs:221 when the crate item has generic parameters that have not been substituted. An `Instance` is a fully concrete (monomorphized) code item, so a generic `fn foo<T>` or generic inherent/impl item cannot become an instance without first choosing concrete generic args. rustc_public surfaces this because it only hands out instances for items whose `requires_monomorphization` query returns false.","triggerScenarios":"Calling `Instance::try_from(crate_item)` (or `.into()`) on a `CrateItem` whose DefId refers to a generic function/type/impl. Iterating `context.crate_items()` and converting each item unconditionally to an `Instance`. Passing a DefId resolved from a generic definition straight into instance construction without substituting args.","commonSituations":"Static analyzers/linters that walk every item in a crate and assume all are monomorphizable. Using a DefId lookup (e.g. by path) that returns a generic function. Migrating from a version where the item was monomorphic to one where it became generic.","solutions":["Filter items before conversion: call `context.requires_monomorphization(def_id)` and only call `Instance::try_from` when it returns false.","If you need a concrete instance of a generic item, build it with explicit generic args via the context's instance-with-args API instead of the bare `TryFrom`.","Handle the `Err` from `try_from` as a non-fatal skip rather than unwrapping, so generic items are skipped during a whole-crate walk."],"exampleFix":"// before\nfor item in context.crate_items() {\n    let instance = Instance::try_from(item)?;\n    process(instance);\n}\n// after\nfor item in context.crate_items() {\n    if context.requires_monomorphization(item.def_id()) {\n        continue;\n    }\n    let instance = Instance::try_from(item)?;\n    process(instance);\n}","handlingStrategy":"validation","validationCode":"// Before Instance::try_from(item):\nif item.requires_monomorphization() {\n    // item is generic (or lives in a generic impl); it cannot become a\n    // monomorphic Instance without explicit args. Skip or resolve via\n    // Instance::resolve(FnDef, &GenericArgs) instead.\n    return Err(format!(\"item {:?} requires monomorphization\", item));\n}\nlet instance = Instance::try_from(item)?;","typeGuard":"// True only for non-generic CrateItems that yield a concrete Instance.\nfn is_monomorphic_item(item: &CrateItem) -> bool {\n    !item.requires_monomorphization()\n}","tryCatchPattern":"// Instance::try_from returns Result; treat the Err as \"needs args\":\nmatch Instance::try_from(item) {\n    Ok(inst) => inst,\n    Err(e) if e.to_string().contains(\"monomorphization\") => {\n        // Resolve with explicit generic args instead of TryFrom.\n        return resolve_with_args(item)?;\n    }\n    Err(e) => return Err(e.into()),\n}","preventionTips":["Filter item lists up front with `!item.requires_monomorphization()` before attempting `Instance::try_from`.","For generic items, resolve a concrete instance via `Instance::resolve(FnDef, &GenericArgs)` with fully concrete args rather than relying on `TryFrom<CrateItem>`.","Remember genericness is transitive: an item in a generic `impl` block reports `requires_monomorphization() == true` even if the item itself has no own type parameters."],"tags":["rust","mir","monomorphization","generics"],"analyzedSha":"22057b88b091743bc0fd8d592a9264f0a6951403","analyzedAt":"2026-08-03T08:09:25.915Z","schemaVersion":2}