var_for_def uses actual constness sometimes

Author: fee1-dead

compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs

@@ -193,7 +193,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
                             let i = param.index as usize;
                             if i < method_generics.parent_count {
-                                self.infcx.var_for_def(DUMMY_SP, param)
+                                self.infcx.var_for_def(DUMMY_SP, param, Some(self.constness))
                             } else {
                                 *method.substs.get(i).unwrap_or_else(|| {
                                     span_bug!(
@@ -1431,7 +1431,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             // This case also occurs as a result of some malformed input, e.g.
                             // a lifetime argument being given instead of a type parameter.
                             // Using inference instead of `Error` gives better error messages.
-                            self.fcx.var_for_def(self.span, param)
+                            self.fcx.var_for_def(self.span, param, None)
                         }
                     }
                     GenericParamDefKind::Const { has_default } => {
@@ -1440,11 +1440,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                 .subst(tcx, substs.unwrap())
                                 .into()
                         } else {
-                            self.fcx.var_for_def(self.span, param)
+                            self.fcx.var_for_def(self.span, param, None)
                         }
                     }
                     GenericParamDefKind::Constness => match constness {
-                        None => self.fcx.var_for_def(self.span, param),
+                        None => self.fcx.constness().into(),
                         Some(constness) => constness.into(),
                     },
                 }

compiler/rustc_typeck/src/check/fn_ctxt/mod.rs

@@ -148,7 +148,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             return_type_has_opaque: false,
             constness: {
                 fn get_constness(tcx: TyCtxt<'_>, did: DefId) -> ty::ConstnessArg {
-                    if tcx.is_const_fn_raw(did) || tcx.is_const_default_method(did) || tcx.def_kind(did) == hir::def::DefKind::Const {
+                    if tcx.is_const_fn_raw(did)
+                        || tcx.is_const_default_method(did)
+                        || tcx.def_kind(did) == hir::def::DefKind::Const
+                    {
                         trace!("const");
                         ty::ConstnessArg::Const
                     } else {
@@ -159,7 +162,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 if body_id.is_owner() {
                     let did = body_id.expect_owner();
                     get_constness(inh.tcx, did.to_def_id())
-                } else if let Some(hir::Node::Expr(hir::Expr { kind, .. })) = inh.tcx.hir().find(body_id) {
+                } else if let Some(hir::Node::Expr(hir::Expr { kind, .. })) =
+                    inh.tcx.hir().find(body_id)
+                {
                     if let hir::ExprKind::Closure { .. } = kind {
                         ty::ConstnessArg::Not
                     } else {
@@ -253,7 +258,7 @@ impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
 
     fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
         if let Some(param) = param {
-            if let GenericArgKind::Type(ty) = self.var_for_def(span, param).unpack() {
+            if let GenericArgKind::Type(ty) = self.var_for_def(span, param, None).unpack() {
                 return ty;
             }
             unreachable!()
@@ -272,7 +277,7 @@ impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
         span: Span,
     ) -> Const<'tcx> {
         if let Some(param) = param {
-            if let GenericArgKind::Const(ct) = self.var_for_def(span, param).unpack() {
+            if let GenericArgKind::Const(ct) = self.var_for_def(span, param, None).unpack() {
                 return ct;
             }
             unreachable!()

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

@@ -405,10 +405,10 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
                     } else {
                         self.cfcx.fcx.constness()
                     };
-                    debug!("inferred_kind constness={constness:?}");
+                    debug!(?constness);
                     constness.into()
                 } else {
-                    self.cfcx.var_for_def(self.cfcx.span, param)
+                    self.cfcx.var_for_def(self.cfcx.span, param, None)
                 }
             }
         }

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

@@ -295,7 +295,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     }
                 }
             }
-            self.var_for_def(span, param)
+            self.var_for_def(span, param, Some(self.constness()))
         });
 
         let trait_ref = ty::TraitRef::new(trait_def_id, substs);
@@ -336,7 +336,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     }
                 }
             }
-            self.var_for_def(span, param)
+            self.var_for_def(span, param, Some(self.constness()))
         });
 
         let trait_ref = ty::TraitRef::new(trait_def_id, substs);

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

@@ -1806,7 +1806,9 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                         }
                         GenericParamDefKind::Constness
                         | GenericParamDefKind::Type { .. }
-                        | GenericParamDefKind::Const { .. } => self.var_for_def(self.span, param),
+                        | GenericParamDefKind::Const { .. } => {
+                            self.var_for_def(self.span, param, Some(self.constness()))
+                        }
                     }
                 }
             });