Auto merge of #144591 - RalfJung:pattern-valtrees, r=BoxyUwU

Patterns: represent constants as valtrees
Const patterns are always valtrees now. Let's represent that in the types. We use `ty::Value` for this since it nicely packages value and type, and has some convenient methods.
Cc `@Nadrieril` `@BoxyUwU`

Author: bors

compiler/rustc_middle/src/mir/consts.rs

@@ -448,6 +448,11 @@ impl<'tcx> Const<'tcx> {
 Self::Val(val, ty)
 }
 
+#[inline]
+pubfnfrom_ty_value(tcx:TyCtxt<'tcx>,val: ty::Value<'tcx>) -> Self{
+Self::Ty(val.ty, ty::Const::new_value(tcx, val.valtree, val.ty))
+}
+
 pubfnfrom_bits(
 tcx:TyCtxt<'tcx>,
 bits:u128,

compiler/rustc_middle/src/thir.rs

@@ -832,17 +832,17 @@ pub enum PatKind<'tcx> {
 },
 
 /// One of the following:
-/// * `&str` (represented as a valtree), which will be handled as a string pattern and thus
+/// * `&str`, which will be handled as a string pattern and thus
 /// exhaustiveness checking will detect if you use the same string twice in different
 /// patterns.
-/// * integer, bool, char or float (represented as a valtree), which will be handled by
+/// * integer, bool, char or float, which will be handled by
 /// exhaustiveness to cover exactly its own value, similar to `&str`, but these values are
 /// much simpler.
 /// * raw pointers derived from integers, other raw pointers will have already resulted in an
 // error.
 /// * `String`, if `string_deref_patterns` is enabled.
 Constant{
-value:mir::Const<'tcx>,
+value:ty::Value<'tcx>,
 },
 
 /// Pattern obtained by converting a constant (inline or named) to its pattern
