Stop appending constness to all substs

oli-obk · fee1-dead · commit 71bcd357f19e · 2022-07-15T06:32:05.000Z
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
@@ -1199,6 +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(),
         }
     }
diff --git a/compiler/rustc_typeck/src/astconv/generics.rs b/compiler/rustc_typeck/src/astconv/generics.rs
@@ -225,11 +225,9 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                 if let Some(&param) = params.peek() {
                     if param.index == 0 {
                         if let GenericParamDefKind::Type { .. } = param.kind {
-                            substs.push(
-                                self_ty
-                                    .map(|ty| ty.into())
-                                    .unwrap_or_else(|| ctx.inferred_kind(None, param, true)),
-                            );
+                            substs.push(self_ty.map(|ty| ty.into()).unwrap_or_else(|| {
+                                ctx.inferred_kind(None, param, true, constness)
+                            }));
                             params.next();
                         }
                     }
@@ -278,7 +276,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                             ) => {
                                 // We expected a lifetime argument, but got a type or const
                                 // argument. That means we're inferring the lifetimes.
-                                substs.push(ctx.inferred_kind(None, param, infer_args));
+                                substs.push(ctx.inferred_kind(None, param, infer_args, constness));
                                 force_infer_lt = Some((arg, param));
                                 params.next();
                             }
@@ -375,7 +373,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                     (None, Some(&param)) => {
                         // If there are fewer arguments than parameters, it means
                         // we're inferring the remaining arguments.
-                        substs.push(ctx.inferred_kind(Some(&substs), param, infer_args));
+                        substs.push(ctx.inferred_kind(Some(&substs), param, infer_args, constness));
                         params.next();
                     }
 
@@ -384,8 +382,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             }
         }
 
-        substs.extend(constness.map(Into::into));
-
         tcx.intern_substs(&substs)
     }
 
diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs
@@ -196,6 +196,7 @@ pub trait CreateSubstsForGenericArgsCtxt<'a, 'tcx> {
         substs: Option<&[subst::GenericArg<'tcx>]>,
         param: &ty::GenericParamDef,
         infer_args: bool,
+        constness: Option<ty::ConstnessArg>,
     ) -> subst::GenericArg<'tcx>;
 }
 
@@ -492,6 +493,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                 substs: Option<&[subst::GenericArg<'tcx>]>,
                 param: &ty::GenericParamDef,
                 infer_args: bool,
+                constness: Option<ty::ConstnessArg>,
             ) -> subst::GenericArg<'tcx> {
                 let tcx = self.astconv.tcx();
                 match param.kind {
@@ -568,21 +570,22 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                         }
                     }
                     GenericParamDefKind::Constness => {
-                        match self.astconv.item_def_id() {
-                            // no information available
-                            // TODO: fall back to `Not`?
-                            None => ty::ConstnessArg::Param,
-                            Some(context) => {
-                                if tcx.generics_of(context).has_constness_param() {
-                                    ty::ConstnessArg::Param
-                                } else {
-                                    // TODO: should use `Required` if we're in a const context
-                                    // like `const`/`static` item initializers.
-                                    ty::ConstnessArg::Not
+                        constness
+                            .unwrap_or_else(|| match self.astconv.item_def_id() {
+                                // no information available
+                                // TODO: fall back to `Not`?
+                                None => ty::ConstnessArg::Param,
+                                Some(context) => {
+                                    if tcx.generics_of(context).has_constness_param() {
+                                        ty::ConstnessArg::Param
+                                    } else {
+                                        // TODO: should use `Required` if we're in a const context
+                                        // like `const`/`static` item initializers.
+                                        ty::ConstnessArg::Not
+                                    }
                                 }
-                            }
-                        }
-                        .into()
+                            })
+                            .into()
                     }
                 }
             }
diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs
@@ -1409,6 +1409,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 substs: Option<&[subst::GenericArg<'tcx>]>,
                 param: &ty::GenericParamDef,
                 infer_args: bool,
+                constness: Option<ty::ConstnessArg>,
             ) -> subst::GenericArg<'tcx> {
                 let tcx = self.fcx.tcx();
                 match param.kind {
@@ -1441,7 +1442,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             self.fcx.var_for_def(self.span, param)
                         }
                     }
-                    GenericParamDefKind::Constness => self.fcx.var_for_def(self.span, param),
+                    GenericParamDefKind::Constness => match constness {
+                        None => self.fcx.var_for_def(self.span, param),
+                        Some(constness) => constness.into(),
+                    },
                 }
             }
         }
diff --git a/compiler/rustc_typeck/src/check/method/confirm.rs b/compiler/rustc_typeck/src/check/method/confirm.rs
@@ -397,6 +397,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
                 _substs: Option<&[subst::GenericArg<'tcx>]>,
                 param: &ty::GenericParamDef,
                 _infer_args: bool,
+                _constness: Option<ty::ConstnessArg>,
             ) -> subst::GenericArg<'tcx> {
                 self.cfcx.var_for_def(self.cfcx.span, param)
             }

