Change:
self.injection_phase.is_some() } <del> /// Finds which basic blocks are actually reachable for a specific /// monomorphization of this body. /// /// This is allowed to have false positives; just because this says a block /// is reachable doesn't mean that's necessarily true. It's thus always /// legal for this to return a filled set. /// /// Regardless, the [`BitSet::domain_size`] of the returned set will always /// exactly match the number of blocks in the body so that `contains` /// checks can be done without worrying about panicking. /// /// This is mostly useful because it lets us skip lowering the `false` side /// of `if <T as Trait>::CONST`, as well as `intrinsics::debug_assertions`. pub fn reachable_blocks_in_mono( &self, tcx: TyCtxt<'tcx>, instance: Instance<'tcx>, ) -> BitSet<BasicBlock> { let mut set = BitSet::new_empty(self.basic_blocks.len()); self.reachable_blocks_in_mono_from(tcx, instance, &mut set, START_BLOCK); set } fn reachable_blocks_in_mono_from( &self, tcx: TyCtxt<'tcx>, instance: Instance<'tcx>, set: &mut BitSet<BasicBlock>, bb: BasicBlock, ) { if !set.insert(bb) { return; } let data = &self.basic_blocks[bb]; if let Some((bits, targets)) = Self::try_const_mono_switchint(tcx, instance, data) { let target = targets.target_for_value(bits); ensure_sufficient_stack(|| { self.reachable_blocks_in_mono_from(tcx, instance, set, target) }); return; } for target in data.terminator().successors() { ensure_sufficient_stack(|| { self.reachable_blocks_in_mono_from(tcx, instance, set, target) }); } } </del> /// If this basic block ends with a [`TerminatorKind::SwitchInt`] for which we can evaluate the /// dimscriminant in monomorphization, we return the discriminant bits and the /// [`SwitchTargets`], just so the caller doesn't also have to match on the terminator.

Discussion:
tracking issue: Inspired by comment in For things like it'd be nice to not have to even give LLVM the code for the else branch to have to emit. Ought to save time and binary size. Tentatively marked mir-opt, since we presumably still need to make the MIR for it, in order to borrow-check and such the unreachable code. But might need to be codegen-time instead to pick up on monomorphized inline constants. Hopefully should be doable relatively easily when the const is an inline const, since that forces const folding already, and thus there should just be a in the MIR.
Well, turns out this already works for simple constants in MIR! However, the place I actually needed it was more like , which doesn't work with today. So maybe come back to this once that's fixed.
This should be done by which AFAIK is run unconditionally. I wonder if its match needs to be expanded? Is there mcve?
The problem is that this can't be done on generic constants, as we don't mir-optimize post-monomorphization. We could start doing some benchmarks to see how bad running all mir opts (or at least a select few) would be if we duplicated, substituted and optimized MIR bodies for concrete generic parameters.
I would say qualifies as an MCVE as the monomorphized gives the following llvm ir
Maybe it should also be evaluated together with polymorphization or constevaluatablechecked since those can cut down on the duplication before applying further optimizations.
Bonus points if this can avoid monomorphizing functions called in the dead code too. Demo extracted from : (cc ) Would be great to not codegen all the downstream stuff that's only called in the else block of a .
FYI this should work with
Totally wild (and probably bad) idea: could we avoid borrow-checking unreachable code? After all, the purpose of borrow-checking is to prevent memory unsafety at runtime, but unreachable code cannot be memory unsafe, because it never executes!
We already do! As a , (But this isn't really the right issue to discuss possible extensions to that.)
This seems closely related to and
recent PR seems related here? If the condition becomes a constant during codegen, we should be entirely skipping it now and not even generate LLVM IR.

However, if that dead code calls functions, those still get codegen'd as usual -- the collector that determines which function to codegen doesn't know about dead branches. We'd have to embed a (simple) monomorphization-time reachability analysis in the collector to fix that.