Move trait bound modifiers into ast::PolyTraitRef

Author: compiler-errors

compiler/rustc_ast/src/ast.rs

@@ -308,7 +308,7 @@ impl TraitBoundModifiers {
 
 #[derive(Clone,Encodable,Decodable,Debug)]
 pubenumGenericBound{
-Trait(PolyTraitRef,TraitBoundModifiers),
+Trait(PolyTraitRef),
 Outlives(Lifetime),
 /// Precise capturing syntax: `impl Sized + use<'a>`
 Use(ThinVec<PreciseCapturingArg>,Span),
@@ -1213,10 +1213,12 @@ impl Expr {
 
 pubfnto_bound(&self) -> Option<GenericBound>{
 match&self.kind{
-ExprKind::Path(None, path) => Some(GenericBound::Trait(
-PolyTraitRef::new(ThinVec::new(), path.clone(),self.span),
+ExprKind::Path(None, path) => Some(GenericBound::Trait(PolyTraitRef::new(
+ThinVec::new(),
+ path.clone(),
 TraitBoundModifiers::NONE,
-)),
+self.span,
+))),
  _ => None,
 }
 }
@@ -2965,16 +2967,25 @@ pub struct PolyTraitRef {
 /// The `'a` in `for<'a> Foo<&'a T>`.
 pubbound_generic_params:ThinVec<GenericParam>,
 
+// Optional constness, asyncness, or polarity.
+pubmodifiers:TraitBoundModifiers,
+
 /// The `Foo<&'a T>` in `<'a> Foo<&'a T>`.
 pubtrait_ref:TraitRef,
 
 pubspan:Span,
 }
 
 implPolyTraitRef{
-pubfnnew(generic_params:ThinVec<GenericParam>,path:Path,span:Span) -> Self{
+pubfnnew(
+generic_params:ThinVec<GenericParam>,
+path:Path,
+modifiers:TraitBoundModifiers,
+span:Span,
+) -> Self{
 PolyTraitRef{
 bound_generic_params: generic_params,
+ modifiers,
 trait_ref:TraitRef{ path,ref_id:DUMMY_NODE_ID},
  span,
 }

compiler/rustc_ast/src/mut_visit.rs

@@ -913,7 +913,7 @@ fn walk_fn_ret_ty<T: MutVisitor>(vis: &mut T, fn_ret_ty: &mut FnRetTy) {
 
 fnwalk_param_bound<T:MutVisitor>(vis:&mutT,pb:&mutGenericBound){
 match pb {
-GenericBound::Trait(ty, _modifier) => vis.visit_poly_trait_ref(ty),
+GenericBound::Trait(trait_ref) => vis.visit_poly_trait_ref(trait_ref),
 GenericBound::Outlives(lifetime) => walk_lifetime(vis, lifetime),
 GenericBound::Use(args, span) => {
 for arg in args {
@@ -1034,7 +1034,7 @@ fn walk_trait_ref<T: MutVisitor>(vis: &mut T, TraitRef { path, ref_id }: &mut Tr
 }
 
 fnwalk_poly_trait_ref<T:MutVisitor>(vis:&mutT,p:&mutPolyTraitRef){
-letPolyTraitRef{ bound_generic_params, trait_ref, span } = p;
+letPolyTraitRef{ bound_generic_params,modifiers: _,trait_ref, span } = p;
  bound_generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
  vis.visit_trait_ref(trait_ref);
  vis.visit_span(span);

compiler/rustc_ast/src/util/classify.rs

@@ -263,7 +263,7 @@ fn type_trailing_braced_mac_call(mut ty: &ast::Ty) -> Option<&ast::MacCall> {
 
  ast::TyKind::TraitObject(bounds, _) | ast::TyKind::ImplTrait(_, bounds) => {
 match bounds.last(){
-Some(ast::GenericBound::Trait(bound, _)) => {
+Some(ast::GenericBound::Trait(bound)) => {
 matchpath_return_type(&bound.trait_ref.path){
 Some(trailing_ty) => ty = trailing_ty,
 None => breakNone,

compiler/rustc_ast/src/visit.rs

@@ -329,7 +329,7 @@ pub fn walk_poly_trait_ref<'a, V>(visitor: &mut V, trait_ref: &'a PolyTraitRef)
 where
 V:Visitor<'a>,
 {
-letPolyTraitRef{ bound_generic_params, trait_ref,span: _ } = trait_ref;
+letPolyTraitRef{ bound_generic_params,modifiers: _,trait_ref,span: _ } = trait_ref;
 walk_list!(visitor, visit_generic_param, bound_generic_params);
  visitor.visit_trait_ref(trait_ref)
 }
@@ -720,7 +720,7 @@ impl WalkItemKind for ForeignItemKind {
 
 pubfnwalk_param_bound<'a,V:Visitor<'a>>(visitor:&mutV,bound:&'aGenericBound) -> V::Result{
 match bound {
-GenericBound::Trait(typ, _modifier) => visitor.visit_poly_trait_ref(typ),
+GenericBound::Trait(trait_ref) => visitor.visit_poly_trait_ref(trait_ref),
 GenericBound::Outlives(lifetime) => visitor.visit_lifetime(lifetime,LifetimeCtxt::Bound),
 GenericBound::Use(args, _span) => {
 walk_list!(visitor, visit_precise_capturing_arg, args);

compiler/rustc_ast_lowering/src/item.rs

@@ -1504,8 +1504,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
 for bound in&bound_pred.bounds{
 if !matches!(
 *bound,
-GenericBound::Trait(_,TraitBoundModifiers{
- polarity:BoundPolarity::Maybe(_),
+GenericBound::Trait(PolyTraitRef{
+modifiers:TraitBoundModifiers{polarity:BoundPolarity::Maybe(_), .. },
  ..
 })
 ){

compiler/rustc_ast_lowering/src/lib.rs

@@ -1219,11 +1219,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 let bound = this.lower_poly_trait_ref(
 &PolyTraitRef{
 bound_generic_params:ThinVec::new(),
+modifiers:TraitBoundModifiers::NONE,
 trait_ref:TraitRef{path: path.clone(),ref_id: t.id},
 span: t.span,
 },
  itctx,
-TraitBoundModifiers::NONE,
 );
 let bounds = this.arena.alloc_from_iter([bound]);
 let lifetime_bound = this.elided_dyn_bound(t.span);
@@ -1325,8 +1325,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 // We can safely ignore constness here since AST validation
 // takes care of rejecting invalid modifier combinations and
 // const trait bounds in trait object types.
-GenericBound::Trait(ty, modifiers) => {
-let trait_ref = this.lower_poly_trait_ref(ty, itctx,*modifiers);
+GenericBound::Trait(ty) => {
+let trait_ref = this.lower_poly_trait_ref(ty, itctx);
 Some(trait_ref)
 }
 GenericBound::Outlives(lifetime) => {
@@ -1974,9 +1974,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 itctx:ImplTraitContext,
 ) -> hir::GenericBound<'hir>{
 match tpb {
-GenericBound::Trait(p, modifiers) => {
- hir::GenericBound::Trait(self.lower_poly_trait_ref(p, itctx,*modifiers))
-}
+GenericBound::Trait(p) => hir::GenericBound::Trait(self.lower_poly_trait_ref(p, itctx)),
 GenericBound::Outlives(lifetime) => {
  hir::GenericBound::Outlives(self.lower_lifetime(lifetime))
 }
@@ -2180,12 +2178,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 &mutself,
 p:&PolyTraitRef,
 itctx:ImplTraitContext,
-modifiers: ast::TraitBoundModifiers,
 ) -> hir::PolyTraitRef<'hir>{
 let bound_generic_params =
 self.lower_lifetime_binder(p.trait_ref.ref_id,&p.bound_generic_params);
-let trait_ref = self.lower_trait_ref(modifiers,&p.trait_ref, itctx);
-let modifiers = self.lower_trait_bound_modifiers(modifiers);
+let trait_ref = self.lower_trait_ref(p.modifiers,&p.trait_ref, itctx);
+let modifiers = self.lower_trait_bound_modifiers(p.modifiers);
  hir::PolyTraitRef{
  bound_generic_params,
  modifiers,

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -1260,7 +1260,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
 if !bound_pred.bound_generic_params.is_empty(){
 for bound in&bound_pred.bounds{
 match bound {
-GenericBound::Trait(t, _) => {
+GenericBound::Trait(t) => {
 if !t.bound_generic_params.is_empty(){
 self.dcx()
 .emit_err(errors::NestedLifetimes{span: t.span});
@@ -1280,8 +1280,8 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
 
 fnvisit_param_bound(&mutself,bound:&'aGenericBound,ctxt:BoundKind){
 match bound {
-GenericBound::Trait(trait_ref, modifiers) => {
-match(ctxt, modifiers.constness, modifiers.polarity){
+GenericBound::Trait(trait_ref) => {
+match(ctxt,trait_ref.modifiers.constness,trait_ref.modifiers.polarity){
 (BoundKind::SuperTraits,BoundConstness::Never,BoundPolarity::Maybe(_))
 if !self.features.more_maybe_bounds =>
 {
@@ -1321,7 +1321,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
 }
 
 // Negative trait bounds are not allowed to have associated constraints
-ifletBoundPolarity::Negative(_) = modifiers.polarity
+ifletBoundPolarity::Negative(_) = trait_ref.modifiers.polarity
  && letSome(segment) = trait_ref.trait_ref.path.segments.last()
 {
 match segment.args.as_deref(){
@@ -1669,7 +1669,9 @@ fn deny_equality_constraints(
 }),
 ){
 for bound in bounds {
-ifletGenericBound::Trait(poly,TraitBoundModifiers::NONE) = bound {
+ifletGenericBound::Trait(poly) = bound
+ && poly.modifiers == TraitBoundModifiers::NONE
+{
 if full_path.segments[..full_path.segments.len() - 1]
 .iter()
 .map(|segment| segment.ident.name)
@@ -1697,7 +1699,9 @@ fn deny_equality_constraints(
 ){
 if ident == potential_param.ident{
 for bound in bounds {
-iflet ast::GenericBound::Trait(poly,TraitBoundModifiers::NONE) = bound {
+iflet ast::GenericBound::Trait(poly) = bound
+ && poly.modifiers == TraitBoundModifiers::NONE
+{
 suggest(poly, potential_assoc, predicate);
 }
 }

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -8,7 +8,6 @@ mod item;
 
 use std::borrow::Cow;
 
-use ast::TraitBoundModifiers;
 use rustc_ast::attr::AttrIdGenerator;
 use rustc_ast::ptr::P;
 use rustc_ast::token::{
@@ -1253,6 +1252,27 @@ impl<'a> State<'a> {
 
 fnprint_poly_trait_ref(&mutself,t:&ast::PolyTraitRef){
 self.print_formal_generic_params(&t.bound_generic_params);
+
+let ast::TraitBoundModifiers{ constness, asyncness, polarity } = t.modifiers;
+match constness {
+ ast::BoundConstness::Never => {}
+ ast::BoundConstness::Always(_) | ast::BoundConstness::Maybe(_) => {
+self.word_space(constness.as_str());
+}
+}
+match asyncness {
+ ast::BoundAsyncness::Normal => {}
+ ast::BoundAsyncness::Async(_) => {
+self.word_space(asyncness.as_str());
+}
+}
+match polarity {
+ ast::BoundPolarity::Positive => {}
+ ast::BoundPolarity::Negative(_) | ast::BoundPolarity::Maybe(_) => {
+self.word(polarity.as_str());
+}
+}
+
 self.print_trait_ref(&t.trait_ref)
 }
 
@@ -1740,31 +1760,7 @@ impl<'a> State<'a> {
 }
 
 match bound {
-GenericBound::Trait(
- tref,
-TraitBoundModifiers{ constness, asyncness, polarity },
-) => {
-match constness {
- ast::BoundConstness::Never => {}
- ast::BoundConstness::Always(_) | ast::BoundConstness::Maybe(_) => {
-self.word_space(constness.as_str());
-}
-}
-
-match asyncness {
- ast::BoundAsyncness::Normal => {}
- ast::BoundAsyncness::Async(_) => {
-self.word_space(asyncness.as_str());
-}
-}
-
-match polarity {
- ast::BoundPolarity::Positive => {}
- ast::BoundPolarity::Negative(_) | ast::BoundPolarity::Maybe(_) => {
-self.word(polarity.as_str());
-}
-}
-
+GenericBound::Trait(tref) => {
 self.print_poly_trait_ref(tref);
 }
 GenericBound::Outlives(lt) => self.print_lifetime(*lt),

compiler/rustc_builtin_macros/src/deriving/smart_ptr.rs

@@ -333,12 +333,12 @@ fn contains_maybe_sized_bound_on_pointee(predicates: &[WherePredicate], pointee:
 }
 
 fnis_maybe_sized_bound(bound:&GenericBound) -> bool{
-ifletGenericBound::Trait(
-trait_ref,
-TraitBoundModifiers{polarity: ast::BoundPolarity::Maybe(_), .. },
-) = bound
+ifletGenericBound::Trait(trait_ref) = bound
+&& letTraitBoundModifiers{polarity: ast::BoundPolarity::Maybe(_), .. } =
+ trait_ref.modifiers
+ && is_sized_marker(&trait_ref.trait_ref.path)
 {
-is_sized_marker(&trait_ref.trait_ref.path)
+true
 }else{
 false
 }

compiler/rustc_expand/src/build.rs

@@ -143,24 +143,25 @@ impl<'a> ExtCtxt<'a> {
  ast::TraitRef{ path,ref_id: ast::DUMMY_NODE_ID}
 }
 
-pubfnpoly_trait_ref(&self,span:Span,path: ast::Path) -> ast::PolyTraitRef{
+pubfnpoly_trait_ref(&self,span:Span,path: ast::Path,is_const:bool) -> ast::PolyTraitRef{
  ast::PolyTraitRef{
 bound_generic_params:ThinVec::new(),
+modifiers: ast::TraitBoundModifiers{
+polarity: ast::BoundPolarity::Positive,
+constness:if is_const {
+ ast::BoundConstness::Maybe(DUMMY_SP)
+}else{
+ ast::BoundConstness::Never
+},
+asyncness: ast::BoundAsyncness::Normal,
+},
 trait_ref:self.trait_ref(path),
  span,
 }
 }
 
 pubfntrait_bound(&self,path: ast::Path,is_const:bool) -> ast::GenericBound{
- ast::GenericBound::Trait(self.poly_trait_ref(path.span, path), ast::TraitBoundModifiers{
-polarity: ast::BoundPolarity::Positive,
-constness:if is_const {
- ast::BoundConstness::Maybe(DUMMY_SP)
-}else{
- ast::BoundConstness::Never
-},
-asyncness: ast::BoundAsyncness::Normal,
-})
+ ast::GenericBound::Trait(self.poly_trait_ref(path.span, path, is_const))
 }
 
 pubfnlifetime(&self,span:Span,ident:Ident) -> ast::Lifetime{