Original file line number	Diff line number	Diff line change
`@@ -1199,6 +1199,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {`
`1199`	`1199`	`});`
`1200`	`1200`	`self.tcx.mk_const_var(const_var_id, self.tcx.type_of(param.def_id)).into()`
`1201`	`1201`	`}`
	`1202`	`+ // TODO: this should actually figure out a yes/no answer from the context`
`1202`	`1203`	`GenericParamDefKind::Constness => ty::ConstnessArg::Param.into(),`
`1203`	`1204`	`}`
`1204`	`1205`	`}`
Original file line number	Diff line number	Diff line change
`@@ -225,11 +225,9 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {`
`225`	`225`	`if let Some(&param) = params.peek() {`
`226`	`226`	`if param.index == 0 {`
`227`	`227`	`if let GenericParamDefKind::Type { .. } = param.kind {`
`228`		`- substs.push(`
`229`		`- self_ty`
`230`		`- .map(\|ty\| ty.into())`
`231`		`- .unwrap_or_else(\|\| ctx.inferred_kind(None, param, true)),`
`232`		`- );`
	`228`	`+ substs.push(self_ty.map(\|ty\| ty.into()).unwrap_or_else(\|\| {`
	`229`	`+ ctx.inferred_kind(None, param, true, constness)`
	`230`	`+ }));`
`233`	`231`	`params.next();`
`234`	`232`	`}`
`235`	`233`	`}`
`@@ -278,7 +276,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {`
`278`	`276`	`) => {`
`279`	`277`	`// We expected a lifetime argument, but got a type or const`
`280`	`278`	`// argument. That means we're inferring the lifetimes.`
`281`		`- substs.push(ctx.inferred_kind(None, param, infer_args));`
	`279`	`+ substs.push(ctx.inferred_kind(None, param, infer_args, constness));`
`282`	`280`	`force_infer_lt = Some((arg, param));`
`283`	`281`	`params.next();`
`284`	`282`	`}`
`@@ -375,7 +373,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {`
`375`	`373`	`(None, Some(&param)) => {`
`376`	`374`	`// If there are fewer arguments than parameters, it means`
`377`	`375`	`// we're inferring the remaining arguments.`
`378`		`- substs.push(ctx.inferred_kind(Some(&substs), param, infer_args));`
	`376`	`+ substs.push(ctx.inferred_kind(Some(&substs), param, infer_args, constness));`
`379`	`377`	`params.next();`
`380`	`378`	`}`
`381`	`379`
`@@ -384,8 +382,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {`
`384`	`382`	`}`
`385`	`383`	`}`
`386`	`384`
`387`		`- substs.extend(constness.map(Into::into));`
`388`		`-`
`389`	`385`	`tcx.intern_substs(&substs)`
`390`	`386`	`}`
`391`	`387`
Original file line number	Diff line number	Diff line change
`@@ -1409,6 +1409,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1409`	`1409`	`substs: Option<&[subst::GenericArg<'tcx>]>,`
`1410`	`1410`	`param: &ty::GenericParamDef,`
`1411`	`1411`	`infer_args: bool,`
	`1412`	`+ constness: Option<ty::ConstnessArg>,`
`1412`	`1413`	`) -> subst::GenericArg<'tcx> {`
`1413`	`1414`	`let tcx = self.fcx.tcx();`
`1414`	`1415`	`match param.kind {`
`@@ -1441,7 +1442,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1441`	`1442`	`self.fcx.var_for_def(self.span, param)`
`1442`	`1443`	`}`
`1443`	`1444`	`}`
`1444`		`- GenericParamDefKind::Constness => self.fcx.var_for_def(self.span, param),`
	`1445`	`+ GenericParamDefKind::Constness => match constness {`
	`1446`	`+ None => self.fcx.var_for_def(self.span, param),`
	`1447`	`+ Some(constness) => constness.into(),`
	`1448`	`+ },`
`1445`	`1449`	`}`
`1446`	`1450`	`}`
`1447`	`1451`	`}`
Original file line number	Diff line number	Diff line change
`@@ -397,6 +397,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {`
`397`	`397`	`_substs: Option<&[subst::GenericArg<'tcx>]>,`
`398`	`398`	`param: &ty::GenericParamDef,`
`399`	`399`	`_infer_args: bool,`
	`400`	`+ _constness: Option<ty::ConstnessArg>,`
`400`	`401`	`) -> subst::GenericArg<'tcx> {`
`401`	`402`	`self.cfcx.var_for_def(self.cfcx.span, param)`
`402`	`403`	`}`