Split thir::PatKind::ExpandedConstant into two distinct kinds

These two kinds of marker node are superficially similar, but are actually very
different in practice, and there is no code that actually wants to treat them
as the same thing.

Author: Zalathar

compiler/rustc_middle/src/thir.rs

@@ -678,11 +678,14 @@ impl<'tcx> Pat<'tcx> {
             | Binding { subpattern: None, .. }
             | Constant { .. }
             | Error(_) => {}
+
             AscribeUserType { subpattern, .. }
             | Binding { subpattern: Some(subpattern), .. }
             | Deref { subpattern }
             | DerefPattern { subpattern, .. }
-            | ExpandedConstant { subpattern, .. } => subpattern.walk_(it),
+            | InlineConstMarker { subpattern, .. }
+            | NamedConstMarker { subpattern, .. } => subpattern.walk_(it),
+
             Leaf { subpatterns } | Variant { subpatterns, .. } => {
                 subpatterns.iter().for_each(|field| field.pattern.walk_(it))
             }
@@ -825,24 +828,29 @@ pub enum PatKind<'tcx> {
         value: mir::Const<'tcx>,
     },
 
-    /// Pattern obtained by converting a constant (inline or named) to its pattern
-    /// representation using `const_to_pat`.
-    ExpandedConstant {
-        /// [DefId] of the constant, we need this so that we have a
-        /// reference that can be used by unsafety checking to visit nested
-        /// unevaluated constants and for diagnostics. If the `DefId` doesn't
-        /// correspond to a local crate, it points at the `const` item.
+    /// Marker node that wraps a pattern representing an inline-const block.
+    ///
+    /// THIR unsafeck uses this marker to discover inline-const blocks that
+    /// appear in patterns, so that they can be checked together with the rest
+    /// of their enclosing body.
+    ///
+    /// Note that if a range pattern has inline-const blocks for both endpoints,
+    /// the resulting THIR pattern will be an `InlineConstMarker`, containing
+    /// another `InlineConstMarker`, containing the underlying `Range` pattern.
+    InlineConstMarker {
+        /// ID of the inline-const block, for use by THIR unsafeck.
+        def_id: LocalDefId,
+        subpattern: Box<Pat<'tcx>>,
+    },
+
+    /// Marker node that wraps a pattern representing a named constant.
+    /// Enables better diagnostics in some cases, but has no other significance.
+    ///
+    /// (Even though this is superficially similar to `InlineConstMarker`, they
+    /// are very different in actual usage, so they should be kept separate.)
+    NamedConstMarker {
+        /// ID of the named constant, for use by diagnostics.
         def_id: DefId,
-        /// If `false`, then `def_id` points at a `const` item, otherwise it
-        /// corresponds to a local inline const.
-        is_inline: bool,
-        /// If the inline constant is used in a range pattern, this subpattern
-        /// represents the range (if both ends are inline constants, there will
-        /// be multiple InlineConstant wrappers).
-        ///
-        /// Otherwise, the actual pattern that the constant lowered to. As with
-        /// other constants, inline constants are matched structurally where
-        /// possible.
         subpattern: Box<Pat<'tcx>>,
     },
 

compiler/rustc_middle/src/thir/visit.rs

@@ -243,15 +243,17 @@ pub fn walk_pat<'thir, 'tcx: 'thir, V: Visitor<'thir, 'tcx>>(
         AscribeUserType { subpattern, ascription: _ }
         | Deref { subpattern }
         | DerefPattern { subpattern, .. }
-        | Binding { subpattern: Some(subpattern), .. } => visitor.visit_pat(subpattern),
+        | Binding { subpattern: Some(subpattern), .. }
+        | InlineConstMarker { subpattern, .. }
+        | NamedConstMarker { subpattern, .. } => visitor.visit_pat(subpattern),
+
         Binding { .. } | Wild | Never | Error(_) => {}
         Variant { subpatterns, adt_def: _, args: _, variant_index: _ } | Leaf { subpatterns } => {
             for subpattern in subpatterns {
                 visitor.visit_pat(&subpattern.pattern);
             }
         }
         Constant { value: _ } => {}
-        ExpandedConstant { def_id: _, is_inline: _, subpattern } => visitor.visit_pat(subpattern),
         Range(_) => {}
         Slice { prefix, slice, suffix } | Array { prefix, slice, suffix } => {
             for subpattern in prefix.iter() {

compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs

@@ -146,7 +146,7 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
             let arm = &self.thir[*arm];
             let value = match arm.pattern.kind {
                 PatKind::Constant { value } => value,
-                PatKind::ExpandedConstant { ref subpattern, def_id: _, is_inline: false }
+                PatKind::NamedConstMarker { ref subpattern, def_id: _ }
                     if let PatKind::Constant { value } = subpattern.kind =>
                 {
                     value

compiler/rustc_mir_build/src/builder/matches/match_pair.rs

@@ -162,11 +162,11 @@ impl<'pat, 'tcx> MatchPairTree<'pat, 'tcx> {
                 TestCase::Irrefutable { ascription: None, binding }
             }
 
-            PatKind::ExpandedConstant { subpattern: ref pattern, def_id: _, is_inline: false } => {
+            PatKind::NamedConstMarker { subpattern: ref pattern, def_id: _ } => {
                 subpairs.push(MatchPairTree::for_pattern(place_builder, pattern, cx));
                 default_irrefutable()
             }
-            PatKind::ExpandedConstant { subpattern: ref pattern, def_id, is_inline: true } => {
+            PatKind::InlineConstMarker { subpattern: ref pattern, def_id } => {
                 // Apply a type ascription for the inline constant to the value at `match_pair.place`
                 let ascription = place.map(|source| {
                     let span = pattern.span;
@@ -177,7 +177,10 @@ impl<'pat, 'tcx> MatchPairTree<'pat, 'tcx> {
                     })
                     .args;
                     let user_ty = cx.infcx.canonicalize_user_type_annotation(ty::UserType::new(
-                        ty::UserTypeKind::TypeOf(def_id, ty::UserArgs { args, user_self_ty: None }),
+                        ty::UserTypeKind::TypeOf(def_id.to_def_id(), ty::UserArgs {
+                            args,
+                            user_self_ty: None,
+                        }),
                     ));
                     let annotation = ty::CanonicalUserTypeAnnotation {
                         inferred_ty: pattern.ty,

compiler/rustc_mir_build/src/builder/matches/mod.rs

@@ -925,7 +925,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 self.visit_primary_bindings(subpattern, subpattern_user_ty, f)
             }
 
-            PatKind::ExpandedConstant { ref subpattern, .. } => {
+            PatKind::InlineConstMarker { ref subpattern, .. }
+            | PatKind::NamedConstMarker { ref subpattern, .. } => {
                 self.visit_primary_bindings(subpattern, pattern_user_ty, f)
             }
 

compiler/rustc_mir_build/src/check_unsafety.rs

@@ -332,7 +332,8 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
                 PatKind::Wild |
                 // these just wrap other patterns, which we recurse on below.
                 PatKind::Or { .. } |
-                PatKind::ExpandedConstant { .. } |
+                PatKind::InlineConstMarker { .. } |
+                PatKind::NamedConstMarker { .. } |
                 PatKind::AscribeUserType { .. } |
                 PatKind::Error(_) => {}
             }
@@ -400,12 +401,10 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
                 visit::walk_pat(self, pat);
                 self.inside_adt = old_inside_adt;
             }
-            PatKind::ExpandedConstant { def_id, is_inline, .. } => {
-                if let Some(def) = def_id.as_local()
-                    && *is_inline
-                {
-                    self.visit_inner_body(def);
-                }
+            PatKind::InlineConstMarker { def_id, .. } => {
+                // Also visit the inline `const {}` block that this pattern
+                // represents. (See #116482 for context.)
+                self.visit_inner_body(*def_id);
                 visit::walk_pat(self, pat);
             }
             _ => {

compiler/rustc_mir_build/src/thir/pattern/check_match.rs

@@ -676,10 +676,10 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
         let mut interpreted_as_const = None;
         let mut interpreted_as_const_sugg = None;
 
-        if let PatKind::ExpandedConstant { def_id, is_inline: false, .. }
+        if let PatKind::NamedConstMarker { def_id,  .. }
         | PatKind::AscribeUserType {
             subpattern:
-                box Pat { kind: PatKind::ExpandedConstant { def_id, is_inline: false, .. }, .. },
+                box Pat { kind: PatKind::NamedConstMarker { def_id,  .. }, .. },
             ..
         } = pat.kind
             && let DefKind::Const = self.tcx.def_kind(def_id)
@@ -1309,7 +1309,7 @@ fn report_non_exhaustive_match<'p, 'tcx>(
 
     for &arm in arms {
         let arm = &thir.arms[arm];
-        if let PatKind::ExpandedConstant { def_id, is_inline: false, .. } = arm.pattern.kind
+        if let PatKind::NamedConstMarker { def_id, .. } = arm.pattern.kind
             && let Ok(snippet) = cx.tcx.sess.source_map().span_to_snippet(arm.pattern.span)
             // We filter out paths with multiple path::segments.
             && snippet.chars().all(|c| c.is_alphanumeric() || c == '_')

compiler/rustc_mir_build/src/thir/pattern/mod.rs

@@ -165,17 +165,23 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
         // deconstructed to obtain the constant value and other data.
         let mut kind: PatKind<'tcx> = self.lower_lit(expr);
 
-        // Unpeel any ascription or inline-const wrapper nodes.
+        // Unpeel any wrapper nodes, while preserving marker data that will
+        // need to be reapplied to the range pattern node.
         loop {
             match kind {
                 PatKind::AscribeUserType { ascription, subpattern } => {
                     ascriptions.push(ascription);
                     kind = subpattern.kind;
                 }
-                PatKind::ExpandedConstant { is_inline, def_id, subpattern } => {
-                    if is_inline {
-                        inline_consts.extend(def_id.as_local());
-                    }
+                PatKind::InlineConstMarker { def_id, subpattern } => {
+                    // Preserve inline-const markers, so that THIR unsafeck can
+                    // see const blocks that are part of a range pattern.
+                    inline_consts.push(def_id);
+                    kind = subpattern.kind;
+                }
+                PatKind::NamedConstMarker { subpattern, .. } => {
+                    // Named-const markers are only used for improved diagnostics that
+                    // aren't relevant to range patterns, so it's OK to discard them.
                     kind = subpattern.kind;
                 }
                 _ => break,
@@ -307,12 +313,11 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
                 subpattern: Box::new(Pat { span, ty, kind }),
             };
         }
-        for def in inline_consts {
-            kind = PatKind::ExpandedConstant {
-                def_id: def.to_def_id(),
-                is_inline: true,
-                subpattern: Box::new(Pat { span, ty, kind }),
-            };
+        // If one or both endpoints is an inline-const block, reapply the marker
+        // nodes so that unsafeck can traverse into the corresponding block body.
+        for def_id in inline_consts {
+            let subpattern = Box::new(Pat { span, ty, kind });
+            kind = PatKind::InlineConstMarker { def_id, subpattern };
         }
         Ok(kind)
     }
@@ -593,11 +598,8 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
         let args = self.typeck_results.node_args(id);
         let c = ty::Const::new_unevaluated(self.tcx, ty::UnevaluatedConst { def: def_id, args });
         let subpattern = self.const_to_pat(c, ty, id, span);
-        let pattern = Box::new(Pat {
-            span,
-            ty,
-            kind: PatKind::ExpandedConstant { subpattern, def_id, is_inline: false },
-        });
+        let pattern =
+            Box::new(Pat { span, ty, kind: PatKind::NamedConstMarker { subpattern, def_id } });
 
         if !is_associated_const {
             return pattern;
@@ -648,7 +650,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
 
         let ct = ty::UnevaluatedConst { def: def_id.to_def_id(), args };
         let subpattern = self.const_to_pat(ty::Const::new_unevaluated(self.tcx, ct), ty, id, span);
-        PatKind::ExpandedConstant { subpattern, def_id: def_id.to_def_id(), is_inline: true }
+        PatKind::InlineConstMarker { subpattern, def_id }
     }
 
     /// Converts literals, paths and negation of literals to patterns.

compiler/rustc_mir_build/src/thir/print.rs

@@ -733,10 +733,16 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
                 print_indented!(self, format!("value: {:?}", value), depth_lvl + 2);
                 print_indented!(self, "}", depth_lvl + 1);
             }
-            PatKind::ExpandedConstant { def_id, is_inline, subpattern } => {
-                print_indented!(self, "ExpandedConstant {", depth_lvl + 1);
+            PatKind::InlineConstMarker { def_id, subpattern } => {
+                print_indented!(self, "InlineConstMarker {", depth_lvl + 1);
+                print_indented!(self, format!("def_id: {def_id:?}"), depth_lvl + 2);
+                print_indented!(self, "subpattern:", depth_lvl + 2);
+                self.print_pat(subpattern, depth_lvl + 2);
+                print_indented!(self, "}", depth_lvl + 1);
+            }
+            PatKind::NamedConstMarker { def_id, subpattern } => {
+                print_indented!(self, "NamedConstMarker {", depth_lvl + 1);
                 print_indented!(self, format!("def_id: {def_id:?}"), depth_lvl + 2);
-                print_indented!(self, format!("is_inline: {is_inline:?}"), depth_lvl + 2);
                 print_indented!(self, "subpattern:", depth_lvl + 2);
                 self.print_pat(subpattern, depth_lvl + 2);
                 print_indented!(self, "}", depth_lvl + 1);

compiler/rustc_pattern_analysis/src/rustc.rs

@@ -456,8 +456,12 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
         let fields: Vec<_>;
         match &pat.kind {
             PatKind::AscribeUserType { subpattern, .. }
-            | PatKind::ExpandedConstant { subpattern, .. } => return self.lower_pat(subpattern),
-            PatKind::Binding { subpattern: Some(subpat), .. } => return self.lower_pat(subpat),
+            | PatKind::InlineConstMarker { subpattern, .. }
+            | PatKind::NamedConstMarker { subpattern, .. }
+            | PatKind::Binding { subpattern: Some(subpattern), .. } => {
+                return self.lower_pat(subpattern);
+            }
+
             PatKind::Binding { subpattern: None, .. } | PatKind::Wild => {
                 ctor = Wildcard;
                 fields = vec![];