HIR ty lowering: Validate PointeeSized bounds

Author: fmease

compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs

@@ -6,7 +6,7 @@ use rustc_errors::struct_span_code_err;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LocalDefId};
-use rustc_hir::{AmbigArg, LangItem, PolyTraitRef};
+use rustc_hir::{AmbigArg, PolyTraitRef};
 use rustc_middle::bug;
 use rustc_middle::ty::{
  self as ty, IsSuggestable, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt,
@@ -124,13 +124,13 @@ fn collect_sizedness_bounds<'tcx>(
  self_ty_where_predicates: Option<(LocalDefId, &'tcx [hir::WherePredicate<'tcx>])>,
  span: Span,
 ) -> CollectedSizednessBounds {
- let sized_did = tcx.require_lang_item(LangItem::Sized, span);
+ let sized_did = tcx.require_lang_item(hir::LangItem::Sized, span);
  let sized = collect_bounds(hir_bounds, self_ty_where_predicates, sized_did);
 
- let meta_sized_did = tcx.require_lang_item(LangItem::MetaSized, span);
+ let meta_sized_did = tcx.require_lang_item(hir::LangItem::MetaSized, span);
  let meta_sized = collect_bounds(hir_bounds, self_ty_where_predicates, meta_sized_did);
 
- let pointee_sized_did = tcx.require_lang_item(LangItem::PointeeSized, span);
+ let pointee_sized_did = tcx.require_lang_item(hir::LangItem::PointeeSized, span);
  let pointee_sized = collect_bounds(hir_bounds, self_ty_where_predicates, pointee_sized_did);
 
  CollectedSizednessBounds { sized, meta_sized, pointee_sized }
@@ -151,24 +151,6 @@ fn add_trait_bound<'tcx>(
 }
 
 impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
- /// Skip `PointeeSized` bounds.
- ///
- /// `PointeeSized` is a "fake bound" insofar as anywhere a `PointeeSized` bound exists, there
- /// is actually the absence of any bounds. This avoids limitations around non-global where
- /// clauses being preferred over item bounds (where `PointeeSized` bounds would be
- /// proven) - which can result in errors when a `PointeeSized` supertrait/bound/predicate is
- /// added to some items.
- pub(crate) fn should_skip_sizedness_bound<'hir>(
- &self,
- bound: &'hir hir::GenericBound<'tcx>,
- ) -> bool {
- bound
- .trait_ref()
- .and_then(|tr| tr.trait_def_id())
- .map(|did| self.tcx().is_lang_item(did, LangItem::PointeeSized))
- .unwrap_or(false)
- }
-
  /// Adds sizedness bounds to a trait, trait alias, parameter, opaque type or associated type.
  ///
  /// - On parameters, opaque type and associated types, add default `Sized` bound if no explicit
@@ -188,8 +170,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
  ) {
  let tcx = self.tcx();
 
- let meta_sized_did = tcx.require_lang_item(LangItem::MetaSized, span);
- let pointee_sized_did = tcx.require_lang_item(LangItem::PointeeSized, span);
+ let meta_sized_did = tcx.require_lang_item(hir::LangItem::MetaSized, span);
+ let pointee_sized_did = tcx.require_lang_item(hir::LangItem::PointeeSized, span);
 
  // If adding sizedness bounds to a trait, then there are some relevant early exits
  if let Some(trait_did) = trait_did {
@@ -230,7 +212,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
  } else {
  // If there are no explicit sizedness bounds on a parameter then add a default
  // `Sized` bound.
- let sized_did = tcx.require_lang_item(LangItem::Sized, span);
+ let sized_did = tcx.require_lang_item(hir::LangItem::Sized, span);
  add_trait_bound(tcx, bounds, self_ty, sized_did, span);
  }
  }
