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

Author: oli-obk

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(_) => {}
  }
  }

compiler/rustc_mir_build/src/thir/pattern/const_to_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 {

compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.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()));
+ }
  _ => {}
  },
  }

compiler/rustc_mir_build/src/thir/pattern/mod.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(..) => {}

compiler/rustc_mir_transform/src/required_consts.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 => {}
  _ => {}

tests/incremental/issue-101518.rs

@@ -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: {

tests/mir-opt/deref-patterns/string.foo.PreCodegen.after.mir

@@ -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
  _ => {}
  }
 }

tests/ui/match/issue-70972-dyn-trait.rs

@@ -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!(),

tests/ui/match/issue-70972-dyn-trait.stderr

@@ -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
  }
 }