Merge ::Required and ::Param

fee1-dead · fee1-dead · commit 84054f719059 · 2022-07-15T06:32:08.000Z
diff --git a/compiler/rustc_borrowck/src/region_infer/opaque_types.rs b/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 {
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/check.rs b/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
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs b/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
diff --git a/compiler/rustc_infer/src/infer/sub.rs b/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),
diff --git a/compiler/rustc_middle/src/ty/context.rs b/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
         }
     }
 
diff --git a/compiler/rustc_middle/src/ty/fast_reject.rs b/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,
         }
     }
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/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)",
         })
     }
 }
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/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
             }
         }
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/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,
             }));
         }
diff --git a/compiler/rustc_middle/src/ty/subst.rs b/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() {
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
@@ -328,7 +328,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                         let trait_predicate = self.resolve_vars_if_possible(trait_predicate);
 
                         let predicate_is_const =
-                            ty::ConstnessArg::Required == trait_predicate.skip_binder().constness();
+                            ty::ConstnessArg::Const == trait_predicate.skip_binder().constness();
 
                         if self.tcx.sess.has_errors().is_some()
                             && trait_predicate.references_error()
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -1207,7 +1207,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                                             .require_lang_item(LangItem::Destruct, None),
                                         substs: self.tcx().mk_substs_trait(
                                             nested_ty,
-                                            &[ty::ConstnessArg::Param.into()],
+                                            &[ty::ConstnessArg::Const.into()],
                                         ),
                                     },
                                     polarity: ty::ImplPolarity::Positive,
@@ -1235,7 +1235,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                                 def_id: self.tcx().require_lang_item(LangItem::Destruct, None),
                                 substs: self.tcx().mk_substs_trait(
                                     nested_ty,
-                                    &[ty::ConstnessArg::Param.into()],
+                                    &[ty::ConstnessArg::Const.into()],
                                 ),
                             },
                             polarity: ty::ImplPolarity::Positive,
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -1199,7 +1199,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     ParamCandidate(trait_pred)
                         if trait_pred.constness() != ty::ConstnessArg::Not =>
                     {
-                        debug_assert_eq!(trait_pred.constness(), ty::ConstnessArg::Param);
+                        debug_assert_eq!(trait_pred.constness(), ty::ConstnessArg::Const);
                     }
                     // auto trait impl
                     AutoImplCandidate(..) => {}
diff --git a/compiler/rustc_traits/src/chalk/db.rs b/compiler/rustc_traits/src/chalk/db.rs
@@ -741,7 +741,7 @@ fn bound_vars_for_item<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> SubstsRef<'tcx
             })
             .into(),
         ty::GenericParamDefKind::Constness => {
-            ty::ConstnessArg::Param.into() // TODO Confirm
+            ty::ConstnessArg::Not.into() // TODO Confirm
         }
     })
 }
diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs
@@ -574,10 +574,10 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                             .unwrap_or_else(|| match self.astconv.item_def_id() {
                                 // no information available
                                 // TODO: fall back to `Not`?
-                                None => if infer_args { ty::ConstnessArg::Infer } else { ty::ConstnessArg::Param },
+                                None => if infer_args { ty::ConstnessArg::Infer } else { ty::ConstnessArg::Not },
                                 Some(context) => {
                                     if tcx.generics_of(context).has_constness_param() {
-                                        ty::ConstnessArg::Param
+                                        ty::ConstnessArg::Const
                                     } else {
                                         // TODO: should use `Required` if we're in a const context
                                         // like `const`/`static` item initializers.
@@ -724,8 +724,9 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             self_ty,
             trait_ref.path.segments.last().unwrap(),
             true,
-            match constness { // TODO check this again
-                hir::Constness::Const => ty::ConstnessArg::Param,
+            match constness {
+                // TODO check this again
+                hir::Constness::Const => ty::ConstnessArg::Const,
                 hir::Constness::NotConst => ty::ConstnessArg::Not,
             },
         )
@@ -1028,7 +1029,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             match ast_bound {
                 hir::GenericBound::Trait(poly_trait_ref, modifier) => {
                     let constness = match modifier {
-                        hir::TraitBoundModifier::MaybeConst => ty::ConstnessArg::Param,
+                        hir::TraitBoundModifier::MaybeConst => ty::ConstnessArg::Const,
                         hir::TraitBoundModifier::None => ty::ConstnessArg::Not,
                         hir::TraitBoundModifier::Maybe => continue,
                     };
diff --git a/compiler/rustc_typeck/src/check/compare_method.rs b/compiler/rustc_typeck/src/check/compare_method.rs
@@ -1378,7 +1378,7 @@ pub fn check_type_bounds<'tcx>(
             })
             .into()
         }
-        GenericParamDefKind::Constness => ty::ConstnessArg::Param.into(),
+        GenericParamDefKind::Constness => ty::ConstnessArg::Const.into(),
     });
     let bound_vars = tcx.mk_bound_variable_kinds(bound_vars.into_iter());
     let impl_ty_substs = tcx.intern_substs(&substs);
diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/mod.rs b/compiler/rustc_typeck/src/check/fn_ctxt/mod.rs
@@ -150,7 +150,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 if body_id.is_owner() {
                     let did = body_id.expect_owner();
                     if inh.tcx.is_const_fn_raw(did.to_def_id()) || inh.tcx.is_const_default_method(did.to_def_id()) || inh.tcx.def_kind(did.to_def_id()) == hir::def::DefKind::Const {
-                        ty::ConstnessArg::Param
+                        ty::ConstnessArg::Const
                     } else {
                         ty::ConstnessArg::Not
                     }
diff --git a/src/test/ui/rfc-2632-const-trait-impl/const-trait-bound.rs b/src/test/ui/rfc-2632-const-trait-impl/const-trait-bound.rs
@@ -1,3 +1,4 @@
+// check-pass
 #![feature(const_trait_impl)]
 
 #[const_trait]

Original file line number	Diff line number	Diff line change
`@@ -381,7 +381,7 @@ fn check_opaque_type_parameter_valid(`
`381`	`381`	`matches!(*lt, ty::ReEarlyBound(_) \| ty::ReFree(_))`
`382`	`382`	`}`
`383`	`383`	`GenericArgKind::Const(ct) => matches!(ct.kind(), ty::ConstKind::Param(_)),`
`384`		`- GenericArgKind::Constness(ct) => matches!(ct, ty::ConstnessArg::Param),`
	`384`	`+ GenericArgKind::Constness(_) => false,`
`385`	`385`	`};`
`386`	`386`
`387`	`387`	`if arg_is_param {`
Original file line number	Diff line number	Diff line change
`@@ -2629,7 +2629,7 @@ impl<'tcx> TyCtxt<'tcx> {`
`2629`	`2629`	`GenericParamDefKind::Const { .. } => {`
`2630`	`2630`	`self.mk_const_param(param.index, param.name, self.type_of(param.def_id)).into()`
`2631`	`2631`	`}`
`2632`		`- GenericParamDefKind::Constness => ty::ConstnessArg::Param.into(),`
	`2632`	`+ GenericParamDefKind::Constness => ty::ConstnessArg::Not.into(), // TODO sus`
`2633`	`2633`	`}`
`2634`	`2634`	`}`
`2635`	`2635`
Original file line number	Diff line number	Diff line change
`@@ -2522,8 +2522,7 @@ define_print_and_forward_display! {`
`2522`	`2522`	`if cx.tcx().sess.verbose() {`
`2523`	`2523`	`match self.0.constness() {`
`2524`	`2524`	`ty::ConstnessArg::Not => {},`
`2525`		`- ty::ConstnessArg::Required => p!(write("const ")),`
`2526`		`- ty::ConstnessArg::Param => p!(write("~const ")),`
	`2525`	`+ ty::ConstnessArg::Const => p!(write("~const ")),`
`2527`	`2526`	`ty::ConstnessArg::Infer => p!(write("_const ")), // TODO wonky`
`2528`	`2527`	`}`
`2529`	`2528`	`}`
Original file line number	Diff line number	Diff line change
`@@ -847,9 +847,9 @@ impl<'tcx> TraitRef<'tcx> {`
`847`	`847`	`}`
`848`	`848`
`849`	`849`	`pub fn with_const(mut self, tcx: TyCtxt<'tcx>) -> Self {`
`850`		`- if self.constness() != ty::ConstnessArg::Required {`
	`850`	`+ if self.constness() != ty::ConstnessArg::Const {`
`851`	`851`	`self.substs = tcx.mk_substs(self.substs.iter().map(\|arg\| match arg.unpack() {`
`852`		`- ty::subst::GenericArgKind::Constness(_) => ty::ConstnessArg::Required.into(),`
	`852`	`+ ty::subst::GenericArgKind::Constness(_) => ty::ConstnessArg::Const.into(),`
`853`	`853`	`_ => arg,`
`854`	`854`	`}));`
`855`	`855`	`}`