rust-lang · bors · Jul 19, 2023 · Jul 13, 2023 · Jul 15, 2023 · Jul 15, 2023
diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs
@@ -335,6 335,10 @@ pub fn from_fn_attrs<'ll, 'tcx>(
  to_add.extend(probestack_attr(cx));
  to_add.extend(stackprotector_attr(cx));
 
  if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::NO_BUILTINS) {
  to_add.push(llvm::CreateAttrString(cx.llcx, "no-builtins"));
  }
 
  if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::COLD) {
  to_add.push(AttributeKind::Cold.create_attr(cx.llcx));
  }

diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -1,4 1,4 @@
-use rustc_ast::{ast, MetaItemKind, NestedMetaItem};
 use rustc_ast::{ast, attr, MetaItemKind, NestedMetaItem};
 use rustc_attr::{list_contains_name, InlineAttr, InstructionSetAttr, OptimizeAttr};
 use rustc_errors::struct_span_err;
 use rustc_hir as hir;
@@ -60,6 60,14 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
  codegen_fn_attrs.flags |= CodegenFnAttrFlags::TRACK_CALLER;
  }
 
  // When `no_builtins` is applied at the crate level, we should add the
  // `no-builtins` attribute to each function to ensure it takes effect in LTO.
  let crate_attrs = tcx.hir().attrs(rustc_hir::CRATE_HIR_ID);
  let no_builtins = attr::contains_name(crate_attrs, sym::no_builtins);
  if no_builtins {
  codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_BUILTINS;
  }
 
  let supported_target_features = tcx.supported_target_features(LOCAL_CRATE);
 
  let mut inline_span = None;

diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -1200,7 1200,7 @@ fn check_matcher_core<'tt>(
  err.span_label(sp, format!("not allowed after `{}` fragments", kind));
 
  if kind == NonterminalKind::PatWithOr
- && sess.edition.rust_2021()
  && sess.edition.at_least_rust_2021()
  && next_token.is_token(&BinOp(token::BinOpToken::Or))
  {
  let suggestion = quoted_tt_to_string(&TokenTree::MetaVarDecl(

diff --git a/compiler/rustc_hir_analysis/src/astconv/lint.rs b/compiler/rustc_hir_analysis/src/astconv/lint.rs
@@ -86,7 86,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> 'o {
  ));
  }
 
