nightly feature tracking: get rid of the per-feature bool fields

compiler/rustc_ast_lowering/src/asm.rs

@@ -49,7 +49,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  | asm::InlineAsmArch::RiscV64
  | asm::InlineAsmArch::LoongArch64
  );
- if !is_stable && !self.tcx.features().asm_experimental_arch {
+ if !is_stable && !self.tcx.features().asm_experimental_arch() {
  feature_err(
  &self.tcx.sess,
  sym::asm_experimental_arch,
@@ -65,7 +65,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  {
  self.dcx().emit_err(AttSyntaxOnlyX86 { span: sp });
  }
- if asm.options.contains(InlineAsmOptions::MAY_UNWIND) && !self.tcx.features().asm_unwind {
+ if asm.options.contains(InlineAsmOptions::MAY_UNWIND) && !self.tcx.features().asm_unwind() {
  feature_err(
  &self.tcx.sess,
  sym::asm_unwind,
@@ -237,7 +237,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  }
  }
  InlineAsmOperand::Label { block } => {
- if !self.tcx.features().asm_goto {
+ if !self.tcx.features().asm_goto() {
  feature_err(
  sess,
  sym::asm_goto,

compiler/rustc_ast_lowering/src/expr.rs

@@ -575,7 +575,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  } else {
  // Either `body.is_none()` or `is_never_pattern` here.
  if !is_never_pattern {
- if self.tcx.features().never_patterns {
+ if self.tcx.features().never_patterns() {
  // If the feature is off we already emitted the error after parsing.
  let suggestion = span.shrink_to_hi();
  self.dcx().emit_err(MatchArmWithNoBody { span, suggestion });
@@ -717,7 +717,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  outer_hir_id: HirId,
  inner_hir_id: HirId,
  ) {
- if self.tcx.features().async_fn_track_caller
+ if self.tcx.features().async_fn_track_caller()
  && let Some(attrs) = self.attrs.get(&outer_hir_id.local_id)
  && attrs.into_iter().any(|attr| attr.has_name(sym::track_caller))
  {
@@ -1572,7 +1572,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  );
  }
  Some(hir::CoroutineKind::Coroutine(_)) => {
- if !self.tcx.features().coroutines {
+ if !self.tcx.features().coroutines() {
  rustc_session::parse::feature_err(
  &self.tcx.sess,
  sym::coroutines,
@@ -1584,7 +1584,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  false
  }
  None => {
- if !self.tcx.features().coroutines {
+ if !self.tcx.features().coroutines() {
  rustc_session::parse::feature_err(
  &self.tcx.sess,
  sym::coroutines,

compiler/rustc_ast_lowering/src/item.rs

@@ -1512,7 +1512,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  continue;
  }
  let is_param = *is_param.get_or_insert_with(compute_is_param);
- if !is_param && !self.tcx.features().more_maybe_bounds {
+ if !is_param && !self.tcx.features().more_maybe_bounds() {
  self.tcx
  .sess
  .create_feature_err(
@@ -1530,7 +1530,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  let host_param_parts = if let Const::Yes(span) = constness
  // if this comes from implementing a `const` trait, we must force constness to be appended
  // to the impl item, no matter whether effects is enabled.
- && (self.tcx.features().effects || force_append_constness)
+ && (self.tcx.features().effects() || force_append_constness)
  {
  let span = self.lower_span(span);
  let param_node_id = self.next_node_id();

compiler/rustc_ast_lowering/src/lib.rs

@@ -193,7 +193,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  impl_trait_defs: Vec::new(),
  impl_trait_bounds: Vec::new(),
  allow_try_trait: [sym::try_trait_v2, sym::yeet_desugar_details].into(),
- allow_gen_future: if tcx.features().async_fn_track_caller {
+ allow_gen_future: if tcx.features().async_fn_track_caller() {
  [sym::gen_future, sym::closure_track_caller].into()
  } else {
  [sym::gen_future].into()
@@ -1035,7 +1035,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  span: data.inputs_span,
  })
  };
- if !self.tcx.features().return_type_notation
+ if !self.tcx.features().return_type_notation()
  && self.tcx.sess.is_nightly_build()
  {
  add_feature_diagnostics(
@@ -1160,7 +1160,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  ast::GenericArg::Lifetime(lt) => GenericArg::Lifetime(self.lower_lifetime(lt)),
  ast::GenericArg::Type(ty) => {
  match &ty.kind {
- TyKind::Infer if self.tcx.features().generic_arg_infer => {
+ TyKind::Infer if self.tcx.features().generic_arg_infer() => {
  return GenericArg::Infer(hir::InferArg {
  hir_id: self.lower_node_id(ty.id),
  span: self.lower_span(ty.span),
@@ -1500,7 +1500,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  // is enabled. We don't check the span of the edition, since this is done
  // on a per-opaque basis to account for nested opaques.
  let always_capture_in_scope = match origin {
- _ if self.tcx.features().lifetime_capture_rules_2024 => true,
+ _ if self.tcx.features().lifetime_capture_rules_2024() => true,
  hir::OpaqueTyOrigin::TyAlias { .. } => true,
  hir::OpaqueTyOrigin::FnReturn { in_trait_or_impl, .. } => in_trait_or_impl.is_some(),
  hir::OpaqueTyOrigin::AsyncFn { .. } => {
@@ -1519,7 +1519,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  // Feature gate for RPITIT + use<..>
  match origin {
  rustc_hir::OpaqueTyOrigin::FnReturn { in_trait_or_impl: Some(_), .. } => {
- if !self.tcx.features().precise_capturing_in_traits
+ if !self.tcx.features().precise_capturing_in_traits()
  && let Some(span) = bounds.iter().find_map(|bound| match *bound {
  ast::GenericBound::Use(_, span) => Some(span),
  _ => None,
@@ -2270,7 +2270,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  fn lower_array_length(&mut self, c: &AnonConst) -> hir::ArrayLen<'hir> {
  match c.value.kind {
  ExprKind::Underscore => {
- if self.tcx.features().generic_arg_infer {
+ if self.tcx.features().generic_arg_infer() {
  hir::ArrayLen::Infer(hir::InferArg {
  hir_id: self.lower_node_id(c.id),
  span: self.lower_span(c.value.span),
@@ -2452,7 +2452,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  (BoundConstness::Never, BoundPolarity::Positive) => hir::TraitBoundModifier::None,
  (_, BoundPolarity::Maybe(_)) => hir::TraitBoundModifier::Maybe,
  (BoundConstness::Never, BoundPolarity::Negative(_)) => {
- if self.tcx.features().negative_bounds {
+ if self.tcx.features().negative_bounds() {
  hir::TraitBoundModifier::Negative
  } else {
  hir::TraitBoundModifier::None

compiler/rustc_ast_lowering/src/path.rs

@@ -268,7 +268,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  span: data.inputs_span,
  })
  };
- if !self.tcx.features().return_type_notation
+ if !self.tcx.features().return_type_notation()
  && self.tcx.sess.is_nightly_build()
  {
  add_feature_diagnostics(
@@ -496,7 +496,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  // // disallowed --^^^^^^^^^^ allowed --^^^^^^^^^^
  // ```
  FnRetTy::Ty(ty) if matches!(itctx, ImplTraitContext::OpaqueTy { .. }) => {
- if self.tcx.features().impl_trait_in_fn_trait_return {
+ if self.tcx.features().impl_trait_in_fn_trait_return() {
  self.lower_ty(ty, itctx)
  } else {
  self.lower_ty(

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -295,7 +295,8 @@ impl<'a> AstValidator<'a> {
  return;
  };
 
- let make_impl_const_sugg = if self.features.const_trait_impl
+ let const_trait_impl = self.features.const_trait_impl();
+ let make_impl_const_sugg = if const_trait_impl
  && let TraitOrTraitImpl::TraitImpl {
  constness: Const::No,
  polarity: ImplPolarity::Positive,
@@ -308,13 +309,12 @@ impl<'a> AstValidator<'a> {
  None
  };
 
- let make_trait_const_sugg = if self.features.const_trait_impl
- && let TraitOrTraitImpl::Trait { span, constness: None } = parent
- {
- Some(span.shrink_to_lo())
- } else {
- None
- };
+ let make_trait_const_sugg =
+ if const_trait_impl && let TraitOrTraitImpl::Trait { span, constness: None } = parent {
+ Some(span.shrink_to_lo())
+ } else {
+ None
+ };
 
  let parent_constness = parent.constness();
  self.dcx().emit_err(errors::TraitFnConst {
@@ -1145,7 +1145,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
  }
  self.check_type_no_bounds(bounds, "this context");
 
- if self.features.lazy_type_alias {
+ if self.features.lazy_type_alias() {
  if let Err(err) = self.check_type_alias_where_clause_location(ty_alias) {
  self.dcx().emit_err(err);
  }
@@ -1286,7 +1286,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
  GenericBound::Trait(trait_ref) => {
  match (ctxt, trait_ref.modifiers.constness, trait_ref.modifiers.polarity) {
  (BoundKind::SuperTraits, BoundConstness::Never, BoundPolarity::Maybe(_))
- if !self.features.more_maybe_bounds =>
+ if !self.features.more_maybe_bounds() =>
  {
  self.sess
  .create_feature_err(
@@ -1299,7 +1299,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
  .emit();
  }
  (BoundKind::TraitObject, BoundConstness::Never, BoundPolarity::Maybe(_))
- if !self.features.more_maybe_bounds =>
+ if !self.features.more_maybe_bounds() =>
  {
  self.sess
  .create_feature_err(

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -15,13 +15,13 @@ use crate::errors;
 /// The common case.
 macro_rules! gate {
  ($visitor:expr, $feature:ident, $span:expr, $explain:expr) => {{
- if !$visitor.features.$feature && !$span.allows_unstable(sym::$feature) {
+ if !$visitor.features.$feature() && !$span.allows_unstable(sym::$feature) {
  #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
  feature_err(&$visitor.sess, sym::$feature, $span, $explain).emit();
  }
  }};
  ($visitor:expr, $feature:ident, $span:expr, $explain:expr, $help:expr) => {{
- if !$visitor.features.$feature && !$span.allows_unstable(sym::$feature) {
+ if !$visitor.features.$feature() && !$span.allows_unstable(sym::$feature) {
  // FIXME: make this translatable
  #[allow(rustc::diagnostic_outside_of_impl)]
  #[allow(rustc::untranslatable_diagnostic)]
@@ -43,7 +43,7 @@ macro_rules! gate_alt {
 /// The case involving a multispan.
 macro_rules! gate_multi {
  ($visitor:expr, $feature:ident, $spans:expr, $explain:expr) => {{
- if !$visitor.features.$feature {
+ if !$visitor.features.$feature() {
  let spans: Vec<_> =
  $spans.filter(|span| !span.allows_unstable(sym::$feature)).collect();
  if !spans.is_empty() {
@@ -56,7 +56,7 @@ macro_rules! gate_multi {
 /// The legacy case.
 macro_rules! gate_legacy {
  ($visitor:expr, $feature:ident, $span:expr, $explain:expr) => {{
- if !$visitor.features.$feature && !$span.allows_unstable(sym::$feature) {
+ if !$visitor.features.$feature() && !$span.allows_unstable(sym::$feature) {
  feature_warn(&$visitor.sess, sym::$feature, $span, $explain);
  }
  }};
@@ -150,7 +150,7 @@ impl<'a> PostExpansionVisitor<'a> {
 
  // FIXME(non_lifetime_binders): Const bound params are pretty broken.
  // Let's keep users from using this feature accidentally.
- if self.features.non_lifetime_binders {
+ if self.features.non_lifetime_binders() {
  let const_param_spans: Vec<_> = params
  .iter()
  .filter_map(|param| match param.kind {
@@ -210,7 +210,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
  }
 
  // Emit errors for non-staged-api crates.
- if !self.features.staged_api {
+ if !self.features.staged_api() {
  if attr.has_name(sym::unstable)
  || attr.has_name(sym::stable)
  || attr.has_name(sym::rustc_const_unstable)
@@ -470,7 +470,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
  // Limit `min_specialization` to only specializing functions.
  gate_alt!(
  &self,
- self.features.specialization || (is_fn && self.features.min_specialization),
+ self.features.specialization() || (is_fn && self.features.min_specialization()),
  sym::specialization,
  i.span,
  "specialization is unstable"
@@ -548,7 +548,7 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
  gate_all!(return_type_notation, "return type notation is experimental");
  gate_all!(pin_ergonomics, "pinned reference syntax is experimental");
 
- if !visitor.features.never_patterns {
+ if !visitor.features.never_patterns() {
  if let Some(spans) = spans.get(&sym::never_patterns) {
  for &span in spans {
  if span.allows_unstable(sym::never_patterns) {
@@ -572,7 +572,7 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
  }
  }
 
- if !visitor.features.negative_bounds {
+ if !visitor.features.negative_bounds() {
  for &span in spans.get(&sym::negative_bounds).iter().copied().flatten() {
  sess.dcx().emit_err(errors::NegativeBoundUnsupported { span });
  }

compiler/rustc_attr/src/builtin.rs

@@ -622,7 +622,7 @@ pub fn eval_condition(
  &((
  if *b { kw::True } else { kw::False },
  sym::cfg_boolean_literals,
- |features: &Features| features.cfg_boolean_literals,
+ |features: &Features| features.cfg_boolean_literals(),
  )),
  cfg.span(),
  sess,
@@ -711,7 +711,7 @@ pub fn eval_condition(
  }
  sym::target => {
  if let Some(features) = features
- && !features.cfg_target_compact
+ && !features.cfg_target_compact()
  {
  feature_err(
  sess,
@@ -831,7 +831,7 @@ pub fn find_deprecation(
  attrs: &[Attribute],
 ) -> Option<(Deprecation, Span)> {
  let mut depr: Option<(Deprecation, Span)> = None;
- let is_rustc = features.staged_api;
+ let is_rustc = features.staged_api();
 
  'outer: for attr in attrs {
  if !attr.has_name(sym::deprecated) {
@@ -891,7 +891,7 @@ pub fn find_deprecation(
  }
  }
  sym::suggestion => {
- if !features.deprecated_suggestion {
+ if !features.deprecated_suggestion() {
  sess.dcx().emit_err(
  session_diagnostics::DeprecatedItemSuggestion {
  span: mi.span,
@@ -909,7 +909,7 @@ pub fn find_deprecation(
  sess.dcx().emit_err(session_diagnostics::UnknownMetaItem {
  span: meta.span(),
  item: pprust::path_to_string(&mi.path),
- expected: if features.deprecated_suggestion {
+ expected: if features.deprecated_suggestion() {
  &["since", "note", "suggestion"]
  } else {
  &["since", "note"]

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -1035,7 +1035,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 
  fn unsized_feature_enabled(&self) -> bool {
  let features = self.tcx().features();
- features.unsized_locals || features.unsized_fn_params
+ features.unsized_locals() || features.unsized_fn_params()
  }
 
  /// Equate the inferred type and the annotated type for user type annotations

compiler/rustc_builtin_macros/src/assert.rs

@@ -69,7 +69,7 @@ pub(crate) fn expand_assert<'cx>(
  // If `generic_assert` is enabled, generates rich captured outputs
  //
  // FIXME(c410-f3r) See https://github.com/rust-lang/rust/issues/96949
- else if cx.ecfg.features.generic_assert {
+ else if cx.ecfg.features.generic_assert() {
  context::Context::new(cx, call_site_span).build(cond_expr, panic_path())
  }
  // If `generic_assert` is not enabled, only outputs a literal "assertion failed: ..."