Auto merge of #66945 - Centril:de-macro-gating, r=<try>

de-macro-ize feature gate checking

This PR removes the usage of macros in feature gating preferring to take in symbols instead. The aim is to make feature gating more understandable overall while also reducing some duplication.

To check whether a feature gate is active, `tcx.features().on(sym::my_feature)` can be used.
Inside `PostExpansionVisitor` it's however better to use `self.gate(...)` which provides a nicer API atop of that. Outside of the visitor, if `gate_feature` can be used, it should be preferred over `feature_err`.

As a follow-up, and once #66878 is merged, it might be a good idea to add a method to `Session` for more convenient access to `gate_feature` and `feature_err` respectively.

Originally I intended to go for a `HashSet` representation, but this felt like a smaller change to just expand to a `match` on the symbol => field pairs.

r? @oli-obk

Author: bors

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)
         }
     }
 }