Change:
<details</summary</details<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:
I will try to reduce this to an MCVE.
Changing to appears to avoid the ICE, so that may be a useful place to focus.
Minimized it down to 60 lines without any dependencies. Maybe it can be minimized further but it's getting really hard. I've also left a few comments to say what's going on. <details<summary"Minimized" </summary</details
This appears to have regressed in Rust 1.64
This continues to ICE on beta and nightly
I bisected the regression, here is the output of : searched nightlies: from nightly-2022-06-24 to nightly-2022-08-05 regressed nightly: nightly-2022-07-14 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-pc-windows-msvc Reproduce with: </details
Out of these seems the most likely, cc
Zooming onto changeset.
Found MVCE: <details<summaryOutput from Rust Playground</summary</details

Discussion:
hir::ExprKind::Match(ref discr, arms, _) => { let discr_place = return_if_err!(self.mc.cat_expr(discr)); <del> self.maybe_read_scrutinee( </del> <ins> return_if_err!(self.maybe_read_scrutinee( </ins> discr, discr_place.clone(), arms.iter().map(|arm| arm.pat), <del> ); </del> <ins> )); </ins> // treatment of the discriminant is handled while walking the arms. for arm in arms {

discr: &Expr<'_>, discr_place: PlaceWithHirId<'tcx>, pats: impl Iterator<Item = &'t hir::Pat<'t>>, <del> ) { </del> <ins> ) -> Result<(), ()> { </ins> // Matching should not always be considered a use of the place, hence // discr does not necessarily need to be borrowed. // We only want to borrow discr if the pattern contain something other

let ExprUseVisitor { ref mc, body_owner: _, delegate: _ } = *self; let mut needs_to_be_read = false; for pat in pats { <del> return_if_err!(mc.cat_pattern(discr_place.clone(), pat, |place, pat| { </del> <ins> mc.cat_pattern(discr_place.clone(), pat, |place, pat| { </ins> match &pat.kind { PatKind::Binding(.., opt_sub_pat) => { // If the opt_sub_pat is None, than the binding does not count as

// examined } } <del> })); </del> <ins> })? </ins> } if needs_to_be_read {

// that the discriminant has been initialized. self.walk_expr(discr); } <ins> Ok(()) </ins> } fn walk_local<F>(

f(self); if let Some(els) = els { // borrowing because we need to test the discriminant <del> self.maybe_read_scrutinee(expr, expr_place.clone(), from_ref(pat).iter()); </del> <ins> return_if_err!(self.maybe_read_scrutinee( expr, expr_place.clone(), from_ref(pat).iter() )); </ins> self.walk_block(els) } self.walk_irrefutable_pat(&expr_place, &pat);

place_a: &Place<'tcx>, place_b: &Place<'tcx>, ) -> PlaceAncestryRelation { <del> // If Place A and Place B, don't start off from the same root variable, they are divergent. </del> <ins> // If Place A and Place B don't start off from the same root variable, they are divergent. </ins> if place_a.base != place_b.base { return PlaceAncestryRelation::Divergent; }

<ins> type Result<T, E = Error> = ::std::result::Result<T, E>; struct Error; trait ForEach { type Input; fn for_each<F, U>(self, f: F) where F: FnOnce(Self::Input) -> U; } impl<T> ForEach for A<T> { type Input = T; fn for_each<F, U>(self, f: F) where F: FnOnce(Self::Input) -> U, { todo!() } } struct A<T>(T); fn main() { let a = A(Result::Ok(Result::Ok(()))); //~ ERROR type annotations needed a.for_each(|a: Result<_>| { let f = || match a { Ok(Ok(a)) => {} Ok(Err(a)) => {} Err(a) => {} }; }); } </ins>

<ins> error[E0282]: type annotations needed for `A<std::result::Result<std::result::Result<(), E>, Error>>` --> $DIR/issue-104649.rs:24:9 | LL |     let a = A(Result::Ok(Result::Ok(()))); |         ^ | help: consider giving `a` an explicit type, where the type for type parameter `E` is specified | LL |     let a: A<std::result::Result<std::result::Result<(), E>, Error>> = A(Result::Ok(Result::Ok(()))); |          +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ error: aborting due to previous error For more information about this error, try `rustc --explain E0282`. </ins>