- if self_ty.span.edition().rust_2021() {
  if self_ty.span.edition().at_least_rust_2021() {
  let msg = "trait objects must include the `dyn` keyword";
  let label = "add `dyn` keyword before this trait";
  let mut diag =

diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -860,7 860,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  .resolve_fully_qualified_call(span, item_name, ty.normalized, qself.span, hir_id)
  .and_then(|r| {
  // lint bare trait if the method is found in the trait
- if span.edition().rust_2021() && let Some(mut diag) = self.tcx.sess.diagnostic().steal_diagnostic(qself.span, StashKey::TraitMissingMethod) {
  if span.edition().at_least_rust_2021() && let Some(mut diag) = self.tcx.sess.diagnostic().steal_diagnostic(qself.span, StashKey::TraitMissingMethod) {
  diag.emit();
  }
  Ok(r)
@@ -890,7 890,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  }
 
  // emit or cancel the diagnostic for bare traits
- if span.edition().rust_2021() && let Some(mut diag) = self.tcx.sess.diagnostic().steal_diagnostic(qself.span, StashKey::TraitMissingMethod) {
  if span.edition().at_least_rust_2021() && let Some(mut diag) = self.tcx.sess.diagnostic().steal_diagnostic(qself.span, StashKey::TraitMissingMethod) {
  if trait_missing_method {
  // cancel the diag for bare traits when meeting `MyTrait::missing_method`
  diag.cancel();
@@ -908,7 908,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  error,
  None,
  Expectation::NoExpectation,
- trait_missing_method && span.edition().rust_2021(), // emits missing method for trait only after edition 2021
  trait_missing_method && span.edition().at_least_rust_2021(), // emits missing method for trait only after edition 2021
  ) {
  e.emit();
  }

diff --git a/compiler/rustc_hir_typeck/src/method/prelude2021.rs b/compiler/rustc_hir_typeck/src/method/prelude2021.rs
@@ -32,7 32,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  );
 
  // Rust 2021 and later is already using the new prelude
- if span.rust_2021() {
  if span.at_least_rust_2021() {
  return;
  }
 
@@ -203,7 203,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  pick: &Pick<'tcx>,
  ) {
  // Rust 2021 and later is already using the new prelude
- if span.rust_2021() {
  if span.at_least_rust_2021() {
  return;
  }
 

diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -437,7 437,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  // this case used to be allowed by the compiler,
  // so we do a future-compat lint here for the 2015 edition
  // (see https://github.com/rust-lang/rust/issues/46906)
- if self.tcx.sess.rust_2018() {
  if self.tcx.sess.at_least_rust_2018() {
  self.tcx.sess.emit_err(MethodCallOnUnknownRawPointee { span });
  } else {
  self.tcx.struct_span_lint_hir(
@@ -1592,7 1592,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
  if let Some(method_name) = self.method_name {
  // Some trait methods are excluded for arrays before 2021.
  // (`array.into_iter()` wants a slice iterator for compatibility.)
- if self_ty.is_array() && !method_name.span.rust_2021() {
  if self_ty.is_array() && !method_name.span.at_least_rust_2021() {
  let trait_def = self.tcx.trait_def(trait_ref.def_id);
  if trait_def.skip_array_during_method_dispatch {
  return ProbeResult::NoMatch;

diff --git a/compiler/rustc_hir_typeck/src/upvar.rs b/compiler/rustc_hir_typeck/src/upvar.rs
@@ -2001,7 2001,7 @@ fn should_do_rust_2021_incompatible_closure_captures_analysis(
  tcx: TyCtxt<'_>,
  closure_id: hir::HirId,
 ) -> bool {
- if tcx.sess.rust_2021() {
  if tcx.sess.at_least_rust_2021() {
  return false;
  }
 
@@ -2247,5 2247,5 @@ fn truncate_capture_for_optimization(
 fn enable_precise_capture(span: Span) -> bool {
  // We use span here to ensure that if the closure was generated by a macro with a different
  // edition.
- span.rust_2021()
  span.at_least_rust_2021()
 }
diff --git a/compiler/rustc_metadata/src/foreign_modules.rs b/compiler/rustc_metadata/src/foreign_modules.rs
@@ -1,19 1,28 @@
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
 use rustc_middle::query::LocalCrate;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::cstore::ForeignModule;
 
-pub(crate) fn collect(tcx: TyCtxt<'_>) -> Vec<ForeignModule> {
- let mut modules = Vec::new();
 pub(crate) fn collect(tcx: TyCtxt<'_>, LocalCrate: LocalCrate) -> FxIndexMap<DefId, ForeignModule> {
  let mut modules = FxIndexMap::default();
 
  // We need to collect all the `ForeignMod`, even if they are empty.
  for id in tcx.hir().items() {
  if !matches!(tcx.def_kind(id.owner_id), DefKind::ForeignMod) {
  continue;
  }
 
  let def_id = id.owner_id.to_def_id();
  let item = tcx.hir().item(id);
- if let hir::ItemKind::ForeignMod { items, .. } = item.kind {
 
  if let hir::ItemKind::ForeignMod { abi, items } = item.kind {
  let foreign_items = items.iter().map(|it| it.id.owner_id.to_def_id()).collect();
- modules.push(ForeignModule { foreign_items, def_id: id.owner_id.to_def_id() });
  modules.insert(def_id, ForeignModule { def_id, abi, foreign_items });
  }
  }
 
  modules
 }
diff --git a/compiler/rustc_metadata/src/native_libs.rs b/compiler/rustc_metadata/src/native_libs.rs
@@ -1,15 1,17 @@
 use rustc_ast::{NestedMetaItem, CRATE_NODE_ID};
 use rustc_attr as attr;
 use rustc_data_structures::fx::FxHashSet;
-use rustc_hir as hir;
-use rustc_hir::def::DefKind;
 use rustc_middle::query::LocalCrate;
 use rustc_middle::ty::{List, ParamEnv, ParamEnvAnd, Ty, TyCtxt};
 use rustc_session::config::CrateType;
-use rustc_session::cstore::{DllCallingConvention, DllImport, NativeLib, PeImportNameType};
 use rustc_session::cstore::{
  DllCallingConvention, DllImport, ForeignModule, NativeLib, PeImportNameType,
 };
 use rustc_session::parse::feature_err;
 use rustc_session::search_paths::PathKind;
 use rustc_session::utils::NativeLibKind;
 use rustc_session::Session;
 use rustc_span::def_id::{DefId, LOCAL_CRATE};
 use rustc_span::symbol::{sym, Symbol};
 use rustc_target::spec::abi::Abi;
 
@@ -66,10 68,12 @@ fn find_bundled_library(
  None
 }
 
-pub(crate) fn collect(tcx: TyCtxt<'_>) -> Vec<NativeLib> {
 pub(crate) fn collect(tcx: TyCtxt<'_>, LocalCrate: LocalCrate) -> Vec<NativeLib> {
  let mut collector = Collector { tcx, libs: Vec::new() };
- for id in tcx.hir().items() {
- collector.process_item(id);
  if tcx.sess.opts.unstable_opts.link_directives {
  for module in tcx.foreign_modules(LOCAL_CRATE).values() {
  collector.process_module(module);
  }
  }
  collector.process_command_line();
  collector.libs
@@ -88,29 92,20 @@ struct Collector<'tcx> {
 }
 
 impl<'tcx> Collector<'tcx> {
- fn process_item(&mut self, id: rustc_hir::ItemId) {
- if !matches!(self.tcx.def_kind(id.owner_id), DefKind::ForeignMod) {
- return;
- }
  fn process_module(&mut self, module: &ForeignModule) {
  let ForeignModule { def_id, abi, ref foreign_items } = *module;
  let def_id = def_id.expect_local();
 
- let it = self.tcx.hir().item(id);
- let hir::ItemKind::ForeignMod { abi, items: foreign_mod_items } = it.kind else {
- return;
- };
  let sess = self.tcx.sess;
 
  if matches!(abi, Abi::Rust | Abi::RustIntrinsic | Abi::PlatformIntrinsic) {
  return;
  }
 
  // Process all of the #[link(..)]-style arguments
- let sess = self.tcx.sess;
  let features = self.tcx.features();
 
- if !sess.opts.unstable_opts.link_directives {
- return;
- }
-
- for m in self.tcx.hir().attrs(it.hir_id()).iter().filter(|a| a.has_name(sym::link)) {
  for m in self.tcx.get_attrs(def_id, sym::link) {
  let Some(items) = m.meta_item_list() else {
  continue;
  };
@@ -340,9 335,9 @@ impl<'tcx> Collector<'tcx> {
  if name.as_str().contains('\0') {
  sess.emit_err(errors::RawDylibNoNul { span: name_span });
  }
- foreign_mod_items
  foreign_items
  .iter()
- .map(|child_item| {
  .map(|&child_item| {
  self.build_dll_import(
  abi,
  import_name_type.map(|(import_name_type, _)| import_name_type),
@@ -352,21 347,12 @@ impl<'tcx> Collector<'tcx> {
  .collect()
  }
  _ => {
- for child_item in foreign_mod_items {
- if self.tcx.def_kind(child_item.id.owner_id).has_codegen_attrs()
- && self
- .tcx
- .codegen_fn_attrs(child_item.id.owner_id)
- .link_ordinal
- .is_some()
  for &child_item in foreign_items {
  if self.tcx.def_kind(child_item).has_codegen_attrs()
  && self.tcx.codegen_fn_attrs(child_item).link_ordinal.is_some()
  {
- let link_ordinal_attr = self
- .tcx
- .hir()
- .attrs(child_item.id.owner_id.into())
- .iter()
- .find(|a| a.has_name(sym::link_ordinal))
- .unwrap();
  let link_ordinal_attr =
  self.tcx.get_attr(child_item, sym::link_ordinal).unwrap();
  sess.emit_err(errors::LinkOrdinalRawDylib {
  span: link_ordinal_attr.span,
  });
@@ -384,7 370,7 @@ impl<'tcx> Collector<'tcx> {
  filename,
  kind,
  cfg,
- foreign_module: Some(it.owner_id.to_def_id()),
  foreign_module: Some(def_id.to_def_id()),
  verbatim,
  dll_imports,
  });
@@ -476,10 462,10 @@ impl<'tcx> Collector<'tcx> {
  }
  }
 
- fn i686_arg_list_size(&self, item: &hir::ForeignItemRef) -> usize {
  fn i686_arg_list_size(&self, item: DefId) -> usize {
  let argument_types: &List<Ty<'_>> = self.tcx.erase_late_bound_regions(
  self.tcx
- .type_of(item.id.owner_id)
  .type_of(item)
  .instantiate_identity()
  .fn_sig(self.tcx)
  .inputs()
@@ -505,8 491,10 @@ impl<'tcx> Collector<'tcx> {
  &self,
  abi: Abi,
  import_name_type: Option<PeImportNameType>,
- item: &hir::ForeignItemRef,
  item: DefId,
  ) -> DllImport {
  let span = self.tcx.def_span(item);
 
  let calling_convention = if self.tcx.sess.target.arch == "x86" {
  match abi {
  Abi::C { .. } | Abi::Cdecl { .. } => DllCallingConvention::C,
@@ -520,29 508,29 @@ impl<'tcx> Collector<'tcx> {
  DllCallingConvention::Vectorcall(self.i686_arg_list_size(item))
  }
  _ => {
- self.tcx.sess.emit_fatal(errors::UnsupportedAbiI686 { span: item.span });
  self.tcx.sess.emit_fatal(errors::UnsupportedAbiI686 { span });
  }
  }
  } else {
  match abi {
  Abi::C { .. } | Abi::Win64 { .. } | Abi::System { .. } => DllCallingConvention::C,
  _ => {
- self.tcx.sess.emit_fatal(errors::UnsupportedAbi { span: item.span });
  self.tcx.sess.emit_fatal(errors::UnsupportedAbi { span });
  }
  }
  };
 
- let codegen_fn_attrs = self.tcx.codegen_fn_attrs(item.id.owner_id);
  let codegen_fn_attrs = self.tcx.codegen_fn_attrs(item);
  let import_name_type = codegen_fn_attrs
  .link_ordinal
  .map_or(import_name_type, |ord| Some(PeImportNameType::Ordinal(ord)));
 
  DllImport {
- name: codegen_fn_attrs.link_name.unwrap_or(item.ident.name),
  name: codegen_fn_attrs.link_name.unwrap_or(self.tcx.item_name(item)),
  import_name_type,
  calling_convention,
- span: item.span,
- is_fn: self.tcx.def_kind(item.id.owner_id).is_fn_like(),
  span,
  is_fn: self.tcx.def_kind(item).is_fn_like(),
  }
  }
 }
diff --git a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
@@ -403,10 403,8 @@ pub(in crate::rmeta) fn provide(providers: &mut Providers) {
  .contains(&id)
  })
  },
- native_libraries: |tcx, LocalCrate| native_libs::collect(tcx),
- foreign_modules: |tcx, LocalCrate| {
- foreign_modules::collect(tcx).into_iter().map(|m| (m.def_id, m)).collect()
- },
  native_libraries: native_libs::collect,
  foreign_modules: foreign_modules::collect,
 
  // Returns a map from a sufficiently visible external item (i.e., an
  // external item that is visible from at least one local module) to a

diff --git a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
@@ -100,6 100,8 @@ bitflags! {
  const REALLOCATOR = 1 << 18;
  /// `#[rustc_allocator_zeroed]`: a hint to LLVM that the function only allocates zeroed memory.
  const ALLOCATOR_ZEROED = 1 << 19;
  /// `#[no_builtins]`: indicates that disable implicit builtin knowledge of functions for the function.
  const NO_BUILTINS = 1 << 20;
  }
 }
 

diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
@@ -1579,7 1579,7 @@ rustc_queries! {
  }
 
  /// Returns a list of all `extern` blocks of a crate.
- query foreign_modules(_: CrateNum) -> &'tcx FxHashMap<DefId, ForeignModule> {
  query foreign_modules(_: CrateNum) -> &'tcx FxIndexMap<DefId, ForeignModule> {
  arena_cache
  desc { "looking up the foreign modules of a linked crate" }
  separate_provide_extern

diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -1932,7 1932,7 @@ impl<'tcx> Printer<'tcx> for FmtPrinter<'_, 'tcx> {
  fn path_crate(mut self, cnum: CrateNum) -> Result<Self::Path, Self::Error> {
  self.empty_path = true;
  if cnum == LOCAL_CRATE {
- if self.tcx.sess.rust_2018() {
  if self.tcx.sess.at_least_rust_2018() {
  // We add the `crate::` keyword on Rust 2018, only when desired.
  if SHOULD_PREFIX_WITH_CRATE.with(|flag| flag.get()) {
  write!(self, "{}", kw::Crate)?;

diff --git a/compiler/rustc_mir_build/src/build/expr/as_place.rs b/compiler/rustc_mir_build/src/build/expr/as_place.rs
@@ -730,5 730,5 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
 /// Precise capture is enabled if user is using Rust Edition 2021 or higher.
 fn enable_precise_capture(closure_span: Span) -> bool {
- closure_span.rust_2021()
  closure_span.at_least_rust_2021()
 }