Implment #[cfg] and #[cfg_attr] in where clauses

Author: frank-king

compiler/rustc_ast/src/ast.rs

@@ -417,9 +417,11 @@ impl WhereClause {
 /// A single predicate in a where-clause.
 #[derive(Clone,Encodable,Decodable,Debug)]
 pubstructWherePredicate{
+pubattrs:AttrVec,
 pubkind:WherePredicateKind,
 pubid:NodeId,
 pubspan:Span,
+pubis_placeholder:bool,
 }
 
 /// Predicate kind in where-clause.

compiler/rustc_ast/src/ast_traits.rs

@@ -11,7 +11,7 @@ use crate::tokenstream::LazyAttrTokenStream;
 usecrate::{
 Arm,AssocItem,AttrItem,AttrKind,AttrVec,Attribute,Block,Crate,Expr,ExprField,
 FieldDef,ForeignItem,GenericParam,Item,NodeId,Param,Pat,PatField,Path,Stmt,StmtKind,
-Ty,Variant,Visibility,
+Ty,Variant,Visibility,WherePredicate,
 };
 
 /// A utility trait to reduce boilerplate.
@@ -79,6 +79,7 @@ impl_has_node_id!(
 Stmt,
 Ty,
 Variant,
+WherePredicate,
 );
 
 impl<T:AstDeref<Target:HasNodeId>>HasNodeIdforT{
@@ -127,7 +128,16 @@ macro_rules! impl_has_tokens_none {
 }
 
 impl_has_tokens!(AssocItem,AttrItem,Block,Expr,ForeignItem,Item,Pat,Path,Ty,Visibility);
-impl_has_tokens_none!(Arm,ExprField,FieldDef,GenericParam,Param,PatField,Variant);
+impl_has_tokens_none!(
+Arm,
+ExprField,
+FieldDef,
+GenericParam,
+Param,
+PatField,
+Variant,
+WherePredicate
+);
 
 impl<T:AstDeref<Target:HasTokens>>HasTokensforT{
 fntokens(&self) -> Option<&LazyAttrTokenStream>{
@@ -279,6 +289,7 @@ impl_has_attrs!(
 Param,
 PatField,
 Variant,
+WherePredicate,
 );
 impl_has_attrs_none!(Attribute,AttrItem,Block,Pat,Path,Ty,Visibility);
 

compiler/rustc_ast/src/mut_visit.rs

@@ -338,8 +338,11 @@ pub trait MutVisitor: Sized {
 walk_where_clause(self, where_clause);
 }
 
-fnvisit_where_predicate(&mutself,where_predicate:&mutWherePredicate){
-walk_where_predicate(self, where_predicate)
+fnflat_map_where_predicate(
+&mutself,
+where_predicate:WherePredicate,
+) -> SmallVec<[WherePredicate;1]>{
+walk_flat_map_where_predicate(self, where_predicate)
 }
 
 fnvisit_where_predicate_kind(&mutself,kind:&mutWherePredicateKind){
@@ -1097,15 +1100,20 @@ fn walk_ty_alias_where_clauses<T: MutVisitor>(vis: &mut T, tawcs: &mut TyAliasWh
 
 fnwalk_where_clause<T:MutVisitor>(vis:&mutT,wc:&mutWhereClause){
 letWhereClause{has_where_token: _, predicates, span } = wc;
-visit_thin_vec(predicates,|predicate| vis.visit_where_predicate(predicate));
+ predicates.flat_map_in_place(|predicate| vis.flat_map_where_predicate(predicate));
  vis.visit_span(span);
 }
 
-pubfnwalk_where_predicate<T:MutVisitor>(vis:&mutT,pred:&mutWherePredicate){
-letWherePredicate{ kind, id, span } = pred;
+pubfnwalk_flat_map_where_predicate<T:MutVisitor>(
+vis:&mutT,
+mutpred:WherePredicate,
+) -> SmallVec<[WherePredicate;1]>{
+letWherePredicate{ attrs, kind, id, span,is_placeholder: _ } = &mut pred;
  vis.visit_id(id);
+visit_attrs(vis, attrs);
  vis.visit_where_predicate_kind(kind);
  vis.visit_span(span);
+smallvec![pred]
 }
 
 pubfnwalk_where_predicate_kind<T:MutVisitor>(vis:&mutT,kind:&mutWherePredicateKind){

compiler/rustc_ast/src/visit.rs

@@ -833,7 +833,8 @@ pub fn walk_where_predicate<'a, V: Visitor<'a>>(
 visitor:&mutV,
 predicate:&'aWherePredicate,
 ) -> V::Result{
-letWherePredicate{ kind,id: _,span: _ } = predicate;
+letWherePredicate{ attrs, kind,id: _,span: _,is_placeholder: _ } = predicate;
+walk_list!(visitor, visit_attribute, attrs);
  visitor.visit_where_predicate_kind(kind)
 }
 

compiler/rustc_ast_lowering/src/item.rs

@@ -1728,6 +1728,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 fnlower_where_predicate(&mutself,pred:&WherePredicate) -> hir::WherePredicate<'hir>{
 let hir_id = self.lower_node_id(pred.id);
 let span = self.lower_span(pred.span);
+self.lower_attrs(hir_id,&pred.attrs, span);
 let kind = self.arena.alloc(match&pred.kind{
 WherePredicateKind::BoundPredicate(WhereBoundPredicate{
  bound_generic_params,

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -503,6 +503,7 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
 gate_all!(unsafe_binders,"unsafe binder types are experimental");
 gate_all!(contracts,"contracts are incomplete");
 gate_all!(contracts_internals,"contract internal machinery is for internal use only");
+gate_all!(where_clause_attrs,"attributes in `where` clause are unstable");
 
 if !visitor.features.never_patterns(){
 ifletSome(spans) = spans.get(&sym::never_patterns){

compiler/rustc_ast_pretty/src/pprust/state/item.rs

@@ -735,7 +735,8 @@ impl<'a> State<'a> {
 }
 
 pubfnprint_where_predicate(&mutself,predicate:&ast::WherePredicate){
-let ast::WherePredicate{ kind,id: _,span: _ } = predicate;
+let ast::WherePredicate{ attrs, kind,id: _,span: _,is_placeholder: _ } = predicate;
+self.print_outer_attributes(attrs);
 match kind {
  ast::WherePredicateKind::BoundPredicate(where_bound_predicate) => {
 self.print_where_bound_predicate(where_bound_predicate);

compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs

@@ -300,13 +300,16 @@ pub(crate) fn expand_deriving_coerce_pointee(
 to_ty:&s_ty,
 rewritten:false,
 };
-letmut predicate = ast::WherePredicate{
-kind: ast::WherePredicateKind::BoundPredicate(bound.clone()),
-span: predicate.span,
-id: ast::DUMMY_NODE_ID,
-};
- substitution.visit_where_predicate(&mut predicate);
+letmut kind = ast::WherePredicateKind::BoundPredicate(bound.clone());
+ substitution.visit_where_predicate_kind(&mut kind);
 if substitution.rewritten{
+let predicate = ast::WherePredicate{
+attrs: predicate.attrs.clone(),
+ kind,
+span: predicate.span,
+id: ast::DUMMY_NODE_ID,
+is_placeholder:false,
+};
  impl_generics.where_clause.predicates.push(predicate);
 }
 }
@@ -388,8 +391,8 @@ impl<'a> ast::mut_visit::MutVisitor for TypeSubstitution<'a> {
 }
 }
 
-fnvisit_where_predicate(&mutself,where_predicate:&mut ast::WherePredicate){
-match&mut where_predicate.kind{
+fnvisit_where_predicate_kind(&mutself,kind:&mut ast::WherePredicateKind){
+match kind {
  rustc_ast::WherePredicateKind::BoundPredicate(bound) => {
  bound
 .bound_generic_params

compiler/rustc_builtin_macros/src/deriving/generic/mod.rs

@@ -687,9 +687,11 @@ impl<'a> TraitDef<'a> {
 // and similarly for where clauses
  where_clause.predicates.extend(generics.where_clause.predicates.iter().map(|clause| {
  ast::WherePredicate{
+attrs: clause.attrs.clone(),
 kind: clause.kind.clone(),
 id: ast::DUMMY_NODE_ID,
 span: clause.span.with_ctxt(ctxt),
+is_placeholder:false,
 }
 }));
 
@@ -744,8 +746,13 @@ impl<'a> TraitDef<'a> {
 };
 
 let kind = ast::WherePredicateKind::BoundPredicate(predicate);
-let predicate =
- ast::WherePredicate{ kind,id: ast::DUMMY_NODE_ID,span:self.span};
+let predicate = ast::WherePredicate{
+attrs:ThinVec::new(),
+ kind,
+id: ast::DUMMY_NODE_ID,
+span:self.span,
+is_placeholder:false,
+};
  where_clause.predicates.push(predicate);
 }
 }

compiler/rustc_expand/src/base.rs

@@ -53,6 +53,7 @@ pub enum Annotatable {
 Param(ast::Param),
 FieldDef(ast::FieldDef),
 Variant(ast::Variant),
+WherePredicate(ast::WherePredicate),
 Crate(ast::Crate),
 }
 
@@ -71,6 +72,7 @@ impl Annotatable {
 Annotatable::Param(p) => p.span,
 Annotatable::FieldDef(sf) => sf.span,
 Annotatable::Variant(v) => v.span,
+Annotatable::WherePredicate(wp) => wp.span,
 Annotatable::Crate(c) => c.spans.inner_span,
 }
 }
@@ -89,6 +91,7 @@ impl Annotatable {
 Annotatable::Param(p) => p.visit_attrs(f),
 Annotatable::FieldDef(sf) => sf.visit_attrs(f),
 Annotatable::Variant(v) => v.visit_attrs(f),
+Annotatable::WherePredicate(wp) => wp.visit_attrs(f),
 Annotatable::Crate(c) => c.visit_attrs(f),
 }
 }
@@ -107,6 +110,7 @@ impl Annotatable {
 Annotatable::Param(p) => visitor.visit_param(p),
 Annotatable::FieldDef(sf) => visitor.visit_field_def(sf),
 Annotatable::Variant(v) => visitor.visit_variant(v),
+Annotatable::WherePredicate(wp) => visitor.visit_where_predicate(wp),
 Annotatable::Crate(c) => visitor.visit_crate(c),
 }
 }
@@ -128,6 +132,7 @@ impl Annotatable {
  | Annotatable::Param(..)
  | Annotatable::FieldDef(..)
  | Annotatable::Variant(..)
+ | Annotatable::WherePredicate(..)
  | Annotatable::Crate(..) => panic!("unexpected annotatable"),
 }
 }
@@ -223,6 +228,13 @@ impl Annotatable {
 }
 }
 
+pubfnexpect_where_predicate(self) -> ast::WherePredicate{
+matchself{
+Annotatable::WherePredicate(wp) => wp,
+ _ => panic!("expected where predicate"),
+}
+}
+
 pubfnexpect_crate(self) -> ast::Crate{
 matchself{
 Annotatable::Crate(krate) => krate,
@@ -446,6 +458,10 @@ pub trait MacResult {
 None
 }
 
+fnmake_where_predicates(self:Box<Self>) -> Option<SmallVec<[ast::WherePredicate;1]>>{
+None
+}
+
 fnmake_crate(self:Box<Self>) -> Option<ast::Crate>{
 // Fn-like macros cannot produce a crate.
 unreachable!()