Change:
<ins> // Regression test for ICE #116473. // The ICE occurs when arguments are specified on an enum variant // (which is illegal) and the variant and its preceding path are // located at different places such as in different macros or // different expansions of the same macro (i.e. when the macro // calls itself recursively) enum Enum<T1, T2> {  VariantA { _v1: T1, _v2: T2 }, VariantB } type EnumUnit = Enum<(), ()>; // Recursive macro call using a tt metavariable for variant macro_rules! recursive_tt { () => (recursive_tt!(VariantB)); ($variant:tt) => (if let EnumUnit::$variant::<i32, u32> {} = 5 { true } else { false }); //~^ ERROR type arguments are not allowed on this type //~| ERROR mismatched types } // Recursive macro call using an ident metavariable for variant // (the behaviour is different for tt and ident) macro_rules! recursive_ident { () => (recursive_ident!(VariantB)); ($variant:ident) => (if let EnumUnit::$variant::<i32, u32> {} = 5 { true } else { false }); //~^ ERROR type arguments are not allowed on this type //~| ERROR mismatched types } // Mested macro calls (i.e. one calling another) using a tt // metavariable for variant macro_rules! nested1_tt { () => (nested2_tt!(VariantB)); } macro_rules! nested2_tt { ($variant:tt) => (if let EnumUnit::$variant::<i32, u32> {} = 5 { true } else { false }); //~^ ERROR type arguments are not allowed on this type //~| ERROR mismatched types } // Mested macro calls using an ident metavariable for variant // (the behaviour is different for tt and ident) macro_rules! nested1_ident { () => (nested2_ident!(VariantB)); } macro_rules! nested2_ident { ($variant:ident) => (if let EnumUnit::$variant::<i32, u32> {} = 5 { true } else { false }); //~^ ERROR type arguments are not allowed on this type //~| ERROR mismatched types } // Mested macro calls when args are passed as metavariable // instead of the enum variant macro_rules! nested1_tt_args_in_first_macro { () => (nested2_tt_args_in_first_macro!(i32, u32)); } macro_rules! nested2_tt_args_in_first_macro { ($arg1:tt, $arg2:tt) => (if let EnumUnit::VariantB::<$arg1, $arg2> {} //~^ ERROR type arguments are not allowed on this type //~| ERROR mismatched types = 5 { true } else { false }); } // Mested macro calls when args are passed as metavariable // instead of the enum variant macro_rules! nested1_ident_args_in_first_macro { () => (nested2_ident_args_in_first_macro!(i32, u32)); } macro_rules! nested2_ident_args_in_first_macro { ($arg1:ident, $arg2:ident) => (if let EnumUnit::VariantB::<$arg1, $arg2> {} //~^ ERROR type arguments are not allowed on this type //~| ERROR mismatched types = 5 { true } else { false }); } fn main() { // Macro cases recursive_tt!(); recursive_ident!(); nested1_tt!(); nested1_ident!(); nested1_tt_args_in_first_macro!(); nested1_ident_args_in_first_macro!(); // Regular, non-macro case if let EnumUnit::VariantB::<i32, u32> {} = 5 { true } else { false }; //~^ ERROR type arguments are not allowed on this type //~| ERROR mismatched types } </ins>

Discussion:
<!-- 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. --<!-- 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. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --
the problem is probably line 8 of the suggestion? !
claim
Minimized a bit more: The issue occurs because we compute a wrong span for the args . Instead of this: it spans the entire distance from the end of in the first line to the end of in the next line: The reasons for this is that we compute the span starting from the end of the variant path segment ( in this case) to end of the args (the right angle bracket of of ). Normally it works, but leads to the above miscalculation when the variant and the args reside in different macros or expansions as in the present case. The offending source code doing the span computation is this: