Change:
<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read "Rust Bug Minimization Patterns" for how to create smaller examples. --Note: this only occurs when the type of the code block is a result. Removing the line and swapping for does not yield the ICE. //! use rustice::sub; //! //! let x = sub::makestruct()?; //! //! assert!(matches!(x, sub::En::A(sub::B { inner: vec![], .. }))); //! Ok::<(), &'static str(()) //! <!-- 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. --: and after a rustup, (still getting the same ICE): <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details
Here's a reproduction without rustdoc involved:
Minimized:

Discussion:
let lower_sub = |this: &mut Self| sub.as_ref().map(|s| this.lower_pat(&*s)); break self.lower_pat_ident(pattern, binding_mode, ident, lower_sub); } <del> PatKind::Lit(ref e) => break hir::PatKind::Lit(self.lower_expr(e)), </del> <ins> PatKind::Lit(ref e) => { break hir::PatKind::Lit(self.lower_expr_within_pat(e, false)); } </ins> PatKind::TupleStruct(ref qself, ref path, ref pats) => { let qpath = self.lower_qpath( pattern.id,

} PatKind::Range(ref e1, ref e2, Spanned { node: ref end, .. }) => { break hir::PatKind::Range( <del> e1.as_deref().map(|e| self.lower_expr(e)), e2.as_deref().map(|e| self.lower_expr(e)), </del> <ins> e1.as_deref().map(|e| self.lower_expr_within_pat(e, true)), e2.as_deref().map(|e| self.lower_expr_within_pat(e, true)), </ins> self.lower_range_end(end, e2.is_some()), ); }

RangeEnd::Excluded | RangeEnd::Included(_) => hir::RangeEnd::Included, } } <ins> /// Matches `'-' lit | lit (cf. parser::Parser::parse_literal_maybe_minus)`, /// or paths for ranges. // // FIXME: do we want to allow `expr -> pattern` conversion to create path expressions? // That means making this work: // // ```rust,ignore (FIXME) // struct S; // macro_rules! m { //     ($a:expr) => { //         let $a = S; //     } // } // m!(S); // ``` fn lower_expr_within_pat(&mut self, expr: &Expr, allow_paths: bool) -> &'hir hir::Expr<'hir> { match expr.kind { ExprKind::Lit(..) | ExprKind::ConstBlock(..) | ExprKind::Err => {} ExprKind::Path(..) if allow_paths => {} ExprKind::Unary(UnOp::Neg, ref inner) if matches!(inner.kind, ExprKind::Lit(_)) => {} _ => { self.diagnostic() .span_err(expr.span, "arbitrary expressions aren't allowed in patterns"); return self.arena.alloc(self.expr_err(expr.span)); } } self.lower_expr(expr) } </ins> }

} } <del> /// Matches `'-' lit | lit (cf. parser::Parser::parse_literal_maybe_minus)`, /// or paths for ranges. // // FIXME: do we want to allow `expr -> pattern` conversion to create path expressions? // That means making this work: // // ```rust,ignore (FIXME) // struct S; // macro_rules! m { //     ($a:expr) => { //         let $a = S; //     } // } // m!(S); // ``` fn check_expr_within_pat(&self, expr: &Expr, allow_paths: bool) { match expr.kind { ExprKind::Lit(..) | ExprKind::ConstBlock(..) | ExprKind::Err => {} ExprKind::Path(..) if allow_paths => {} ExprKind::Unary(UnOp::Neg, ref inner) if matches!(inner.kind, ExprKind::Lit(_)) => {} _ => self.err_handler().span_err( expr.span, "arbitrary expressions aren't allowed  in patterns", ), } } </del> fn check_late_bound_lifetime_defs(&self, params: &[GenericParam]) { // Check only lifetime parameters are present and that the lifetime // parameters that are present have no bounds.

visit::walk_param_bound(self, bound) } <del> fn visit_pat(&mut self, pat: &'a Pat) { match &pat.kind { PatKind::Lit(expr) => { self.check_expr_within_pat(expr, false); } PatKind::Range(start, end, _) => { if let Some(expr) = start { self.check_expr_within_pat(expr, true); } if let Some(expr) = end { self.check_expr_within_pat(expr, true); } } _ => {} } visit::walk_pat(self, pat) } </del> fn visit_poly_trait_ref(&mut self, t: &'a PolyTraitRef, m: &'a TraitBoundModifier) { self.check_late_bound_lifetime_defs(&t.bound_generic_params); visit::walk_poly_trait_ref(self, t, m);

<del> error: arbitrary expressions aren't allowed in patterns </del> <ins> error[E0425]: cannot find value `a` in this scope </ins> --> $DIR/expr_before_ident_pat.rs:12:12 | LL |     funny!(a, a); <del> |            ^ </del> <ins> |            ^ not found in this scope </ins> <del> error[E0425]: cannot find value `a` in this scope </del> <ins> error: arbitrary expressions aren't allowed in patterns </ins> --> $DIR/expr_before_ident_pat.rs:12:12 | LL |     funny!(a, a); <del> |            ^ not found in this scope </del> <ins> |            ^ </ins> error: aborting due to 2 previous errors

<ins> pub enum En { A(Vec<u8>) } fn get_usize() -> usize { 0 } macro_rules! force_expr { ($e:expr) => { $e } } macro_rules! force_pat { ($a:expr, $b:expr) => { $a..=$b } } macro_rules! make_vec { () => { force_expr!(Vec::new()) } //~ ERROR arbitrary expressions aren't allowed } macro_rules! make_pat { () => { force_pat!(get_usize(), get_usize()) } //~^ ERROR arbitrary expressions aren't allowed //~| ERROR arbitrary expressions aren't allowed } #[allow(unreachable_code)] fn f() -> Result<(), impl core::fmt::Debug> { let x: En = loop {}; assert!(matches!(x, En::A(make_vec!()))); assert!(matches!(5, make_pat!())); Ok::<(), &'static str>(()) } fn main() {} </ins>

<ins> error: arbitrary expressions aren't allowed in patterns --> $DIR/issue-92074-macro-ice.rs:18:25 | LL |     () => { force_expr!(Vec::new()) } |                         ^^^^^^^^^^ ... LL |     assert!(matches!(x, En::A(make_vec!()))); |                               ----------- in this macro invocation | = note: this error originates in the macro `make_vec` (in Nightly builds, run with -Z macro-backtrace for more info) error: arbitrary expressions aren't allowed in patterns --> $DIR/issue-92074-macro-ice.rs:22:24 | LL |     () => { force_pat!(get_usize(), get_usize()) } |                        ^^^^^^^^^^^ ... LL |     assert!(matches!(5, make_pat!())); |                         ----------- in this macro invocation | = note: this error originates in the macro `make_pat` (in Nightly builds, run with -Z macro-backtrace for more info) error: arbitrary expressions aren't allowed in patterns --> $DIR/issue-92074-macro-ice.rs:22:37 | LL |     () => { force_pat!(get_usize(), get_usize()) } |                                     ^^^^^^^^^^^ ... LL |     assert!(matches!(5, make_pat!())); |                         ----------- in this macro invocation | = note: this error originates in the macro `make_pat` (in Nightly builds, run with -Z macro-backtrace for more info) error: aborting due to 3 previous errors </ins>