de-macro-ize feature gate checking

Author: Centril

src/librustc/hir/lowering.rs

@@ -834,7 +834,7 @@ impl<'a> LoweringContext<'a> {
             return;
         }
 
-        if !self.sess.features_untracked().in_band_lifetimes {
+        if !self.sess.features_untracked().on(sym::in_band_lifetimes) {
             return;
         }
 
@@ -1394,7 +1394,7 @@ impl<'a> LoweringContext<'a> {
                     }
                     ImplTraitContext::Disallowed(pos) => {
                         let allowed_in = if self.sess.features_untracked()
-                                                .impl_trait_in_bindings {
+                                                .on(sym::impl_trait_in_bindings) {
                             "bindings or function and inherent method return types"
                         } else {
                             "function and inherent method return types"
@@ -2118,7 +2118,7 @@ impl<'a> LoweringContext<'a> {
 
     fn lower_local(&mut self, l: &Local) -> (hir::Local, SmallVec<[NodeId; 1]>) {
         let mut ids = SmallVec::<[NodeId; 1]>::new();
-        if self.sess.features_untracked().impl_trait_in_bindings {
+        if self.sess.features_untracked().on(sym::impl_trait_in_bindings) {
             if let Some(ref ty) = l.ty {
                 let mut visitor = ImplTraitTypeIdVisitor { ids: &mut ids };
                 visitor.visit_ty(ty);
@@ -2130,7 +2130,7 @@ impl<'a> LoweringContext<'a> {
             ty: l.ty
                 .as_ref()
                 .map(|t| self.lower_ty(t,
-                    if self.sess.features_untracked().impl_trait_in_bindings {
+                    if self.sess.features_untracked().on(sym::impl_trait_in_bindings) {
                         ImplTraitContext::OpaqueTy(Some(parent_def_id))
                     } else {
                         ImplTraitContext::Disallowed(ImplTraitPosition::Binding)

src/librustc/hir/lowering/item.rs

@@ -181,15 +181,15 @@ impl LoweringContext<'_> {
             ItemKind::Impl(.., None, _, _) => smallvec![i.id],
             ItemKind::Static(ref ty, ..) => {
                 let mut ids = smallvec![i.id];
-                if self.sess.features_untracked().impl_trait_in_bindings {
+                if self.sess.features_untracked().on(sym::impl_trait_in_bindings) {
                     let mut visitor = ImplTraitTypeIdVisitor { ids: &mut ids };
                     visitor.visit_ty(ty);
                 }
                 ids
             },
             ItemKind::Const(ref ty, ..) => {
                 let mut ids = smallvec![i.id];
-                if self.sess.features_untracked().impl_trait_in_bindings {
+                if self.sess.features_untracked().on(sym::impl_trait_in_bindings) {
                     let mut visitor = ImplTraitTypeIdVisitor { ids: &mut ids };
                     visitor.visit_ty(ty);
                 }
@@ -285,7 +285,7 @@ impl LoweringContext<'_> {
                 hir::ItemKind::Static(
                     self.lower_ty(
                         t,
-                        if self.sess.features_untracked().impl_trait_in_bindings {
+                        if self.sess.features_untracked().on(sym::impl_trait_in_bindings) {
                             ImplTraitContext::OpaqueTy(None)
                         } else {
                             ImplTraitContext::Disallowed(ImplTraitPosition::Binding)
@@ -299,7 +299,7 @@ impl LoweringContext<'_> {
                 hir::ItemKind::Const(
                     self.lower_ty(
                         t,
-                        if self.sess.features_untracked().impl_trait_in_bindings {
+                        if self.sess.features_untracked().on(sym::impl_trait_in_bindings) {
                             ImplTraitContext::OpaqueTy(None)
                         } else {
                             ImplTraitContext::Disallowed(ImplTraitPosition::Binding)

src/librustc/infer/error_reporting/need_type_info.rs

@@ -5,8 +5,8 @@ use crate::infer::InferCtxt;
 use crate::infer::type_variable::TypeVariableOriginKind;
 use crate::ty::{self, Ty, Infer, TyVar};
 use crate::ty::print::Print;
-use syntax::source_map::DesugaringKind;
-use syntax_pos::Span;
+use syntax_pos::source_map::DesugaringKind;
+use syntax_pos::{Span, symbol::sym};
 use errors::{Applicability, DiagnosticBuilder};
 
 use rustc_error_codes::*;
@@ -217,7 +217,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         let is_named_and_not_impl_trait = |ty: Ty<'_>| {
             &ty.to_string() != "_" &&
                 // FIXME: Remove this check after `impl_trait_in_bindings` is stabilized. #63527
-                (!ty.is_impl_trait() || self.tcx.features().impl_trait_in_bindings)
+                (!ty.is_impl_trait() || self.tcx.features().on(sym::impl_trait_in_bindings))
         };
 
         let ty_msg = match local_visitor.found_ty {

src/librustc/infer/opaque_types/mod.rs

@@ -13,7 +13,7 @@ use errors::DiagnosticBuilder;
 use rustc::session::config::nightly_options;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync::Lrc;
-use syntax_pos::Span;
+use syntax_pos::{Span, symbol::sym};
 
 use rustc_error_codes::*;
 
@@ -488,7 +488,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         conflict2: ty::Region<'tcx>,
     ) -> bool {
         // If we have `#![feature(member_constraints)]`, no problems.
-        if self.tcx.features().member_constraints {
+        if self.tcx.features().on(sym::member_constraints) {
             return false;
         }
 

src/librustc/lint/levels.rs

@@ -231,15 +231,13 @@ impl<'a> LintLevelsBuilder<'a> {
                             // FIXME (#55112): issue unused-attributes lint if we thereby
                             // don't have any lint names (`#[level(reason = "foo")]`)
                             if let ast::LitKind::Str(rationale, _) = name_value.kind {
-                                if !self.sess.features_untracked().lint_reasons {
-                                    feature_gate::feature_err(
-                                        &self.sess.parse_sess,
-                                        sym::lint_reasons,
-                                        item.span,
-                                        "lint reasons are experimental"
-                                    )
-                                    .emit();
-                                }
+                                feature_gate::gate_feature(
+                                    &self.sess.parse_sess,
+                                    self.sess.features_untracked(),
+                                    item.span,
+                                    sym::lint_reasons,
+                                    "lint reasons are experimental"
+                                );
                                 reason = Some(rationale);
                             } else {
                                 bad_attr(name_value.span)

src/librustc/middle/stability.rs

@@ -116,7 +116,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
                    item_sp: Span, kind: AnnotationKind, visit_children: F)
         where F: FnOnce(&mut Self)
     {
-        if self.tcx.features().staged_api {
+        if self.tcx.features().on(sym::staged_api) {
             // This crate explicitly wants staged API.
             debug!("annotate(id = {:?}, attrs = {:?})", hir_id, attrs);
             if let Some(..) = attr::find_deprecation(&self.tcx.sess.parse_sess, attrs, item_sp) {
@@ -393,7 +393,7 @@ impl<'tcx> Index<'tcx> {
     pub fn new(tcx: TyCtxt<'tcx>) -> Index<'tcx> {
         let is_staged_api =
             tcx.sess.opts.debugging_opts.force_unstable_if_unmarked ||
-            tcx.features().staged_api;
+            tcx.features().on(sym::staged_api);
         let mut staged_api = FxHashMap::default();
         staged_api.insert(LOCAL_CRATE, is_staged_api);
         let mut index = Index {
@@ -836,7 +836,7 @@ impl Visitor<'tcx> for Checker<'tcx> {
 
             // There's no good place to insert stability check for non-Copy unions,
             // so semi-randomly perform it here in stability.rs
-            hir::ItemKind::Union(..) if !self.tcx.features().untagged_unions => {
+            hir::ItemKind::Union(..) if !self.tcx.features().on(sym::untagged_unions) => {
                 let def_id = self.tcx.hir().local_def_id(item.hir_id);
                 let adt_def = self.tcx.adt_def(def_id);
                 let ty = self.tcx.type_of(def_id);

src/librustc/traits/error_reporting.rs

@@ -2353,13 +2353,13 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
             }
             ObligationCauseCode::VariableType(_) => {
                 err.note("all local variables must have a statically known size");
-                if !self.tcx.features().unsized_locals {
+                if !self.tcx.features().on(sym::unsized_locals) {
                     err.help("unsized locals are gated as an unstable feature");
                 }
             }
             ObligationCauseCode::SizedArgumentType => {
                 err.note("all function arguments must have a statically known size");
-                if !self.tcx.features().unsized_locals {
+                if !self.tcx.features().on(sym::unsized_locals) {
                     err.help("unsized locals are gated as an unstable feature");
                 }
             }

src/librustc/traits/select.rs

@@ -2215,7 +2215,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     }
 
                     if let Some(principal) = data.principal() {
-                        if !self.infcx.tcx.features().object_safe_for_dispatch {
+                        if !self.infcx.tcx.features().on(sym::object_safe_for_dispatch) {
                             principal.with_self_ty(self.tcx(), self_ty)
                         } else if self.tcx().is_object_safe(principal.def_id()) {
                             principal.with_self_ty(self.tcx(), self_ty)

src/librustc/traits/specialize/mod.rs

@@ -16,7 +16,7 @@ use crate::infer::{InferCtxt, InferOk};
 use crate::lint;
 use crate::traits::{self, coherence, FutureCompatOverlapErrorKind, ObligationCause, TraitEngine};
 use rustc_data_structures::fx::FxHashSet;
-use syntax_pos::DUMMY_SP;
+use syntax_pos::{DUMMY_SP, symbol::sym};
 use crate::traits::select::IntercrateAmbiguityCause;
 use crate::ty::{self, TyCtxt, TypeFoldable};
 use crate::ty::subst::{Subst, InternalSubsts, SubstsRef};
@@ -155,7 +155,7 @@ pub(super) fn specializes(
 
     // The feature gate should prevent introducing new specializations, but not
     // taking advantage of upstream ones.
-    if !tcx.features().specialization &&
+    if !tcx.features().on(sym::specialization) &&
         (impl1_def_id.is_local() || impl2_def_id.is_local()) {
         return false;
     }

src/librustc/ty/constness.rs

@@ -2,7 +2,7 @@ use crate::ty::query::Providers;
 use crate::hir::def_id::DefId;
 use crate::hir;
 use crate::ty::TyCtxt;
-use syntax_pos::symbol::Symbol;
+use syntax_pos::symbol::{sym, Symbol};
 use crate::hir::map::blocks::FnLikeNode;
 use syntax::attr;
 
@@ -42,7 +42,7 @@ impl<'tcx> TyCtxt<'tcx> {
             return false;
         }
 
-        if self.features().staged_api {
+        if self.features().on(sym::staged_api) {
             // in order for a libstd function to be considered min_const_fn
             // it needs to be stable and have no `rustc_const_unstable` attribute
             match self.lookup_stability(def_id) {
@@ -56,7 +56,7 @@ impl<'tcx> TyCtxt<'tcx> {
             }
         } else {
             // users enabling the `const_fn` feature gate can do what they want
-            !self.features().const_fn
+            !self.features().on(sym::const_fn)
         }
     }
 }