mod.rs

mod environment;

use rustc::hir::map::definitions::DefPathData;
use rustc::hir::map::Map;
use rustc::traits::{
    Clause, Clauses, DomainGoal, FromEnv, GoalKind, PolyDomainGoal, ProgramClause,
    ProgramClauseCategory, WellFormed, WhereClause,
};
use rustc::ty::query::Providers;
use rustc::ty::subst::{InternalSubsts, Subst};
use rustc::ty::{self, List, TyCtxt};
use rustc_ast::ast;
use rustc_hir as hir;
use rustc_hir::def::DefKind;
use rustc_hir::def_id::DefId;
use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
use rustc_span::symbol::sym;

use std::iter;

crate fn provide(p: &mut Providers<'_>) {
    *p = Providers {
        program_clauses_for,
        program_clauses_for_env: environment::program_clauses_for_env,
        environment: environment::environment,
        ..*p
    };
}

crate trait Lower<T> {
    /// Lower a rustc construct (e.g., `ty::TraitPredicate`) to a chalk-like type.
    fn lower(&self) -> T;
}

impl<T, U> Lower<Vec<U>> for Vec<T>
where
    T: Lower<U>,
{
    fn lower(&self) -> Vec<U> {
        self.iter().map(|item| item.lower()).collect()
    }
}

impl<'tcx> Lower<WhereClause<'tcx>> for ty::TraitPredicate<'tcx> {
    fn lower(&self) -> WhereClause<'tcx> {
        WhereClause::Implemented(*self)
    }
}

impl<'tcx> Lower<WhereClause<'tcx>> for ty::ProjectionPredicate<'tcx> {
    fn lower(&self) -> WhereClause<'tcx> {
        WhereClause::ProjectionEq(*self)
    }
}

impl<'tcx> Lower<WhereClause<'tcx>> for ty::RegionOutlivesPredicate<'tcx> {
    fn lower(&self) -> WhereClause<'tcx> {
        WhereClause::RegionOutlives(*self)
    }
}

impl<'tcx> Lower<WhereClause<'tcx>> for ty::TypeOutlivesPredicate<'tcx> {
    fn lower(&self) -> WhereClause<'tcx> {
        WhereClause::TypeOutlives(*self)
    }
}

impl<'tcx, T> Lower<DomainGoal<'tcx>> for T
where
    T: Lower<WhereClause<'tcx>>,
{
    fn lower(&self) -> DomainGoal<'tcx> {
        DomainGoal::Holds(self.lower())
    }
}

/// `ty::Binder` is used for wrapping a rustc construction possibly containing generic
/// lifetimes, e.g., `for<'a> T: Fn(&'a i32)`. Instead of representing higher-ranked things
/// in that leaf-form (i.e., `Holds(Implemented(Binder<TraitPredicate>))` in the previous
/// example), we model them with quantified domain goals, e.g., as for the previous example:
/// `forall<'a> { T: Fn(&'a i32) }` which corresponds to something like
/// `Binder<Holds(Implemented(TraitPredicate))>`.
impl<'tcx, T> Lower<PolyDomainGoal<'tcx>> for ty::Binder<T>
where
    T: Lower<DomainGoal<'tcx>> + ty::fold::TypeFoldable<'tcx>,
{
    fn lower(&self) -> PolyDomainGoal<'tcx> {
        self.map_bound_ref(|p| p.lower())
    }
}

impl<'tcx> Lower<PolyDomainGoal<'tcx>> for ty::Predicate<'tcx> {
    fn lower(&self) -> PolyDomainGoal<'tcx> {
        use rustc::ty::Predicate;

        match self {
            Predicate::Trait(predicate, _) => predicate.lower(),
            Predicate::RegionOutlives(predicate) => predicate.lower(),
            Predicate::TypeOutlives(predicate) => predicate.lower(),
            Predicate::Projection(predicate) => predicate.lower(),

            Predicate::WellFormed(..)
            | Predicate::ObjectSafe(..)
            | Predicate::ClosureKind(..)
            | Predicate::Subtype(..)
            | Predicate::ConstEvaluatable(..) => bug!("unexpected predicate {}", self),
        }
    }
}

/// Used for implied bounds related rules (see rustc guide).
trait IntoFromEnvGoal {
    /// Transforms an existing goal into a `FromEnv` goal.
    fn into_from_env_goal(self) -> Self;
}

