[WIP] Rework the entire const trait system

compiler/rustc_borrowck/src/diagnostics/region_name.rs

@@ -642,6 +642,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
                 (
                     GenericArgKind::Lifetime(_)
                     | GenericArgKind::Type(_)
+                    | GenericArgKind::Constness(_)
                     | GenericArgKind::Const(_),
                     _,
                 ) => {

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -381,6 +381,7 @@ fn check_opaque_type_parameter_valid(
                 matches!(*lt, ty::ReEarlyBound(_) | ty::ReFree(_))
             }
             GenericArgKind::Const(ct) => matches!(ct.kind(), ty::ConstKind::Param(_)),
+            GenericArgKind::Constness(_) => false,
         };
 
         if arg_is_param {

compiler/rustc_borrowck/src/type_check/canonical.rs

@@ -93,7 +93,6 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         self.prove_predicates(
             Some(ty::Binder::dummy(ty::PredicateKind::Trait(ty::TraitPredicate {
                 trait_ref,
-                constness: ty::BoundConstness::NotConst,
                 polarity: ty::ImplPolarity::Positive,
             }))),
             locations,

compiler/rustc_borrowck/src/type_check/constraint_conversion.rs

@@ -126,7 +126,7 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
                 .type_must_outlive(origin, t1, r2);
             }
 
-            GenericArgKind::Const(_) => {
+            GenericArgKind::Constness(_) | GenericArgKind::Const(_) => {
                 // Consts cannot outlive one another, so we
                 // don't need to handle any relations here.
             }

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -2026,6 +2026,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                         let trait_ref = ty::TraitRef {
                             def_id: tcx
                                 .require_lang_item(LangItem::CoerceUnsized, Some(self.last_span)),
+                            // TODO: pick constness arg from context
                             substs: tcx.mk_substs_trait(op.ty(body, tcx), &[ty.into()]),
                         };
 
@@ -2603,7 +2604,9 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                                 (outlives_requirements.category, outlives_requirements.blame_span),
                             ))
                         }
-                        GenericArgKind::Type(_) | GenericArgKind::Const(_) => None,
+                        GenericArgKind::Type(_)
+                        | GenericArgKind::Const(_)
+                        | GenericArgKind::Constness(_) => None,
                     }
                 })
                 .collect();

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -226,7 +226,6 @@ pub fn eval_to_const_value_raw_provider<'tcx>(
     tcx: TyCtxt<'tcx>,
     key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
 ) -> ::rustc_middle::mir::interpret::EvalToConstValueResult<'tcx> {
-    assert!(key.param_env.is_const());
     // see comment in eval_to_allocation_raw_provider for what we're doing here
     if key.param_env.reveal() == Reveal::All {
         let mut key = key;
@@ -261,7 +260,6 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
     tcx: TyCtxt<'tcx>,
     key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
 ) -> ::rustc_middle::mir::interpret::EvalToAllocationRawResult<'tcx> {
-    assert!(key.param_env.is_const());
     // Because the constant is computed twice (once per value of `Reveal`), we are at risk of
     // reporting the same error twice here. To resolve this, we check whether we can evaluate the
     // constant in the more restrictive `Reveal::UserFacing`, which most likely already was

compiler/rustc_const_eval/src/interpret/eval_context.rs

@@ -924,7 +924,6 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         } else {
             self.param_env
         };
-        let param_env = param_env.with_const();
         // Use a precise span for better cycle errors.
         let val = self.tcx.at(self.cur_span()).eval_to_allocation_raw(param_env.and(gid))?;
         self.raw_const_to_mplace(val)

compiler/rustc_const_eval/src/transform/check_consts/check.rs

@@ -346,7 +346,9 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
 
                 // No constraints on lifetimes or constants, except potentially
                 // constants' types, but `walk` will get to them as well.
-                GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => continue,
+                GenericArgKind::Constness(_)
+                | GenericArgKind::Lifetime(_)
+                | GenericArgKind::Const(_) => continue,
             };
 
             match *ty.kind() {
@@ -720,10 +722,9 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                         return;
                     }
 
-                    let trait_ref = TraitRef::from_method(tcx, trait_id, substs);
+                    let trait_ref = TraitRef::from_method(tcx, trait_id, substs).with_const(tcx);
                     let poly_trait_pred = Binder::dummy(TraitPredicate {
                         trait_ref,
-                        constness: ty::BoundConstness::ConstIfConst,
                         polarity: ty::ImplPolarity::Positive,
                     });
                     let obligation =
