Port some more crates

oli-obk · fee1-dead · commit 1b7063864ba9 · 2022-07-15T06:32:03.000Z
diff --git a/compiler/rustc_typeck/src/check/compare_method.rs b/compiler/rustc_typeck/src/check/compare_method.rs
@@ -834,11 +834,15 @@ fn compare_synthetic_generics<'tcx>(
     let trait_m_generics = tcx.generics_of(trait_m.def_id);
     let impl_m_type_params = impl_m_generics.params.iter().filter_map(|param| match param.kind {
         GenericParamDefKind::Type { synthetic, .. } => Some((param.def_id, synthetic)),
-        GenericParamDefKind::Lifetime | GenericParamDefKind::Const { .. } => None,
+        GenericParamDefKind::Constness
+        | GenericParamDefKind::Lifetime
+        | GenericParamDefKind::Const { .. } => None,
     });
     let trait_m_type_params = trait_m_generics.params.iter().filter_map(|param| match param.kind {
         GenericParamDefKind::Type { synthetic, .. } => Some((param.def_id, synthetic)),
-        GenericParamDefKind::Lifetime | GenericParamDefKind::Const { .. } => None,
+        GenericParamDefKind::Constness
+        | GenericParamDefKind::Lifetime
+        | GenericParamDefKind::Const { .. } => None,
     });
     for ((impl_def_id, impl_synthetic), (trait_def_id, trait_synthetic)) in
         iter::zip(impl_m_type_params, trait_m_type_params)
diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs
@@ -1433,6 +1433,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             self.fcx.var_for_def(self.span, param)
                         }
                     }
+                    GenericParamDefKind::Constness => self.fcx.var_for_def(self.span, param),
                 }
             }
         }
diff --git a/compiler/rustc_typeck/src/check/method/mod.rs b/compiler/rustc_typeck/src/check/method/mod.rs
@@ -284,7 +284,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // Construct a trait-reference `self_ty : Trait<input_tys>`
         let substs = InternalSubsts::for_item(self.tcx, trait_def_id, |param, _| {
             match param.kind {
-                GenericParamDefKind::Lifetime | GenericParamDefKind::Const { .. } => {}
+                GenericParamDefKind::Constness
+                | GenericParamDefKind::Lifetime
+                | GenericParamDefKind::Const { .. } => {}
                 GenericParamDefKind::Type { .. } => {
                     if param.index == 0 {
                         return self_ty.into();
@@ -323,7 +325,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // Construct a trait-reference `self_ty : Trait<input_tys>`
         let substs = InternalSubsts::for_item(self.tcx, trait_def_id, |param, _| {
             match param.kind {
-                GenericParamDefKind::Lifetime | GenericParamDefKind::Const { .. } => {}
+                GenericParamDefKind::Constness
+                | GenericParamDefKind::Lifetime
+                | GenericParamDefKind::Const { .. } => {}
                 GenericParamDefKind::Type { .. } => {
                     if param.index == 0 {
                         return self_ty.into();
diff --git a/compiler/rustc_typeck/src/check/method/probe.rs b/compiler/rustc_typeck/src/check/method/probe.rs
@@ -1796,9 +1796,9 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                             // In general, during probe we erase regions.
                             self.tcx.lifetimes.re_erased.into()
                         }
-                        GenericParamDefKind::Type { .. } | GenericParamDefKind::Const { .. } => {
-                            self.var_for_def(self.span, param)
-                        }
+                        GenericParamDefKind::Constness
+                        | GenericParamDefKind::Type { .. }
+                        | GenericParamDefKind::Const { .. } => self.var_for_def(self.span, param),
                     }
                 }
             });
@@ -1833,6 +1833,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                 };
                 self.next_const_var(self.tcx.type_of(param.def_id), origin).into()
             }
+            GenericParamDefKind::Constness => ty::ConstnessArg::Param.into(),
         })
     }
 
diff --git a/compiler/rustc_typeck/src/check/wfcheck.rs b/compiler/rustc_typeck/src/check/wfcheck.rs
@@ -1281,7 +1281,7 @@ fn check_where_clauses<'tcx, 'fcx>(
         | GenericParamDefKind::Const { has_default } => {
             has_default && def.index >= generics.parent_count as u32
         }
-        GenericParamDefKind::Lifetime => unreachable!(),
+        GenericParamDefKind::Constness | GenericParamDefKind::Lifetime => unreachable!(),
     };
 
     // Check that concrete defaults are well-formed. See test `type-check-defaults.rs`.
@@ -1323,8 +1323,8 @@ fn check_where_clauses<'tcx, 'fcx>(
                     }
                 }
             }
