Only rewrite valtree-constants to patterns and keep other constants opaque

oli-obk · oli-obk · commit d030ece6f795 · 2023-05-31T14:02:57.000Z
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
@@ -2487,8 +2487,8 @@ impl<'tcx> ConstantKind<'tcx> {
         if let Some(lit_input) = lit_input {
             // If an error occurred, ignore that it's a literal and leave reporting the error up to
             // mir.
-            match tcx.at(expr.span).lit_to_mir_constant(lit_input) {
-                Ok(c) => return c,
+            match tcx.at(expr.span).lit_to_const(lit_input) {
+                Ok(c) => return Self::Ty(c),
                 Err(_) => {}
             }
         }
diff --git a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
diff --git a/compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs
@@ -141,22 +141,21 @@ impl IntRange {
     ) -> Option<IntRange> {
         let ty = value.ty();
         if let Some((target_size, bias)) = Self::integral_size_and_signed_bias(tcx, ty) {
-            let val = if let mir::ConstantKind::Val(ConstValue::Scalar(scalar), _) = value {
-                // For this specific pattern we can skip a lot of effort and go
-                // straight to the result, after doing a bit of checking. (We
-                // could remove this branch and just fall through, which
-                // is more general but much slower.)
-                scalar.to_bits_or_ptr_internal(target_size).unwrap().left()?
-            } else {
-                if let mir::ConstantKind::Ty(c) = value
-                    && let ty::ConstKind::Value(_) = c.kind()
-                {
-                    bug!("encountered ConstValue in mir::ConstantKind::Ty, whereas this is expected to be in ConstantKind::Val");
+            let val = match value {
+                mir::ConstantKind::Val(ConstValue::Scalar(scalar), _) => {
+                    // For this specific pattern we can skip a lot of effort and go
+                    // straight to the result, after doing a bit of checking. (We
+                    // could remove this branch and just fall through, which
+                    // is more general but much slower.)
+                    scalar.to_bits_or_ptr_internal(target_size).unwrap().left()
                 }
-
+                mir::ConstantKind::Ty(c) if let ty::ConstKind::Value(valtree) = c.kind() => {
+                    valtree.unwrap_leaf().to_bits(target_size).ok()
+                },
                 // This is a more general form of the previous case.
-                value.try_eval_bits(tcx, param_env, ty)?
-            };
+                _ => value.try_eval_bits(tcx, param_env, ty),
+            }?;
+
             let val = val ^ bias;
             Some(IntRange { range: val..=val, bias })
         } else {
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -18,7 +18,7 @@ use rustc_hir::pat_util::EnumerateAndAdjustIterator;
 use rustc_hir::RangeEnd;
 use rustc_index::Idx;
 use rustc_middle::mir::interpret::{
-    ConstValue, ErrorHandled, LitToConstError, LitToConstInput, Scalar,
+    ConstValue, ErrorHandled, GlobalId, LitToConstError, LitToConstInput, Scalar,
 };
 use rustc_middle::mir::{self, UserTypeProjection};
 use rustc_middle::mir::{BorrowKind, Mutability};
@@ -518,16 +518,22 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
             }
         };
 
-        // `mir_const_qualif` must be called with the `DefId` of the item where the const is
-        // defined, not where it is declared. The difference is significant for associated
-        // constants.
-        let mir_structural_match_violation = self.tcx.mir_const_qualif(instance.def_id()).custom_eq;
-        debug!("mir_structural_match_violation({:?}) -> {}", qpath, mir_structural_match_violation);
-
-        match self.tcx.const_eval_instance(param_env_reveal_all, instance, Some(span)) {
-            Ok(literal) => {
-                let const_ = mir::ConstantKind::Val(literal, ty);
-                let pattern = self.const_to_pat(const_, id, span, mir_structural_match_violation);
+        let cid = GlobalId { instance, promoted: None };
+        // Prefer
+        let const_value = self
+            .tcx
+            .const_eval_global_id_for_typeck(param_env_reveal_all, cid, Some(span))
+            .and_then(|val| match val {
+                Some(valtree) => Ok(mir::ConstantKind::Ty(self.tcx.mk_const(valtree, ty))),
+                None => self
+                    .tcx
+                    .const_eval_global_id(param_env_reveal_all, cid, Some(span))
+                    .map(|lit| mir::ConstantKind::Val(lit, ty)),
+            });
+
+        match const_value {
+            Ok(const_) => {
+                let pattern = self.const_to_pat(const_, id, span, Some(instance.def_id()));
 
                 if !is_associated_const {
                     return pattern;
@@ -578,9 +584,21 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
         span: Span,
     ) -> PatKind<'tcx> {
         let value = mir::ConstantKind::from_inline_const(self.tcx, anon_const.def_id);
-
-        // Evaluate early like we do in `lower_path`.
-        let value = value.eval(self.tcx, self.param_env);
+        let value = match value {
+            mir::ConstantKind::Ty(_) => value,
+            // Evaluate early like we do in `lower_path`.
+            mir::ConstantKind::Unevaluated(ct, ty) => {
+                let ct = ty::UnevaluatedConst { def: ct.def, substs: ct.substs };
+                if let Ok(Some(valtree)) =
+                    self.tcx.const_eval_resolve_for_typeck(self.param_env, ct, Some(span))
+                {
+                    mir::ConstantKind::Ty(self.tcx.mk_const(valtree, ty))
+                } else {
+                    value.eval(self.tcx, self.param_env)
+                }
+            }
+            mir::ConstantKind::Val(_, _) => unreachable!(),
+        };
 
         match value {
             mir::ConstantKind::Ty(c) => match c.kind() {
@@ -591,15 +609,17 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
                 ConstKind::Error(_) => {
                     return PatKind::Wild;
                 }
-                _ => bug!("Expected ConstKind::Param"),
+                _ => {}
             },
-            mir::ConstantKind::Val(_, _) => self.const_to_pat(value, id, span, false).kind,
+            mir::ConstantKind::Val(_, _) => {}
             mir::ConstantKind::Unevaluated(..) => {
                 // If we land here it means the const can't be evaluated because it's `TooGeneric`.
                 self.tcx.sess.emit_err(ConstPatternDependsOnGenericParameter { span });
                 return PatKind::Wild;
             }
         }
+
+        self.const_to_pat(value, id, span, None).kind
     }
 
     /// Converts literals, paths and negation of literals to patterns.
@@ -626,8 +646,14 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
 
         let lit_input =
             LitToConstInput { lit: &lit.node, ty: self.typeck_results.expr_ty(expr), neg };
-        match self.tcx.at(expr.span).lit_to_mir_constant(lit_input) {
-            Ok(constant) => self.const_to_pat(constant, expr.hir_id, lit.span, false).kind,
+        match self
+            .tcx
+            .at(expr.span)
+            .lit_to_const(lit_input)
+            .map(mir::ConstantKind::Ty)
+            .or_else(|_| self.tcx.at(expr.span).lit_to_mir_constant(lit_input))
+        {
+            Ok(constant) => self.const_to_pat(constant, expr.hir_id, lit.span, None).kind,
             Err(LitToConstError::Reported(_)) => PatKind::Wild,
             Err(LitToConstError::TypeError) => bug!("lower_lit: had type error"),
         }
@@ -806,6 +832,9 @@ pub(crate) fn compare_const_vals<'tcx>(
                 mir::ConstantKind::Val(ConstValue::Scalar(Scalar::Int(a)), _a_ty),
                 mir::ConstantKind::Val(ConstValue::Scalar(Scalar::Int(b)), _b_ty),
             ) => return Some(a.cmp(&b)),
+            (mir::ConstantKind::Ty(a), mir::ConstantKind::Ty(b)) => {
+                return Some(a.kind().cmp(&b.kind()));
+            }
             _ => {}
         },
     }
diff --git a/compiler/rustc_mir_transform/src/required_consts.rs b/compiler/rustc_mir_transform/src/required_consts.rs
@@ -17,8 +17,8 @@ impl<'tcx> Visitor<'tcx> for RequiredConstsVisitor<'_, 'tcx> {
         let literal = constant.literal;
         match literal {
             ConstantKind::Ty(c) => match c.kind() {
-                ConstKind::Param(_) | ConstKind::Error(_) => {}
-                _ => bug!("only ConstKind::Param should be encountered here, got {:#?}", c),
+                ConstKind::Param(_) | ConstKind::Error(_) | ConstKind::Value(_) => {}
+                _ => bug!("only ConstKind::Param/Value should be encountered here, got {:#?}", c),
             },
             ConstantKind::Unevaluated(..) => self.required_consts.push(*constant),
             ConstantKind::Val(..) => {}
diff --git a/tests/incremental/issue-101518.rs b/tests/incremental/issue-101518.rs
@@ -1,27 +1,20 @@
-// revisions: cfail1
-// should-ice
-// error-pattern: forcing query
-// known-bug: #101518
+// revisions: cpass
 
 #[derive(PartialEq, Eq)]
 struct Id<'a> {
     ns: &'a str,
 }
 fn visit_struct() {
     let id = Id { ns: "random1" };
-    const FLAG: Id<'static> = Id {
-        ns: "needs_to_be_the_same",
-    };
+    const FLAG: Id<'static> = Id { ns: "needs_to_be_the_same" };
     match id {
         FLAG => {}
         _ => {}
     }
 }
 fn visit_struct2() {
     let id = Id { ns: "random2" };
-    const FLAG: Id<'static> = Id {
-        ns: "needs_to_be_the_same",
-    };
+    const FLAG: Id<'static> = Id { ns: "needs_to_be_the_same" };
     match id {
         FLAG => {}
         _ => {}
diff --git a/tests/mir-opt/deref-patterns/string.foo.PreCodegen.after.mir b/tests/mir-opt/deref-patterns/string.foo.PreCodegen.after.mir
@@ -35,7 +35,7 @@ fn foo(_1: Option<String>) -> i32 {
                                          // + literal: Const { ty: for<'a, 'b> fn(&'a str, &'b str) -> bool {<str as PartialEq>::eq}, val: Value(<ZST>) }
                                          // mir::Constant
                                          // + span: $DIR/string.rs:9:14: 9:17
-                                         // + literal: Const { ty: &str, val: Value(Slice(..)) }
+                                         // + literal: Const { ty: &str, val: Value(ValTree::Branch(..)) }
     }
 
     bb3: {
diff --git a/tests/ui/match/issue-70972-dyn-trait.rs b/tests/ui/match/issue-70972-dyn-trait.rs
@@ -4,7 +4,7 @@ fn main() {
     let a: &dyn Send = &7u32;
     match a {
         F => panic!(),
-        //~^ ERROR `&dyn Send` cannot be used in patterns
+        //~^ ERROR `dyn Send` cannot be used in patterns
         _ => {}
     }
 }
diff --git a/tests/ui/match/issue-70972-dyn-trait.stderr b/tests/ui/match/issue-70972-dyn-trait.stderr
@@ -1,4 +1,4 @@
-error: `&dyn Send` cannot be used in patterns
+error: `dyn Send` cannot be used in patterns
   --> $DIR/issue-70972-dyn-trait.rs:6:9
    |
 LL |         F => panic!(),
diff --git a/tests/ui/pattern/issue-72565.rs b/tests/ui/pattern/issue-72565.rs
@@ -3,6 +3,6 @@ const F: &'static dyn PartialEq<u32> = &7u32;
 fn main() {
     let a: &dyn PartialEq<u32> = &7u32;
     match a {
-        F => panic!(), //~ ERROR: `&dyn PartialEq<u32>` cannot be used in patterns
+        F => panic!(), //~ ERROR: `dyn PartialEq<u32>` cannot be used in patterns
     }
 }
diff --git a/tests/ui/pattern/issue-72565.stderr b/tests/ui/pattern/issue-72565.stderr
@@ -1,4 +1,4 @@
-error: `&dyn PartialEq<u32>` cannot be used in patterns
+error: `dyn PartialEq<u32>` cannot be used in patterns
   --> $DIR/issue-72565.rs:6:9
    |
 LL |         F => panic!(),

Original file line number	Diff line number	Diff line change
`@@ -2487,8 +2487,8 @@ impl<'tcx> ConstantKind<'tcx> {`
`2487`	`2487`	`if let Some(lit_input) = lit_input {`
`2488`	`2488`	`// If an error occurred, ignore that it's a literal and leave reporting the error up to`
`2489`	`2489`	`// mir.`
`2490`		`- match tcx.at(expr.span).lit_to_mir_constant(lit_input) {`
`2491`		`- Ok(c) => return c,`
	`2490`	`+ match tcx.at(expr.span).lit_to_const(lit_input) {`
	`2491`	`+ Ok(c) => return Self::Ty(c),`
`2492`	`2492`	`Err(_) => {}`
`2493`	`2493`	`}`
`2494`	`2494`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ fn foo(_1: Option<String>) -> i32 {`
`35`	`35`	`// + literal: Const { ty: for<'a, 'b> fn(&'a str, &'b str) -> bool {<str as PartialEq>::eq}, val: Value(<ZST>) }`
`36`	`36`	`// mir::Constant`
`37`	`37`	`// + span: $DIR/string.rs:9:14: 9:17`
`38`		`- // + literal: Const { ty: &str, val: Value(Slice(..)) }`
	`38`	`+ // + literal: Const { ty: &str, val: Value(ValTree::Branch(..)) }`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`bb3: {`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ fn main() {`
`4`	`4`	`let a: &dyn Send = &7u32;`
`5`	`5`	`match a {`
`6`	`6`	`F => panic!(),`
`7`		- //~^ ERROR `&dyn Send` cannot be used in patterns
	`7`	+ //~^ ERROR `dyn Send` cannot be used in patterns
`8`	`8`	`_ => {}`
`9`	`9`	`}`
`10`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		-error: `&dyn Send` cannot be used in patterns
	`1`	+error: `dyn Send` cannot be used in patterns
`2`	`2`	`--> $DIR/issue-70972-dyn-trait.rs:6:9`
`3`	`3`	`\|`
`4`	`4`	`LL \| F => panic!(),`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,6 @@ const F: &'static dyn PartialEq<u32> = &7u32;`
`3`	`3`	`fn main() {`
`4`	`4`	`let a: &dyn PartialEq<u32> = &7u32;`
`5`	`5`	`match a {`
`6`		- F => panic!(), //~ ERROR: `&dyn PartialEq<u32>` cannot be used in patterns
	`6`	+ F => panic!(), //~ ERROR: `dyn PartialEq<u32>` cannot be used in patterns
`7`	`7`	`}`
`8`	`8`	`}`