/// Used for well-formedness related rules (see rustc guide).
trait IntoWellFormedGoal {
    /// Transforms an existing goal into a `WellFormed` goal.
    fn into_well_formed_goal(self) -> Self;
}

impl<'tcx> IntoFromEnvGoal for DomainGoal<'tcx> {
    fn into_from_env_goal(self) -> DomainGoal<'tcx> {
        use self::WhereClause::*;

        match self {
            DomainGoal::Holds(Implemented(trait_ref)) => {
                DomainGoal::FromEnv(FromEnv::Trait(trait_ref))
            }
            other => other,
        }
    }
}

impl<'tcx> IntoWellFormedGoal for DomainGoal<'tcx> {
    fn into_well_formed_goal(self) -> DomainGoal<'tcx> {
        use self::WhereClause::*;

        match self {
            DomainGoal::Holds(Implemented(trait_ref)) => {
                DomainGoal::WellFormed(WellFormed::Trait(trait_ref))
            }
            other => other,
        }
    }
}

crate fn program_clauses_for(tcx: TyCtxt<'_>, def_id: DefId) -> Clauses<'_> {
    // FIXME(eddyb) this should only be using `def_kind`.
    match tcx.def_key(def_id).disambiguated_data.data {
        DefPathData::TypeNs(..) => match tcx.def_kind(def_id) {
            Some(DefKind::Trait) | Some(DefKind::TraitAlias) => {
                program_clauses_for_trait(tcx, def_id)
            }
            // FIXME(eddyb) deduplicate this `associated_item` call with
            // `program_clauses_for_associated_type_{value,def}`.
            Some(DefKind::AssocTy) => match tcx.associated_item(def_id).container {
                ty::AssocItemContainer::ImplContainer(_) => {
                    program_clauses_for_associated_type_value(tcx, def_id)
                }
                ty::AssocItemContainer::TraitContainer(_) => {
                    program_clauses_for_associated_type_def(tcx, def_id)
                }
            },
            Some(DefKind::Struct)
            | Some(DefKind::Enum)
            | Some(DefKind::TyAlias)
            | Some(DefKind::Union)
            | Some(DefKind::OpaqueTy) => program_clauses_for_type_def(tcx, def_id),
            _ => List::empty(),
        },
        DefPathData::Impl => program_clauses_for_impl(tcx, def_id),
        _ => List::empty(),
    }
}

fn program_clauses_for_trait(tcx: TyCtxt<'_>, def_id: DefId) -> Clauses<'_> {
    // `trait Trait<P1..Pn> where WC { .. } // P0 == Self`

    // Rule Implemented-From-Env (see rustc guide)
    //
    // ```
    // forall<Self, P1..Pn> {
    //   Implemented(Self: Trait<P1..Pn>) :- FromEnv(Self: Trait<P1..Pn>)
    // }
    // ```

    let bound_vars = InternalSubsts::bound_vars_for_item(tcx, def_id);

    // `Self: Trait<P1..Pn>`
    let trait_pred = ty::TraitPredicate { trait_ref: ty::TraitRef { def_id, substs: bound_vars } };

    // `Implemented(Self: Trait<P1..Pn>)`
    let impl_trait: DomainGoal<'_> = trait_pred.lower();

    // `FromEnv(Self: Trait<P1..Pn>)`
    let from_env_goal = tcx.mk_goal(impl_trait.into_from_env_goal().into_goal());
    let hypotheses = tcx.intern_goals(&[from_env_goal]);

    // `Implemented(Self: Trait<P1..Pn>) :- FromEnv(Self: Trait<P1..Pn>)`
    let implemented_from_env = ProgramClause {
        goal: impl_trait,
        hypotheses,
        category: ProgramClauseCategory::ImpliedBound,
    };

    let implemented_from_env = Clause::ForAll(ty::Binder::bind(implemented_from_env));

    let predicates = tcx.predicates_defined_on(def_id).predicates;

    // Warning: these where clauses are not substituted for bound vars yet,
    // so that we don't need to adjust binders in the `FromEnv` rules below
    // (see the FIXME).
    let where_clauses = &predicates.iter().map(|(wc, _)| wc.lower()).collect::<Vec<_>>();

    // Rule Implied-Bound-From-Trait
    //
    // For each where clause WC:
    // ```
    // forall<Self, P1..Pn> {
    //   FromEnv(WC) :- FromEnv(Self: Trait<P1..Pn)
    // }
    // ```

    // `FromEnv(WC) :- FromEnv(Self: Trait<P1..Pn>)`, for each where clause WC
    let implied_bound_clauses = where_clauses
        .iter()
        .cloned()
        // `FromEnv(WC) :- FromEnv(Self: Trait<P1..Pn>)`
        .map(|wc| {
            // we move binders to the left
            wc.map_bound(|goal| ProgramClause {
                // FIXME: As where clauses can only bind lifetimes for now, and that named
                // bound regions have a def-id, it is safe to just inject `bound_vars` and
                // `hypotheses` (which contain named vars bound at index `0`) into this
                // binding level. This may change if we ever allow where clauses to bind
                // types (e.g. for GATs things), because bound types only use a `BoundVar`
                // index (no def-id).
                goal: goal.subst(tcx, bound_vars).into_from_env_goal(),
                hypotheses,

                category: ProgramClauseCategory::ImpliedBound,
            })
        })
        .map(Clause::ForAll);

    // Rule WellFormed-TraitRef
    //
    // Here `WC` denotes the set of all where clauses:
    // ```
    // forall<Self, P1..Pn> {
    //   WellFormed(Self: Trait<P1..Pn>) :- Implemented(Self: Trait<P1..Pn>) && WellFormed(WC)
    // }
    // ```

    // `WellFormed(WC)`
    let wf_conditions = where_clauses
        .iter()
        .map(|wc| wc.subst(tcx, bound_vars))
        .map(|wc| wc.map_bound(|goal| goal.into_well_formed_goal()));

    // `WellFormed(Self: Trait<P1..Pn>) :- Implemented(Self: Trait<P1..Pn>) && WellFormed(WC)`
    let wf_clause = ProgramClause {
        goal: DomainGoal::WellFormed(WellFormed::Trait(trait_pred)),
        hypotheses: tcx.mk_goals(
            iter::once(tcx.mk_goal(GoalKind::DomainGoal(impl_trait))).chain(
                wf_conditions.map(|wc| tcx.mk_goal(GoalKind::from_poly_domain_goal(wc, tcx))),
            ),
        ),
        category: ProgramClauseCategory::WellFormed,
    };
    let wf_clause = Clause::ForAll(ty::Binder::bind(wf_clause));

    tcx.mk_clauses(
        iter::once(implemented_from_env).chain(implied_bound_clauses).chain(iter::once(wf_clause)),
    )
}

fn program_clauses_for_impl(tcx: TyCtxt<'tcx>, def_id: DefId) -> Clauses<'tcx> {
    if let ty::ImplPolarity::Negative = tcx.impl_polarity(def_id) {
        return List::empty();
    }

    // Rule Implemented-From-Impl (see rustc guide)
    //
    // `impl<P0..Pn> Trait<A1..An> for A0 where WC { .. }`
    //
    // ```
    // forall<P0..Pn> {
    //   Implemented(A0: Trait<A1..An>) :- WC
    // }
    // ```

    let bound_vars = InternalSubsts::bound_vars_for_item(tcx, def_id);

    let trait_ref = tcx.impl_trait_ref(def_id).expect("not an impl").subst(tcx, bound_vars);

    // `Implemented(A0: Trait<A1..An>)`
    let trait_pred = ty::TraitPredicate { trait_ref }.lower();

    // `WC`
    let predicates = tcx.predicates_of(def_id).predicates;
    let where_clauses =
        predicates.iter().map(|(wc, _)| wc.lower()).map(|wc| wc.subst(tcx, bound_vars));

    // `Implemented(A0: Trait<A1..An>) :- WC`
    let clause = ProgramClause {
        goal: trait_pred,
        hypotheses: tcx.mk_goals(
            where_clauses.map(|wc| tcx.mk_goal(GoalKind::from_poly_domain_goal(wc, tcx))),
        ),
        category: ProgramClauseCategory::Other,
    };
    tcx.mk_clauses(iter::once(Clause::ForAll(ty::Binder::bind(clause))))
}

pub fn program_clauses_for_type_def(tcx: TyCtxt<'_>, def_id: DefId) -> Clauses<'_> {
    // Rule WellFormed-Type
    //
    // `struct Ty<P1..Pn> where WC1, ..., WCm`
    //
    // ```
    // forall<P1..Pn> {
    //   WellFormed(Ty<...>) :- WellFormed(WC1), ..., WellFormed(WCm)`
    // }
    // ```

    let bound_vars = InternalSubsts::bound_vars_for_item(tcx, def_id);

    // `Ty<...>`
    let ty = tcx.type_of(def_id).subst(tcx, bound_vars);

    // Warning: these where clauses are not substituted for bound vars yet,
    // so that we don't need to adjust binders in the `FromEnv` rules below
    // (see the FIXME).
    let where_clauses =
        tcx.predicates_of(def_id).predicates.iter().map(|(wc, _)| wc.lower()).collect::<Vec<_>>();

    // `WellFormed(Ty<...>) :- WellFormed(WC1), ..., WellFormed(WCm)`
    let well_formed_clause = ProgramClause {
        goal: DomainGoal::WellFormed(WellFormed::Ty(ty)),
        hypotheses: tcx.mk_goals(
            where_clauses
                .iter()
                .map(|wc| wc.subst(tcx, bound_vars))
                .map(|wc| wc.map_bound(|bound| bound.into_well_formed_goal()))
                .map(|wc| tcx.mk_goal(GoalKind::from_poly_domain_goal(wc, tcx))),
        ),
        category: ProgramClauseCategory::WellFormed,
    };
    let well_formed_clause = Clause::ForAll(ty::Binder::bind(well_formed_clause));

    // Rule Implied-Bound-From-Type
    //
    // For each where clause `WC`:
    // ```
    // forall<P1..Pn> {
    //   FromEnv(WC) :- FromEnv(Ty<...>)
    // }
    // ```

    // `FromEnv(Ty<...>)`
    let from_env_goal = tcx.mk_goal(DomainGoal::FromEnv(FromEnv::Ty(ty)).into_goal());
    let hypotheses = tcx.intern_goals(&[from_env_goal]);

    // For each where clause `WC`:
    let from_env_clauses = where_clauses
        .into_iter()
        // `FromEnv(WC) :- FromEnv(Ty<...>)`
        .map(|wc| {
            // move the binders to the left
            wc.map_bound(|goal| ProgramClause {
                // FIXME: we inject `bound_vars` and `hypotheses` into this binding
                // level, which may be incorrect in the future: see the FIXME in
                // `program_clauses_for_trait`.
                goal: goal.subst(tcx, bound_vars).into_from_env_goal(),
                hypotheses,

                category: ProgramClauseCategory::ImpliedBound,
            })
        })
        .map(Clause::ForAll);

    tcx.mk_clauses(iter::once(well_formed_clause).chain(from_env_clauses))
}

pub fn program_clauses_for_associated_type_def(tcx: TyCtxt<'_>, item_id: DefId) -> Clauses<'_> {
    // Rule ProjectionEq-Placeholder
    //
    // ```
    // trait Trait<P1..Pn> {
    //     type AssocType<Pn+1..Pm>;
    // }
    // ```
    //
    // `ProjectionEq` can succeed by skolemizing, see "associated type"
    // chapter for more:
    // ```
    // forall<Self, P1..Pn, Pn+1..Pm> {
    //     ProjectionEq(
    //         <Self as Trait<P1..Pn>>::AssocType<Pn+1..Pm> =
    //         (Trait::AssocType)<Self, P1..Pn, Pn+1..Pm>
    //     )
    // }
    // ```

    let item = tcx.associated_item(item_id);
    debug_assert_eq!(item.kind, ty::AssocKind::Type);
    let trait_id = match item.container {
        ty::AssocItemContainer::TraitContainer(trait_id) => trait_id,
        _ => bug!("not an trait container"),
    };

    let trait_bound_vars = InternalSubsts::bound_vars_for_item(tcx, trait_id);
    let trait_ref = ty::TraitRef { def_id: trait_id, substs: trait_bound_vars };

    let projection_ty = ty::ProjectionTy::from_ref_and_name(tcx, trait_ref, item.ident);
    let placeholder_ty = tcx.mk_ty(ty::UnnormalizedProjection(projection_ty));
    let projection_eq =
        WhereClause::ProjectionEq(ty::ProjectionPredicate { projection_ty, ty: placeholder_ty });

    let projection_eq_clause = ProgramClause {
        goal: DomainGoal::Holds(projection_eq),
        hypotheses: ty::List::empty(),
        category: ProgramClauseCategory::Other,
    };
    let projection_eq_clause = Clause::ForAll(ty::Binder::bind(projection_eq_clause));

    // Rule WellFormed-AssocTy
    // ```
    // forall<Self, P1..Pn, Pn+1..Pm> {
    //     WellFormed((Trait::AssocType)<Self, P1..Pn, Pn+1..Pm>)
    //         :- WellFormed(Self: Trait<P1..Pn>)
    // }
    // ```

    let trait_predicate = ty::TraitPredicate { trait_ref };
    let hypothesis =
        tcx.mk_goal(DomainGoal::WellFormed(WellFormed::Trait(trait_predicate)).into_goal());

    let wf_clause = ProgramClause {
        goal: DomainGoal::WellFormed(WellFormed::Ty(placeholder_ty)),
        hypotheses: tcx.mk_goals(iter::once(hypothesis)),
        category: ProgramClauseCategory::WellFormed,
    };
    let wf_clause = Clause::ForAll(ty::Binder::bind(wf_clause));

    // Rule Implied-Trait-From-AssocTy
    // ```
    // forall<Self, P1..Pn, Pn+1..Pm> {
    //     FromEnv(Self: Trait<P1..Pn>)
    //         :- FromEnv((Trait::AssocType)<Self, P1..Pn, Pn+1..Pm>)
    // }
    // ```

    let hypothesis = tcx.mk_goal(DomainGoal::FromEnv(FromEnv::Ty(placeholder_ty)).into_goal());

    let from_env_clause = ProgramClause {
        goal: DomainGoal::FromEnv(FromEnv::Trait(trait_predicate)),
        hypotheses: tcx.mk_goals(iter::once(hypothesis)),
        category: ProgramClauseCategory::ImpliedBound,
    };
    let from_env_clause = Clause::ForAll(ty::Binder::bind(from_env_clause));

    // Rule ProjectionEq-Normalize
    //
    // ProjectionEq can succeed by normalizing:
    // ```
    // forall<Self, P1..Pn, Pn+1..Pm, U> {
    //   ProjectionEq(<Self as Trait<P1..Pn>>::AssocType<Pn+1..Pm> = U) :-
    //       Normalize(<Self as Trait<P1..Pn>>::AssocType<Pn+1..Pm> -> U)
    // }
    // ```

    let offset = tcx.generics_of(trait_id).params.iter().map(|p| p.index).max().unwrap_or(0);
    // Add a new type param after the existing ones (`U` in the comment above).
    let ty_var = ty::Bound(ty::INNERMOST, ty::BoundVar::from_u32(offset + 1).into());

    // `ProjectionEq(<Self as Trait<P1..Pn>>::AssocType<Pn+1..Pm> = U)`
    let projection = ty::ProjectionPredicate { projection_ty, ty: tcx.mk_ty(ty_var) };

    // `Normalize(<A0 as Trait<A1..An>>::AssocType<Pn+1..Pm> -> U)`
    let hypothesis = tcx.mk_goal(DomainGoal::Normalize(projection).into_goal());

    //  ProjectionEq(<Self as Trait<P1..Pn>>::AssocType<Pn+1..Pm> = U) :-
    //      Normalize(<Self as Trait<P1..Pn>>::AssocType<Pn+1..Pm> -> U)
    let normalize_clause = ProgramClause {
        goal: DomainGoal::Holds(WhereClause::ProjectionEq(projection)),
        hypotheses: tcx.mk_goals(iter::once(hypothesis)),
        category: ProgramClauseCategory::Other,
    };
    let normalize_clause = Clause::ForAll(ty::Binder::bind(normalize_clause));

    let clauses = iter::once(projection_eq_clause)
        .chain(iter::once(wf_clause))
        .chain(iter::once(from_env_clause))
        .chain(iter::once(normalize_clause));

    tcx.mk_clauses(clauses)
}

pub fn program_clauses_for_associated_type_value(tcx: TyCtxt<'_>, item_id: DefId) -> Clauses<'_> {
    // Rule Normalize-From-Impl (see rustc guide)
    //
    // ```
    // impl<P0..Pn> Trait<A1..An> for A0 {
    //     type AssocType<Pn+1..Pm> = T;
    // }
    // ```
    //
    // FIXME: For the moment, we don't account for where clauses written on the associated
    // ty definition (i.e., in the trait def, as in `type AssocType<T> where T: Sized`).
    // ```
    // forall<P0..Pm> {
    //   forall<Pn+1..Pm> {
    //     Normalize(<A0 as Trait<A1..An>>::AssocType<Pn+1..Pm> -> T) :-
    //       Implemented(A0: Trait<A1..An>)
    //   }
    // }
    // ```

    let item = tcx.associated_item(item_id);
    debug_assert_eq!(item.kind, ty::AssocKind::Type);
    let impl_id = match item.container {
        ty::AssocItemContainer::ImplContainer(impl_id) => impl_id,
        _ => bug!("not an impl container"),
    };

    let impl_bound_vars = InternalSubsts::bound_vars_for_item(tcx, impl_id);

    // `A0 as Trait<A1..An>`
    let trait_ref = tcx.impl_trait_ref(impl_id).unwrap().subst(tcx, impl_bound_vars);

    // `T`
    let ty = tcx.type_of(item_id);

    // `Implemented(A0: Trait<A1..An>)`
    let trait_implemented: DomainGoal<'_> = ty::TraitPredicate { trait_ref }.lower();

    // `<A0 as Trait<A1..An>>::AssocType<Pn+1..Pm>`
    let projection_ty = ty::ProjectionTy::from_ref_and_name(tcx, trait_ref, item.ident);

    // `Normalize(<A0 as Trait<A1..An>>::AssocType<Pn+1..Pm> -> T)`
    let normalize_goal = DomainGoal::Normalize(ty::ProjectionPredicate { projection_ty, ty });

    // `Normalize(... -> T) :- ...`
    let normalize_clause = ProgramClause {
        goal: normalize_goal,
        hypotheses: tcx.mk_goals(iter::once(tcx.mk_goal(GoalKind::DomainGoal(trait_implemented)))),
        category: ProgramClauseCategory::Other,
    };
    let normalize_clause = Clause::ForAll(ty::Binder::bind(normalize_clause));

    tcx.mk_clauses(iter::once(normalize_clause))
}

pub fn dump_program_clauses(tcx: TyCtxt<'_>) {
    if !tcx.features().rustc_attrs {
        return;
    }

    let mut visitor = ClauseDumper { tcx };
    tcx.hir().krate().visit_all_item_likes(&mut visitor.as_deep_visitor());
}

struct ClauseDumper<'tcx> {
    tcx: TyCtxt<'tcx>,
}

impl ClauseDumper<'tcx> {
    fn process_attrs(&mut self, hir_id: hir::HirId, attrs: &[ast::Attribute]) {
        let def_id = self.tcx.hir().local_def_id(hir_id);
        for attr in attrs {
            let mut clauses = None;

            if attr.check_name(sym::rustc_dump_program_clauses) {
                clauses = Some(self.tcx.program_clauses_for(def_id));
            }

            if attr.check_name(sym::rustc_dump_env_program_clauses) {
                let environment = self.tcx.environment(def_id);
                clauses = Some(self.tcx.program_clauses_for_env(environment));
            }

            if let Some(clauses) = clauses {
                let mut err = self.tcx.sess.struct_span_err(attr.span, "program clause dump");

                let mut strings: Vec<_> = clauses.iter().map(|clause| clause.to_string()).collect();

                strings.sort();

                for string in strings {
                    err.note(&string);
                }

                err.emit();
            }
        }
    }
}

impl Visitor<'tcx> for ClauseDumper<'tcx> {
    type Map = Map<'tcx>;

    fn nested_visit_map(&mut self) -> NestedVisitorMap<'_, Self::Map> {
        NestedVisitorMap::OnlyBodies(&self.tcx.hir())
    }

    fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) {
        self.process_attrs(item.hir_id, &item.attrs);
        intravisit::walk_item(self, item);
    }

    fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem<'tcx>) {
        self.process_attrs(trait_item.hir_id, &trait_item.attrs);
        intravisit::walk_trait_item(self, trait_item);
    }

    fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) {
        self.process_attrs(impl_item.hir_id, &impl_item.attrs);
        intravisit::walk_impl_item(self, impl_item);
    }

    fn visit_struct_field(&mut self, s: &'tcx hir::StructField<'tcx>) {
        self.process_attrs(s.hir_id, &s.attrs);
        intravisit::walk_struct_field(self, s);
    }
}