-            // Doesn't have defaults.
-            GenericParamDefKind::Lifetime => {}
+            // Don't have defaults.
+            GenericParamDefKind::Constness | GenericParamDefKind::Lifetime => {}
         }
     }
 
@@ -1338,7 +1338,7 @@ fn check_where_clauses<'tcx, 'fcx>(
     // First we build the defaulted substitution.
     let substs = InternalSubsts::for_item(tcx, def_id.to_def_id(), |param, _| {
         match param.kind {
-            GenericParamDefKind::Lifetime => {
+            GenericParamDefKind::Constness | GenericParamDefKind::Lifetime => {
                 // All regions are identity.
                 tcx.mk_param_from_def(param)
             }
diff --git a/compiler/rustc_typeck/src/impl_wf_check.rs b/compiler/rustc_typeck/src/impl_wf_check.rs
@@ -155,6 +155,9 @@ fn enforce_impl_params_are_constrained(tcx: TyCtxt<'_>, impl_def_id: LocalDefId)
                     );
                 }
             }
+            ty::GenericParamDefKind::Constness => {
+                // TODO: users can't write these, do we have to do anything here?
+            }
         }
     }
 
diff --git a/compiler/rustc_typeck/src/outlives/implicit_infer.rs b/compiler/rustc_typeck/src/outlives/implicit_infer.rs
@@ -99,7 +99,11 @@ fn insert_required_predicates_to_be_wf<'tcx>(
 
             // No predicates from lifetimes or constants, except potentially
             // constants' types, but `walk` will get to them as well.
-            GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => continue,
+            GenericArgKind::Constness(_)
+            | GenericArgKind::Lifetime(_)
+            | GenericArgKind::Const(_) => {
+                continue;
+            }
         };
 
         match *ty.kind() {
diff --git a/compiler/rustc_typeck/src/outlives/mod.rs b/compiler/rustc_typeck/src/outlives/mod.rs
@@ -119,6 +119,10 @@ fn inferred_outlives_crate(tcx: TyCtxt<'_>, (): ()) -> CratePredicatesMap<'_> {
                             // Generic consts don't impose any constraints.
                             None
                         }
+                        GenericArgKind::Constness(_) => {
+                            // Constness effect doesn't impose any constraints.
+                            None
+                        }
                     }
                 },
             ));
diff --git a/compiler/rustc_typeck/src/outlives/utils.rs b/compiler/rustc_typeck/src/outlives/utils.rs
@@ -128,6 +128,9 @@ pub(crate) fn insert_outlives_predicate<'tcx>(
         GenericArgKind::Const(_) => {
             // Generic consts don't impose any constraints.
         }
+        GenericArgKind::Constness(_) => {
+            // Constness effect doesn't impose any constraints.
+        }
     }
 }
 
diff --git a/compiler/rustc_typeck/src/variance/constraints.rs b/compiler/rustc_typeck/src/variance/constraints.rs
@@ -189,6 +189,8 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
                 GenericArgKind::Const(val) => {
                     self.add_constraints_from_const(current, val, variance_i)
                 }
+                // Does not contain anything with constraints
+                GenericArgKind::Constness(_) => {}
             }
         }
     }
@@ -354,6 +356,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
                 GenericArgKind::Const(val) => {
                     self.add_constraints_from_const(current, val, variance)
                 }
+                GenericArgKind::Constness(_) => {}
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -1433,6 +1433,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1433`	`1433`	`self.fcx.var_for_def(self.span, param)`
`1434`	`1434`	`}`
`1435`	`1435`	`}`
	`1436`	`+ GenericParamDefKind::Constness => self.fcx.var_for_def(self.span, param),`
`1436`	`1437`	`}`
`1437`	`1438`	`}`
`1438`	`1439`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1796,9 +1796,9 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {`
`1796`	`1796`	`// In general, during probe we erase regions.`
`1797`	`1797`	`self.tcx.lifetimes.re_erased.into()`
`1798`	`1798`	`}`
`1799`		`- GenericParamDefKind::Type { .. } \| GenericParamDefKind::Const { .. } => {`
`1800`		`- self.var_for_def(self.span, param)`
`1801`		`- }`
	`1799`	`+ GenericParamDefKind::Constness`
	`1800`	`+ \| GenericParamDefKind::Type { .. }`
	`1801`	`+ \| GenericParamDefKind::Const { .. } => self.var_for_def(self.span, param),`
`1802`	`1802`	`}`
`1803`	`1803`	`}`
`1804`	`1804`	`});`
`@@ -1833,6 +1833,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {`
`1833`	`1833`	`};`
`1834`	`1834`	`self.next_const_var(self.tcx.type_of(param.def_id), origin).into()`
`1835`	`1835`	`}`
	`1836`	`+ GenericParamDefKind::Constness => ty::ConstnessArg::Param.into(),`
