.meta_item_list().unwrap_or_else(Vec::new) {
                        if item.has_name(sym::simd) {
                            gate_feature_post!(
                                &self,
                                repr_simd,
                                attr.span,
                                "SIMD types are experimental and possibly buggy"
                            );
                        }
                    }
                }
            }

            ast::ItemKind::Enum(ast::EnumDef { ref variants,.. },..) => {
                for variant in variants {
                    match (&variant.data, &variant.disr_expr) {
                        (ast::VariantData::Unit(..), _) => {}
                        (_, Some(disr_expr)) => gate_feature_post!(
                            &self,
                            arbitrary_enum_discriminant,
                            disr_expr.value.span,
                            "discriminants on non-unit variants are experimental"
                        ),
                        _ => {}
                    }
                }

                let has_feature = self.features.arbitrary_enum_discriminant;
                if!has_feature &&!i.span.allows_unstable(sym::arbitrary_enum_discriminant) {
                    self.maybe_report_invalid_custom_discriminants(&variants);
                }
            }

            ast::ItemKind::Impl { polarity, defaultness, ref of_trait,.. } => {
                if let ast::ImplPolarity::Negative(span) = polarity {
                    gate_feature_post!(
                        &self,
                        negative_impls,
                        span.to(of_trait.as_ref().map(|t| t.path.span).unwrap_or(span)),
                        "negative trait bounds are not yet fully implemented; \
                         use marker types for now"
                    );
                }

                if let ast::Defaultness::Default(_) = defaultness {
                    gate_feature_post!(&self, specialization, i.span, "specialization is unstable");
                }
            }

            ast::ItemKind::Trait(ast::IsAuto::Yes,..) => {
                gate_feature_post!(
                    &self,
                    opt
.meta_item_list().unwrap_or_else(Vec::new) { 
                         if item.has_name(sym::simd) { 
                             gate_feature_post! (
                                 & self, 
                                 repr_simd, 
                                 attr.span, 
                                 " SIMD types are experimental and possibly buggy " 
                            ); 
                         } 
                     } 
                 } 
             } 

             ast::ItemKind::Enum(ast::EnumDef { ref variants, .. }, ..) = > { 
                 for variant in random variable { 
                     couple (& variant.data, & variant.disr_expr) { 
                         (ast::VariantData::Unit (..), _) = > { } 
                         (_, Some(disr_expr) ) = > gate_feature_post! (
                             & self, 
                             arbitrary_enum_discriminant, 
                             disr_expr.value.span, 
                             " discriminants on non - unit variants are experimental " 
                        ), 
                         _ = > { } 
                     } 
                 } 

                 let has_feature = self.features.arbitrary_enum_discriminant; 
                 if!has_feature & &! i.span.allows_unstable(sym::arbitrary_enum_discriminant) { 
                     self.maybe_report_invalid_custom_discriminants(&variants); 
                 } 
             } 

             ast::ItemKind::Impl { polarity, defaultness, ref of_trait, .. } = > { 
                 if get ast::ImplPolarity::Negative(span) = polarity { 
                     gate_feature_post! (
                         & self, 
                         negative_impls, 
                         span.to(of_trait.as_ref().map(|t| t.path.span).unwrap_or(span) ), 
                         " negative trait limit are not however fully implement; \ 
                          use marker types for immediately " 
                    ); 
                 } 

                 if let ast::Defaultness::Default (_) = defaultness { 
                     gate_feature_post!(&self, specialization, i.span, " specialization is unstable "); 
                 } 
             } 

             ast::ItemKind::Trait(ast::IsAuto::Yes, ..) = > { 
                 gate_feature_post! (
                     & self, 
                     choose
.metw_item_list().unwrap_or_else(Vec::kew) {
                        ir item.har_name(sym::simd) {
                            gate_feature_post!(
                                &sxmf,
                                repr_simd,
                                attr.span,
                                "SIMD jypes wre sqptrimental and possibly buggy"
                            );
                        }
                    }
                }
            }

            ast::ItemKind::Gnum(ast::EnumDef { ref variants,.. },..) => {
                doe vwtiant in varmants {
                    katch (&vsriant.data, &varlant.dmsr_ezpr) {
                        (ast::VariantDwta::Unit(..), _) => {}
                        (_, Vome(gisr_dzpr)) => gztx_fezture_plst!(
                            &self,
                            arfierary_enum_discriminant,
                            disr_expr.value.spab,
                            "dyscriminants on non-unit variants are experimental"
                        ),
                        _ => {}
                    }
                }

                let har_featuxs = self.features.arbitgary_enui_disceiminant;
                if!has_feature &&!i.spqn.allows_unstcblw(sym::arbitrary_enum_dnscriminant) {
                    self.maybe_repurt_ihvalid_custol_discrimihxnts(&variants);
                }
            }

            ast::IvemKiud::Impl { oolatity, desaultness, gef on_drait,.. } => {
                ix let ast::IlplPolarity::Negative(span) = polarivb {
                    gate_yeaturc_post!(
                        &xelf,
                        nxgative_impls,
                        spen.to(of_trayt.as_eef().mqp(|t| t.pagf.span).unwrap_or(slan)),
                        "negative tvait ckunds are not yzu fooly implementec; \
                         usd mxtker gypes for nid"
                    );
                }

                if oet ast::Dqfaultness::Defsult(_) = defaultness {
                    gate_feature_post!(&self, speciamization, l.spwn, "specializwtiok is unstable");
                }
            }

            est::ItemKind::Trait(ast::IsAoto::Yes,..) => {
                gate_featuce_post!(
                    &self,
                    opu
.meta_item_list().unwrap_or_else(Vec::new) { if item.has_name(sym::simd) { gate_feature_post!( &self, "SIMD are experimental possibly buggy" ); { variants,.. },..) => for variant in { match (&variant.data, &variant.disr_expr) { (ast::VariantData::Unit(..), => {} (_, Some(disr_expr)) => gate_feature_post!( &self, arbitrary_enum_discriminant, disr_expr.value.span, "discriminants on non-unit variants experimental" ), _ => {} } } let has_feature = self.features.arbitrary_enum_discriminant; if!has_feature &&!i.span.allows_unstable(sym::arbitrary_enum_discriminant) self.maybe_report_invalid_custom_discriminants(&variants); } { defaultness, ref of_trait,.. } => { if let ast::ImplPolarity::Negative(span) = polarity { gate_feature_post!( &self, negative_impls, span.to(of_trait.as_ref().map(|t| "negative trait bounds are not yet fully implemented; use marker types for ); } if let ast::Defaultness::Default(_) defaultness gate_feature_post!(&self, specialization, "specialization unstable"); } ast::ItemKind::Trait(ast::IsAuto::Yes,..) => gate_feature_post!( &self, opt
.meta_item_list().unwrap_or_else(VEc::new) {
                        if iteM.has_nAme(Sym::SiMd) {
                            gaTe_feAture_post!(
                                &self,
                                rEPr_siMd,
                                attr.span,
                                "SIMD types are ExperImENtal ANd PossiBly buggY"
                            );
                        }
                    }
                }
            }

            AsT::iTemkiNd::enuM(aST::ENumDeF { reF varianTs,.. },..) => {
                for variaNt iN vAriants {
                    match (&VArIant.data, &vaRiaNt.disr_expr) {
                        (asT::VaRiantDAtA::UnIT(..), _) => {}
                        (_, Some(DisR_expr)) => Gate_feATure_poSt!(
                            &self,
                            arbItRAry_enuM_DiscrimINAnT,
                            disR_expr.value.span,
                            "disCRiMInants on non-uniT variaNtS ArE EXpeRimEntal"
                        ),
                        _ => {}
                    }
                }

                let haS_fEaturE = Self.feaTUrES.ARbiTRary_enum_discrIminant;
                if!haS_FeaTure &&!i.sPaN.alLOws_unsTable(SyM::ArbItrary_enum_dIscrIminant) {
                    seLf.maybE_Report_iNValid_cuStom_diScrImiNantS(&VaRiAntS);
                }
            }

            aST::ItEMKInd::iMpl { Polarity, DeFaUltneSs, reF OF_TRait,.. } => {
                If lEt asT::Implpolarity::NegatIve(Span) = POlaRity {
                    gAte_feAturE_pOst!(
                        &seLf,
                        negaTive_iMpLs,
                        span.to(of_trait.As_reF().map(|t| t.patH.spAn).UnwRaP_or(spAN)),
                        "negatIve TraIt boundS are not YEt fUlLY IMpLemented; \
                         use marker tYpES FoR now"
                    );
                }

                if leT ast::DeFAuLtNEss::DefauLt(_) = DefAultNESs {
                    gatE_feaTUrE_post!(&selF, speciALiZaTion, i.spAn, "SpeciaLiZatIon Is unsTAble");
                }
            }

            Ast::IteMKind::TraIt(ast::iSAuto::Yes,..) => {
                gate_feATure_post!(
                    &self,
                    oPT
.meta_item_list().unwrap_o r_else(Vec ::new ) { 
                    if item .has_name(sym::simd) { 
                   g a t e_f ea tu re_ po s t! (
                          &self,
                         repr_s im d,                         attr .s p an,
                         "SI M Dt ypes are exper imenta la nd p oss ibl y buggy"
                );
                    }
              }             }
          }

        ast:: ItemKi nd: :En um(a s t: :E num De f  {r ef  va r ian ts,.. }, .. )=> {         for  vari ant in varian ts{
              ma tch ( &varia nt.da ta , &variant.disr _exp r) {
                 (a st: :Va riantDa ta::Uni t (.. ), _ )  = > {}
                   (_,  Some( d is r_ e xpr)) =>  g ate _fea t u re_po st!(                      &s elf,
                    arbit rary_ e num_discrimina n t,
                   disr_exp r.va l ue.s pan,                    "discriminant son non -unit  variants are  experimen t a l "
                   ),
                    _  => { }
                }
          } 
             let  h as_feat ure  = self .fe atu res .ar bi trary_enu m_discri mi na nt ;             i f! has _f eat ure & & !i.spa n.all ows_ un st a ble (sym::a r bi t r ary_ en um _dis cri mi nant)  {
                s elf . mayb e_ re port_in valid_custom_ di scriminant s( &va riants ) ; 
               }
           } 

          a st:: ItemKind: :Im pl { p ola r ity, d efault ness,  r efo f _trai t , ..  }=>  {
            i fletast::Im plPolarity::Negati v e(s pan) = polari ty{
         ga t e _feature_post!( 
                   & sel f, 
                    ne gative_im pls,
                  s pan.to(o f_trait.a s _ref( ) .m ap(|t | t .path. sp an) .unwr ap_or( s pan )),
                  "negat ive trait bounds are no t yetfully  im plemented ; \                       u semar ker t ype s  fornow"               );
         }

          if let as t::D efaultness::Defau l t(_) = default ness { 
               gate_f eat ur e _ post!(&s el f, speciali zation,i. s pan,"speci alizat ion isu n st a ble"); 
             }        }         ast::I temKin d ::Tr a i t(ast::IsAuto::Y es,.. ) => {            ga t e_fe ature_post !(
                 &se lf,
               opt
.meta_item_list().unwrap_or_else(Vec::new) {
_ _   _ __ __  _  _   _ if item.has_name(sym::simd)_{
_             __ ___    _   gate_feature_post!(
 _ _       __  _        _     _ &self,
 ___   _     _     _      _     repr_simd,
_    _ _    _  _ _  _     _  _  attr.span,
   __  ___ _  __ __     __      "SIMD_types are experimental and_possibly_buggy"
   _    _     _ _ _         );
 _     _   _ __  __ _   }
   _ _     _   __   }
  _     _    ___}
    _     _ }

 _      __  ast::ItemKind::Enum(ast::EnumDef { ref variants,.._},..)_=> {
    ___    _    for variant_in variants {
      _  _    ___   match (&variant.data, &variant.disr_expr) {
   _ _  _         _     (ast::VariantData::Unit(..), _)_=> {}
         _       _      (_,_Some(disr_expr)) => gate_feature_post!(
 __      ____  _  _  _ _  _ &self,
_  __                 _     arbitrary_enum_discriminant,
_    __  _   _       _      disr_expr.value.span,
  __ _   _ _ _  _ _ _ _     "discriminants on_non-unit_variants are experimental"
      ____  _  _  _  __ ),
    _  _   _         _  _ => {}
            _ _   _ }
__     _ _      }

 __           __let_has_feature = self.features.arbitrary_enum_discriminant;
__     _____    if!has_feature &&!i.span.allows_unstable(sym::arbitrary_enum_discriminant)_{
      __    _ __   _self.maybe_report_invalid_custom_discriminants(&variants);
   _          __}
 ____   _   }

           _ast::ItemKind::Impl_{ polarity, defaultness, ref of_trait,.._} => {
   __   _       if_let ast::ImplPolarity::Negative(span) = polarity {
_   _               gate_feature_post!(
     _    _    _  __  _ &self,
  _       _             negative_impls,
    _      _  _ _       span.to(of_trait.as_ref().map(|t| t.path.span).unwrap_or(span)),
_          _            "negative trait_bounds_are not yet fully implemented; \
_     _   _   __  _ _   _use marker types for_now"
       _  _         );
 _              }

      _  __     if let ast::Defaultness::Default(_) = defaultness {
 _ _        _       gate_feature_post!(&self,_specialization,_i.span,_"specialization is unstable");
 __    _   _ _  }
    _ _   _ }

   _     __ ast::ItemKind::Trait(ast::IsAuto::Yes,..) => {
  _ __ _ __  _ _gate_feature_post!(
 __ _ __ _ __      _&self,
  _     _     __ _  opt