@@ -735,7 +736,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                     });
 
                     match implsrc {
-                        Ok(Some(ImplSource::Param(_, ty::BoundConstness::ConstIfConst))) => {
+                        Ok(Some(ImplSource::Param(_, ty::ConstnessArg::Const))) => {
                             debug!(
                                 "const_trait_impl: provided {:?} via where-clause in {:?}",
                                 trait_ref, param_env

compiler/rustc_const_eval/src/transform/check_consts/ops.rs

@@ -15,7 +15,7 @@ use rustc_middle::ty::{
     suggest_constraining_type_param, Adt, Closure, DefIdTree, FnDef, FnPtr, Param, TraitPredicate,
     Ty,
 };
-use rustc_middle::ty::{Binder, BoundConstness, ImplPolarity, TraitRef};
+use rustc_middle::ty::{Binder, ImplPolarity, TraitRef};
 use rustc_session::parse::feature_err;
 use rustc_span::symbol::sym;
 use rustc_span::{BytePos, Pos, Span, Symbol};
@@ -150,7 +150,6 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
                         param_env,
                         Binder::dummy(TraitPredicate {
                             trait_ref,
-                            constness: BoundConstness::NotConst,
                             polarity: ImplPolarity::Positive,
                         }),
                     );

compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs

@@ -161,9 +161,8 @@ impl Qualif for NeedsNonConstDrop {
             ty::Binder::dummy(ty::TraitPredicate {
                 trait_ref: ty::TraitRef {
                     def_id: destruct,
-                    substs: cx.tcx.mk_substs_trait(ty, &[]),
+                    substs: cx.tcx.mk_substs_trait(ty, &[ty::ConstnessArg::Const.into()]),
                 },
-                constness: ty::BoundConstness::ConstIfConst,
                 polarity: ty::ImplPolarity::Positive,
             }),
         );
@@ -177,8 +176,7 @@ impl Qualif for NeedsNonConstDrop {
 
             if !matches!(
                 impl_src,
-                ImplSource::ConstDestruct(_)
-                    | ImplSource::Param(_, ty::BoundConstness::ConstIfConst)
+                ImplSource::ConstDestruct(_) | ImplSource::Param(_, ty::ConstnessArg::Const)
             ) {
                 // If our const destruct candidate is not ConstDestruct or implied by the param env,
                 // then it's bad

compiler/rustc_infer/src/infer/canonical/query_response.rs

@@ -466,6 +466,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
                         opt_values[b] = Some(*original_value);
                     }
                 }
+                GenericArgKind::Constness(_) => {}
             }
         }
 
@@ -571,6 +572,9 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
                 // encounter this branch.
                 span_bug!(cause.span, "unexpected const outlives {:?}", predicate);
             }
+            GenericArgKind::Constness(_) => {
+                span_bug!(cause.span, "unexpected constness outlives {:?}", predicate);
+            }
         };
         let predicate = predicate.rebind(atom).to_predicate(self.tcx);
 

compiler/rustc_infer/src/infer/combine.rs

@@ -767,6 +767,15 @@ impl<'tcx> TypeRelation<'tcx> for Generalizer<'_, 'tcx> {
             _ => relate::super_relate_consts(self, c, c),
         }
     }
+
+    fn constness_args(
+        &mut self,
+        a: ty::ConstnessArg,
+        b: ty::ConstnessArg,
+    ) -> RelateResult<'tcx, ty::ConstnessArg> {
+        assert_eq!(a, b);
+        Ok(a)
+    }
 }
 
 pub trait ConstEquateRelation<'tcx>: TypeRelation<'tcx> {
@@ -998,4 +1007,12 @@ impl<'tcx> TypeRelation<'tcx> for ConstInferUnifier<'_, 'tcx> {
             _ => relate::super_relate_consts(self, c, c),
         }
     }
+    fn constness_args(
+        &mut self,
+        a: ty::ConstnessArg,
+        b: ty::ConstnessArg,
+    ) -> RelateResult<'tcx, ty::ConstnessArg> {
+        assert_eq!(a, b);
+        Ok(a)
+    }
 }

compiler/rustc_infer/src/infer/equate.rs

@@ -160,6 +160,17 @@ impl<'tcx> TypeRelation<'tcx> for Equate<'_, '_, 'tcx> {
         }
         Ok(a)
     }