@@ -465,10 +447,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
  'tcx: 'hir,
  {
  for hir_bound in hir_bounds {
- if self.should_skip_sizedness_bound(hir_bound) {
- continue;
- }
-
  // In order to avoid cycles, when we're lowering `SelfTraitThatDefines`,
  // we skip over any traits that don't define the given associated type.
  if let PredicateFilter::SelfTraitThatDefines(assoc_ident) = predicate_filter {

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -758,13 +758,37 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
  bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
  predicate_filter: PredicateFilter,
  ) -> GenericArgCountResult {
+ let tcx = self.tcx();
+
  // We use the *resolved* bound vars later instead of the HIR ones since the former
  // also include the bound vars of the overarching predicate if applicable.
  let hir::PolyTraitRef { bound_generic_params: _, modifiers, ref trait_ref, span } =
  *poly_trait_ref;
  let hir::TraitBoundModifiers { constness, polarity } = modifiers;
 
  let trait_def_id = trait_ref.trait_def_id().unwrap_or_else(|| FatalError.raise());
+
+ let (polarity, bounds) = match polarity {
+ rustc_ast::BoundPolarity::Positive
+ if tcx.is_lang_item(trait_def_id, hir::LangItem::PointeeSized) =>
+ {
+ // Skip `PointeeSized` bounds.
+ //
+ // `PointeeSized` is a "fake bound" insofar as anywhere a `PointeeSized` bound exists, there
+ // is actually the absence of any bounds. This avoids limitations around non-global where
+ // clauses being preferred over item bounds (where `PointeeSized` bounds would be
+ // proven) - which can result in errors when a `PointeeSized` supertrait/bound/predicate is
+ // added to some items.
+ (ty::PredicatePolarity::Positive, &mut Vec::new())
+ }
+ rustc_ast::BoundPolarity::Positive => (ty::PredicatePolarity::Positive, bounds),
+ rustc_ast::BoundPolarity::Negative(_) => (ty::PredicatePolarity::Negative, bounds),
+ // FIXME(fmease): This is super hacky! `Option<Polarity>` is also sad.
+ rustc_ast::BoundPolarity::Maybe(_) => {
+ (ty::PredicatePolarity::Positive, &mut Vec::new())
+ }
+ };
+
  let trait_segment = trait_ref.path.segments.last().unwrap();
 
  let _ = self.prohibit_generic_args(
@@ -781,7 +805,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
  Some(self_ty),
  );
 
- let tcx = self.tcx();
  let bound_vars = tcx.late_bound_vars(trait_ref.hir_ref_id);
  debug!(?bound_vars);
 
@@ -792,27 +815,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
  debug!(?poly_trait_ref);
 
- let polarity = match polarity {
- rustc_ast::BoundPolarity::Positive => ty::PredicatePolarity::Positive,
- rustc_ast::BoundPolarity::Negative(_) => ty::PredicatePolarity::Negative,
- rustc_ast::BoundPolarity::Maybe(_) => {
- // Validate associated type at least. We may want to reject these
- // outright in the future...
- for constraint in trait_segment.args().constraints {
- let _ = self.lower_assoc_item_constraint(
- trait_ref.hir_ref_id,
- poly_trait_ref,
- constraint,
- &mut Default::default(),
- &mut Default::default(),
- constraint.span,
- predicate_filter,
- );
- }
- return arg_count;
- }
- };
-
  // We deal with const conditions later.
  match predicate_filter {
  PredicateFilter::All
@@ -915,7 +917,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
  // Don't register any associated item constraints for negative bounds,
  // since we should have emitted an error for them earlier, and they
  // would not be well-formed!
- if polarity != ty::PredicatePolarity::Positive {
+ if polarity == ty::PredicatePolarity::Negative {
  self.dcx().span_delayed_bug(
  constraint.span,
  "negative trait bounds should not have assoc item constraints",

tests/ui/sized-hierarchy/pointee-validation.rs

@@ -0,0 +1,14 @@
+// Test that despite us dropping `PointeeSized` bounds during HIR ty lowering
+// we still validate it first.
+// issue: <https://github.com/rust-lang/rust/issues/142718>
+#![feature(sized_hierarchy)]
+
+use std::marker::PointeeSized;
+
+struct Test where (): const PointeeSized<(), Undefined = ()>;
+//~^ ERROR trait takes 0 generic arguments but 1 generic argument was supplied
+//~| ERROR associated type `Undefined` not found for `PointeeSized`
+//~| ERROR `const` can only be applied to `#[const_trait]` traits
+//~| ERROR const trait impls are experimental
+
+fn main() {}

tests/ui/sized-hierarchy/pointee-validation.stderr

@@ -0,0 +1,37 @@
+error[E0658]: const trait impls are experimental
+ --> $DIR/pointee-validation.rs:8:23
+ |
+LL | struct Test where (): const PointeeSized<(), Undefined = ()>;
+ | ^^^^^
+ |
+ = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+ = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
+ = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0107]: trait takes 0 generic arguments but 1 generic argument was supplied
+ --> $DIR/pointee-validation.rs:8:29
+ |
+LL | struct Test where (): const PointeeSized<(), Undefined = ()>;
+ | ^^^^^^^^^^^^-------------------- help: remove the unnecessary generics
+ | |
+ | expected 0 generic arguments
+
+error: `const` can only be applied to `#[const_trait]` traits
+ --> $DIR/pointee-validation.rs:8:23
+ |
+LL | struct Test where (): const PointeeSized<(), Undefined = ()>;
+ | ^^^^^ can't be applied to `PointeeSized`
+ |
+note: `PointeeSized` can't be used with `const` because it isn't annotated with `#[const_trait]`
+ --> $SRC_DIR/core/src/marker.rs:LL:COL
+
+error[E0220]: associated type `Undefined` not found for `PointeeSized`
+ --> $DIR/pointee-validation.rs:8:46
+ |
+LL | struct Test where (): const PointeeSized<(), Undefined = ()>;
+ | ^^^^^^^^^ associated type `Undefined` not found
+
+error: aborting due to 4 previous errors
+
+Some errors have detailed explanations: E0107, E0220, E0658.
+For more information about an error, try `rustc --explain E0107`.