Introduce ConstnessArg::Infer and fix some tests

Author: fee1-dead

compiler/rustc_infer/src/infer/mod.rs

@@ -1199,8 +1199,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                     });
                 self.tcx.mk_const_var(const_var_id, self.tcx.type_of(param.def_id)).into()
             }
-            // TODO: this should actually figure out a yes/no answer from the context
-            GenericParamDefKind::Constness => ty::ConstnessArg::Param.into(),
+            GenericParamDefKind::Constness => constness.unwrap_or(ty::ConstnessArg::Infer).into(),
         }
     }
 

compiler/rustc_middle/src/ty/fast_reject.rs

@@ -417,6 +417,8 @@ impl DeepRejectCtxt {
                 TreatParams::AsPlaceholder => false,
                 TreatParams::AsInfer => true,
             },
+            (ty::ConstnessArg::Infer, _) => true,
+            (ty::ConstnessArg::Not, ty::ConstnessArg::Required) => true,
             _ => obligation_ct == impl_ct,
         }
     }

compiler/rustc_middle/src/ty/mod.rs

@@ -315,6 +315,7 @@ pub enum ConstnessArg {
     Required,
     Not,
     Param,
+    Infer,
 }
 
 impl fmt::Display for ConstnessArg {
@@ -323,6 +324,7 @@ impl fmt::Display for ConstnessArg {
             Self::Required => "(constness: required)",
             Self::Not => "(constness: not)",
             Self::Param => "(constness: parameterized)",
+            Self::Infer => "(constness: infer)"
         })
     }
 }

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

@@ -2524,6 +2524,7 @@ define_print_and_forward_display! {
                 ty::ConstnessArg::Not => {},
                 ty::ConstnessArg::Required => p!(write("const ")),
                 ty::ConstnessArg::Param => p!(write("~const ")),
+                ty::ConstnessArg::Infer => p!(write("_const ")), // TODO wonky
             }
         }
         p!(print_def_path(self.0.def_id, self.0.substs));

compiler/rustc_middle/src/ty/sty.rs

@@ -815,6 +815,16 @@ impl<'tcx> TraitRef<'tcx> {
         ty::TraitRef { def_id: trait_id, substs: tcx.intern_substs(&substs[..defs.params.len()]) }
     }
 
+    // TODO remove this hack!
+    pub fn normalize_constness_equate(&self, tcx: TyCtxt<'tcx>, actual: &mut Self) {
+        if self.constness() == ty::ConstnessArg::Not {
+            *actual = tcx.mk_substs(actual.iter().filter(|arg| match arg.unpack() {
+                ty::subst::GenericArgKind::Constness(_) => false,
+                _ => true,
+            }));
+        }
+    }
+
     pub fn constness(self) -> ty::ConstnessArg {
         for arg in self.substs.iter() {
             match arg.unpack() {

compiler/rustc_middle/src/ty/subst.rs

@@ -101,6 +101,7 @@ impl<'tcx> GenericArgKind<'tcx> {
                     ty::ConstnessArg::Not => 0,
                     ty::ConstnessArg::Required => 0b100,
                     ty::ConstnessArg::Param => 0b1000,
+                    ty::ConstnessArg::Infer => 0b10000,
                 },
             ),
         };
@@ -182,6 +183,7 @@ impl<'tcx> GenericArg<'tcx> {
                     0 => ty::ConstnessArg::Not,
                     0b100 => ty::ConstnessArg::Required,
                     0b1000 => ty::ConstnessArg::Param,
+                    0b10000 => ty::ConstnessArg::Infer,
                     _ => intrinsics::unreachable(),
                 }),
                 _ => intrinsics::unreachable(),
@@ -611,7 +613,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 = c {
+        if let ty::ConstnessArg::Param | ty::ConstnessArg::Infer = c {
             self.substs
                 .iter()
                 .find_map(|param| match param.unpack() {

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -2157,7 +2157,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
         let impl_substs = self.infcx.fresh_substs_for_item(obligation.cause.span, impl_def_id);
 
-        let impl_trait_ref = impl_trait_ref.subst(self.tcx(), impl_substs);
+        let mut impl_trait_ref = impl_trait_ref.subst(self.tcx(), impl_substs);
+        placeholder_obligation_trait_ref.normalize_constness_equate(self.tcx(), &mut impl_trait_ref);
 
         debug!(?impl_trait_ref);
 

compiler/rustc_typeck/src/astconv/generics.rs

@@ -213,7 +213,12 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             // If we have already computed substitutions for parents, we can use those directly.
             while let Some(&param) = params.peek() {
                 if let Some(&kind) = parent_substs.get(param.index as usize) {
-                    substs.push(kind);
+                    if let subst::GenericArgKind::Constness(ty::ConstnessArg::Infer) = kind.unpack()
+                    {
+                        substs.push(ctx.inferred_kind(None, param, false, None))
+                    } else {
+                        substs.push(kind);
+                    }
                     params.next();
                 } else {
                     break;

compiler/rustc_typeck/src/astconv/mod.rs

@@ -574,7 +574,7 @@ 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 => ty::ConstnessArg::Param,
+                                None => if infer_args { ty::ConstnessArg::Infer } else { ty::ConstnessArg::Param },
                                 Some(context) => {
                                     if tcx.generics_of(context).has_constness_param() {
                                         ty::ConstnessArg::Param
@@ -724,8 +724,8 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             self_ty,
             trait_ref.path.segments.last().unwrap(),
             true,
-            match constness {
-                hir::Constness::Const => ty::ConstnessArg::Param,
+            match constness { // TODO check this again
+                hir::Constness::Const => ty::ConstnessArg::Required,
                 hir::Constness::NotConst => ty::ConstnessArg::Not,
             },
         )

compiler/rustc_typeck/src/check/method/confirm.rs

@@ -397,9 +397,19 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
                 _substs: Option<&[subst::GenericArg<'tcx>]>,
                 param: &ty::GenericParamDef,
                 _infer_args: bool,
-                _constness: Option<ty::ConstnessArg>,
+                constness: Option<ty::ConstnessArg>,
             ) -> subst::GenericArg<'tcx> {
-                self.cfcx.var_for_def(self.cfcx.span, param)
+                if let ty::GenericParamDefKind::Constness = param.kind {
+                    let constness = if let Some(constness) = constness {
+                        constness
+                    } else {
+                        self.cfcx.fcx.constness()
+                    };
+                    debug!("inferred_kind constness={constness:?}");
+                    constness.into()
+                } else {
+                    self.cfcx.var_for_def(self.cfcx.span, param)
+                }
             }
         }
         <dyn AstConv<'_>>::create_substs_for_generic_args(