+
+    fn constness_args(
+        &mut self,
+        a: ty::ConstnessArg,
+        b: ty::ConstnessArg,
+    ) -> RelateResult<'tcx, ty::ConstnessArg> {
+        match (a, b) {
+            (ty::ConstnessArg::Infer, x) | (x, ty::ConstnessArg::Infer) => Ok(x),
+            _ => relate::super_relate_constness(self, a, b),
+        }
+    }
 }
 
 impl<'tcx> ConstEquateRelation<'tcx> for Equate<'_, '_, 'tcx> {

compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs

@@ -292,6 +292,8 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                 }
             }
             GenericArgKind::Lifetime(_) => bug!("unexpected lifetime"),
+            // TODO ?
+            GenericArgKind::Constness(_) => bug!("unexpected constness arg"),
         }
     }
 
@@ -616,7 +618,7 @@ impl<'a, 'tcx> FindInferSourceVisitor<'a, 'tcx> {
 
     /// Computes cost for the given source.
     ///
-    /// Sources with a small cost are prefer and should result
+    /// Sources with a small cost are preferred and should result
     /// in a clearer and idiomatic suggestion.
     fn source_cost(&self, source: &InferSource<'tcx>) -> usize {
         #[derive(Clone, Copy)]
@@ -629,6 +631,7 @@ impl<'a, 'tcx> FindInferSourceVisitor<'a, 'tcx> {
                     GenericArgKind::Lifetime(_) => 0, // erased
                     GenericArgKind::Type(ty) => self.ty_cost(ty),
                     GenericArgKind::Const(_) => 3, // some non-zero value
+                    GenericArgKind::Constness(_) => 1,
                 }
             }
             fn ty_cost(self, ty: Ty<'tcx>) -> usize {
@@ -746,6 +749,7 @@ impl<'a, 'tcx> FindInferSourceVisitor<'a, 'tcx> {
             }
             match inner.unpack() {
                 GenericArgKind::Lifetime(_) => {}
+                GenericArgKind::Constness(_) => {}
                 GenericArgKind::Type(ty) => {
                     if matches!(ty.kind(), ty::Opaque(..) | ty::Closure(..) | ty::Generator(..)) {
                         // Opaque types can't be named by the user right now.

compiler/rustc_infer/src/infer/glb.rs

@@ -7,7 +7,7 @@ use super::Subtype;
 
 use crate::infer::combine::ConstEquateRelation;
 use crate::traits::{ObligationCause, PredicateObligation};
-use rustc_middle::ty::relate::{Relate, RelateResult, TypeRelation};
+use rustc_middle::ty::relate::{self, Relate, RelateResult, TypeRelation};
 use rustc_middle::ty::{self, Ty, TyCtxt};
 
 /// "Greatest lower bound" (common subtype)
@@ -110,6 +110,15 @@ impl<'tcx> TypeRelation<'tcx> for Glb<'_, '_, 'tcx> {
             Ok(ty::Binder::dummy(self.relate(a.skip_binder(), b.skip_binder())?))
         }
     }
+
+    fn constness_args(
+        &mut self,
+        a: ty::ConstnessArg,
+        b: ty::ConstnessArg,
+    ) -> RelateResult<'tcx, ty::ConstnessArg> {
+        // TODO.
+        relate::super_relate_constness(self, a, b)
+    }
 }
 
 impl<'combine, 'infcx, 'tcx> LatticeDir<'infcx, 'tcx> for Glb<'combine, 'infcx, 'tcx> {

compiler/rustc_infer/src/infer/lub.rs

@@ -7,7 +7,7 @@ use super::Subtype;
 
 use crate::infer::combine::ConstEquateRelation;
 use crate::traits::{ObligationCause, PredicateObligation};
-use rustc_middle::ty::relate::{Relate, RelateResult, TypeRelation};
+use rustc_middle::ty::relate::{super_relate_constness, Relate, RelateResult, TypeRelation};
 use rustc_middle::ty::{self, Ty, TyCtxt};
 
 /// "Least upper bound" (common supertype)
@@ -110,6 +110,14 @@ impl<'tcx> TypeRelation<'tcx> for Lub<'_, '_, 'tcx> {
             Ok(ty::Binder::dummy(self.relate(a.skip_binder(), b.skip_binder())?))
         }
     }
+
+    fn constness_args(
+        &mut self,
+        a: ty::ConstnessArg,
+        b: ty::ConstnessArg,
+    ) -> RelateResult<'tcx, ty::ConstnessArg> {
+        super_relate_constness(self, a, b)
+    }
 }
 
 impl<'tcx> ConstEquateRelation<'tcx> for Lub<'_, '_, 'tcx> {