@@ -935,7 +935,7 @@ impl<'tcx> PatRange<'tcx> {
 let lo_is_min = matchself.lo{
 PatRangeBoundary::NegInfinity => true,
 PatRangeBoundary::Finite(value) => {
-let lo = value.try_to_bits(size).unwrap() ^ bias;
+let lo = value.try_to_scalar_int().unwrap().to_bits(size) ^ bias;
  lo <= min
 }
 PatRangeBoundary::PosInfinity => false,
@@ -944,7 +944,7 @@ impl<'tcx> PatRange<'tcx> {
 let hi_is_max = matchself.hi{
 PatRangeBoundary::NegInfinity => false,
 PatRangeBoundary::Finite(value) => {
-let hi = value.try_to_bits(size).unwrap() ^ bias;
+let hi = value.try_to_scalar_int().unwrap().to_bits(size) ^ bias;
  hi > max || hi == max && self.end == RangeEnd::Included
 }
 PatRangeBoundary::PosInfinity => true,
@@ -957,22 +957,17 @@ impl<'tcx> PatRange<'tcx> {
 }
 
 #[inline]
-pubfncontains(
-&self,
-value: mir::Const<'tcx>,
-tcx:TyCtxt<'tcx>,
-typing_env: ty::TypingEnv<'tcx>,
-) -> Option<bool>{
+pubfncontains(&self,value: ty::Value<'tcx>,tcx:TyCtxt<'tcx>) -> Option<bool>{
 useOrdering::*;
-debug_assert_eq!(self.ty,value.ty());
+debug_assert_eq!(value.ty,self.ty);
 let ty = self.ty;
-let value = PatRangeBoundary::Finite(value);
+let value = PatRangeBoundary::Finite(value.valtree);
 // For performance, it's important to only do the second comparison if necessary.
 Some(
-matchself.lo.compare_with(value, ty, tcx, typing_env)? {
+matchself.lo.compare_with(value, ty, tcx)? {
 Less | Equal => true,
 Greater => false,
-} && match value.compare_with(self.hi, ty, tcx, typing_env)? {
+} && match value.compare_with(self.hi, ty, tcx)? {
 Less => true,
 Equal => self.end == RangeEnd::Included,
 Greater => false,
@@ -981,21 +976,16 @@ impl<'tcx> PatRange<'tcx> {
 }
 
 #[inline]
-pubfnoverlaps(
-&self,
-other:&Self,
-tcx:TyCtxt<'tcx>,
-typing_env: ty::TypingEnv<'tcx>,
-) -> Option<bool>{
+pubfnoverlaps(&self,other:&Self,tcx:TyCtxt<'tcx>) -> Option<bool>{
 useOrdering::*;
 debug_assert_eq!(self.ty, other.ty);
 // For performance, it's important to only do the second comparison if necessary.
 Some(
-match other.lo.compare_with(self.hi,self.ty, tcx, typing_env)? {
+match other.lo.compare_with(self.hi,self.ty, tcx)? {
 Less => true,
 Equal => self.end == RangeEnd::Included,
 Greater => false,
-} && matchself.lo.compare_with(other.hi,self.ty, tcx, typing_env)? {
+} && matchself.lo.compare_with(other.hi,self.ty, tcx)? {
 Less => true,
 Equal => other.end == RangeEnd::Included,
 Greater => false,
@@ -1006,11 +996,13 @@ impl<'tcx> PatRange<'tcx> {
 
 impl<'tcx> fmt::DisplayforPatRange<'tcx>{
 fnfmt(&self,f:&mut fmt::Formatter<'_>) -> fmt::Result{
-ifletPatRangeBoundary::Finite(value) = &self.lo{
+iflet&PatRangeBoundary::Finite(valtree) = &self.lo{
+let value = ty::Value{ty:self.ty, valtree };
 write!(f,"{value}")?;
 }
-ifletPatRangeBoundary::Finite(value) = &self.hi{
+iflet&PatRangeBoundary::Finite(valtree) = &self.hi{
 write!(f,"{}",self.end)?;
+let value = ty::Value{ty:self.ty, valtree };
 write!(f,"{value}")?;
 }else{
 // `0..` is parsed as an inclusive range, we must display it correctly.
@@ -1024,7 +1016,8 @@ impl<'tcx> fmt::Display for PatRange<'tcx> {
 /// If present, the const must be of a numeric type.
 #[derive(Copy,Clone,Debug,PartialEq,HashStable,TypeVisitable)]
 pubenumPatRangeBoundary<'tcx>{
-Finite(mir::Const<'tcx>),
+/// The type of this valtree is stored in the surrounding `PatRange`.
+Finite(ty::ValTree<'tcx>),
 NegInfinity,
 PosInfinity,
 }
@@ -1035,20 +1028,15 @@ impl<'tcx> PatRangeBoundary<'tcx> {
 matches!(self,Self::Finite(..))
 }
 #[inline]
-pubfnas_finite(self) -> Option<mir::Const<'tcx>>{
+pubfnas_finite(self) -> Option<ty::ValTree<'tcx>>{
 matchself{
 Self::Finite(value) => Some(value),
 Self::NegInfinity | Self::PosInfinity => None,
 }
 }
-pubfneval_bits(
-self,
-ty:Ty<'tcx>,
-tcx:TyCtxt<'tcx>,
-typing_env: ty::TypingEnv<'tcx>,
-) -> u128{
+pubfnto_bits(self,ty:Ty<'tcx>,tcx:TyCtxt<'tcx>) -> u128{
 matchself{
-Self::Finite(value) => value.eval_bits(tcx, typing_env),
+Self::Finite(value) => value.try_to_scalar_int().unwrap().to_bits_unchecked(),
 Self::NegInfinity => {
 // Unwrap is ok because the type is known to be numeric.
  ty.numeric_min_and_max_as_bits(tcx).unwrap().0
@@ -1060,14 +1048,8 @@ impl<'tcx> PatRangeBoundary<'tcx> {
 }
 }
 
-#[instrument(skip(tcx, typing_env), level = "debug", ret)]
-pubfncompare_with(
-self,
-other:Self,
-ty:Ty<'tcx>,
-tcx:TyCtxt<'tcx>,
-typing_env: ty::TypingEnv<'tcx>,
-) -> Option<Ordering>{
+#[instrument(skip(tcx), level = "debug", ret)]
+pubfncompare_with(self,other:Self,ty:Ty<'tcx>,tcx:TyCtxt<'tcx>) -> Option<Ordering>{
 usePatRangeBoundary::*;
 match(self, other){
 // When comparing with infinities, we must remember that `0u8..` and `0u8..=255`
@@ -1095,8 +1077,8 @@ impl<'tcx> PatRangeBoundary<'tcx> {
  _ => {}
 }
 
-let a = self.eval_bits(ty, tcx, typing_env);
-let b = other.eval_bits(ty, tcx, typing_env);
+let a = self.to_bits(ty, tcx);
+let b = other.to_bits(ty, tcx);
 
 match ty.kind(){
  ty::Float(ty::FloatTy::F16) => {

compiler/rustc_middle/src/ty/consts/valtree.rs

@@ -2,10 +2,12 @@ use std::fmt;
 use std::ops::Deref;
 
 use rustc_data_structures::intern::Interned;
+use rustc_hir::def::Namespace;
 use rustc_macros::{HashStable,Lift,TyDecodable,TyEncodable,TypeFoldable,TypeVisitable};
 
 usesuper::ScalarInt;
 usecrate::mir::interpret::{ErrorHandled,Scalar};
+usecrate::ty::print::{FmtPrinter,PrettyPrinter};
 usecrate::ty::{self,Ty,TyCtxt};
 
 /// This datastructure is used to represent the value of constants used in the type system.
@@ -133,6 +135,8 @@ pub type ConstToValTreeResult<'tcx> = Result<Result<ValTree<'tcx>, Ty<'tcx>>, Er
 /// A type-level constant value.
 ///
 /// Represents a typed, fully evaluated constant.
+/// Note that this is also used by pattern elaboration to represent values which cannot occur in types,
+/// such as raw pointers and floats.
 #[derive(Copy,Clone,Debug,Hash,Eq,PartialEq)]
 #[derive(HashStable,TyEncodable,TyDecodable,TypeFoldable,TypeVisitable,Lift)]
 pubstructValue<'tcx>{
@@ -203,3 +207,14 @@ impl<'tcx> rustc_type_ir::inherent::ValueConst<TyCtxt<'tcx>> for Value<'tcx> {
 self.valtree
 }
 }
+
+impl<'tcx> fmt::DisplayforValue<'tcx>{
+fnfmt(&self,f:&mut fmt::Formatter<'_>) -> fmt::Result{
+ ty::tls::with(move |tcx| {
+let cv = tcx.lift(*self).unwrap();
+letmut p = FmtPrinter::new(tcx,Namespace::ValueNS);
+ p.pretty_print_const_valtree(cv,/*print_ty*/true)?;
+ f.write_str(&p.into_buffer())
+})
+}
+}

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -12,7 +12,6 @@ use rustc_hir::def_id::LocalDefId;
 use rustc_span::source_map::Spanned;
 use rustc_type_ir::{ConstKind,TypeFolder,VisitorResult, try_visit};
 
-usesuper::print::PrettyPrinter;
 usesuper::{GenericArg,GenericArgKind,Pattern,Region};
 usecrate::mir::PlaceElem;
 usecrate::ty::print::{FmtPrinter,Printer, with_no_trimmed_paths};
@@ -168,15 +167,11 @@ impl<'tcx> fmt::Debug for ty::Const<'tcx> {
 fnfmt(&self,f:&mut fmt::Formatter<'_>) -> fmt::Result{
 // If this is a value, we spend some effort to make it look nice.
 ifletConstKind::Value(cv) = self.kind(){
-return ty::tls::with(move |tcx| {
-let cv = tcx.lift(cv).unwrap();
-letmut p = FmtPrinter::new(tcx,Namespace::ValueNS);
- p.pretty_print_const_valtree(cv,/*print_ty*/true)?;
- f.write_str(&p.into_buffer())
-});
+write!(f,"{}", cv)
+}else{
+// Fall back to something verbose.
+write!(f,"{:?}",self.kind())
 }
-// Fall back to something verbose.
-write!(f,"{:?}",self.kind())
 }
 }
 

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

@@ -160,7 +160,7 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
 });
 }
 };
- values.push(value.eval_bits(self.tcx,self.typing_env));
+ values.push(value.valtree.unwrap_leaf().to_bits_unchecked());
  targets.push(self.parse_block(arm.body)?);
 }
 

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

@@ -16,7 +16,7 @@ use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_hir::{BindingMode,ByRef,LetStmt,LocalSource,Node};
 use rustc_middle::bug;
 use rustc_middle::middle::region;
-use rustc_middle::mir::{self,*};
+use rustc_middle::mir::*;
 use rustc_middle::thir::{self,*};
 use rustc_middle::ty::{self,CanonicalUserTypeAnnotation,Ty,ValTree,ValTreeKind};
 use rustc_pattern_analysis::constructor::RangeEnd;
@@ -1245,7 +1245,7 @@ struct Ascription<'tcx> {
 #[derive(Debug,Clone)]
 enumTestCase<'tcx>{
 Variant{adt_def: ty::AdtDef<'tcx>,variant_index:VariantIdx},
-Constant{value:mir::Const<'tcx>},
+Constant{value:ty::Value<'tcx>},
 Range(Arc<PatRange<'tcx>>),
 Slice{len:usize,variable_length:bool},
 Deref{temp:Place<'tcx>,mutability:Mutability},
@@ -1316,13 +1316,13 @@ enum TestKind<'tcx> {
 If,
 
 /// Test for equality with value, possibly after an unsizing coercion to
-/// `ty`,
+/// `cast_ty`,
 Eq{
-value:Const<'tcx>,
+value:ty::Value<'tcx>,
 // Integer types are handled by `SwitchInt`, and constants with ADT
 // types and `&[T]` types are converted back into patterns, so this can
-// only be `&str`, `f32` or `f64`.
-ty:Ty<'tcx>,
+// only be `&str`or floats.
+cast_ty:Ty<'tcx>,
 },
 
 /// Test whether the value falls within an inclusive or exclusive range.
@@ -1357,17 +1357,17 @@ pub(crate) struct Test<'tcx> {
 enumTestBranch<'tcx>{
 /// Success branch, used for tests with two possible outcomes.
 Success,
-/// Branch corresponding to this constant.
-Constant(Const<'tcx>,u128),
+/// Branch corresponding to this constant. Must be a scalar.
+Constant(ty::Value<'tcx>),
 /// Branch corresponding to this variant.
 Variant(VariantIdx),
 /// Failure branch for tests with two possible outcomes, and "otherwise" branch for other tests.
 Failure,
 }
 
 impl<'tcx>TestBranch<'tcx>{
-fnas_constant(&self) -> Option<&Const<'tcx>>{
-ifletSelf::Constant(v, _) = self{Some(v)}else{None}
+fnas_constant(&self) -> Option<ty::Value<'tcx>>{
+ifletSelf::Constant(v) = self{Some(*v)}else{None}
 }
 }