`1836`	`1837`	`})`
`1837`	`1838`	`}`
`1838`	`1839`
Original file line number	Diff line number	Diff line change
`@@ -1281,7 +1281,7 @@ fn check_where_clauses<'tcx, 'fcx>(`
`1281`	`1281`	`\| GenericParamDefKind::Const { has_default } => {`
`1282`	`1282`	`has_default && def.index >= generics.parent_count as u32`
`1283`	`1283`	`}`
`1284`		`- GenericParamDefKind::Lifetime => unreachable!(),`
	`1284`	`+ GenericParamDefKind::Constness \| GenericParamDefKind::Lifetime => unreachable!(),`
`1285`	`1285`	`};`
`1286`	`1286`
`1287`	`1287`	// Check that concrete defaults are well-formed. See test `type-check-defaults.rs`.
`@@ -1323,8 +1323,8 @@ fn check_where_clauses<'tcx, 'fcx>(`
`1323`	`1323`	`}`
`1324`	`1324`	`}`
`1325`	`1325`	`}`
`1326`		`- // Doesn't have defaults.`
`1327`		`- GenericParamDefKind::Lifetime => {}`
	`1326`	`+ // Don't have defaults.`
	`1327`	`+ GenericParamDefKind::Constness \| GenericParamDefKind::Lifetime => {}`
`1328`	`1328`	`}`
`1329`	`1329`	`}`
`1330`	`1330`
`@@ -1338,7 +1338,7 @@ fn check_where_clauses<'tcx, 'fcx>(`
`1338`	`1338`	`// First we build the defaulted substitution.`
`1339`	`1339`	`let substs = InternalSubsts::for_item(tcx, def_id.to_def_id(), \|param, _\| {`
`1340`	`1340`	`match param.kind {`
`1341`		`- GenericParamDefKind::Lifetime => {`
	`1341`	`+ GenericParamDefKind::Constness \| GenericParamDefKind::Lifetime => {`
`1342`	`1342`	`// All regions are identity.`
`1343`	`1343`	`tcx.mk_param_from_def(param)`
`1344`	`1344`	`}`
Original file line number	Diff line number	Diff line change
`@@ -155,6 +155,9 @@ fn enforce_impl_params_are_constrained(tcx: TyCtxt<'_>, impl_def_id: LocalDefId)`
`155`	`155`	`);`
`156`	`156`	`}`
`157`	`157`	`}`
	`158`	`+ ty::GenericParamDefKind::Constness => {`
	`159`	`+ // TODO: users can't write these, do we have to do anything here?`
	`160`	`+ }`
`158`	`161`	`}`
`159`	`162`	`}`
`160`	`163`
Original file line number	Diff line number	Diff line change
`@@ -119,6 +119,10 @@ fn inferred_outlives_crate(tcx: TyCtxt<'_>, (): ()) -> CratePredicatesMap<'_> {`
`119`	`119`	`// Generic consts don't impose any constraints.`
`120`	`120`	`None`
`121`	`121`	`}`
	`122`	`+ GenericArgKind::Constness(_) => {`
	`123`	`+ // Constness effect doesn't impose any constraints.`
	`124`	`+ None`
	`125`	`+ }`
`122`	`126`	`}`
`123`	`127`	`},`
`124`	`128`	`));`
Original file line number	Diff line number	Diff line change
`@@ -128,6 +128,9 @@ pub(crate) fn insert_outlives_predicate<'tcx>(`
`128`	`128`	`GenericArgKind::Const(_) => {`
`129`	`129`	`// Generic consts don't impose any constraints.`
`130`	`130`	`}`
	`131`	`+ GenericArgKind::Constness(_) => {`
	`132`	`+ // Constness effect doesn't impose any constraints.`
	`133`	`+ }`
`131`	`134`	`}`
`132`	`135`	`}`
`133`	`136`
Original file line number	Diff line number	Diff line change
`@@ -189,6 +189,8 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {`
`189`	`189`	`GenericArgKind::Const(val) => {`
`190`	`190`	`self.add_constraints_from_const(current, val, variance_i)`
`191`	`191`	`}`
	`192`	`+ // Does not contain anything with constraints`
	`193`	`+ GenericArgKind::Constness(_) => {}`
`192`	`194`	`}`
`193`	`195`	`}`
`194`	`196`	`}`
`@@ -354,6 +356,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {`
`354`	`356`	`GenericArgKind::Const(val) => {`
`355`	`357`	`self.add_constraints_from_const(current, val, variance)`
`356`	`358`	`}`
	`359`	`+ GenericArgKind::Constness(_) => {}`
`357`	`360`	`}`
`358`	`361`	`}`
`359`	`362`	`}`