Merge ::Required and ::Param

Author: fee1-dead

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -381,7 +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(ct) => matches!(ct, ty::ConstnessArg::Param),
+            GenericArgKind::Constness(_) => false,
         };
 
         if arg_is_param {

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

@@ -736,7 +736,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                     });
 
                     match implsrc {
-                        Ok(Some(ImplSource::Param(_, ty::ConstnessArg::Required | ty::ConstnessArg::Param))) => {
+                        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/qualifs.rs

@@ -161,7 +161,7 @@ impl Qualif for NeedsNonConstDrop {
             ty::Binder::dummy(ty::TraitPredicate {
                 trait_ref: ty::TraitRef {
                     def_id: destruct,
-                    substs: cx.tcx.mk_substs_trait(ty, &[ty::ConstnessArg::Param.into()]),
+                    substs: cx.tcx.mk_substs_trait(ty, &[ty::ConstnessArg::Const.into()]),
                 },
                 polarity: ty::ImplPolarity::Positive,
             }),
@@ -176,7 +176,7 @@ impl Qualif for NeedsNonConstDrop {
 
             if !matches!(
                 impl_src,
-                ImplSource::ConstDestruct(_) | ImplSource::Param(_, ty::ConstnessArg::Required | ty::ConstnessArg::Param)
+                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/sub.rs

@@ -209,7 +209,7 @@ impl<'tcx> TypeRelation<'tcx> for Sub<'_, '_, 'tcx> {
     ) -> RelateResult<'tcx, ty::ConstnessArg> {
         trace!(?a, ?b);
         match (a, b) {
-            (ty::ConstnessArg::Required, _) => Ok(a),
+            (ty::ConstnessArg::Const, _) => Ok(a),
             (a, ty::ConstnessArg::Infer) => Ok(a),
             (ty::ConstnessArg::Infer, b) => Ok(b),
             (a, ty::ConstnessArg::Not) => Ok(a),

compiler/rustc_middle/src/ty/context.rs

@@ -2629,7 +2629,7 @@ impl<'tcx> TyCtxt<'tcx> {
             GenericParamDefKind::Const { .. } => {
                 self.mk_const_param(param.index, param.name, self.type_of(param.def_id)).into()
             }
-            GenericParamDefKind::Constness => ty::ConstnessArg::Param.into(),
+            GenericParamDefKind::Constness => ty::ConstnessArg::Not.into(), // TODO sus
         }
     }
 

compiler/rustc_middle/src/ty/fast_reject.rs

@@ -412,13 +412,8 @@ impl DeepRejectCtxt {
         impl_ct: ty::ConstnessArg,
     ) -> bool {
         match (obligation_ct, impl_ct) {
-            (_, ty::ConstnessArg::Param) => true,
-            (ty::ConstnessArg::Param, _) => match self.treat_obligation_params {
-                TreatParams::AsPlaceholder => false,
-                TreatParams::AsInfer => true,
-            },
+            (_, ty::ConstnessArg::Const) => true,
             (ty::ConstnessArg::Infer, _) => true,
-            (ty::ConstnessArg::Not, ty::ConstnessArg::Required) => true,
             _ => obligation_ct == impl_ct,
         }
     }

compiler/rustc_middle/src/ty/mod.rs

@@ -312,19 +312,17 @@ impl fmt::Display for BoundConstness {
     Ord
 )]
 pub enum ConstnessArg {
-    Required,
+    Const,
     Not,
-    Param,
     Infer,
 }
 
 impl fmt::Display for ConstnessArg {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(match self {
-            Self::Required => "(constness: required)",
             Self::Not => "(constness: not)",
-            Self::Param => "(constness: parameterized)",
-            Self::Infer => "(constness: infer)"
+            Self::Const => "(constness: const)",
+            Self::Infer => "(constness: infer)",
         })
     }
 }

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -2522,8 +2522,7 @@ define_print_and_forward_display! {
         if cx.tcx().sess.verbose() {
             match self.0.constness() {
                 ty::ConstnessArg::Not => {},
-                ty::ConstnessArg::Required => p!(write("const ")),
-                ty::ConstnessArg::Param => p!(write("~const ")),
+                ty::ConstnessArg::Const => p!(write("~const ")),
                 ty::ConstnessArg::Infer => p!(write("_const ")), // TODO wonky
             }
         }

compiler/rustc_middle/src/ty/sty.rs

@@ -847,9 +847,9 @@ impl<'tcx> TraitRef<'tcx> {
     }
 
     pub fn with_const(mut self, tcx: TyCtxt<'tcx>) -> Self {
-        if self.constness() != ty::ConstnessArg::Required {
+        if self.constness() != ty::ConstnessArg::Const {
             self.substs = tcx.mk_substs(self.substs.iter().map(|arg| match arg.unpack() {
-                ty::subst::GenericArgKind::Constness(_) => ty::ConstnessArg::Required.into(),
+                ty::subst::GenericArgKind::Constness(_) => ty::ConstnessArg::Const.into(),
                 _ => arg,
             }));
         }

compiler/rustc_middle/src/ty/subst.rs

@@ -99,9 +99,8 @@ impl<'tcx> GenericArgKind<'tcx> {
                 CONSTNESS_TAG,
                 match carg {
                     ty::ConstnessArg::Not => 0,
-                    ty::ConstnessArg::Required => 0b100,
-                    ty::ConstnessArg::Param => 0b1000,
-                    ty::ConstnessArg::Infer => 0b10000,
+                    ty::ConstnessArg::Const => 0b100,
+                    ty::ConstnessArg::Infer => 0b1000,
                 },
             ),
         };
@@ -181,9 +180,8 @@ impl<'tcx> GenericArg<'tcx> {
                 ))),
                 CONSTNESS_TAG => GenericArgKind::Constness(match ptr & (!TAG_MASK) {
                     0 => ty::ConstnessArg::Not,
-                    0b100 => ty::ConstnessArg::Required,
-                    0b1000 => ty::ConstnessArg::Param,
-                    0b10000 => ty::ConstnessArg::Infer,
+                    0b100 => ty::ConstnessArg::Const,
+                    0b1000 => ty::ConstnessArg::Infer,
                     _ => intrinsics::unreachable(),
                 }),
                 _ => intrinsics::unreachable(),
@@ -613,7 +611,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> {
     }
 
     fn fold_constness(&mut self, c: ty::ConstnessArg) -> ty::ConstnessArg {
-        if let ty::ConstnessArg::Param | ty::ConstnessArg::Infer = c {
+        if let ty::ConstnessArg::Const | ty::ConstnessArg::Infer = c {
             self.substs
                 .iter()
                 .find_map(|param| match param.unpack() {