compiler/rustc_infer/src/infer/mod.rs

@@ -1155,7 +1155,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         self.next_region_var_in_universe(RegionVariableOrigin::Nll(origin), universe)
     }
 
-    pub fn var_for_def(&self, span: Span, param: &ty::GenericParamDef) -> GenericArg<'tcx> {
+    pub fn var_for_def(&self, span: Span, param: &ty::GenericParamDef, constness: Option<ty::ConstnessArg>) -> GenericArg<'tcx> {
         match param.kind {
             GenericParamDefKind::Lifetime => {
                 // Create a region inference variable for the given
@@ -1199,13 +1199,14 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                     });
                 self.tcx.mk_const_var(const_var_id, self.tcx.type_of(param.def_id)).into()
             }
+            GenericParamDefKind::Constness => constness.unwrap_or(ty::ConstnessArg::Infer).into(),
         }
     }
 
     /// Given a set of generics defined on a type or impl, returns a substitution mapping each
     /// type/region parameter to a fresh inference variable.
     pub fn fresh_substs_for_item(&self, span: Span, def_id: DefId) -> SubstsRef<'tcx> {
-        InternalSubsts::for_item(self.tcx, def_id, |param, _| self.var_for_def(span, param))
+        InternalSubsts::for_item(self.tcx, def_id, |param, _| self.var_for_def(span, param, None))
     }
 
     /// Returns `true` if errors have been reported since this infcx was
@@ -1752,7 +1753,7 @@ impl<'tcx> TyOrConstInferVar<'tcx> {
         match arg.unpack() {
             GenericArgKind::Type(ty) => Self::maybe_from_ty(ty),
             GenericArgKind::Const(ct) => Self::maybe_from_const(ct),
-            GenericArgKind::Lifetime(_) => None,
+            GenericArgKind::Lifetime(_) | GenericArgKind::Constness(_) => None,
         }
     }
 

compiler/rustc_infer/src/infer/nll_relate/mod.rs

@@ -784,6 +784,15 @@ where
 
         Ok(a)
     }
+
+    fn constness_args(
+        &mut self,
+        a: ty::ConstnessArg,
+        b: ty::ConstnessArg,
+    ) -> RelateResult<'tcx, ty::ConstnessArg> {
+        // TODO.
+        relate::super_relate_constness(self, a, b)
+    }
 }
 
 impl<'tcx, D> ConstEquateRelation<'tcx> for TypeRelating<'_, 'tcx, D>
@@ -1077,4 +1086,13 @@ where
         self.first_free_index.shift_out(1);
         Ok(a.rebind(result))
     }
+
+    fn constness_args(
+        &mut self,
+        a: ty::ConstnessArg,
+        b: ty::ConstnessArg,
+    ) -> RelateResult<'tcx, ty::ConstnessArg> {
+        // TODO
+        relate::super_relate_constness(self, a, b)
+    }
 }

compiler/rustc_infer/src/infer/opaque_types.rs

@@ -379,7 +379,9 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                 .iter()
                 .filter_map(|arg| match arg.unpack() {
                     GenericArgKind::Lifetime(r) => Some(r),
-                    GenericArgKind::Type(_) | GenericArgKind::Const(_) => None,
+                    GenericArgKind::Type(_)
+                    | GenericArgKind::Const(_)
+                    | GenericArgKind::Constness(_) => None,
                 })
                 .chain(std::iter::once(self.tcx.lifetimes.re_static))
                 .collect(),

compiler/rustc_infer/src/infer/outlives/components.rs

@@ -88,6 +88,8 @@ fn compute_components<'tcx>(
                         GenericArgKind::Const(_) => {
                             compute_components_recursive(tcx, child, out, visited);
                         }
+                        // TODO ?
+                        GenericArgKind::Constness(_) => {}
                     }
                 }
             }
@@ -210,6 +212,8 @@ fn compute_components_recursive<'tcx>(
             GenericArgKind::Const(_) => {
                 compute_components_recursive(tcx, child, out, visited);
             }
+            // TODO ?
+            GenericArgKind::Constness(_) => {}
         }
     }
 }

compiler/rustc_infer/src/infer/outlives/obligations.rs

@@ -391,6 +391,8 @@ where
                     GenericArgKind::Const(_) => {
                         // Const parameters don't impose constraints.
                     }
+                    // TODO ?
+                    GenericArgKind::Constness(_) => {}
                 }
             }