From 6b29bb6680e0df3bbcd8e9defdf0ad142e80cdf0 Mon Sep 17 00:00:00 2001
From: Sa4dUs <dmmarcelo27@gmail.com>
Date: Sun, 2 Mar 2025 23:38:55 +0100
Subject: [PATCH 01/28] Prevent ICE in autodiff validation by emitting
user-friendly errors
---
compiler/rustc_codegen_ssa/src/codegen_attrs.rs | 10 ++++++++--
1 file changed, 8 insertions(+), 2 deletions(-)
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index 673740b4aab9f..c8f13dc0bae61 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -930,13 +930,19 @@ fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> Option<AutoDiffAttrs> {
}
}
+ // Validate input and return activities
+ let mut msg = "".to_string();
for &input in &arg_activities {
if !valid_input_activity(mode, input) {
- span_bug!(attr.span(), "Invalid input activity {} for {} mode", input, mode);
+ msg = format!("Invalid input activity {} for {} mode", input, mode);
}
}
if !valid_ret_activity(mode, ret_activity) {
- span_bug!(attr.span(), "Invalid return activity {} for {} mode", ret_activity, mode);
+ msg = format!("Invalid return activity {} for {} mode", ret_activity, mode);
+ }
+ if msg != "".to_string() {
+ tcx.dcx().struct_span_err(attr.span(), msg).with_note("invalid activity").emit();
+ return Some(AutoDiffAttrs::error());
}
Some(AutoDiffAttrs { mode, ret_activity, input_activity: arg_activities })
From 50efba29f9603daeea6e924578c0e0e13f162fb5 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Fri, 21 Feb 2025 18:51:45 +1100
Subject: [PATCH 02/28] Adjust `Map`'s `to_string` functionality.
`Map::node_to_string` just calls the free function `hir_id_to_string`.
This commit removes the former and changes the latter into a `TyCtxt`
method.
---
compiler/rustc_hir_typeck/src/expr.rs | 2 +-
.../rustc_hir_typeck/src/expr_use_visitor.rs | 2 +-
.../rustc_hir_typeck/src/fn_ctxt/_impl.rs | 8 +-
compiler/rustc_middle/src/hir/map.rs | 230 +++++++++---------
compiler/rustc_middle/src/ty/context.rs | 8 +-
.../rustc_middle/src/ty/typeck_results.rs | 4 +-
compiler/rustc_passes/src/hir_id_validator.rs | 7 +-
compiler/rustc_passes/src/reachable.rs | 2 +-
8 files changed, 132 insertions(+), 131 deletions(-)
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index dec1779d92ca4..bc579df2b6851 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -298,7 +298,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// Combine the diverging and has_error flags.
self.diverges.set(self.diverges.get() | old_diverges);
- debug!("type of {} is...", self.tcx.hir().node_to_string(expr.hir_id));
+ debug!("type of {} is...", self.tcx.hir_id_to_string(expr.hir_id));
debug!("... {:?}, expected is {:?}", ty, expected);
ty
diff --git a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
index c0617119d67c7..c02685696aec3 100644
--- a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
+++ b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
@@ -1172,7 +1172,7 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
self.cx.tainted_by_errors()?;
bug!(
"no type for node {} in mem_categorization",
- self.cx.tcx().hir().node_to_string(id)
+ self.cx.tcx().hir_id_to_string(id)
);
}
}
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 054e3bcb67c3d..9cf7f35db051a 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -140,7 +140,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
pub(crate) fn local_ty(&self, span: Span, nid: HirId) -> Ty<'tcx> {
self.locals.borrow().get(&nid).cloned().unwrap_or_else(|| {
- span_bug!(span, "no type for local variable {}", self.tcx.hir().node_to_string(nid))
+ span_bug!(span, "no type for local variable {}", self.tcx.hir_id_to_string(nid))
})
}
@@ -552,11 +552,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
Some(&t) => t,
None if let Some(e) = self.tainted_by_errors() => Ty::new_error(self.tcx, e),
None => {
- bug!(
- "no type for node {} in fcx {}",
- self.tcx.hir().node_to_string(id),
- self.tag()
- );
+ bug!("no type for node {} in fcx {}", self.tcx.hir_id_to_string(id), self.tag());
}
}
}
diff --git a/compiler/rustc_middle/src/hir/map.rs b/compiler/rustc_middle/src/hir/map.rs
index fad8c7dcbcbcb..e06603f260503 100644
--- a/compiler/rustc_middle/src/hir/map.rs
+++ b/compiler/rustc_middle/src/hir/map.rs
@@ -275,7 +275,7 @@ impl<'tcx> TyCtxt<'tcx> {
span_bug!(
self.hir().span(hir_id),
"body_owned_by: {} has no associated body",
- self.hir().node_to_string(hir_id)
+ self.hir_id_to_string(hir_id)
);
})
}
@@ -674,6 +674,106 @@ impl<'tcx> TyCtxt<'tcx> {
}
}
}
+
+ /// Get a representation of this `id` for debugging purposes.
+ /// NOTE: Do NOT use this in diagnostics!
+ pub fn hir_id_to_string(self, id: HirId) -> String {
+ let path_str = |def_id: LocalDefId| self.def_path_str(def_id);
+
+ let span_str = || {
+ self.sess.source_map().span_to_snippet(Map { tcx: self }.span(id)).unwrap_or_default()
+ };
+ let node_str = |prefix| format!("{id} ({prefix} `{}`)", span_str());
+
+ match self.hir_node(id) {
+ Node::Item(item) => {
+ let item_str = match item.kind {
+ ItemKind::ExternCrate(..) => "extern crate",
+ ItemKind::Use(..) => "use",
+ ItemKind::Static(..) => "static",
+ ItemKind::Const(..) => "const",
+ ItemKind::Fn { .. } => "fn",
+ ItemKind::Macro(..) => "macro",
+ ItemKind::Mod(..) => "mod",
+ ItemKind::ForeignMod { .. } => "foreign mod",
+ ItemKind::GlobalAsm { .. } => "global asm",
+ ItemKind::TyAlias(..) => "ty",
+ ItemKind::Enum(..) => "enum",
+ ItemKind::Struct(..) => "struct",
+ ItemKind::Union(..) => "union",
+ ItemKind::Trait(..) => "trait",
+ ItemKind::TraitAlias(..) => "trait alias",
+ ItemKind::Impl { .. } => "impl",
+ };
+ format!("{id} ({item_str} {})", path_str(item.owner_id.def_id))
+ }
+ Node::ForeignItem(item) => {
+ format!("{id} (foreign item {})", path_str(item.owner_id.def_id))
+ }
+ Node::ImplItem(ii) => {
+ let kind = match ii.kind {
+ ImplItemKind::Const(..) => "associated constant",
+ ImplItemKind::Fn(fn_sig, _) => match fn_sig.decl.implicit_self {
+ ImplicitSelfKind::None => "associated function",
+ _ => "method",
+ },
+ ImplItemKind::Type(_) => "associated type",
+ };
+ format!("{id} ({kind} `{}` in {})", ii.ident, path_str(ii.owner_id.def_id))
+ }
+ Node::TraitItem(ti) => {
+ let kind = match ti.kind {
+ TraitItemKind::Const(..) => "associated constant",
+ TraitItemKind::Fn(fn_sig, _) => match fn_sig.decl.implicit_self {
+ ImplicitSelfKind::None => "associated function",
+ _ => "trait method",
+ },
+ TraitItemKind::Type(..) => "associated type",
+ };
+
+ format!("{id} ({kind} `{}` in {})", ti.ident, path_str(ti.owner_id.def_id))
+ }
+ Node::Variant(variant) => {
+ format!("{id} (variant `{}` in {})", variant.ident, path_str(variant.def_id))
+ }
+ Node::Field(field) => {
+ format!("{id} (field `{}` in {})", field.ident, path_str(field.def_id))
+ }
+ Node::AnonConst(_) => node_str("const"),
+ Node::ConstBlock(_) => node_str("const"),
+ Node::ConstArg(_) => node_str("const"),
+ Node::Expr(_) => node_str("expr"),
+ Node::ExprField(_) => node_str("expr field"),
+ Node::Stmt(_) => node_str("stmt"),
+ Node::PathSegment(_) => node_str("path segment"),
+ Node::Ty(_) => node_str("type"),
+ Node::AssocItemConstraint(_) => node_str("assoc item constraint"),
+ Node::TraitRef(_) => node_str("trait ref"),
+ Node::OpaqueTy(_) => node_str("opaque type"),
+ Node::Pat(_) => node_str("pat"),
+ Node::TyPat(_) => node_str("pat ty"),
+ Node::PatField(_) => node_str("pattern field"),
+ Node::PatExpr(_) => node_str("pattern literal"),
+ Node::Param(_) => node_str("param"),
+ Node::Arm(_) => node_str("arm"),
+ Node::Block(_) => node_str("block"),
+ Node::Infer(_) => node_str("infer"),
+ Node::LetStmt(_) => node_str("local"),
+ Node::Ctor(ctor) => format!(
+ "{id} (ctor {})",
+ ctor.ctor_def_id().map_or("<missing path>".into(), |def_id| path_str(def_id)),
+ ),
+ Node::Lifetime(_) => node_str("lifetime"),
+ Node::GenericParam(param) => {
+ format!("{id} (generic_param {})", path_str(param.def_id))
+ }
+ Node::Crate(..) => String::from("(root_crate)"),
+ Node::WherePredicate(_) => node_str("where predicate"),
+ Node::Synthetic => unreachable!(),
+ Node::Err(_) => node_str("error"),
+ Node::PreciseCapturingNonLifetimeArg(_param) => node_str("parameter"),
+ }
+ }
}
impl<'hir> Map<'hir> {
@@ -686,28 +786,34 @@ impl<'hir> Map<'hir> {
}
bug!(
"expected foreign mod or inlined parent, found {}",
- self.node_to_string(HirId::make_owner(parent.def_id))
+ self.tcx.hir_id_to_string(HirId::make_owner(parent.def_id))
)
}
pub fn expect_item(self, id: LocalDefId) -> &'hir Item<'hir> {
match self.tcx.expect_hir_owner_node(id) {
OwnerNode::Item(item) => item,
- _ => bug!("expected item, found {}", self.node_to_string(HirId::make_owner(id))),
+ _ => bug!("expected item, found {}", self.tcx.hir_id_to_string(HirId::make_owner(id))),
}
}
pub fn expect_impl_item(self, id: LocalDefId) -> &'hir ImplItem<'hir> {
match self.tcx.expect_hir_owner_node(id) {
OwnerNode::ImplItem(item) => item,
- _ => bug!("expected impl item, found {}", self.node_to_string(HirId::make_owner(id))),
+ _ => bug!(
+ "expected impl item, found {}",
+ self.tcx.hir_id_to_string(HirId::make_owner(id))
+ ),
}
}
pub fn expect_trait_item(self, id: LocalDefId) -> &'hir TraitItem<'hir> {
match self.tcx.expect_hir_owner_node(id) {
OwnerNode::TraitItem(item) => item,
- _ => bug!("expected trait item, found {}", self.node_to_string(HirId::make_owner(id))),
+ _ => bug!(
+ "expected trait item, found {}",
+ self.tcx.hir_id_to_string(HirId::make_owner(id))
+ ),
}
}
@@ -718,14 +824,14 @@ impl<'hir> Map<'hir> {
pub fn expect_variant(self, id: HirId) -> &'hir Variant<'hir> {
match self.tcx.hir_node(id) {
Node::Variant(variant) => variant,
- _ => bug!("expected variant, found {}", self.node_to_string(id)),
+ _ => bug!("expected variant, found {}", self.tcx.hir_id_to_string(id)),
}
}
pub fn expect_field(self, id: HirId) -> &'hir FieldDef<'hir> {
match self.tcx.hir_node(id) {
Node::Field(field) => field,
- _ => bug!("expected field, found {}", self.node_to_string(id)),
+ _ => bug!("expected field, found {}", self.tcx.hir_id_to_string(id)),
}
}
@@ -735,7 +841,7 @@ impl<'hir> Map<'hir> {
_ => {
bug!(
"expected foreign item, found {}",
- self.node_to_string(HirId::make_owner(id.def_id))
+ self.tcx.hir_id_to_string(HirId::make_owner(id.def_id))
)
}
}
@@ -748,7 +854,7 @@ impl<'hir> Map<'hir> {
_ => {
bug!(
"expected opaque type definition, found {}",
- self.node_to_string(self.tcx.local_def_id_to_hir_id(id))
+ self.tcx.hir_id_to_string(self.tcx.local_def_id_to_hir_id(id))
)
}
}
@@ -757,7 +863,7 @@ impl<'hir> Map<'hir> {
pub fn expect_expr(self, id: HirId) -> &'hir Expr<'hir> {
match self.tcx.hir_node(id) {
Node::Expr(expr) => expr,
- _ => bug!("expected expr, found {}", self.node_to_string(id)),
+ _ => bug!("expected expr, found {}", self.tcx.hir_id_to_string(id)),
}
}
@@ -796,7 +902,7 @@ impl<'hir> Map<'hir> {
}
pub fn name(self, id: HirId) -> Symbol {
- self.opt_name(id).unwrap_or_else(|| bug!("no name for {}", self.node_to_string(id)))
+ self.opt_name(id).unwrap_or_else(|| bug!("no name for {}", self.tcx.hir_id_to_string(id)))
}
/// Given a node ID, gets a list of attributes associated with the AST
@@ -977,12 +1083,6 @@ impl<'hir> Map<'hir> {
}
}
- /// Get a representation of this `id` for debugging purposes.
- /// NOTE: Do NOT use this in diagnostics!
- pub fn node_to_string(self, id: HirId) -> String {
- hir_id_to_string(self, id)
- }
-
/// Returns the HirId of `N` in `struct Foo<const N: usize = { ... }>` when
/// called with the HirId for the `{ ... }` anon const
pub fn opt_const_param_default_param_def_id(self, anon_const: HirId) -> Option<LocalDefId> {
@@ -1147,102 +1247,6 @@ fn upstream_crates(tcx: TyCtxt<'_>) -> Vec<(StableCrateId, Svh)> {
upstream_crates
}
-fn hir_id_to_string(map: Map<'_>, id: HirId) -> String {
- let path_str = |def_id: LocalDefId| map.tcx.def_path_str(def_id);
-
- let span_str = || map.tcx.sess.source_map().span_to_snippet(map.span(id)).unwrap_or_default();
- let node_str = |prefix| format!("{id} ({prefix} `{}`)", span_str());
-
- match map.tcx.hir_node(id) {
- Node::Item(item) => {
- let item_str = match item.kind {
- ItemKind::ExternCrate(..) => "extern crate",
- ItemKind::Use(..) => "use",
- ItemKind::Static(..) => "static",
- ItemKind::Const(..) => "const",
- ItemKind::Fn { .. } => "fn",
- ItemKind::Macro(..) => "macro",
- ItemKind::Mod(..) => "mod",
- ItemKind::ForeignMod { .. } => "foreign mod",
- ItemKind::GlobalAsm { .. } => "global asm",
- ItemKind::TyAlias(..) => "ty",
- ItemKind::Enum(..) => "enum",
- ItemKind::Struct(..) => "struct",
- ItemKind::Union(..) => "union",
- ItemKind::Trait(..) => "trait",
- ItemKind::TraitAlias(..) => "trait alias",
- ItemKind::Impl { .. } => "impl",
- };
- format!("{id} ({item_str} {})", path_str(item.owner_id.def_id))
- }
- Node::ForeignItem(item) => {
- format!("{id} (foreign item {})", path_str(item.owner_id.def_id))
- }
- Node::ImplItem(ii) => {
- let kind = match ii.kind {
- ImplItemKind::Const(..) => "associated constant",
- ImplItemKind::Fn(fn_sig, _) => match fn_sig.decl.implicit_self {
- ImplicitSelfKind::None => "associated function",
- _ => "method",
- },
- ImplItemKind::Type(_) => "associated type",
- };
- format!("{id} ({kind} `{}` in {})", ii.ident, path_str(ii.owner_id.def_id))
- }
- Node::TraitItem(ti) => {
- let kind = match ti.kind {
- TraitItemKind::Const(..) => "associated constant",
- TraitItemKind::Fn(fn_sig, _) => match fn_sig.decl.implicit_self {
- ImplicitSelfKind::None => "associated function",
- _ => "trait method",
- },
- TraitItemKind::Type(..) => "associated type",
- };
-
- format!("{id} ({kind} `{}` in {})", ti.ident, path_str(ti.owner_id.def_id))
- }
- Node::Variant(variant) => {
- format!("{id} (variant `{}` in {})", variant.ident, path_str(variant.def_id))
- }
- Node::Field(field) => {
- format!("{id} (field `{}` in {})", field.ident, path_str(field.def_id))
- }
- Node::AnonConst(_) => node_str("const"),
- Node::ConstBlock(_) => node_str("const"),
- Node::ConstArg(_) => node_str("const"),
- Node::Expr(_) => node_str("expr"),
- Node::ExprField(_) => node_str("expr field"),
- Node::Stmt(_) => node_str("stmt"),
- Node::PathSegment(_) => node_str("path segment"),
- Node::Ty(_) => node_str("type"),
- Node::AssocItemConstraint(_) => node_str("assoc item constraint"),
- Node::TraitRef(_) => node_str("trait ref"),
- Node::OpaqueTy(_) => node_str("opaque type"),
- Node::Pat(_) => node_str("pat"),
- Node::TyPat(_) => node_str("pat ty"),
- Node::PatField(_) => node_str("pattern field"),
- Node::PatExpr(_) => node_str("pattern literal"),
- Node::Param(_) => node_str("param"),
- Node::Arm(_) => node_str("arm"),
- Node::Block(_) => node_str("block"),
- Node::Infer(_) => node_str("infer"),
- Node::LetStmt(_) => node_str("local"),
- Node::Ctor(ctor) => format!(
- "{id} (ctor {})",
- ctor.ctor_def_id().map_or("<missing path>".into(), |def_id| path_str(def_id)),
- ),
- Node::Lifetime(_) => node_str("lifetime"),
- Node::GenericParam(param) => {
- format!("{id} (generic_param {})", path_str(param.def_id))
- }
- Node::Crate(..) => String::from("(root_crate)"),
- Node::WherePredicate(_) => node_str("where predicate"),
- Node::Synthetic => unreachable!(),
- Node::Err(_) => node_str("error"),
- Node::PreciseCapturingNonLifetimeArg(_param) => node_str("parameter"),
- }
-}
-
pub(super) fn hir_module_items(tcx: TyCtxt<'_>, module_id: LocalModDefId) -> ModuleItems {
let mut collector = ItemCollector::new(tcx, false);
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index d0aa2b8cbdad3..c78f54d27dee9 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -3113,9 +3113,11 @@ impl<'tcx> TyCtxt<'tcx> {
pub fn late_bound_vars(self, id: HirId) -> &'tcx List<ty::BoundVariableKind> {
self.mk_bound_variable_kinds(
- &self.late_bound_vars_map(id.owner).get(&id.local_id).cloned().unwrap_or_else(|| {
- bug!("No bound vars found for {}", self.hir().node_to_string(id))
- }),
+ &self
+ .late_bound_vars_map(id.owner)
+ .get(&id.local_id)
+ .cloned()
+ .unwrap_or_else(|| bug!("No bound vars found for {}", self.hir_id_to_string(id))),
)
}
diff --git a/compiler/rustc_middle/src/ty/typeck_results.rs b/compiler/rustc_middle/src/ty/typeck_results.rs
index 7d9c23c05f950..06054e22e7601 100644
--- a/compiler/rustc_middle/src/ty/typeck_results.rs
+++ b/compiler/rustc_middle/src/ty/typeck_results.rs
@@ -310,7 +310,7 @@ impl<'tcx> TypeckResults<'tcx> {
pub fn node_type(&self, id: HirId) -> Ty<'tcx> {
self.node_type_opt(id).unwrap_or_else(|| {
- bug!("node_type: no type for node {}", tls::with(|tcx| tcx.hir().node_to_string(id)))
+ bug!("node_type: no type for node {}", tls::with(|tcx| tcx.hir_id_to_string(id)))
})
}
@@ -554,7 +554,7 @@ fn invalid_hir_id_for_typeck_results(hir_owner: OwnerId, hir_id: HirId) {
ty::tls::with(|tcx| {
bug!(
"node {} cannot be placed in TypeckResults with hir_owner {:?}",
- tcx.hir().node_to_string(hir_id),
+ tcx.hir_id_to_string(hir_id),
hir_owner
)
});
diff --git a/compiler/rustc_passes/src/hir_id_validator.rs b/compiler/rustc_passes/src/hir_id_validator.rs
index 509c2f5477524..84b92d49f24c2 100644
--- a/compiler/rustc_passes/src/hir_id_validator.rs
+++ b/compiler/rustc_passes/src/hir_id_validator.rs
@@ -60,19 +60,18 @@ impl<'a, 'hir> HirIdValidator<'a, 'hir> {
.expect("owning item has no entry");
if max != self.hir_ids_seen.len() - 1 {
- let hir = self.tcx.hir();
let pretty_owner = self.tcx.hir_def_path(owner.def_id).to_string_no_crate_verbose();
let missing_items: Vec<_> = (0..=max as u32)
.map(|i| ItemLocalId::from_u32(i))
.filter(|&local_id| !self.hir_ids_seen.contains(local_id))
- .map(|local_id| hir.node_to_string(HirId { owner, local_id }))
+ .map(|local_id| self.tcx.hir_id_to_string(HirId { owner, local_id }))
.collect();
let seen_items: Vec<_> = self
.hir_ids_seen
.iter()
- .map(|local_id| hir.node_to_string(HirId { owner, local_id }))
+ .map(|local_id| self.tcx.hir_id_to_string(HirId { owner, local_id }))
.collect();
self.error(|| {
@@ -137,7 +136,7 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for HirIdValidator<'a, 'hir> {
self.error(|| {
format!(
"HirIdValidator: The recorded owner of {} is {} instead of {}",
- self.tcx.hir().node_to_string(hir_id),
+ self.tcx.hir_id_to_string(hir_id),
self.tcx.hir_def_path(hir_id.owner.def_id).to_string_no_crate_verbose(),
self.tcx.hir_def_path(owner.def_id).to_string_no_crate_verbose()
)
diff --git a/compiler/rustc_passes/src/reachable.rs b/compiler/rustc_passes/src/reachable.rs
index fd465717bf766..599a08bac20de 100644
--- a/compiler/rustc_passes/src/reachable.rs
+++ b/compiler/rustc_passes/src/reachable.rs
@@ -291,7 +291,7 @@ impl<'tcx> ReachableContext<'tcx> {
_ => {
bug!(
"found unexpected node kind in worklist: {} ({:?})",
- self.tcx.hir().node_to_string(self.tcx.local_def_id_to_hir_id(search_item)),
+ self.tcx.hir_id_to_string(self.tcx.local_def_id_to_hir_id(search_item)),
node,
);
}
From fc40f6f9ede25f6fc161ed70d97e7bb4a7b01dc0 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 24 Feb 2025 13:01:43 +1100
Subject: [PATCH 03/28] Rename `hir_attrs` query as `hir_attr_map`.
To make room for the moving of `Map::attrs` to `TyCtxt::hir_attrs` in
the next commit. (It makes sense to rename the query, because it has
many fewer uses than the method.)
---
compiler/rustc_lint/src/levels.rs | 2 +-
compiler/rustc_middle/src/hir/map.rs | 2 +-
compiler/rustc_middle/src/hir/mod.rs | 2 +-
compiler/rustc_middle/src/query/mod.rs | 2 +-
compiler/rustc_middle/src/ty/context.rs | 2 +-
5 files changed, 5 insertions(+), 5 deletions(-)
diff --git a/compiler/rustc_lint/src/levels.rs b/compiler/rustc_lint/src/levels.rs
index 4ede9b4408798..aa6eef906ea42 100644
--- a/compiler/rustc_lint/src/levels.rs
+++ b/compiler/rustc_lint/src/levels.rs
@@ -152,7 +152,7 @@ fn lints_that_dont_need_to_run(tcx: TyCtxt<'_>, (): ()) -> FxIndexSet<LintId> {
#[instrument(level = "trace", skip(tcx), ret)]
fn shallow_lint_levels_on(tcx: TyCtxt<'_>, owner: hir::OwnerId) -> ShallowLintLevelMap {
let store = unerased_lint_store(tcx.sess);
- let attrs = tcx.hir_attrs(owner);
+ let attrs = tcx.hir_attr_map(owner);
let mut levels = LintLevelsBuilder {
sess: tcx.sess,
diff --git a/compiler/rustc_middle/src/hir/map.rs b/compiler/rustc_middle/src/hir/map.rs
index e06603f260503..705b09f10e4af 100644
--- a/compiler/rustc_middle/src/hir/map.rs
+++ b/compiler/rustc_middle/src/hir/map.rs
@@ -908,7 +908,7 @@ impl<'hir> Map<'hir> {
/// Given a node ID, gets a list of attributes associated with the AST
/// corresponding to the node-ID.
pub fn attrs(self, id: HirId) -> &'hir [Attribute] {
- self.tcx.hir_attrs(id.owner).get(id.local_id)
+ self.tcx.hir_attr_map(id.owner).get(id.local_id)
}
/// Gets the span of the definition of the specified HIR node.
diff --git a/compiler/rustc_middle/src/hir/mod.rs b/compiler/rustc_middle/src/hir/mod.rs
index 6071a58367ed1..a19458ad7994d 100644
--- a/compiler/rustc_middle/src/hir/mod.rs
+++ b/compiler/rustc_middle/src/hir/mod.rs
@@ -202,7 +202,7 @@ pub fn provide(providers: &mut Providers) {
}
})
};
- providers.hir_attrs = |tcx, id| {
+ providers.hir_attr_map = |tcx, id| {
tcx.hir_crate(()).owners[id.def_id].as_owner().map_or(AttributeMap::EMPTY, |o| &o.attrs)
};
providers.def_span = |tcx, def_id| tcx.hir().span(tcx.local_def_id_to_hir_id(def_id));
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 1302027aabb36..9773366fa10cc 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -198,7 +198,7 @@ rustc_queries! {
///
/// This can be conveniently accessed by methods on `tcx.hir()`.
/// Avoid calling this query directly.
- query hir_attrs(key: hir::OwnerId) -> &'tcx hir::AttributeMap<'tcx> {
+ query hir_attr_map(key: hir::OwnerId) -> &'tcx hir::AttributeMap<'tcx> {
desc { |tcx| "getting HIR owner attributes in `{}`", tcx.def_path_str(key) }
feedable
}
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index c78f54d27dee9..d899ae4bd7070 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -1299,7 +1299,7 @@ impl<'tcx> TyCtxtFeed<'tcx, LocalDefId> {
),
bodies,
})));
- self.feed_owner_id().hir_attrs(attrs);
+ self.feed_owner_id().hir_attr_map(attrs);
}
}
From 10477685d6383e0ddde516644dd7fc6fbfb593ca Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Fri, 21 Feb 2025 18:33:05 +1100
Subject: [PATCH 04/28] Move methods from `Map` to `TyCtxt`, part 4.
Continuing the work from #137350.
Removes the unused methods: `expect_variant`, `expect_field`,
`expect_foreign_item`.
Every method gains a `hir_` prefix.
---
.../rustc_borrowck/src/diagnostics/mod.rs | 4 +-
.../src/diagnostics/mutability_errors.rs | 2 +-
.../src/diagnostics/opaque_suggestions.rs | 2 +-
.../src/diagnostics/region_name.rs | 2 +-
.../src/diagnostics/var_name.rs | 2 +-
.../src/assert_module_sources.rs | 2 +-
compiler/rustc_codegen_ssa/src/back/write.rs | 2 +-
compiler/rustc_codegen_ssa/src/base.rs | 2 +-
.../rustc_codegen_ssa/src/codegen_attrs.rs | 4 +-
.../rustc_const_eval/src/check_consts/mod.rs | 2 +-
compiler/rustc_driver_impl/src/pretty.rs | 3 +-
.../rustc_hir_analysis/src/check/check.rs | 4 +-
.../src/check/compare_impl_item.rs | 26 ++--
.../rustc_hir_analysis/src/check/wfcheck.rs | 2 +-
.../rustc_hir_analysis/src/check_unused.rs | 2 +-
.../src/coherence/builtin.rs | 20 ++--
.../src/coherence/orphan.rs | 2 +-
compiler/rustc_hir_analysis/src/collect.rs | 9 +-
.../rustc_hir_analysis/src/collect/dump.rs | 2 +-
.../rustc_hir_analysis/src/collect/type_of.rs | 2 +-
compiler/rustc_hir_analysis/src/delegation.rs | 4 +-
.../src/hir_ty_lowering/mod.rs | 2 +-
compiler/rustc_hir_typeck/src/callee.rs | 2 +-
.../src/fn_ctxt/suggestions.rs | 2 +-
.../src/method/prelude_edition_lints.rs | 2 +-
compiler/rustc_hir_typeck/src/method/probe.rs | 2 +-
.../rustc_hir_typeck/src/method/suggest.rs | 11 +-
compiler/rustc_hir_typeck/src/upvar.rs | 14 +--
.../rustc_incremental/src/assert_dep_graph.rs | 2 +-
.../rustc_interface/src/proc_macro_decls.rs | 2 +-
compiler/rustc_lint/src/builtin.rs | 6 +-
compiler/rustc_lint/src/expect.rs | 2 +-
compiler/rustc_lint/src/late.rs | 2 +-
compiler/rustc_lint/src/nonstandard_style.rs | 9 +-
compiler/rustc_lint/src/types.rs | 2 +-
compiler/rustc_metadata/src/rmeta/encoder.rs | 9 +-
compiler/rustc_middle/src/hir/map.rs | 112 +++++++-----------
compiler/rustc_middle/src/hir/mod.rs | 2 +-
compiler/rustc_middle/src/mir/pretty.rs | 4 +-
.../src/traits/specialization_graph.rs | 2 +-
compiler/rustc_middle/src/ty/closure.rs | 2 +-
compiler/rustc_middle/src/ty/context.rs | 2 +-
compiler/rustc_middle/src/ty/mod.rs | 6 +-
.../rustc_middle/src/ty/structural_impls.rs | 2 +-
compiler/rustc_mir_build/src/builder/mod.rs | 4 +-
compiler/rustc_mir_build/src/builder/scope.rs | 3 +-
compiler/rustc_mir_build/src/thir/cx/expr.rs | 2 +-
compiler/rustc_mir_build/src/thir/cx/mod.rs | 5 +-
.../src/thir/pattern/check_match.rs | 2 +-
compiler/rustc_passes/src/check_attr.rs | 19 ++-
compiler/rustc_passes/src/dead.rs | 6 +-
compiler/rustc_passes/src/diagnostic_items.rs | 2 +-
compiler/rustc_passes/src/entry.rs | 6 +-
compiler/rustc_passes/src/liveness.rs | 2 +-
compiler/rustc_passes/src/loops.rs | 2 +-
compiler/rustc_passes/src/stability.rs | 6 +-
compiler/rustc_privacy/src/lib.rs | 6 +-
compiler/rustc_smir/src/rustc_smir/context.rs | 2 +-
.../src/error_reporting/infer/mod.rs | 4 +-
.../error_reporting/infer/need_type_info.rs | 2 +-
.../error_reporting/infer/note_and_explain.rs | 2 +-
.../src/error_reporting/infer/region.rs | 2 +-
.../src/error_reporting/infer/suggest.rs | 4 +-
.../src/error_reporting/traits/suggestions.rs | 18 ++-
compiler/rustc_ty_utils/src/assoc.rs | 6 +-
compiler/rustc_ty_utils/src/implied_bounds.rs | 2 +-
src/doc/rustc-dev-guide/src/hir.md | 4 +-
src/librustdoc/clean/inline.rs | 4 +-
src/librustdoc/clean/mod.rs | 16 +--
src/librustdoc/doctest.rs | 2 +-
src/librustdoc/doctest/rust.rs | 2 +-
src/librustdoc/visit_ast.rs | 9 +-
.../clippy/clippy_lints/src/attrs/mod.rs | 6 +-
.../src/default_union_representation.rs | 2 +-
.../clippy_lints/src/derivable_impls.rs | 4 +-
src/tools/clippy/clippy_lints/src/derive.rs | 2 +-
.../clippy_lints/src/doc/missing_headers.rs | 2 +-
src/tools/clippy/clippy_lints/src/escape.rs | 3 +-
.../clippy_lints/src/exhaustive_items.rs | 2 +-
.../clippy/clippy_lints/src/format_impl.rs | 3 +-
.../clippy_lints/src/four_forward_slashes.rs | 3 +-
.../clippy_lints/src/functions/must_use.rs | 6 +-
.../src/inconsistent_struct_constructor.rs | 2 +-
.../src/inline_fn_without_body.rs | 3 +-
.../clippy/clippy_lints/src/macro_use.rs | 2 +-
.../clippy_lints/src/manual_non_exhaustive.rs | 6 +-
.../src/matches/match_like_matches.rs | 2 +-
.../src/matches/match_same_arms.rs | 2 +-
.../clippy_lints/src/methods/is_empty.rs | 2 +-
.../clippy/clippy_lints/src/methods/mod.rs | 2 +-
.../clippy/clippy_lints/src/missing_doc.rs | 12 +-
.../clippy/clippy_lints/src/missing_inline.rs | 6 +-
.../src/mixed_read_write_in_expression.rs | 2 +-
.../clippy/clippy_lints/src/needless_if.rs | 2 +-
.../clippy_lints/src/needless_late_init.rs | 2 +-
.../src/needless_pass_by_ref_mut.rs | 2 +-
.../src/needless_pass_by_value.rs | 2 +-
.../src/no_mangle_with_rust_abi.rs | 2 +-
.../clippy/clippy_lints/src/non_copy_const.rs | 2 +-
.../clippy_lints/src/operators/op_ref.rs | 4 +-
.../clippy_lints/src/pass_by_ref_or_value.rs | 2 +-
.../clippy_lints/src/pub_underscore_fields.rs | 2 +-
.../clippy_lints/src/read_zero_byte_vec.rs | 2 +-
.../src/return_self_not_must_use.rs | 2 +-
src/tools/clippy/clippy_lints/src/returns.rs | 4 +-
.../src/self_named_constructors.rs | 2 +-
.../src/undocumented_unsafe_blocks.rs | 3 +-
.../clippy/clippy_lints/src/unused_self.rs | 2 +-
src/tools/clippy/clippy_lints/src/unwrap.rs | 2 +-
.../clippy/clippy_lints/src/utils/author.rs | 2 +-
.../clippy/clippy_lints/src/utils/dump_hir.rs | 2 +-
.../internal_lints/lint_without_lint_pass.rs | 2 +-
src/tools/clippy/clippy_utils/src/lib.rs | 22 ++--
src/tools/clippy/clippy_utils/src/msrvs.rs | 2 +-
src/tools/clippy/clippy_utils/src/sugg.rs | 4 +-
115 files changed, 269 insertions(+), 321 deletions(-)
diff --git a/compiler/rustc_borrowck/src/diagnostics/mod.rs b/compiler/rustc_borrowck/src/diagnostics/mod.rs
index d1f238331d56f..208d510db2e1f 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mod.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mod.rs
@@ -505,7 +505,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
let var_id =
self.infcx.tcx.closure_captures(def_id)[field.index()].get_root_variable();
- Some(self.infcx.tcx.hir().name(var_id).to_string())
+ Some(self.infcx.tcx.hir_name(var_id).to_string())
}
_ => {
// Might need a revision when the fields in trait RFC is implemented
@@ -1124,7 +1124,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
def_id, target_place, places
);
let hir_id = self.infcx.tcx.local_def_id_to_hir_id(def_id);
- let expr = &self.infcx.tcx.hir().expect_expr(hir_id).kind;
+ let expr = &self.infcx.tcx.hir_expect_expr(hir_id).kind;
debug!("closure_span: hir_id={:?} expr={:?}", hir_id, expr);
if let &hir::ExprKind::Closure(&hir::Closure { kind, fn_decl_span, .. }) = expr {
for (captured_place, place) in
diff --git a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
index be4a7736b1c20..91290ce888a10 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
@@ -698,7 +698,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
if !matches!(k, hir::AssocItemKind::Fn { .. }) {
continue;
}
- if self.infcx.tcx.hir().name(hi) != self.infcx.tcx.hir().name(my_hir) {
+ if self.infcx.tcx.hir_name(hi) != self.infcx.tcx.hir_name(my_hir) {
continue;
}
f_in_trait_opt = Some(hi);
diff --git a/compiler/rustc_borrowck/src/diagnostics/opaque_suggestions.rs b/compiler/rustc_borrowck/src/diagnostics/opaque_suggestions.rs
index 876b8f214b017..7192a889adcbc 100644
--- a/compiler/rustc_borrowck/src/diagnostics/opaque_suggestions.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/opaque_suggestions.rs
@@ -105,7 +105,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
if let Some(opaque_def_id) = opaque_def_id.as_local()
&& let hir::OpaqueTyOrigin::FnReturn { parent, .. } =
- tcx.hir().expect_opaque_ty(opaque_def_id).origin
+ tcx.hir_expect_opaque_ty(opaque_def_id).origin
{
if let Some(sugg) = impl_trait_overcapture_suggestion(
tcx,
diff --git a/compiler/rustc_borrowck/src/diagnostics/region_name.rs b/compiler/rustc_borrowck/src/diagnostics/region_name.rs
index a15f9744bf310..412aaf70c3f19 100644
--- a/compiler/rustc_borrowck/src/diagnostics/region_name.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/region_name.rs
@@ -343,7 +343,7 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
}
};
let hir::ExprKind::Closure(&hir::Closure { fn_decl_span, .. }) =
- tcx.hir().expect_expr(self.mir_hir_id()).kind
+ tcx.hir_expect_expr(self.mir_hir_id()).kind
else {
bug!("Closure is not defined by a closure expr");
};
diff --git a/compiler/rustc_borrowck/src/diagnostics/var_name.rs b/compiler/rustc_borrowck/src/diagnostics/var_name.rs
index 191c0444c742e..693d22abbe6c8 100644
--- a/compiler/rustc_borrowck/src/diagnostics/var_name.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/var_name.rs
@@ -69,7 +69,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
let upvar_hir_id = upvars[upvar_index].get_root_variable();
debug!("get_upvar_name_and_span_for_region: upvar_hir_id={upvar_hir_id:?}");
- let upvar_name = tcx.hir().name(upvar_hir_id);
+ let upvar_name = tcx.hir_name(upvar_hir_id);
let upvar_span = tcx.hir().span(upvar_hir_id);
debug!(
"get_upvar_name_and_span_for_region: upvar_name={upvar_name:?} upvar_span={upvar_span:?}",
diff --git a/compiler/rustc_codegen_ssa/src/assert_module_sources.rs b/compiler/rustc_codegen_ssa/src/assert_module_sources.rs
index 32f689608f816..3710625ac12d7 100644
--- a/compiler/rustc_codegen_ssa/src/assert_module_sources.rs
+++ b/compiler/rustc_codegen_ssa/src/assert_module_sources.rs
@@ -63,7 +63,7 @@ pub fn assert_module_sources(tcx: TyCtxt<'_>, set_reuse: &dyn Fn(&mut CguReuseTr
},
};
- for attr in tcx.hir().attrs(rustc_hir::CRATE_HIR_ID) {
+ for attr in tcx.hir_attrs(rustc_hir::CRATE_HIR_ID) {
ams.check_attr(attr);
}
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index c8bb229998ea3..3e60778bee24d 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -473,7 +473,7 @@ pub(crate) fn start_async_codegen<B: ExtraBackendMethods>(
) -> OngoingCodegen<B> {
let (coordinator_send, coordinator_receive) = channel();
- let crate_attrs = tcx.hir().attrs(rustc_hir::CRATE_HIR_ID);
+ let crate_attrs = tcx.hir_attrs(rustc_hir::CRATE_HIR_ID);
let no_builtins = attr::contains_name(crate_attrs, sym::no_builtins);
let crate_info = CrateInfo::new(tcx, target_cpu);
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
index 63f2f8fa3d177..e9c886d28edf6 100644
--- a/compiler/rustc_codegen_ssa/src/base.rs
+++ b/compiler/rustc_codegen_ssa/src/base.rs
@@ -876,7 +876,7 @@ impl CrateInfo {
let linked_symbols =
crate_types.iter().map(|&c| (c, crate::back::linker::linked_symbols(tcx, c))).collect();
let local_crate_name = tcx.crate_name(LOCAL_CRATE);
- let crate_attrs = tcx.hir().attrs(rustc_hir::CRATE_HIR_ID);
+ let crate_attrs = tcx.hir_attrs(rustc_hir::CRATE_HIR_ID);
let subsystem =
ast::attr::first_attr_value_str_by_name(crate_attrs, sym::windows_subsystem);
let windows_subsystem = subsystem.map(|subsystem| {
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index 673740b4aab9f..b58f14bbb828e 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -64,7 +64,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
);
}
- let attrs = tcx.hir().attrs(tcx.local_def_id_to_hir_id(did));
+ let attrs = tcx.hir_attrs(tcx.local_def_id_to_hir_id(did));
let mut codegen_fn_attrs = CodegenFnAttrs::new();
if tcx.should_inherit_track_caller(did) {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::TRACK_CALLER;
@@ -79,7 +79,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
// 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 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;
diff --git a/compiler/rustc_const_eval/src/check_consts/mod.rs b/compiler/rustc_const_eval/src/check_consts/mod.rs
index 607cb2e497d8d..06ee7075170ff 100644
--- a/compiler/rustc_const_eval/src/check_consts/mod.rs
+++ b/compiler/rustc_const_eval/src/check_consts/mod.rs
@@ -81,7 +81,7 @@ pub fn rustc_allow_const_fn_unstable(
def_id: LocalDefId,
feature_gate: Symbol,
) -> bool {
- let attrs = tcx.hir().attrs(tcx.local_def_id_to_hir_id(def_id));
+ let attrs = tcx.hir_attrs(tcx.local_def_id_to_hir_id(def_id));
find_attr!(attrs, AttributeKind::AllowConstFnUnstable(syms) if syms.contains(&feature_gate))
}
diff --git a/compiler/rustc_driver_impl/src/pretty.rs b/compiler/rustc_driver_impl/src/pretty.rs
index 828a14e707c50..16d70af7e05d8 100644
--- a/compiler/rustc_driver_impl/src/pretty.rs
+++ b/compiler/rustc_driver_impl/src/pretty.rs
@@ -268,8 +268,7 @@ pub fn print<'tcx>(sess: &Session, ppm: PpMode, ex: PrintExtra<'tcx>) {
let tcx = ex.tcx();
let f = |annotation: &dyn pprust_hir::PpAnn| {
let sm = sess.source_map();
- let hir_map = tcx.hir();
- let attrs = |id| hir_map.attrs(id);
+ let attrs = |id| tcx.hir_attrs(id);
pprust_hir::print_crate(
sm,
tcx.hir_root_module(),
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index f2331f3fd8e13..bc1b646e6b9f4 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -216,7 +216,7 @@ fn check_static_inhabited(tcx: TyCtxt<'_>, def_id: LocalDefId) {
/// Checks that an opaque type does not contain cycles and does not use `Self` or `T::Foo`
/// projections that would result in "inheriting lifetimes".
fn check_opaque(tcx: TyCtxt<'_>, def_id: LocalDefId) {
- let hir::OpaqueTy { origin, .. } = *tcx.hir().expect_opaque_ty(def_id);
+ let hir::OpaqueTy { origin, .. } = *tcx.hir_expect_opaque_ty(def_id);
// HACK(jynelson): trying to infer the type of `impl trait` breaks documenting
// `async-std` (and `pub async fn` in general).
@@ -827,7 +827,7 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {
check_type_alias_type_params_are_used(tcx, def_id);
}
DefKind::ForeignMod => {
- let it = tcx.hir().expect_item(def_id);
+ let it = tcx.hir_expect_item(def_id);
let hir::ItemKind::ForeignMod { abi, items } = it.kind else {
return;
};
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
index c193aad2afd00..0a37a27b35bab 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -1031,7 +1031,7 @@ fn report_trait_method_mismatch<'tcx>(
// When the `impl` receiver is an arbitrary self type, like `self: Box<Self>`, the
// span points only at the type `Box<Self`>, but we want to cover the whole
// argument pattern and type.
- let (sig, body) = tcx.hir().expect_impl_item(impl_m.def_id.expect_local()).expect_fn();
+ let (sig, body) = tcx.hir_expect_impl_item(impl_m.def_id.expect_local()).expect_fn();
let span = tcx
.hir_body_param_names(body)
.zip(sig.decl.inputs.iter())
@@ -1051,7 +1051,7 @@ fn report_trait_method_mismatch<'tcx>(
// Suggestion to change output type. We do not suggest in `async` functions
// to avoid complex logic or incorrect output.
if let ImplItemKind::Fn(sig, _) =
- &tcx.hir().expect_impl_item(impl_m.def_id.expect_local()).kind
+ &tcx.hir_expect_impl_item(impl_m.def_id.expect_local()).kind
&& !sig.header.asyncness.is_async()
{
let msg = "change the output type to match the trait";
@@ -1190,12 +1190,12 @@ fn extract_spans_for_error_reporting<'tcx>(
) -> (Span, Option<Span>) {
let tcx = infcx.tcx;
let mut impl_args = {
- let (sig, _) = tcx.hir().expect_impl_item(impl_m.def_id.expect_local()).expect_fn();
+ let (sig, _) = tcx.hir_expect_impl_item(impl_m.def_id.expect_local()).expect_fn();
sig.decl.inputs.iter().map(|t| t.span).chain(iter::once(sig.decl.output.span()))
};
let trait_args = trait_m.def_id.as_local().map(|def_id| {
- let (sig, _) = tcx.hir().expect_trait_item(def_id).expect_fn();
+ let (sig, _) = tcx.hir_expect_trait_item(def_id).expect_fn();
sig.decl.inputs.iter().map(|t| t.span).chain(iter::once(sig.decl.output.span()))
});
@@ -1371,7 +1371,7 @@ fn compare_number_of_generics<'tcx>(
spans
};
let (trait_spans, impl_trait_spans) = if let Some(def_id) = trait_.def_id.as_local() {
- let trait_item = tcx.hir().expect_trait_item(def_id);
+ let trait_item = tcx.hir_expect_trait_item(def_id);
let arg_spans: Vec<Span> = arg_spans(trait_.kind, trait_item.generics);
let impl_trait_spans: Vec<Span> = trait_item
.generics
@@ -1388,7 +1388,7 @@ fn compare_number_of_generics<'tcx>(
(trait_span.map(|s| vec![s]), vec![])
};
- let impl_item = tcx.hir().expect_impl_item(impl_.def_id.expect_local());
+ let impl_item = tcx.hir_expect_impl_item(impl_.def_id.expect_local());
let impl_item_impl_trait_spans: Vec<Span> = impl_item
.generics
.params
@@ -1466,7 +1466,7 @@ fn compare_number_of_method_arguments<'tcx>(
.def_id
.as_local()
.and_then(|def_id| {
- let (trait_m_sig, _) = &tcx.hir().expect_trait_item(def_id).expect_fn();
+ let (trait_m_sig, _) = &tcx.hir_expect_trait_item(def_id).expect_fn();
let pos = trait_number_args.saturating_sub(1);
trait_m_sig.decl.inputs.get(pos).map(|arg| {
if pos == 0 {
@@ -1478,7 +1478,7 @@ fn compare_number_of_method_arguments<'tcx>(
})
.or_else(|| tcx.hir().span_if_local(trait_m.def_id));
- let (impl_m_sig, _) = &tcx.hir().expect_impl_item(impl_m.def_id.expect_local()).expect_fn();
+ let (impl_m_sig, _) = &tcx.hir_expect_impl_item(impl_m.def_id.expect_local()).expect_fn();
let pos = impl_number_args.saturating_sub(1);
let impl_span = impl_m_sig
.decl
@@ -1580,10 +1580,10 @@ fn compare_synthetic_generics<'tcx>(
// as another generic argument
let new_name = tcx.opt_item_name(trait_def_id)?;
let trait_m = trait_m.def_id.as_local()?;
- let trait_m = tcx.hir().expect_trait_item(trait_m);
+ let trait_m = tcx.hir_expect_trait_item(trait_m);
let impl_m = impl_m.def_id.as_local()?;
- let impl_m = tcx.hir().expect_impl_item(impl_m);
+ let impl_m = tcx.hir_expect_impl_item(impl_m);
// in case there are no generics, take the spot between the function name
// and the opening paren of the argument list
@@ -1613,7 +1613,7 @@ fn compare_synthetic_generics<'tcx>(
err.span_label(impl_span, "expected `impl Trait`, found generic parameter");
let _: Option<_> = try {
let impl_m = impl_m.def_id.as_local()?;
- let impl_m = tcx.hir().expect_impl_item(impl_m);
+ let impl_m = tcx.hir_expect_impl_item(impl_m);
let (sig, _) = impl_m.expect_fn();
let input_tys = sig.decl.inputs;
@@ -1855,7 +1855,7 @@ fn compare_const_predicate_entailment<'tcx>(
debug!(?impl_ty, ?trait_ty);
// Locate the Span containing just the type of the offending impl
- let (ty, _) = tcx.hir().expect_impl_item(impl_ct_def_id).expect_const();
+ let (ty, _) = tcx.hir_expect_impl_item(impl_ct_def_id).expect_const();
cause.span = ty.span;
let mut diag = struct_span_code_err!(
@@ -1868,7 +1868,7 @@ fn compare_const_predicate_entailment<'tcx>(
let trait_c_span = trait_ct.def_id.as_local().map(|trait_ct_def_id| {
// Add a label to the Span containing just the type of the const
- let (ty, _) = tcx.hir().expect_trait_item(trait_ct_def_id).expect_const();
+ let (ty, _) = tcx.hir_expect_trait_item(trait_ct_def_id).expect_const();
ty.span
});
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index d72cf00293f0c..bc33882794eb4 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -543,7 +543,7 @@ fn check_gat_where_clauses(tcx: TyCtxt<'_>, trait_def_id: LocalDefId) {
continue;
}
- let gat_item_hir = tcx.hir().expect_trait_item(gat_def_id);
+ let gat_item_hir = tcx.hir_expect_trait_item(gat_def_id);
debug!(?required_bounds);
let param_env = tcx.param_env(gat_def_id);
diff --git a/compiler/rustc_hir_analysis/src/check_unused.rs b/compiler/rustc_hir_analysis/src/check_unused.rs
index 750c09887a1e5..464ffa8711a53 100644
--- a/compiler/rustc_hir_analysis/src/check_unused.rs
+++ b/compiler/rustc_hir_analysis/src/check_unused.rs
@@ -31,7 +31,7 @@ fn check_unused_traits(tcx: TyCtxt<'_>, (): ()) {
if used_trait_imports.contains(&id) {
continue;
}
- let item = tcx.hir().expect_item(id);
+ let item = tcx.hir_expect_item(id);
if item.span.is_dummy() {
continue;
}
diff --git a/compiler/rustc_hir_analysis/src/coherence/builtin.rs b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
index cee2f487639db..c918abe4c0755 100644
--- a/compiler/rustc_hir_analysis/src/coherence/builtin.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
@@ -82,7 +82,7 @@ fn visit_implementation_of_drop(checker: &Checker<'_>) -> Result<(), ErrorGuaran
_ => {}
}
- let impl_ = tcx.hir().expect_item(impl_did).expect_impl();
+ let impl_ = tcx.hir_expect_item(impl_did).expect_impl();
Err(tcx.dcx().emit_err(errors::DropImplOnWrongItem { span: impl_.self_ty.span }))
}
@@ -109,7 +109,7 @@ fn visit_implementation_of_copy(checker: &Checker<'_>) -> Result<(), ErrorGuaran
match type_allowed_to_implement_copy(tcx, param_env, self_type, cause, impl_header.safety) {
Ok(()) => Ok(()),
Err(CopyImplementationError::InfringingFields(fields)) => {
- let span = tcx.hir().expect_item(impl_did).expect_impl().self_ty.span;
+ let span = tcx.hir_expect_item(impl_did).expect_impl().self_ty.span;
Err(infringing_fields_error(
tcx,
fields.into_iter().map(|(field, ty, reason)| (tcx.def_span(field.did), ty, reason)),
@@ -119,15 +119,15 @@ fn visit_implementation_of_copy(checker: &Checker<'_>) -> Result<(), ErrorGuaran
))
}
Err(CopyImplementationError::NotAnAdt) => {
- let span = tcx.hir().expect_item(impl_did).expect_impl().self_ty.span;
+ let span = tcx.hir_expect_item(impl_did).expect_impl().self_ty.span;
Err(tcx.dcx().emit_err(errors::CopyImplOnNonAdt { span }))
}
Err(CopyImplementationError::HasDestructor) => {
- let span = tcx.hir().expect_item(impl_did).expect_impl().self_ty.span;
+ let span = tcx.hir_expect_item(impl_did).expect_impl().self_ty.span;
Err(tcx.dcx().emit_err(errors::CopyImplOnTypeWithDtor { span }))
}
Err(CopyImplementationError::HasUnsafeFields) => {
- let span = tcx.hir().expect_item(impl_did).expect_impl().self_ty.span;
+ let span = tcx.hir_expect_item(impl_did).expect_impl().self_ty.span;
Err(tcx
.dcx()
.span_delayed_bug(span, format!("cannot implement `Copy` for `{}`", self_type)))
@@ -157,7 +157,7 @@ fn visit_implementation_of_const_param_ty(
match type_allowed_to_implement_const_param_ty(tcx, param_env, self_type, kind, cause) {
Ok(()) => Ok(()),
Err(ConstParamTyImplementationError::InfrigingFields(fields)) => {
- let span = tcx.hir().expect_item(impl_did).expect_impl().self_ty.span;
+ let span = tcx.hir_expect_item(impl_did).expect_impl().self_ty.span;
Err(infringing_fields_error(
tcx,
fields.into_iter().map(|(field, ty, reason)| (tcx.def_span(field.did), ty, reason)),
@@ -167,11 +167,11 @@ fn visit_implementation_of_const_param_ty(
))
}
Err(ConstParamTyImplementationError::NotAnAdtOrBuiltinAllowed) => {
- let span = tcx.hir().expect_item(impl_did).expect_impl().self_ty.span;
+ let span = tcx.hir_expect_item(impl_did).expect_impl().self_ty.span;
Err(tcx.dcx().emit_err(errors::ConstParamTyImplOnNonAdt { span }))
}
Err(ConstParamTyImplementationError::InvalidInnerTyOfBuiltinTy(infringing_tys)) => {
- let span = tcx.hir().expect_item(impl_did).expect_impl().self_ty.span;
+ let span = tcx.hir_expect_item(impl_did).expect_impl().self_ty.span;
Err(infringing_fields_error(
tcx,
infringing_tys.into_iter().map(|(ty, reason)| (span, ty, reason)),
@@ -181,7 +181,7 @@ fn visit_implementation_of_const_param_ty(
))
}
Err(ConstParamTyImplementationError::UnsizedConstParamsFeatureRequired) => {
- let span = tcx.hir().expect_item(impl_did).expect_impl().self_ty.span;
+ let span = tcx.hir_expect_item(impl_did).expect_impl().self_ty.span;
Err(tcx.dcx().emit_err(errors::ConstParamTyImplOnUnsized { span }))
}
}
@@ -526,7 +526,7 @@ pub(crate) fn coerce_unsized_info<'tcx>(
note: true,
}));
} else if diff_fields.len() > 1 {
- let item = tcx.hir().expect_item(impl_did);
+ let item = tcx.hir_expect_item(impl_did);
let span = if let ItemKind::Impl(hir::Impl { of_trait: Some(t), .. }) = &item.kind {
t.path.span
} else {
diff --git a/compiler/rustc_hir_analysis/src/coherence/orphan.rs b/compiler/rustc_hir_analysis/src/coherence/orphan.rs
index dbf7a7378f5ab..0b7fc44460ead 100644
--- a/compiler/rustc_hir_analysis/src/coherence/orphan.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/orphan.rs
@@ -376,7 +376,7 @@ fn emit_orphan_check_error<'tcx>(
) -> ErrorGuaranteed {
match err {
traits::OrphanCheckErr::NonLocalInputType(tys) => {
- let item = tcx.hir().expect_item(impl_def_id);
+ let item = tcx.hir_expect_item(impl_def_id);
let impl_ = item.expect_impl();
let hir_trait_ref = impl_.of_trait.as_ref().unwrap();
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 027aa5554a40c..3cb65a5e6aa5c 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -467,8 +467,7 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
hir::Node::Field(_) | hir::Node::Ctor(_) | hir::Node::Variant(_) => {
let item = self
.tcx
- .hir()
- .expect_item(self.tcx.hir_get_parent_item(self.hir_id()).def_id);
+ .hir_expect_item(self.tcx.hir_get_parent_item(self.hir_id()).def_id);
match &item.kind {
hir::ItemKind::Enum(_, generics)
| hir::ItemKind::Struct(_, generics)
@@ -1143,7 +1142,7 @@ fn adt_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::AdtDef<'_> {
}
fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
- let item = tcx.hir().expect_item(def_id);
+ let item = tcx.hir_expect_item(def_id);
let (is_alias, is_auto, safety, items) = match item.kind {
hir::ItemKind::Trait(is_auto, safety, .., items) => {
@@ -1342,7 +1341,7 @@ fn fn_sig(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_, ty::PolyFn
),
ForeignItem(&hir::ForeignItem { kind: ForeignItemKind::Fn(sig, _, _), .. }) => {
- let abi = tcx.hir().get_foreign_abi(hir_id);
+ let abi = tcx.hir_get_foreign_abi(hir_id);
compute_sig_of_foreign_fn_decl(tcx, def_id, sig.decl, abi, sig.header.safety())
}
@@ -1597,7 +1596,7 @@ pub fn suggest_impl_trait<'tcx>(
fn impl_trait_header(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<ty::ImplTraitHeader<'_>> {
let icx = ItemCtxt::new(tcx, def_id);
- let item = tcx.hir().expect_item(def_id);
+ let item = tcx.hir_expect_item(def_id);
let impl_ = item.expect_impl();
impl_.of_trait.as_ref().map(|ast_trait_ref| {
let selfty = tcx.type_of(def_id).instantiate_identity();
diff --git a/compiler/rustc_hir_analysis/src/collect/dump.rs b/compiler/rustc_hir_analysis/src/collect/dump.rs
index 4debd3977f50a..7cbd31de6bab2 100644
--- a/compiler/rustc_hir_analysis/src/collect/dump.rs
+++ b/compiler/rustc_hir_analysis/src/collect/dump.rs
@@ -13,7 +13,7 @@ pub(crate) fn opaque_hidden_types(tcx: TyCtxt<'_>) {
for id in tcx.hir_crate_items(()).opaques() {
if let hir::OpaqueTyOrigin::FnReturn { parent: fn_def_id, .. }
| hir::OpaqueTyOrigin::AsyncFn { parent: fn_def_id, .. } =
- tcx.hir().expect_opaque_ty(id).origin
+ tcx.hir_expect_opaque_ty(id).origin
&& let hir::Node::TraitItem(trait_item) = tcx.hir_node_by_def_id(fn_def_id)
&& let (_, hir::TraitFn::Required(..)) = trait_item.expect_fn()
{
diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
index 6936544838c81..16caa4f6874c7 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -480,5 +480,5 @@ pub(crate) fn type_alias_is_lazy<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) ->
}
}
}
- HasTait.visit_ty_unambig(tcx.hir().expect_item(def_id).expect_ty_alias().0).is_break()
+ HasTait.visit_ty_unambig(tcx.hir_expect_item(def_id).expect_ty_alias().0).is_break()
}
diff --git a/compiler/rustc_hir_analysis/src/delegation.rs b/compiler/rustc_hir_analysis/src/delegation.rs
index 4dbdfa3d85a9b..cb711ebb91a8e 100644
--- a/compiler/rustc_hir_analysis/src/delegation.rs
+++ b/compiler/rustc_hir_analysis/src/delegation.rs
@@ -404,7 +404,7 @@ fn check_constraints<'tcx>(
};
if let Some(local_sig_id) = sig_id.as_local()
- && tcx.hir().opt_delegation_sig_id(local_sig_id).is_some()
+ && tcx.hir_opt_delegation_sig_id(local_sig_id).is_some()
{
emit("recursive delegation is not supported yet");
}
@@ -416,7 +416,7 @@ pub(crate) fn inherit_sig_for_delegation_item<'tcx>(
tcx: TyCtxt<'tcx>,
def_id: LocalDefId,
) -> &'tcx [Ty<'tcx>] {
- let sig_id = tcx.hir().opt_delegation_sig_id(def_id).unwrap();
+ let sig_id = tcx.hir_opt_delegation_sig_id(def_id).unwrap();
let caller_sig = tcx.fn_sig(sig_id);
if let Err(err) = check_constraints(tcx, def_id, sig_id) {
let sig_len = caller_sig.instantiate_identity().skip_binder().inputs().len() + 1;
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index a0f848f07c4b2..3b17861e90894 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -333,7 +333,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
#[instrument(level = "debug", skip(self), ret)]
pub fn lower_resolved_lifetime(&self, resolved: rbv::ResolvedArg) -> ty::Region<'tcx> {
let tcx = self.tcx();
- let lifetime_name = |def_id| tcx.hir().name(tcx.local_def_id_to_hir_id(def_id));
+ let lifetime_name = |def_id| tcx.hir_name(tcx.local_def_id_to_hir_id(def_id));
match resolved {
rbv::ResolvedArg::StaticLifetime => tcx.lifetimes.re_static,
diff --git a/compiler/rustc_hir_typeck/src/callee.rs b/compiler/rustc_hir_typeck/src/callee.rs
index 5e00161f693f6..2a24d626ac357 100644
--- a/compiler/rustc_hir_typeck/src/callee.rs
+++ b/compiler/rustc_hir_typeck/src/callee.rs
@@ -799,7 +799,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// Emit a different diagnostic for local variables, as they are not
// type definitions themselves, but rather variables *of* that type.
Res::Local(hir_id) => {
- err.arg("local_name", self.tcx.hir().name(hir_id));
+ err.arg("local_name", self.tcx.hir_name(hir_id));
Some(fluent_generated::hir_typeck_invalid_local)
}
Res::Def(kind, def_id) if kind.ns() == Some(Namespace::ValueNS) => {
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
index 35a3491f7c089..37aaaed5477dd 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -613,7 +613,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
.iter()
.take(4)
.map(|(var_hir_id, upvar)| {
- let var_name = self.tcx.hir().name(*var_hir_id).to_string();
+ let var_name = self.tcx.hir_name(*var_hir_id).to_string();
let msg = format!("`{var_name}` captured here");
(upvar.span, msg)
})
diff --git a/compiler/rustc_hir_typeck/src/method/prelude_edition_lints.rs b/compiler/rustc_hir_typeck/src/method/prelude_edition_lints.rs
index 69d7a6c97cb36..72f8793d78399 100644
--- a/compiler/rustc_hir_typeck/src/method/prelude_edition_lints.rs
+++ b/compiler/rustc_hir_typeck/src/method/prelude_edition_lints.rs
@@ -363,7 +363,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let import_items: Vec<_> = applicable_trait
.import_ids
.iter()
- .map(|&import_id| self.tcx.hir().expect_item(import_id))
+ .map(|&import_id| self.tcx.hir_expect_item(import_id))
.collect();
// Find an identifier with which this trait was imported (note that `_` doesn't count).
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
index f87e5b5202ab5..ee01d78965d5c 100644
--- a/compiler/rustc_hir_typeck/src/method/probe.rs
+++ b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -2344,7 +2344,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
return false;
};
let hir_id = self.fcx.tcx.local_def_id_to_hir_id(local_def_id);
- let attrs = self.fcx.tcx.hir().attrs(hir_id);
+ let attrs = self.fcx.tcx.hir_attrs(hir_id);
for attr in attrs {
if sym::doc == attr.name_or_empty() {
} else if sym::rustc_confusables == attr.name_or_empty() {
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 18218a7a0a641..ed6ea8457ceca 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -773,7 +773,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
&& let Ok(pick) = self.lookup_probe_for_diagnostic(
item_name,
Ty::new_ref(tcx, ty::Region::new_error_misc(tcx), ty, ptr_mutbl),
- self.tcx.hir().expect_expr(self.tcx.parent_hir_id(rcvr_expr.hir_id)),
+ self.tcx.hir_expect_expr(self.tcx.parent_hir_id(rcvr_expr.hir_id)),
ProbeScope::TraitsInScope,
None,
)
@@ -816,8 +816,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if let SelfSource::MethodCall(rcvr_expr) = source {
self.suggest_fn_call(&mut err, rcvr_expr, rcvr_ty, |output_ty| {
- let call_expr =
- self.tcx.hir().expect_expr(self.tcx.parent_hir_id(rcvr_expr.hir_id));
+ let call_expr = self.tcx.hir_expect_expr(self.tcx.parent_hir_id(rcvr_expr.hir_id));
let probe = self.lookup_probe_for_diagnostic(
item_name,
output_ty,
@@ -2355,7 +2354,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
Applicability::MachineApplicable,
);
} else {
- let call_expr = tcx.hir().expect_expr(tcx.parent_hir_id(expr.hir_id));
+ let call_expr = tcx.hir_expect_expr(tcx.parent_hir_id(expr.hir_id));
if let Some(span) = call_expr.span.trim_start(item_name.span) {
err.span_suggestion(
@@ -2662,7 +2661,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
mod_id,
expr.hir_id,
) {
- let call_expr = self.tcx.hir().expect_expr(self.tcx.parent_hir_id(expr.hir_id));
+ let call_expr = self.tcx.hir_expect_expr(self.tcx.parent_hir_id(expr.hir_id));
let lang_items = self.tcx.lang_items();
let never_mention_traits = [
@@ -2739,7 +2738,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let SelfSource::MethodCall(expr) = source else {
return;
};
- let call_expr = tcx.hir().expect_expr(tcx.parent_hir_id(expr.hir_id));
+ let call_expr = tcx.hir_expect_expr(tcx.parent_hir_id(expr.hir_id));
let ty::Adt(kind, args) = actual.kind() else {
return;
diff --git a/compiler/rustc_hir_typeck/src/upvar.rs b/compiler/rustc_hir_typeck/src/upvar.rs
index 9a0b22470585f..7111230b7e555 100644
--- a/compiler/rustc_hir_typeck/src/upvar.rs
+++ b/compiler/rustc_hir_typeck/src/upvar.rs
@@ -780,7 +780,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
PlaceBase::Upvar(upvar_id) => upvar_id.var_path.hir_id,
base => bug!("Expected upvar, found={:?}", base),
};
- let var_ident = self.tcx.hir().ident(var_hir_id);
+ let var_ident = self.tcx.hir_ident(var_hir_id);
let Some(min_cap_list) = root_var_min_capture_list.get_mut(&var_hir_id) else {
let mutability = self.determine_capture_mutability(&typeck_results, &place);
@@ -987,13 +987,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
UpvarMigrationInfo::CapturingPrecise { source_expr: Some(capture_expr_id), var_name: captured_name } => {
let cause_span = self.tcx.hir().span(*capture_expr_id);
lint.span_label(cause_span, format!("in Rust 2018, this closure captures all of `{}`, but in Rust 2021, it will only capture `{}`",
- self.tcx.hir().name(*var_hir_id),
+ self.tcx.hir_name(*var_hir_id),
captured_name,
));
}
UpvarMigrationInfo::CapturingNothing { use_span } => {
lint.span_label(*use_span, format!("in Rust 2018, this causes the closure to capture `{}`, but in Rust 2021, it has no effect",
- self.tcx.hir().name(*var_hir_id),
+ self.tcx.hir_name(*var_hir_id),
));
}
@@ -1008,13 +1008,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
match &lint_note.captures_info {
UpvarMigrationInfo::CapturingPrecise { var_name: captured_name, .. } => {
lint.span_label(drop_location_span, format!("in Rust 2018, `{}` is dropped here, but in Rust 2021, only `{}` will be dropped here as part of the closure",
- self.tcx.hir().name(*var_hir_id),
+ self.tcx.hir_name(*var_hir_id),
captured_name,
));
}
UpvarMigrationInfo::CapturingNothing { use_span: _ } => {
lint.span_label(drop_location_span, format!("in Rust 2018, `{v}` is dropped here along with the closure, but in Rust 2021 `{v}` is not part of the closure",
- v = self.tcx.hir().name(*var_hir_id),
+ v = self.tcx.hir_name(*var_hir_id),
));
}
}
@@ -1025,7 +1025,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// not capturing something anymore cannot cause a trait to fail to be implemented:
match &lint_note.captures_info {
UpvarMigrationInfo::CapturingPrecise { var_name: captured_name, .. } => {
- let var_name = self.tcx.hir().name(*var_hir_id);
+ let var_name = self.tcx.hir_name(*var_hir_id);
lint.span_label(closure_head_span, format!("\
in Rust 2018, this closure implements {missing_trait} \
as `{var_name}` implements {missing_trait}, but in Rust 2021, \
@@ -2246,7 +2246,7 @@ fn construct_capture_info_string<'tcx>(
}
fn var_name(tcx: TyCtxt<'_>, var_hir_id: HirId) -> Symbol {
- tcx.hir().name(var_hir_id)
+ tcx.hir_name(var_hir_id)
}
#[instrument(level = "debug", skip(tcx))]
diff --git a/compiler/rustc_incremental/src/assert_dep_graph.rs b/compiler/rustc_incremental/src/assert_dep_graph.rs
index 8f2ca6babea88..1b2056f541f3e 100644
--- a/compiler/rustc_incremental/src/assert_dep_graph.rs
+++ b/compiler/rustc_incremental/src/assert_dep_graph.rs
@@ -123,7 +123,7 @@ impl<'tcx> IfThisChanged<'tcx> {
fn process_attrs(&mut self, def_id: LocalDefId) {
let def_path_hash = self.tcx.def_path_hash(def_id.to_def_id());
let hir_id = self.tcx.local_def_id_to_hir_id(def_id);
- let attrs = self.tcx.hir().attrs(hir_id);
+ let attrs = self.tcx.hir_attrs(hir_id);
for attr in attrs {
if attr.has_name(sym::rustc_if_this_changed) {
let dep_node_interned = self.argument(attr);
diff --git a/compiler/rustc_interface/src/proc_macro_decls.rs b/compiler/rustc_interface/src/proc_macro_decls.rs
index 00600abb5f1e3..a2c1f1dbeda6b 100644
--- a/compiler/rustc_interface/src/proc_macro_decls.rs
+++ b/compiler/rustc_interface/src/proc_macro_decls.rs
@@ -8,7 +8,7 @@ fn proc_macro_decls_static(tcx: TyCtxt<'_>, (): ()) -> Option<LocalDefId> {
let mut decls = None;
for id in tcx.hir_free_items() {
- let attrs = tcx.hir().attrs(id.hir_id());
+ let attrs = tcx.hir_attrs(id.hir_id());
if attr::contains_name(attrs, sym::rustc_proc_macro_decls) {
decls = Some(id.owner_id.def_id);
}
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index f7be37dc4a2c3..918a42f304780 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -419,7 +419,7 @@ impl MissingDoc {
return;
}
- let attrs = cx.tcx.hir().attrs(cx.tcx.local_def_id_to_hir_id(def_id));
+ let attrs = cx.tcx.hir_attrs(cx.tcx.local_def_id_to_hir_id(def_id));
let has_doc = attrs.iter().any(has_doc);
if !has_doc {
cx.emit_span_lint(
@@ -997,7 +997,7 @@ declare_lint_pass!(InvalidNoMangleItems => [NO_MANGLE_CONST_ITEMS, NO_MANGLE_GEN
impl<'tcx> LateLintPass<'tcx> for InvalidNoMangleItems {
fn check_item(&mut self, cx: &LateContext<'_>, it: &hir::Item<'_>) {
- let attrs = cx.tcx.hir().attrs(it.hir_id());
+ let attrs = cx.tcx.hir_attrs(it.hir_id());
let check_no_mangle_on_generic_fn = |no_mangle_attr: &hir::Attribute,
impl_generics: Option<&hir::Generics<'_>>,
generics: &hir::Generics<'_>,
@@ -1050,7 +1050,7 @@ impl<'tcx> LateLintPass<'tcx> for InvalidNoMangleItems {
for it in *items {
if let hir::AssocItemKind::Fn { .. } = it.kind {
if let Some(no_mangle_attr) =
- attr::find_by_name(cx.tcx.hir().attrs(it.id.hir_id()), sym::no_mangle)
+ attr::find_by_name(cx.tcx.hir_attrs(it.id.hir_id()), sym::no_mangle)
{
check_no_mangle_on_generic_fn(
no_mangle_attr,
diff --git a/compiler/rustc_lint/src/expect.rs b/compiler/rustc_lint/src/expect.rs
index 9ca148e1f2549..4c2b82a9a23a6 100644
--- a/compiler/rustc_lint/src/expect.rs
+++ b/compiler/rustc_lint/src/expect.rs
@@ -38,7 +38,7 @@ fn check_expectations(tcx: TyCtxt<'_>, tool_filter: Option<Symbol>) {
}
LintExpectationId::Stable { hir_id, attr_index, lint_index: Some(lint_index) } => {
// We are an `eval_always` query, so looking at the attribute's `AttrId` is ok.
- let attr_id = tcx.hir().attrs(hir_id)[attr_index as usize].id();
+ let attr_id = tcx.hir_attrs(hir_id)[attr_index as usize].id();
(attr_id, lint_index)
}
diff --git a/compiler/rustc_lint/src/late.rs b/compiler/rustc_lint/src/late.rs
index d22515d62d60e..460acd372805b 100644
--- a/compiler/rustc_lint/src/late.rs
+++ b/compiler/rustc_lint/src/late.rs
@@ -48,7 +48,7 @@ impl<'tcx, T: LateLintPass<'tcx>> LateContextAndPass<'tcx, T> {
where
F: FnOnce(&mut Self),
{
- let attrs = self.context.tcx.hir().attrs(id);
+ let attrs = self.context.tcx.hir_attrs(id);
let prev = self.context.last_node_with_lint_attrs;
self.context.last_node_with_lint_attrs = id;
debug!("late context: enter_attrs({:?})", attrs);
diff --git a/compiler/rustc_lint/src/nonstandard_style.rs b/compiler/rustc_lint/src/nonstandard_style.rs
index 49f9ad39780a3..722779d326891 100644
--- a/compiler/rustc_lint/src/nonstandard_style.rs
+++ b/compiler/rustc_lint/src/nonstandard_style.rs
@@ -342,8 +342,8 @@ impl<'tcx> LateLintPass<'tcx> for NonSnakeCase {
let crate_ident = if let Some(name) = &cx.tcx.sess.opts.crate_name {
Some(Ident::from_str(name))
} else {
- ast::attr::find_by_name(cx.tcx.hir().attrs(hir::CRATE_HIR_ID), sym::crate_name)
- .and_then(|attr| {
+ ast::attr::find_by_name(cx.tcx.hir_attrs(hir::CRATE_HIR_ID), sym::crate_name).and_then(
+ |attr| {
if let Attribute::Unparsed(n) = attr
&& let AttrItem { args: AttrArgs::Eq { eq_span: _, expr: lit }, .. } =
n.as_ref()
@@ -371,7 +371,8 @@ impl<'tcx> LateLintPass<'tcx> for NonSnakeCase {
} else {
None
}
- })
+ },
+ )
};
if let Some(ident) = &crate_ident {
@@ -500,7 +501,7 @@ impl NonUpperCaseGlobals {
impl<'tcx> LateLintPass<'tcx> for NonUpperCaseGlobals {
fn check_item(&mut self, cx: &LateContext<'_>, it: &hir::Item<'_>) {
- let attrs = cx.tcx.hir().attrs(it.hir_id());
+ let attrs = cx.tcx.hir_attrs(it.hir_id());
match it.kind {
hir::ItemKind::Static(..) if !ast::attr::contains_name(attrs, sym::no_mangle) => {
NonUpperCaseGlobals::check_upper_case(cx, "static variable", &it.ident);
diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
index cb83d405cc3ed..cf7f9379e39b2 100644
--- a/compiler/rustc_lint/src/types.rs
+++ b/compiler/rustc_lint/src/types.rs
@@ -1611,7 +1611,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
impl<'tcx> LateLintPass<'tcx> for ImproperCTypesDeclarations {
fn check_foreign_item(&mut self, cx: &LateContext<'tcx>, it: &hir::ForeignItem<'tcx>) {
let mut vis = ImproperCTypesVisitor { cx, mode: CItemKind::Declaration };
- let abi = cx.tcx.hir().get_foreign_abi(it.hir_id());
+ let abi = cx.tcx.hir_get_foreign_abi(it.hir_id());
match it.kind {
hir::ForeignItemKind::Fn(sig, _, _) => {
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index 88a88847e6b8b..57c941976e44b 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1357,8 +1357,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
features: &tcx.features(),
};
let attr_iter = tcx
- .hir()
- .attrs(tcx.local_def_id_to_hir_id(def_id))
+ .hir_attrs(tcx.local_def_id_to_hir_id(def_id))
.iter()
.filter(|attr| analyze_attr(*attr, &mut state));
@@ -1839,7 +1838,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
fn encode_info_for_macro(&mut self, def_id: LocalDefId) {
let tcx = self.tcx;
- let hir::ItemKind::Macro(macro_def, _) = tcx.hir().expect_item(def_id).kind else { bug!() };
+ let hir::ItemKind::Macro(macro_def, _) = tcx.hir_expect_item(def_id).kind else { bug!() };
self.tables.is_macro_rules.set(def_id.local_def_index, macro_def.macro_rules);
record!(self.tables.macro_definition[def_id.to_def_id()] <- &*macro_def.body);
}
@@ -1918,11 +1917,11 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
for &proc_macro in &tcx.resolutions(()).proc_macros {
let id = proc_macro;
let proc_macro = tcx.local_def_id_to_hir_id(proc_macro);
- let mut name = hir.name(proc_macro);
+ let mut name = tcx.hir_name(proc_macro);
let span = hir.span(proc_macro);
// Proc-macros may have attributes like `#[allow_internal_unstable]`,
// so downstream crates need access to them.
- let attrs = hir.attrs(proc_macro);
+ let attrs = tcx.hir_attrs(proc_macro);
let macro_kind = if ast::attr::contains_name(attrs, sym::proc_macro) {
MacroKind::Bang
} else if ast::attr::contains_name(attrs, sym::proc_macro_attribute) {
diff --git a/compiler/rustc_middle/src/hir/map.rs b/compiler/rustc_middle/src/hir/map.rs
index 705b09f10e4af..7807709e71050 100644
--- a/compiler/rustc_middle/src/hir/map.rs
+++ b/compiler/rustc_middle/src/hir/map.rs
@@ -374,7 +374,7 @@ impl<'tcx> TyCtxt<'tcx> {
/// invoking `krate.attrs` because it registers a tighter
/// dep-graph access.
pub fn hir_krate_attrs(self) -> &'tcx [Attribute] {
- self.hir().attrs(CRATE_HIR_ID)
+ self.hir_attrs(CRATE_HIR_ID)
}
pub fn hir_rustc_coherence_is_core(self) -> bool {
@@ -774,110 +774,78 @@ impl<'tcx> TyCtxt<'tcx> {
Node::PreciseCapturingNonLifetimeArg(_param) => node_str("parameter"),
}
}
-}
-impl<'hir> Map<'hir> {
- pub fn get_foreign_abi(self, hir_id: HirId) -> ExternAbi {
- let parent = self.tcx.hir_get_parent_item(hir_id);
+ pub fn hir_get_foreign_abi(self, hir_id: HirId) -> ExternAbi {
+ let parent = self.hir_get_parent_item(hir_id);
if let OwnerNode::Item(Item { kind: ItemKind::ForeignMod { abi, .. }, .. }) =
- self.tcx.hir_owner_node(parent)
+ self.hir_owner_node(parent)
{
return *abi;
}
bug!(
"expected foreign mod or inlined parent, found {}",
- self.tcx.hir_id_to_string(HirId::make_owner(parent.def_id))
+ self.hir_id_to_string(HirId::make_owner(parent.def_id))
)
}
- pub fn expect_item(self, id: LocalDefId) -> &'hir Item<'hir> {
- match self.tcx.expect_hir_owner_node(id) {
+ pub fn hir_expect_item(self, id: LocalDefId) -> &'tcx Item<'tcx> {
+ match self.expect_hir_owner_node(id) {
OwnerNode::Item(item) => item,
- _ => bug!("expected item, found {}", self.tcx.hir_id_to_string(HirId::make_owner(id))),
+ _ => bug!("expected item, found {}", self.hir_id_to_string(HirId::make_owner(id))),
}
}
- pub fn expect_impl_item(self, id: LocalDefId) -> &'hir ImplItem<'hir> {
- match self.tcx.expect_hir_owner_node(id) {
+ pub fn hir_expect_impl_item(self, id: LocalDefId) -> &'tcx ImplItem<'tcx> {
+ match self.expect_hir_owner_node(id) {
OwnerNode::ImplItem(item) => item,
- _ => bug!(
- "expected impl item, found {}",
- self.tcx.hir_id_to_string(HirId::make_owner(id))
- ),
+ _ => bug!("expected impl item, found {}", self.hir_id_to_string(HirId::make_owner(id))),
}
}
- pub fn expect_trait_item(self, id: LocalDefId) -> &'hir TraitItem<'hir> {
- match self.tcx.expect_hir_owner_node(id) {
+ pub fn hir_expect_trait_item(self, id: LocalDefId) -> &'tcx TraitItem<'tcx> {
+ match self.expect_hir_owner_node(id) {
OwnerNode::TraitItem(item) => item,
- _ => bug!(
- "expected trait item, found {}",
- self.tcx.hir_id_to_string(HirId::make_owner(id))
- ),
- }
- }
-
- pub fn get_fn_output(self, def_id: LocalDefId) -> Option<&'hir FnRetTy<'hir>> {
- Some(&self.tcx.opt_hir_owner_node(def_id)?.fn_decl()?.output)
- }
-
- pub fn expect_variant(self, id: HirId) -> &'hir Variant<'hir> {
- match self.tcx.hir_node(id) {
- Node::Variant(variant) => variant,
- _ => bug!("expected variant, found {}", self.tcx.hir_id_to_string(id)),
- }
- }
-
- pub fn expect_field(self, id: HirId) -> &'hir FieldDef<'hir> {
- match self.tcx.hir_node(id) {
- Node::Field(field) => field,
- _ => bug!("expected field, found {}", self.tcx.hir_id_to_string(id)),
- }
- }
-
- pub fn expect_foreign_item(self, id: OwnerId) -> &'hir ForeignItem<'hir> {
- match self.tcx.hir_owner_node(id) {
- OwnerNode::ForeignItem(item) => item,
_ => {
- bug!(
- "expected foreign item, found {}",
- self.tcx.hir_id_to_string(HirId::make_owner(id.def_id))
- )
+ bug!("expected trait item, found {}", self.hir_id_to_string(HirId::make_owner(id)))
}
}
}
+ pub fn hir_get_fn_output(self, def_id: LocalDefId) -> Option<&'tcx FnRetTy<'tcx>> {
+ Some(&self.opt_hir_owner_node(def_id)?.fn_decl()?.output)
+ }
+
#[track_caller]
- pub fn expect_opaque_ty(self, id: LocalDefId) -> &'hir OpaqueTy<'hir> {
- match self.tcx.hir_node_by_def_id(id) {
+ pub fn hir_expect_opaque_ty(self, id: LocalDefId) -> &'tcx OpaqueTy<'tcx> {
+ match self.hir_node_by_def_id(id) {
Node::OpaqueTy(opaq) => opaq,
_ => {
bug!(
"expected opaque type definition, found {}",
- self.tcx.hir_id_to_string(self.tcx.local_def_id_to_hir_id(id))
+ self.hir_id_to_string(self.local_def_id_to_hir_id(id))
)
}
}
}
- pub fn expect_expr(self, id: HirId) -> &'hir Expr<'hir> {
- match self.tcx.hir_node(id) {
+ pub fn hir_expect_expr(self, id: HirId) -> &'tcx Expr<'tcx> {
+ match self.hir_node(id) {
Node::Expr(expr) => expr,
- _ => bug!("expected expr, found {}", self.tcx.hir_id_to_string(id)),
+ _ => bug!("expected expr, found {}", self.hir_id_to_string(id)),
}
}
- pub fn opt_delegation_sig_id(self, def_id: LocalDefId) -> Option<DefId> {
- self.tcx.opt_hir_owner_node(def_id)?.fn_decl()?.opt_delegation_sig_id()
+ pub fn hir_opt_delegation_sig_id(self, def_id: LocalDefId) -> Option<DefId> {
+ self.opt_hir_owner_node(def_id)?.fn_decl()?.opt_delegation_sig_id()
}
#[inline]
- fn opt_ident(self, id: HirId) -> Option<Ident> {
- match self.tcx.hir_node(id) {
+ fn hir_opt_ident(self, id: HirId) -> Option<Ident> {
+ match self.hir_node(id) {
Node::Pat(&Pat { kind: PatKind::Binding(_, _, ident, _), .. }) => Some(ident),
// A `Ctor` doesn't have an identifier itself, but its parent
// struct/variant does. Compare with `hir::Map::span`.
- Node::Ctor(..) => match self.tcx.parent_hir_node(id) {
+ Node::Ctor(..) => match self.parent_hir_node(id) {
Node::Item(item) => Some(item.ident),
Node::Variant(variant) => Some(variant.ident),
_ => unreachable!(),
@@ -887,30 +855,32 @@ impl<'hir> Map<'hir> {
}
#[inline]
- pub(super) fn opt_ident_span(self, id: HirId) -> Option<Span> {
- self.opt_ident(id).map(|ident| ident.span)
+ pub(super) fn hir_opt_ident_span(self, id: HirId) -> Option<Span> {
+ self.hir_opt_ident(id).map(|ident| ident.span)
}
#[inline]
- pub fn ident(self, id: HirId) -> Ident {
- self.opt_ident(id).unwrap()
+ pub fn hir_ident(self, id: HirId) -> Ident {
+ self.hir_opt_ident(id).unwrap()
}
#[inline]
- pub fn opt_name(self, id: HirId) -> Option<Symbol> {
- self.opt_ident(id).map(|ident| ident.name)
+ pub fn hir_opt_name(self, id: HirId) -> Option<Symbol> {
+ self.hir_opt_ident(id).map(|ident| ident.name)
}
- pub fn name(self, id: HirId) -> Symbol {
- self.opt_name(id).unwrap_or_else(|| bug!("no name for {}", self.tcx.hir_id_to_string(id)))
+ pub fn hir_name(self, id: HirId) -> Symbol {
+ self.hir_opt_name(id).unwrap_or_else(|| bug!("no name for {}", self.hir_id_to_string(id)))
}
/// Given a node ID, gets a list of attributes associated with the AST
/// corresponding to the node-ID.
- pub fn attrs(self, id: HirId) -> &'hir [Attribute] {
- self.tcx.hir_attr_map(id.owner).get(id.local_id)
+ pub fn hir_attrs(self, id: HirId) -> &'tcx [Attribute] {
+ self.hir_attr_map(id.owner).get(id.local_id)
}
+}
+impl<'hir> Map<'hir> {
/// Gets the span of the definition of the specified HIR node.
/// This is used by `tcx.def_span`.
pub fn span(self, hir_id: HirId) -> Span {
diff --git a/compiler/rustc_middle/src/hir/mod.rs b/compiler/rustc_middle/src/hir/mod.rs
index a19458ad7994d..68b9a4f56b96d 100644
--- a/compiler/rustc_middle/src/hir/mod.rs
+++ b/compiler/rustc_middle/src/hir/mod.rs
@@ -208,7 +208,7 @@ pub fn provide(providers: &mut Providers) {
providers.def_span = |tcx, def_id| tcx.hir().span(tcx.local_def_id_to_hir_id(def_id));
providers.def_ident_span = |tcx, def_id| {
let hir_id = tcx.local_def_id_to_hir_id(def_id);
- tcx.hir().opt_ident_span(hir_id)
+ tcx.hir_opt_ident_span(hir_id)
};
providers.fn_arg_names = |tcx, def_id| {
let hir = tcx.hir();
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index f880b1364c2cd..007e8d3a245ce 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -1200,7 +1200,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
&& let Some(upvars) = tcx.upvars_mentioned(def_id)
{
for (&var_id, place) in iter::zip(upvars.keys(), places) {
- let var_name = tcx.hir().name(var_id);
+ let var_name = tcx.hir_name(var_id);
struct_fmt.field(var_name.as_str(), place);
}
} else {
@@ -1221,7 +1221,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
&& let Some(upvars) = tcx.upvars_mentioned(def_id)
{
for (&var_id, place) in iter::zip(upvars.keys(), places) {
- let var_name = tcx.hir().name(var_id);
+ let var_name = tcx.hir_name(var_id);
struct_fmt.field(var_name.as_str(), place);
}
} else {
diff --git a/compiler/rustc_middle/src/traits/specialization_graph.rs b/compiler/rustc_middle/src/traits/specialization_graph.rs
index 9ce5373b03118..8e54a9d487d92 100644
--- a/compiler/rustc_middle/src/traits/specialization_graph.rs
+++ b/compiler/rustc_middle/src/traits/specialization_graph.rs
@@ -72,7 +72,7 @@ impl OverlapMode {
.as_local()
.into_iter()
.flat_map(|local_def_id| {
- tcx.hir().attrs(tcx.local_def_id_to_hir_id(local_def_id))
+ tcx.hir_attrs(tcx.local_def_id_to_hir_id(local_def_id))
})
.find(|attr| attr.has_name(sym::rustc_strict_coherence))
.map(|attr| attr.span());
diff --git a/compiler/rustc_middle/src/ty/closure.rs b/compiler/rustc_middle/src/ty/closure.rs
index 3605f2402e7ff..c0af69bb68e08 100644
--- a/compiler/rustc_middle/src/ty/closure.rs
+++ b/compiler/rustc_middle/src/ty/closure.rs
@@ -293,7 +293,7 @@ pub struct CaptureInfo {
pub fn place_to_string_for_capture<'tcx>(tcx: TyCtxt<'tcx>, place: &HirPlace<'tcx>) -> String {
let mut curr_string: String = match place.base {
- HirPlaceBase::Upvar(upvar_id) => tcx.hir().name(upvar_id.var_path.hir_id).to_string(),
+ HirPlaceBase::Upvar(upvar_id) => tcx.hir_name(upvar_id.var_path.hir_id).to_string(),
_ => bug!("Capture_information should only contain upvars"),
};
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index d899ae4bd7070..50a400007efc5 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -2209,7 +2209,7 @@ impl<'tcx> TyCtxt<'tcx> {
/// Returns the origin of the opaque type `def_id`.
#[instrument(skip(self), level = "trace", ret)]
pub fn local_opaque_ty_origin(self, def_id: LocalDefId) -> hir::OpaqueTyOrigin<LocalDefId> {
- self.hir().expect_opaque_ty(def_id).origin
+ self.hir_expect_opaque_ty(def_id).origin
}
pub fn finish(self) {
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 527509af05fc7..e8bdd650a7f52 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -1740,7 +1740,7 @@ impl<'tcx> TyCtxt<'tcx> {
// FIXME(@lcnr): Remove this function.
pub fn get_attrs_unchecked(self, did: DefId) -> &'tcx [hir::Attribute] {
if let Some(did) = did.as_local() {
- self.hir().attrs(self.local_def_id_to_hir_id(did))
+ self.hir_attrs(self.local_def_id_to_hir_id(did))
} else {
self.attrs_for_def(did)
}
@@ -1764,7 +1764,7 @@ impl<'tcx> TyCtxt<'tcx> {
) -> impl Iterator<Item = &'tcx hir::Attribute> {
let did: DefId = did.into();
if let Some(did) = did.as_local() {
- self.hir().attrs(self.local_def_id_to_hir_id(did)).iter()
+ self.hir_attrs(self.local_def_id_to_hir_id(did)).iter()
} else {
self.attrs_for_def(did).iter()
}
@@ -1808,7 +1808,7 @@ impl<'tcx> TyCtxt<'tcx> {
) -> impl Iterator<Item = &'tcx hir::Attribute> {
let filter_fn = move |a: &&hir::Attribute| a.path_matches(attr);
if let Some(did) = did.as_local() {
- self.hir().attrs(self.local_def_id_to_hir_id(did)).iter().filter(filter_fn)
+ self.hir_attrs(self.local_def_id_to_hir_id(did)).iter().filter(filter_fn)
} else {
self.attrs_for_def(did).iter().filter(filter_fn)
}
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
index db9e9fbc643b2..f44dbe1d0ea94 100644
--- a/compiler/rustc_middle/src/ty/structural_impls.rs
+++ b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -50,7 +50,7 @@ impl<'tcx> fmt::Debug for ty::AdtDef<'tcx> {
impl fmt::Debug for ty::UpvarId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- let name = ty::tls::with(|tcx| tcx.hir().name(self.var_path.hir_id));
+ let name = ty::tls::with(|tcx| tcx.hir_name(self.var_path.hir_id));
write!(f, "UpvarId({:?};`{}`;{:?})", self.var_path.hir_id, name, self.closure_expr_id)
}
}
diff --git a/compiler/rustc_mir_build/src/builder/mod.rs b/compiler/rustc_mir_build/src/builder/mod.rs
index 949559549345f..3657add04cde9 100644
--- a/compiler/rustc_mir_build/src/builder/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/mod.rs
@@ -485,7 +485,7 @@ fn construct_fn<'tcx>(
};
if let Some(custom_mir_attr) =
- tcx.hir().attrs(fn_id).iter().find(|attr| attr.name_or_empty() == sym::custom_mir)
+ tcx.hir_attrs(fn_id).iter().find(|attr| attr.name_or_empty() == sym::custom_mir)
{
return custom::build_custom_mir(
tcx,
@@ -740,7 +740,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
coroutine: Option<Box<CoroutineInfo<'tcx>>>,
) -> Builder<'a, 'tcx> {
let tcx = infcx.tcx;
- let attrs = tcx.hir().attrs(hir_id);
+ let attrs = tcx.hir_attrs(hir_id);
// Some functions always have overflow checks enabled,
// however, they may not get codegen'd, depending on
// the settings for the crate they are codegened in.
diff --git a/compiler/rustc_mir_build/src/builder/scope.rs b/compiler/rustc_mir_build/src/builder/scope.rs
index 8156123949121..27ff01b48034b 100644
--- a/compiler/rustc_mir_build/src/builder/scope.rs
+++ b/compiler/rustc_mir_build/src/builder/scope.rs
@@ -942,14 +942,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
assert_eq!(orig_id.owner, self.hir_id.owner);
let mut id = orig_id;
- let hir = self.tcx.hir();
loop {
if id == self.hir_id {
// This is a moderately common case, mostly hit for previously unseen nodes.
break;
}
- if hir.attrs(id).iter().any(|attr| Level::from_attr(attr).is_some()) {
+ if self.tcx.hir_attrs(id).iter().any(|attr| Level::from_attr(attr).is_some()) {
// This is a rare case. It's for a node path that doesn't reach the root due to an
// intervening lint level attribute. This result doesn't get cached.
return id;
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index 7139516702e99..adc07f89beb5b 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -1037,7 +1037,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
"Should have already errored about late bound consts: {def_id:?}"
);
};
- let name = self.tcx.hir().name(hir_id);
+ let name = self.tcx.hir_name(hir_id);
let param = ty::ParamConst::new(index, name);
ExprKind::ConstParam { param, def_id }
diff --git a/compiler/rustc_mir_build/src/thir/cx/mod.rs b/compiler/rustc_mir_build/src/thir/cx/mod.rs
index 2e069cae4269f..1e84f4aada12f 100644
--- a/compiler/rustc_mir_build/src/thir/cx/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/mod.rs
@@ -73,7 +73,6 @@ struct ThirBuildCx<'tcx> {
impl<'tcx> ThirBuildCx<'tcx> {
fn new(tcx: TyCtxt<'tcx>, def: LocalDefId) -> Self {
let typeck_results = tcx.typeck(def);
- let hir = tcx.hir();
let hir_id = tcx.local_def_id_to_hir_id(def);
let body_type = match tcx.hir_body_owner_kind(def) {
@@ -111,8 +110,8 @@ impl<'tcx> ThirBuildCx<'tcx> {
typeck_results,
rvalue_scopes: &typeck_results.rvalue_scopes,
body_owner: def.to_def_id(),
- apply_adjustments: hir
- .attrs(hir_id)
+ apply_adjustments: tcx
+ .hir_attrs(hir_id)
.iter()
.all(|attr| attr.name_or_empty() != rustc_span::sym::custom_mir),
}
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index 954d0cf97abef..c06f0f2a975a7 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -1042,7 +1042,7 @@ fn find_fallback_pattern_typo<'tcx>(
for item in cx.tcx.hir_crate_items(()).free_items() {
if let DefKind::Use = cx.tcx.def_kind(item.owner_id) {
// Look for consts being re-exported.
- let item = cx.tcx.hir().expect_item(item.owner_id.def_id);
+ let item = cx.tcx.hir_expect_item(item.owner_id.def_id);
let use_name = item.ident.name;
let hir::ItemKind::Use(path, _) = item.kind else {
continue;
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index d6c0edf5ae7b8..f88f84cbcd11d 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -51,7 +51,7 @@ fn target_from_impl_item<'tcx>(tcx: TyCtxt<'tcx>, impl_item: &hir::ImplItem<'_>)
hir::ImplItemKind::Const(..) => Target::AssocConst,
hir::ImplItemKind::Fn(..) => {
let parent_def_id = tcx.hir_get_parent_item(impl_item.hir_id()).def_id;
- let containing_item = tcx.hir().expect_item(parent_def_id);
+ let containing_item = tcx.hir_expect_item(parent_def_id);
let containing_impl_is_for_trait = match &containing_item.kind {
hir::ItemKind::Impl(impl_) => impl_.of_trait.is_some(),
_ => bug!("parent of an ImplItem must be an Impl"),
@@ -113,7 +113,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
let mut doc_aliases = FxHashMap::default();
let mut specified_inline = None;
let mut seen = FxHashMap::default();
- let attrs = self.tcx.hir().attrs(hir_id);
+ let attrs = self.tcx.hir_attrs(hir_id);
for attr in attrs {
match attr {
Attribute::Parsed(AttributeKind::Confusables { first_span, .. }) => {
@@ -895,7 +895,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
if let Some(location) = match target {
Target::AssocTy => {
let parent_def_id = self.tcx.hir_get_parent_item(hir_id).def_id;
- let containing_item = self.tcx.hir().expect_item(parent_def_id);
+ let containing_item = self.tcx.hir_expect_item(parent_def_id);
if Target::from_item(containing_item) == Target::Impl {
Some("type alias in implementation block")
} else {
@@ -904,7 +904,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
}
Target::AssocConst => {
let parent_def_id = self.tcx.hir_get_parent_item(hir_id).def_id;
- let containing_item = self.tcx.hir().expect_item(parent_def_id);
+ let containing_item = self.tcx.hir_expect_item(parent_def_id);
// We can't link to trait impl's consts.
let err = "associated constant in trait implementation block";
match containing_item.kind {
@@ -948,7 +948,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
tcx.dcx().emit_err(errors::DocAliasBadLocation { span, attr_str, location });
return;
}
- let item_name = self.tcx.hir().name(hir_id);
+ let item_name = self.tcx.hir_name(hir_id);
if item_name == doc_alias {
tcx.dcx().emit_err(errors::DocAliasNotAnAlias { span, attr_str });
return;
@@ -1477,7 +1477,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
// `#[must_use]` can be applied to a trait method definition with a default body
if let Target::Method(MethodKind::Trait { body: true }) = target
&& let parent_def_id = self.tcx.hir_get_parent_item(hir_id).def_id
- && let containing_item = self.tcx.hir().expect_item(parent_def_id)
+ && let containing_item = self.tcx.hir_expect_item(parent_def_id)
&& let hir::ItemKind::Trait(..) = containing_item.kind
{
return;
@@ -2551,7 +2551,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
match (target, force_inline_attr) {
(Target::Closure, None) => {
let is_coro = matches!(
- self.tcx.hir().expect_expr(hir_id).kind,
+ self.tcx.hir_expect_expr(hir_id).kind,
hir::ExprKind::Closure(hir::Closure {
kind: hir::ClosureKind::Coroutine(..)
| hir::ClosureKind::CoroutineClosure(..),
@@ -2623,8 +2623,7 @@ impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {
const ATTRS_ALLOWED: &[Symbol] = &[sym::cfg, sym::cfg_attr];
let spans = self
.tcx
- .hir()
- .attrs(where_predicate.hir_id)
+ .hir_attrs(where_predicate.hir_id)
.iter()
.filter(|attr| !ATTRS_ALLOWED.iter().any(|&sym| attr.has_name(sym)))
.map(|attr| attr.span())
@@ -2793,7 +2792,7 @@ fn check_invalid_crate_level_attr(tcx: TyCtxt<'_>, attrs: &[Attribute]) {
}
fn check_non_exported_macro_for_invalid_attrs(tcx: TyCtxt<'_>, item: &Item<'_>) {
- let attrs = tcx.hir().attrs(item.hir_id());
+ let attrs = tcx.hir_attrs(item.hir_id());
for attr in attrs {
if attr.has_name(sym::inline) {
diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs
index 7a14a7a5db299..7029c60c3439b 100644
--- a/compiler/rustc_passes/src/dead.rs
+++ b/compiler/rustc_passes/src/dead.rs
@@ -361,7 +361,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
self.tcx.hir_fn_sig_by_hir_id(self.tcx.local_def_id_to_hir_id(local_def_id))
&& matches!(fn_sig.decl.implicit_self, hir::ImplicitSelfKind::None)
&& let TyKind::Path(hir::QPath::Resolved(_, path)) =
- self.tcx.hir().expect_item(local_impl_of).expect_impl().self_ty.kind
+ self.tcx.hir_expect_item(local_impl_of).expect_impl().self_ty.kind
&& let Res::Def(def_kind, did) = path.res
{
match def_kind {
@@ -424,7 +424,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
for impl_def_id in self.tcx.all_impls(item.owner_id.to_def_id()) {
if let Some(local_def_id) = impl_def_id.as_local()
&& let ItemKind::Impl(impl_ref) =
- self.tcx.hir().expect_item(local_def_id).kind
+ self.tcx.hir_expect_item(local_def_id).kind
{
// skip items
// mark dependent traits live
@@ -448,7 +448,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
for impl_id in self.tcx.all_impls(trait_id) {
if let Some(local_impl_id) = impl_id.as_local()
&& let ItemKind::Impl(impl_ref) =
- self.tcx.hir().expect_item(local_impl_id).kind
+ self.tcx.hir_expect_item(local_impl_id).kind
{
if !matches!(trait_item.kind, hir::TraitItemKind::Type(..))
&& !ty_ref_to_pub_struct(self.tcx, impl_ref.self_ty)
diff --git a/compiler/rustc_passes/src/diagnostic_items.rs b/compiler/rustc_passes/src/diagnostic_items.rs
index 323b414cca04c..e13d94c1031ac 100644
--- a/compiler/rustc_passes/src/diagnostic_items.rs
+++ b/compiler/rustc_passes/src/diagnostic_items.rs
@@ -19,7 +19,7 @@ use rustc_span::{Symbol, sym};
use crate::errors::DuplicateDiagnosticItemInCrate;
fn observe_item<'tcx>(tcx: TyCtxt<'tcx>, diagnostic_items: &mut DiagnosticItems, owner: OwnerId) {
- let attrs = tcx.hir().attrs(owner.into());
+ let attrs = tcx.hir_attrs(owner.into());
if let Some(name) = extract(attrs) {
// insert into our table
collect_item(tcx, diagnostic_items, name, owner.to_def_id());
diff --git a/compiler/rustc_passes/src/entry.rs b/compiler/rustc_passes/src/entry.rs
index 25e679a84601e..d2729876ebbb4 100644
--- a/compiler/rustc_passes/src/entry.rs
+++ b/compiler/rustc_passes/src/entry.rs
@@ -31,7 +31,7 @@ fn entry_fn(tcx: TyCtxt<'_>, (): ()) -> Option<(DefId, EntryFnType)> {
}
// If the user wants no main function at all, then stop here.
- if attr::contains_name(tcx.hir().attrs(CRATE_HIR_ID), sym::no_main) {
+ if attr::contains_name(tcx.hir_attrs(CRATE_HIR_ID), sym::no_main) {
return None;
}
@@ -45,7 +45,7 @@ fn entry_fn(tcx: TyCtxt<'_>, (): ()) -> Option<(DefId, EntryFnType)> {
}
fn attr_span_by_symbol(ctxt: &EntryContext<'_>, id: ItemId, sym: Symbol) -> Option<Span> {
- let attrs = ctxt.tcx.hir().attrs(id.hir_id());
+ let attrs = ctxt.tcx.hir_attrs(id.hir_id());
attr::find_by_name(attrs, sym).map(|attr| attr.span())
}
@@ -61,7 +61,7 @@ fn check_and_search_item(id: ItemId, ctxt: &mut EntryContext<'_>) {
let at_root = ctxt.tcx.opt_local_parent(id.owner_id.def_id) == Some(CRATE_DEF_ID);
- let attrs = ctxt.tcx.hir().attrs(id.hir_id());
+ let attrs = ctxt.tcx.hir_attrs(id.hir_id());
let entry_point_type = rustc_ast::entry::entry_point_type(
attrs,
at_root,
diff --git a/compiler/rustc_passes/src/liveness.rs b/compiler/rustc_passes/src/liveness.rs
index 24dc018c66124..2d3aca675d415 100644
--- a/compiler/rustc_passes/src/liveness.rs
+++ b/compiler/rustc_passes/src/liveness.rs
@@ -157,7 +157,7 @@ fn check_liveness(tcx: TyCtxt<'_>, def_id: LocalDefId) {
if let Some(upvars) = tcx.upvars_mentioned(def_id) {
for &var_hir_id in upvars.keys() {
- let var_name = tcx.hir().name(var_hir_id);
+ let var_name = tcx.hir_name(var_hir_id);
maps.add_variable(Upvar(var_hir_id, var_name));
}
}
diff --git a/compiler/rustc_passes/src/loops.rs b/compiler/rustc_passes/src/loops.rs
index 8e59c0b3251ca..b06f16cc7bd2f 100644
--- a/compiler/rustc_passes/src/loops.rs
+++ b/compiler/rustc_passes/src/loops.rs
@@ -222,7 +222,7 @@ impl<'hir> Visitor<'hir> for CheckLoopVisitor<'hir> {
if let Some(break_expr) = opt_expr {
let (head, loop_label, loop_kind) = if let Some(loop_id) = loop_id {
- match self.tcx.hir().expect_expr(loop_id).kind {
+ match self.tcx.hir_expect_expr(loop_id).kind {
hir::ExprKind::Loop(_, label, source, sp) => {
(Some(sp), label, Some(source))
}
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index 0fcf6a80ec4de..aea4386295f31 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -118,7 +118,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
) where
F: FnOnce(&mut Self),
{
- let attrs = self.tcx.hir().attrs(self.tcx.local_def_id_to_hir_id(def_id));
+ let attrs = self.tcx.hir_attrs(self.tcx.local_def_id_to_hir_id(def_id));
debug!("annotate(id = {:?}, attrs = {:?})", def_id, attrs);
let depr = attr::find_attr!(attrs, AttributeKind::Deprecation{deprecation, span} => (*deprecation, *span));
@@ -795,7 +795,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
}) => {
let features = self.tcx.features();
if features.staged_api() {
- let attrs = self.tcx.hir().attrs(item.hir_id());
+ let attrs = self.tcx.hir_attrs(item.hir_id());
let stab = attr::find_attr!(attrs, AttributeKind::Stability{stability, span} => (*stability, *span));
// FIXME(jdonszelmann): make it impossible to miss the or_else in the typesystem
@@ -1034,7 +1034,7 @@ fn is_unstable_reexport(tcx: TyCtxt<'_>, id: hir::HirId) -> bool {
}
// If this is a path that isn't a use, we don't need to do anything special
- if !matches!(tcx.hir().expect_item(def_id).kind, ItemKind::Use(..)) {
+ if !matches!(tcx.hir_expect_item(def_id).kind, ItemKind::Use(..)) {
return false;
}
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
index 5271d03a6f617..3794b23c86a60 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -493,7 +493,7 @@ impl<'tcx> EmbargoVisitor<'tcx> {
) {
// Non-opaque macros cannot make other items more accessible than they already are.
let hir_id = self.tcx.local_def_id_to_hir_id(local_def_id);
- let attrs = self.tcx.hir().attrs(hir_id);
+ let attrs = self.tcx.hir_attrs(hir_id);
if attr::find_attr!(attrs, AttributeKind::MacroTransparency(x) => *x)
.unwrap_or(Transparency::fallback(md.macro_rules))
@@ -573,7 +573,7 @@ impl<'tcx> EmbargoVisitor<'tcx> {
// have normal hygiene, so we can treat them like other items without type
// privacy and mark them reachable.
DefKind::Macro(_) => {
- let item = self.tcx.hir().expect_item(def_id);
+ let item = self.tcx.hir_expect_item(def_id);
if let hir::ItemKind::Macro(MacroDef { macro_rules: false, .. }, _) = item.kind {
if vis.is_accessible_from(module, self.tcx) {
self.update(def_id, macro_ev, Level::Reachable);
@@ -597,7 +597,7 @@ impl<'tcx> EmbargoVisitor<'tcx> {
DefKind::Struct | DefKind::Union => {
// While structs and unions have type privacy, their fields do not.
- let item = self.tcx.hir().expect_item(def_id);
+ let item = self.tcx.hir_expect_item(def_id);
if let hir::ItemKind::Struct(ref struct_def, _)
| hir::ItemKind::Union(ref struct_def, _) = item.kind
{
diff --git a/compiler/rustc_smir/src/rustc_smir/context.rs b/compiler/rustc_smir/src/rustc_smir/context.rs
index acd3b75835105..aa1921fc8e784 100644
--- a/compiler/rustc_smir/src/rustc_smir/context.rs
+++ b/compiler/rustc_smir/src/rustc_smir/context.rs
@@ -272,7 +272,7 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
let tcx = tables.tcx;
let did = tables[def_id];
let attrs_iter = if let Some(did) = did.as_local() {
- tcx.hir().attrs(tcx.local_def_id_to_hir_id(did)).iter()
+ tcx.hir_attrs(tcx.local_def_id_to_hir_id(did)).iter()
} else {
tcx.attrs_for_def(did).iter()
};
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
index 42d37418fb848..baf2489b2b8b2 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
@@ -509,7 +509,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
hir::MatchSource::TryDesugar(scrut_hir_id),
) => {
if let Some(ty::error::ExpectedFound { expected, .. }) = exp_found {
- let scrut_expr = self.tcx.hir().expect_expr(scrut_hir_id);
+ let scrut_expr = self.tcx.hir_expect_expr(scrut_hir_id);
let scrut_ty = if let hir::ExprKind::Call(_, args) = &scrut_expr.kind {
let arg_expr = args.first().expect("try desugaring call w/out arg");
self.typeck_results
@@ -548,7 +548,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
}) => match source {
hir::MatchSource::TryDesugar(scrut_hir_id) => {
if let Some(ty::error::ExpectedFound { expected, .. }) = exp_found {
- let scrut_expr = self.tcx.hir().expect_expr(scrut_hir_id);
+ let scrut_expr = self.tcx.hir_expect_expr(scrut_hir_id);
let scrut_ty = if let hir::ExprKind::Call(_, args) = &scrut_expr.kind {
let arg_expr = args.first().expect("try desugaring call w/out arg");
self.typeck_results
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
index a6d8eb6add7d0..40958ec1088bc 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
@@ -1351,7 +1351,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindInferSourceVisitor<'a, 'tcx> {
&& !has_impl_trait(def_id)
// FIXME(fn_delegation): In delegation item argument spans are equal to last path
// segment. This leads to ICE's when emitting `multipart_suggestion`.
- && tcx.hir().opt_delegation_sig_id(expr.hir_id.owner.def_id).is_none()
+ && tcx.hir_opt_delegation_sig_id(expr.hir_id.owner.def_id).is_none()
{
let successor =
method_args.get(0).map_or_else(|| (")", span.hi()), |arg| (", ", arg.span.lo()));
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
index 514615735a507..b39b9c15f2547 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
@@ -726,7 +726,7 @@ fn foo(&self) -> Self::T { String::new() }
if let ty::Alias(ty::Opaque, ty::AliasTy { def_id, .. }) = *proj_ty.self_ty().kind() {
let opaque_local_def_id = def_id.as_local();
let opaque_hir_ty = if let Some(opaque_local_def_id) = opaque_local_def_id {
- tcx.hir().expect_opaque_ty(opaque_local_def_id)
+ tcx.hir_expect_opaque_ty(opaque_local_def_id)
} else {
return false;
};
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
index fecb38ab597e4..c7f0a88f951a8 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
@@ -1023,7 +1023,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
format!(" for lifetime parameter `{name}`")
}
infer::UpvarRegion(ref upvar_id, _) => {
- let var_name = self.tcx.hir().name(upvar_id.var_path.hir_id);
+ let var_name = self.tcx.hir_name(upvar_id.var_path.hir_id);
format!(" for capture of `{var_name}` by closure")
}
infer::Nll(..) => bug!("NLL variable found in lexical phase"),
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/suggest.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/suggest.rs
index a7e68e6419d84..cdbb92f4c7baa 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/suggest.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/suggest.rs
@@ -778,8 +778,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let exp_local_id = exp_def_id.as_local()?;
match (
- &self.tcx.hir().expect_opaque_ty(last_local_id),
- &self.tcx.hir().expect_opaque_ty(exp_local_id),
+ &self.tcx.hir_expect_opaque_ty(last_local_id),
+ &self.tcx.hir_expect_opaque_ty(exp_local_id),
) {
(
hir::OpaqueTy { bounds: last_bounds, .. },
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
index b85c18c53121f..957a74544ea96 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -22,7 +22,6 @@ use rustc_hir::{
expr_needs_parens, is_range_literal,
};
use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes, InferCtxt, InferOk};
-use rustc_middle::hir::map;
use rustc_middle::traits::IsConstable;
use rustc_middle::ty::error::TypeError;
use rustc_middle::ty::print::{
@@ -93,7 +92,7 @@ impl<'a, 'tcx> CoroutineData<'a, 'tcx> {
fn get_from_await_ty<F>(
&self,
visitor: AwaitsVisitor,
- hir: map::Map<'tcx>,
+ tcx: TyCtxt<'tcx>,
ty_matches: F,
) -> Option<Span>
where
@@ -102,7 +101,7 @@ impl<'a, 'tcx> CoroutineData<'a, 'tcx> {
visitor
.awaits
.into_iter()
- .map(|id| hir.expect_expr(id))
+ .map(|id| tcx.hir_expect_expr(id))
.find(|await_expr| ty_matches(ty::Binder::dummy(self.0.expr_ty_adjusted(await_expr))))
.map(|expr| expr.span)
}
@@ -2180,8 +2179,6 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
err: &mut Diag<'_, G>,
obligation: &PredicateObligation<'tcx>,
) -> bool {
- let hir = self.tcx.hir();
-
// Attempt to detect an async-await error by looking at the obligation causes, looking
// for a coroutine to be present.
//
@@ -2350,7 +2347,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
let mut interior_or_upvar_span = None;
- let from_awaited_ty = coroutine_data.get_from_await_ty(visitor, hir, ty_matches);
+ let from_awaited_ty = coroutine_data.get_from_await_ty(visitor, self.tcx, ty_matches);
debug!(?from_awaited_ty);
// Avoid disclosing internal information to downstream crates.
@@ -2428,7 +2425,6 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
// Special case the primary error message when send or sync is the trait that was
// not implemented.
- let hir = self.tcx.hir();
let trait_explanation = if let Some(name @ (sym::Send | sym::Sync)) =
self.tcx.get_diagnostic_name(trait_pred.def_id())
{
@@ -2455,7 +2451,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
.parent(coroutine_did)
.as_local()
.map(|parent_did| self.tcx.local_def_id_to_hir_id(parent_did))
- .and_then(|parent_hir_id| hir.opt_name(parent_hir_id))
+ .and_then(|parent_hir_id| self.tcx.hir_opt_name(parent_hir_id))
.map(|name| {
format!("future returned by `{name}` is not {trait_name}")
})?,
@@ -2479,7 +2475,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
.parent(coroutine_did)
.as_local()
.map(|parent_did| self.tcx.local_def_id_to_hir_id(parent_did))
- .and_then(|parent_hir_id| hir.opt_name(parent_hir_id))
+ .and_then(|parent_hir_id| self.tcx.hir_opt_name(parent_hir_id))
.map(|name| {
format!("async iterator returned by `{name}` is not {trait_name}")
})?,
@@ -2502,7 +2498,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
.parent(coroutine_did)
.as_local()
.map(|parent_did| self.tcx.local_def_id_to_hir_id(parent_did))
- .and_then(|parent_hir_id| hir.opt_name(parent_hir_id))
+ .and_then(|parent_hir_id| self.tcx.hir_opt_name(parent_hir_id))
.map(|name| {
format!("iterator returned by `{name}` is not {trait_name}")
})?
@@ -3566,7 +3562,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
ObligationCauseCode::OpaqueReturnType(expr_info) => {
let (expr_ty, expr) = if let Some((expr_ty, hir_id)) = expr_info {
let expr_ty = tcx.short_string(expr_ty, err.long_ty_path());
- let expr = tcx.hir().expect_expr(hir_id);
+ let expr = tcx.hir_expect_expr(hir_id);
(expr_ty, expr)
} else if let Some(body_id) = tcx.hir_node_by_def_id(body_id).body_id()
&& let body = tcx.hir_body(body_id)
diff --git a/compiler/rustc_ty_utils/src/assoc.rs b/compiler/rustc_ty_utils/src/assoc.rs
index c8034f4e7b9f6..fb53e280af806 100644
--- a/compiler/rustc_ty_utils/src/assoc.rs
+++ b/compiler/rustc_ty_utils/src/assoc.rs
@@ -21,7 +21,7 @@ pub(crate) fn provide(providers: &mut Providers) {
}
fn associated_item_def_ids(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &[DefId] {
- let item = tcx.hir().expect_item(def_id);
+ let item = tcx.hir_expect_item(def_id);
match item.kind {
hir::ItemKind::Trait(.., trait_item_refs) => {
// We collect RPITITs for each trait method's return type and create a
@@ -96,7 +96,7 @@ fn impl_item_implementor_ids(tcx: TyCtxt<'_>, impl_id: DefId) -> DefIdMap<DefId>
fn associated_item(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::AssocItem {
let id = tcx.local_def_id_to_hir_id(def_id);
let parent_def_id = tcx.hir_get_parent_item(id);
- let parent_item = tcx.hir().expect_item(parent_def_id.def_id);
+ let parent_item = tcx.hir_expect_item(parent_def_id.def_id);
match parent_item.kind {
hir::ItemKind::Impl(impl_) => {
if let Some(impl_item_ref) = impl_.items.iter().find(|i| i.id.owner_id.def_id == def_id)
@@ -201,7 +201,7 @@ fn associated_types_for_impl_traits_in_associated_fn(
let mut visitor = RPITVisitor { rpits: FxIndexSet::default() };
- if let Some(output) = tcx.hir().get_fn_output(fn_def_id) {
+ if let Some(output) = tcx.hir_get_fn_output(fn_def_id) {
visitor.visit_fn_ret_ty(output);
tcx.arena.alloc_from_iter(visitor.rpits.iter().map(|opaque_ty_def_id| {
diff --git a/compiler/rustc_ty_utils/src/implied_bounds.rs b/compiler/rustc_ty_utils/src/implied_bounds.rs
index 6205578bf7476..aeaa83c77b5f1 100644
--- a/compiler/rustc_ty_utils/src/implied_bounds.rs
+++ b/compiler/rustc_ty_utils/src/implied_bounds.rs
@@ -161,7 +161,7 @@ fn fn_sig_spans(tcx: TyCtxt<'_>, def_id: LocalDefId) -> impl Iterator<Item = Spa
}
fn impl_spans(tcx: TyCtxt<'_>, def_id: LocalDefId) -> impl Iterator<Item = Span> {
- let item = tcx.hir().expect_item(def_id);
+ let item = tcx.hir_expect_item(def_id);
if let hir::ItemKind::Impl(impl_) = item.kind {
let trait_args = impl_
.of_trait
diff --git a/src/doc/rustc-dev-guide/src/hir.md b/src/doc/rustc-dev-guide/src/hir.md
index 51893d537d750..75f5a9e204528 100644
--- a/src/doc/rustc-dev-guide/src/hir.md
+++ b/src/doc/rustc-dev-guide/src/hir.md
@@ -139,12 +139,12 @@ defined in the map. By matching on this, you can find out what sort of
node the `HirId` referred to and also get a pointer to the data
itself. Often, you know what sort of node `n` is – e.g. if you know
that `n` must be some HIR expression, you can do
-[`tcx.hir().expect_expr(n)`][expect_expr], which will extract and return the
+[`tcx.hir_expect_expr(n)`][expect_expr], which will extract and return the
[`&hir::Expr`][Expr], panicking if `n` is not in fact an expression.
[find]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/hir/map/struct.Map.html#method.find
[`Node`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/hir/enum.Node.html
-[expect_expr]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/hir/map/struct.Map.html#method.expect_expr
+[expect_expr]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyCtxt.html#method.expect_expr
[Expr]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/hir/struct.Expr.html
Finally, you can use the HIR map to find the parents of nodes, via
diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
index e10a74221ae2e..09059bfbf0140 100644
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@@ -181,7 +181,7 @@ pub(crate) fn try_inline_glob(
.filter_map(|child| child.res.opt_def_id())
.filter(|def_id| !cx.tcx.is_doc_hidden(def_id))
.collect();
- let attrs = cx.tcx.hir().attrs(import.hir_id());
+ let attrs = cx.tcx.hir_attrs(import.hir_id());
let mut items = build_module_items(
cx,
did,
@@ -455,7 +455,7 @@ pub(crate) fn build_impl(
}
let impl_item = match did.as_local() {
- Some(did) => match &tcx.hir().expect_item(did).kind {
+ Some(did) => match &tcx.hir_expect_item(did).kind {
hir::ItemKind::Impl(impl_) => Some(impl_),
_ => panic!("`DefID` passed to `build_impl` is not an `impl"),
},
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index ceffe5e5ce04e..393c0784483ee 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -112,7 +112,7 @@ pub(crate) fn clean_doc_module<'tcx>(doc: &DocModule<'tcx>, cx: &mut DocContext<
items.extend(doc.inlined_foreigns.iter().flat_map(|((_, renamed), (res, local_import_id))| {
let Some(def_id) = res.opt_def_id() else { return Vec::new() };
let name = renamed.unwrap_or_else(|| cx.tcx.item_name(def_id));
- let import = cx.tcx.hir().expect_item(*local_import_id);
+ let import = cx.tcx.hir_expect_item(*local_import_id);
match import.kind {
hir::ItemKind::Use(path, kind) => {
let hir::UsePath { segments, span, .. } = *path;
@@ -125,7 +125,7 @@ pub(crate) fn clean_doc_module<'tcx>(doc: &DocModule<'tcx>, cx: &mut DocContext<
items.extend(doc.items.values().flat_map(|(item, renamed, _)| {
// Now we actually lower the imports, skipping everything else.
if let hir::ItemKind::Use(path, hir::UseKind::Glob) = item.kind {
- let name = renamed.unwrap_or_else(|| cx.tcx.hir().name(item.hir_id()));
+ let name = renamed.unwrap_or_else(|| cx.tcx.hir_name(item.hir_id()));
clean_use_statement(item, name, path, hir::UseKind::Glob, cx, &mut inserted)
} else {
// skip everything else
@@ -990,7 +990,7 @@ fn clean_proc_macro<'tcx>(
kind: MacroKind,
cx: &mut DocContext<'tcx>,
) -> ItemKind {
- let attrs = cx.tcx.hir().attrs(item.hir_id());
+ let attrs = cx.tcx.hir_attrs(item.hir_id());
if kind == MacroKind::Derive
&& let Some(derive_name) =
hir_attr_lists(attrs, sym::proc_macro_derive).find_map(|mi| mi.ident())
@@ -1023,7 +1023,7 @@ fn clean_fn_or_proc_macro<'tcx>(
name: &mut Symbol,
cx: &mut DocContext<'tcx>,
) -> ItemKind {
- let attrs = cx.tcx.hir().attrs(item.hir_id());
+ let attrs = cx.tcx.hir_attrs(item.hir_id());
let macro_kind = attrs.iter().find_map(|a| {
if a.has_name(sym::proc_macro) {
Some(MacroKind::Bang)
@@ -1760,7 +1760,7 @@ fn maybe_expand_private_type_alias<'tcx>(
let alias = if !cx.cache.effective_visibilities.is_exported(cx.tcx, def_id.to_def_id())
&& !cx.current_type_aliases.contains_key(&def_id.to_def_id())
{
- &cx.tcx.hir().expect_item(def_id).kind
+ &cx.tcx.hir_expect_item(def_id).kind
} else {
return None;
};
@@ -2773,7 +2773,7 @@ fn clean_maybe_renamed_item<'tcx>(
use hir::ItemKind;
let def_id = item.owner_id.to_def_id();
- let mut name = renamed.unwrap_or_else(|| cx.tcx.hir().name(item.hir_id()));
+ let mut name = renamed.unwrap_or_else(|| cx.tcx.hir_name(item.hir_id()));
cx.with_param_env(def_id, |cx| {
let kind = match item.kind {
ItemKind::Static(ty, mutability, body_id) => StaticItem(Static {
@@ -2948,7 +2948,7 @@ fn clean_extern_crate<'tcx>(
let cnum = cx.tcx.extern_mod_stmt_cnum(krate.owner_id.def_id).unwrap_or(LOCAL_CRATE);
// this is the ID of the crate itself
let crate_def_id = cnum.as_def_id();
- let attrs = cx.tcx.hir().attrs(krate.hir_id());
+ let attrs = cx.tcx.hir_attrs(krate.hir_id());
let ty_vis = cx.tcx.visibility(krate.owner_id);
let please_inline = ty_vis.is_public()
&& attrs.iter().any(|a| {
@@ -3017,7 +3017,7 @@ fn clean_use_statement_inner<'tcx>(
}
let visibility = cx.tcx.visibility(import.owner_id);
- let attrs = cx.tcx.hir().attrs(import.hir_id());
+ let attrs = cx.tcx.hir_attrs(import.hir_id());
let inline_attr = hir_attr_lists(attrs, sym::doc).get_word_attr(sym::inline);
let pub_underscore = visibility.is_public() && name == kw::Underscore;
let current_mod = cx.tcx.parent_module_from_def_id(import.owner_id.def_id);
diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 4a379b4235ff0..edf064b54f48a 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -216,7 +216,7 @@ pub(crate) fn run(dcx: DiagCtxtHandle<'_>, input: Input, options: RustdocOptions
let collector = rustc_interface::create_and_enter_global_ctxt(compiler, krate, |tcx| {
let crate_name = tcx.crate_name(LOCAL_CRATE).to_string();
- let crate_attrs = tcx.hir().attrs(CRATE_HIR_ID);
+ let crate_attrs = tcx.hir_attrs(CRATE_HIR_ID);
let opts = scrape_test_config(crate_name, crate_attrs, args_path);
let enable_per_target_ignores = options.enable_per_target_ignores;
diff --git a/src/librustdoc/doctest/rust.rs b/src/librustdoc/doctest/rust.rs
index 3ac7abd0aa5d0..21f41eeb469b9 100644
--- a/src/librustdoc/doctest/rust.rs
+++ b/src/librustdoc/doctest/rust.rs
@@ -95,7 +95,7 @@ impl HirCollector<'_> {
sp: Span,
nested: F,
) {
- let ast_attrs = self.tcx.hir().attrs(self.tcx.local_def_id_to_hir_id(def_id));
+ let ast_attrs = self.tcx.hir_attrs(self.tcx.local_def_id_to_hir_id(def_id));
if let Some(ref cfg) =
extract_cfg_from_attrs(ast_attrs.iter(), self.tcx, &FxHashSet::default())
{
diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs
index 7b6921afa0808..68e381fa3f171 100644
--- a/src/librustdoc/visit_ast.rs
+++ b/src/librustdoc/visit_ast.rs
@@ -143,7 +143,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
&& self.cx.tcx.has_attr(def_id, sym::macro_export)
&& inserted.insert(def_id)
{
- let item = self.cx.tcx.hir().expect_item(local_def_id);
+ let item = self.cx.tcx.hir_expect_item(local_def_id);
top_level_module
.items
.insert((local_def_id, Some(item.ident.name)), (item, None, None));
@@ -153,8 +153,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
self.cx.cache.hidden_cfg = self
.cx
.tcx
- .hir()
- .attrs(CRATE_HIR_ID)
+ .hir_attrs(CRATE_HIR_ID)
.iter()
.filter(|attr| attr.has_name(sym::doc))
.flat_map(|attr| attr.meta_item_list().into_iter().flatten())
@@ -245,7 +244,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
};
let document_hidden = self.cx.render_options.document_hidden;
- let use_attrs = tcx.hir().attrs(tcx.local_def_id_to_hir_id(def_id));
+ let use_attrs = tcx.hir_attrs(tcx.local_def_id_to_hir_id(def_id));
// Don't inline `doc(hidden)` imports so they can be stripped at a later stage.
let is_no_inline = hir_attr_lists(use_attrs, sym::doc).has_word(sym::no_inline)
|| (document_hidden && hir_attr_lists(use_attrs, sym::doc).has_word(sym::hidden));
@@ -449,7 +448,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
continue;
}
- let attrs = tcx.hir().attrs(tcx.local_def_id_to_hir_id(item.owner_id.def_id));
+ let attrs = tcx.hir_attrs(tcx.local_def_id_to_hir_id(item.owner_id.def_id));
// If there was a private module in the current path then don't bother inlining
// anything as it will probably be stripped anyway.
diff --git a/src/tools/clippy/clippy_lints/src/attrs/mod.rs b/src/tools/clippy/clippy_lints/src/attrs/mod.rs
index 2b59c218d57a1..f9a2f011a144f 100644
--- a/src/tools/clippy/clippy_lints/src/attrs/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs/mod.rs
@@ -465,7 +465,7 @@ impl Attributes {
impl<'tcx> LateLintPass<'tcx> for Attributes {
fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
- let attrs = cx.tcx.hir().attrs(item.hir_id());
+ let attrs = cx.tcx.hir_attrs(item.hir_id());
if is_relevant_item(cx, item) {
inline_always::check(cx, item.span, item.ident.name, attrs);
}
@@ -474,13 +474,13 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) {
if is_relevant_impl(cx, item) {
- inline_always::check(cx, item.span, item.ident.name, cx.tcx.hir().attrs(item.hir_id()));
+ inline_always::check(cx, item.span, item.ident.name, cx.tcx.hir_attrs(item.hir_id()));
}
}
fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
if is_relevant_trait(cx, item) {
- inline_always::check(cx, item.span, item.ident.name, cx.tcx.hir().attrs(item.hir_id()));
+ inline_always::check(cx, item.span, item.ident.name, cx.tcx.hir_attrs(item.hir_id()));
}
}
}
diff --git a/src/tools/clippy/clippy_lints/src/default_union_representation.rs b/src/tools/clippy/clippy_lints/src/default_union_representation.rs
index 085ed9222c91a..7c64bf46e7bd2 100644
--- a/src/tools/clippy/clippy_lints/src/default_union_representation.rs
+++ b/src/tools/clippy/clippy_lints/src/default_union_representation.rs
@@ -97,7 +97,7 @@ fn is_zst<'tcx>(cx: &LateContext<'tcx>, field: &FieldDef, args: ty::GenericArgsR
}
fn has_c_repr_attr(cx: &LateContext<'_>, hir_id: HirId) -> bool {
- let attrs = cx.tcx.hir().attrs(hir_id);
+ let attrs = cx.tcx.hir_attrs(hir_id);
find_attr!(attrs, AttributeKind::Repr(r) if r.iter().any(|(x, _)| *x == ReprAttr::ReprC))
}
diff --git a/src/tools/clippy/clippy_lints/src/derivable_impls.rs b/src/tools/clippy/clippy_lints/src/derivable_impls.rs
index 66a3e5e3d3c7f..8d9222e4bf61e 100644
--- a/src/tools/clippy/clippy_lints/src/derivable_impls.rs
+++ b/src/tools/clippy/clippy_lints/src/derivable_impls.rs
@@ -197,9 +197,9 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
&& let ImplItemKind::Fn(_, b) = &impl_item.kind
&& let Body { value: func_expr, .. } = cx.tcx.hir_body(*b)
&& let &ty::Adt(adt_def, args) = cx.tcx.type_of(item.owner_id).instantiate_identity().kind()
- && let attrs = cx.tcx.hir().attrs(item.hir_id())
+ && let attrs = cx.tcx.hir_attrs(item.hir_id())
&& !attrs.iter().any(|attr| attr.doc_str().is_some())
- && cx.tcx.hir().attrs(impl_item_hir).is_empty()
+ && cx.tcx.hir_attrs(impl_item_hir).is_empty()
{
if adt_def.is_struct() {
check_struct(cx, item, self_ty, func_expr, adt_def, args, cx.tcx.typeck_body(*b));
diff --git a/src/tools/clippy/clippy_lints/src/derive.rs b/src/tools/clippy/clippy_lints/src/derive.rs
index db3e6034c5baf..2ae35b4005579 100644
--- a/src/tools/clippy/clippy_lints/src/derive.rs
+++ b/src/tools/clippy/clippy_lints/src/derive.rs
@@ -384,7 +384,7 @@ fn check_unsafe_derive_deserialize<'tcx>(
.tcx
.inherent_impls(def.did())
.iter()
- .map(|imp_did| cx.tcx.hir().expect_item(imp_did.expect_local()))
+ .map(|imp_did| cx.tcx.hir_expect_item(imp_did.expect_local()))
.any(|imp| has_unsafe(cx, imp))
{
span_lint_hir_and_then(
diff --git a/src/tools/clippy/clippy_lints/src/doc/missing_headers.rs b/src/tools/clippy/clippy_lints/src/doc/missing_headers.rs
index e8638595c4b26..e75abf28bace8 100644
--- a/src/tools/clippy/clippy_lints/src/doc/missing_headers.rs
+++ b/src/tools/clippy/clippy_lints/src/doc/missing_headers.rs
@@ -25,7 +25,7 @@ pub fn check(
&& cx
.tcx
.hir_parent_iter(owner_id.into())
- .any(|(id, _node)| is_doc_hidden(cx.tcx.hir().attrs(id)))
+ .any(|(id, _node)| is_doc_hidden(cx.tcx.hir_attrs(id)))
{
return;
}
diff --git a/src/tools/clippy/clippy_lints/src/escape.rs b/src/tools/clippy/clippy_lints/src/escape.rs
index 8d1e893cb1af2..8651d1f5e6964 100644
--- a/src/tools/clippy/clippy_lints/src/escape.rs
+++ b/src/tools/clippy/clippy_lints/src/escape.rs
@@ -161,7 +161,6 @@ impl<'tcx> Delegate<'tcx> for EscapeDelegate<'_, 'tcx> {
fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId) {
if cmt.place.projections.is_empty() {
- let map = &self.cx.tcx.hir();
if is_argument(self.cx.tcx, cmt.hir_id) {
// Skip closure arguments
let parent_id = self.cx.tcx.parent_hir_id(cmt.hir_id);
@@ -172,7 +171,7 @@ impl<'tcx> Delegate<'tcx> for EscapeDelegate<'_, 'tcx> {
// skip if there is a `self` parameter binding to a type
// that contains `Self` (i.e.: `self: Box<Self>`), see #4804
if let Some(trait_self_ty) = self.trait_self_ty {
- if map.name(cmt.hir_id) == kw::SelfLower && cmt.place.ty().contains(trait_self_ty) {
+ if self.cx.tcx.hir_name(cmt.hir_id) == kw::SelfLower && cmt.place.ty().contains(trait_self_ty) {
return;
}
}
diff --git a/src/tools/clippy/clippy_lints/src/exhaustive_items.rs b/src/tools/clippy/clippy_lints/src/exhaustive_items.rs
index 9bf3baba4b597..591912cc8d5e8 100644
--- a/src/tools/clippy/clippy_lints/src/exhaustive_items.rs
+++ b/src/tools/clippy/clippy_lints/src/exhaustive_items.rs
@@ -84,7 +84,7 @@ impl LateLintPass<'_> for ExhaustiveItems {
_ => return,
};
if cx.effective_visibilities.is_exported(item.owner_id.def_id)
- && let attrs = cx.tcx.hir().attrs(item.hir_id())
+ && let attrs = cx.tcx.hir_attrs(item.hir_id())
&& !attrs.iter().any(|a| a.has_name(sym::non_exhaustive))
&& fields.iter().all(|f| cx.tcx.visibility(f.def_id).is_public())
{
diff --git a/src/tools/clippy/clippy_lints/src/format_impl.rs b/src/tools/clippy/clippy_lints/src/format_impl.rs
index ff75fcf2b417c..5b42a40d850bb 100644
--- a/src/tools/clippy/clippy_lints/src/format_impl.rs
+++ b/src/tools/clippy/clippy_lints/src/format_impl.rs
@@ -209,9 +209,8 @@ impl FormatImplExpr<'_, '_> {
// Handle dereference of &self -> self that is equivalent (i.e. via *self in fmt() impl)
// Since the argument to fmt is itself a reference: &self
let reference = peel_ref_operators(self.cx, arg);
- let map = self.cx.tcx.hir();
// Is the reference self?
- if path_to_local(reference).map(|x| map.name(x)) == Some(kw::SelfLower) {
+ if path_to_local(reference).map(|x| self.cx.tcx.hir_name(x)) == Some(kw::SelfLower) {
let FormatTraitNames { name, .. } = self.format_trait_impl;
span_lint(
self.cx,
diff --git a/src/tools/clippy/clippy_lints/src/four_forward_slashes.rs b/src/tools/clippy/clippy_lints/src/four_forward_slashes.rs
index 0bdb99d7b9a4d..8822b87f92f72 100644
--- a/src/tools/clippy/clippy_lints/src/four_forward_slashes.rs
+++ b/src/tools/clippy/clippy_lints/src/four_forward_slashes.rs
@@ -43,8 +43,7 @@ impl<'tcx> LateLintPass<'tcx> for FourForwardSlashes {
let sm = cx.sess().source_map();
let mut span = cx
.tcx
- .hir()
- .attrs(item.hir_id())
+ .hir_attrs(item.hir_id())
.iter()
.filter(|i| i.is_doc_comment())
.fold(item.span.shrink_to_lo(), |span, attr| span.to(attr.span()));
diff --git a/src/tools/clippy/clippy_lints/src/functions/must_use.rs b/src/tools/clippy/clippy_lints/src/functions/must_use.rs
index f1c9657f22404..c3e0d5e8b694d 100644
--- a/src/tools/clippy/clippy_lints/src/functions/must_use.rs
+++ b/src/tools/clippy/clippy_lints/src/functions/must_use.rs
@@ -21,7 +21,7 @@ use core::ops::ControlFlow;
use super::{DOUBLE_MUST_USE, MUST_USE_CANDIDATE, MUST_USE_UNIT};
pub(super) fn check_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
- let attrs = cx.tcx.hir().attrs(item.hir_id());
+ let attrs = cx.tcx.hir_attrs(item.hir_id());
let attr = cx.tcx.get_attr(item.owner_id, sym::must_use);
if let hir::ItemKind::Fn {
ref sig,
@@ -51,7 +51,7 @@ pub(super) fn check_impl_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Imp
if let hir::ImplItemKind::Fn(ref sig, ref body_id) = item.kind {
let is_public = cx.effective_visibilities.is_exported(item.owner_id.def_id);
let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
- let attrs = cx.tcx.hir().attrs(item.hir_id());
+ let attrs = cx.tcx.hir_attrs(item.hir_id());
let attr = cx.tcx.get_attr(item.owner_id, sym::must_use);
if let Some(attr) = attr {
check_needless_must_use(cx, sig.decl, item.owner_id, item.span, fn_header_span, attr, attrs, sig);
@@ -74,7 +74,7 @@ pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Tr
let is_public = cx.effective_visibilities.is_exported(item.owner_id.def_id);
let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
- let attrs = cx.tcx.hir().attrs(item.hir_id());
+ let attrs = cx.tcx.hir_attrs(item.hir_id());
let attr = cx.tcx.get_attr(item.owner_id, sym::must_use);
if let Some(attr) = attr {
check_needless_must_use(cx, sig.decl, item.owner_id, item.span, fn_header_span, attr, attrs, sig);
diff --git a/src/tools/clippy/clippy_lints/src/inconsistent_struct_constructor.rs b/src/tools/clippy/clippy_lints/src/inconsistent_struct_constructor.rs
index 5b58113169b1e..e1dd7872b9d48 100644
--- a/src/tools/clippy/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/src/tools/clippy/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -182,7 +182,7 @@ fn suggestion<'tcx>(
}
fn field_with_attrs_span(tcx: TyCtxt<'_>, field: &hir::ExprField<'_>) -> Span {
- if let Some(attr) = tcx.hir().attrs(field.hir_id).first() {
+ if let Some(attr) = tcx.hir_attrs(field.hir_id).first() {
field.span.with_lo(attr.span().lo())
} else {
field.span
diff --git a/src/tools/clippy/clippy_lints/src/inline_fn_without_body.rs b/src/tools/clippy/clippy_lints/src/inline_fn_without_body.rs
index 9b4a3b3f9c84c..6a436fb4a9d1e 100644
--- a/src/tools/clippy/clippy_lints/src/inline_fn_without_body.rs
+++ b/src/tools/clippy/clippy_lints/src/inline_fn_without_body.rs
@@ -34,8 +34,7 @@ impl<'tcx> LateLintPass<'tcx> for InlineFnWithoutBody {
if let TraitItemKind::Fn(_, TraitFn::Required(_)) = item.kind
&& let Some(attr) = cx
.tcx
- .hir()
- .attrs(item.hir_id())
+ .hir_attrs(item.hir_id())
.iter()
.find(|a| a.has_name(sym::inline))
{
diff --git a/src/tools/clippy/clippy_lints/src/macro_use.rs b/src/tools/clippy/clippy_lints/src/macro_use.rs
index 20be22850b760..b712b351d063c 100644
--- a/src/tools/clippy/clippy_lints/src/macro_use.rs
+++ b/src/tools/clippy/clippy_lints/src/macro_use.rs
@@ -98,7 +98,7 @@ impl LateLintPass<'_> for MacroUseImports {
if cx.sess().opts.edition >= Edition::Edition2018
&& let hir::ItemKind::Use(path, _kind) = &item.kind
&& let hir_id = item.hir_id()
- && let attrs = cx.tcx.hir().attrs(hir_id)
+ && let attrs = cx.tcx.hir_attrs(hir_id)
&& let Some(mac_attr) = attrs.iter().find(|attr| attr.has_name(sym::macro_use))
&& let Some(id) = path.res.iter().find_map(|res| match res {
Res::Def(DefKind::Mod, id) => Some(id),
diff --git a/src/tools/clippy/clippy_lints/src/manual_non_exhaustive.rs b/src/tools/clippy/clippy_lints/src/manual_non_exhaustive.rs
index 496e0660d4f9a..64b07a5536b4d 100644
--- a/src/tools/clippy/clippy_lints/src/manual_non_exhaustive.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_non_exhaustive.rs
@@ -89,11 +89,11 @@ impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustive {
match item.kind {
ItemKind::Enum(def, _) if def.variants.len() > 1 => {
let iter = def.variants.iter().filter_map(|v| {
- (matches!(v.data, VariantData::Unit(_, _)) && is_doc_hidden(cx.tcx.hir().attrs(v.hir_id)))
+ (matches!(v.data, VariantData::Unit(_, _)) && is_doc_hidden(cx.tcx.hir_attrs(v.hir_id)))
.then_some((v.def_id, v.span))
});
if let Ok((id, span)) = iter.exactly_one()
- && !attr::contains_name(cx.tcx.hir().attrs(item.hir_id()), sym::non_exhaustive)
+ && !attr::contains_name(cx.tcx.hir_attrs(item.hir_id()), sym::non_exhaustive)
{
self.potential_enums.push((item.owner_id.def_id, id, item.span, span));
}
@@ -114,7 +114,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustive {
"this seems like a manual implementation of the non-exhaustive pattern",
|diag| {
if let Some(non_exhaustive) =
- attr::find_by_name(cx.tcx.hir().attrs(item.hir_id()), sym::non_exhaustive)
+ attr::find_by_name(cx.tcx.hir_attrs(item.hir_id()), sym::non_exhaustive)
{
diag.span_note(non_exhaustive.span(), "the struct is already non-exhaustive");
} else {
diff --git a/src/tools/clippy/clippy_lints/src/matches/match_like_matches.rs b/src/tools/clippy/clippy_lints/src/matches/match_like_matches.rs
index d697f427c7052..d29d1ea3e96d9 100644
--- a/src/tools/clippy/clippy_lints/src/matches/match_like_matches.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/match_like_matches.rs
@@ -42,7 +42,7 @@ pub(super) fn check_match<'tcx>(
cx,
scrutinee,
arms.iter()
- .map(|arm| (cx.tcx.hir().attrs(arm.hir_id), Some(arm.pat), arm.body, arm.guard)),
+ .map(|arm| (cx.tcx.hir_attrs(arm.hir_id), Some(arm.pat), arm.body, arm.guard)),
e,
false,
)
diff --git a/src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs b/src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs
index 41e4c75f843e5..250f17fa9025a 100644
--- a/src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs
@@ -75,7 +75,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
HirIdMapEntry::Occupied(entry) => return *entry.get() == b_id,
}
// the names technically don't have to match; this makes the lint more conservative
- && cx.tcx.hir().name(a_id) == cx.tcx.hir().name(b_id)
+ && cx.tcx.hir_name(a_id) == cx.tcx.hir_name(b_id)
&& cx.typeck_results().expr_ty(a) == cx.typeck_results().expr_ty(b)
&& pat_contains_local(lhs.pat, a_id)
&& pat_contains_local(rhs.pat, b_id)
diff --git a/src/tools/clippy/clippy_lints/src/methods/is_empty.rs b/src/tools/clippy/clippy_lints/src/methods/is_empty.rs
index 1c64f78678aeb..7c190e123b72e 100644
--- a/src/tools/clippy/clippy_lints/src/methods/is_empty.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/is_empty.rs
@@ -41,7 +41,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &'_ Expr<'_>, receiver: &Expr<'_
fn is_under_cfg(cx: &LateContext<'_>, id: HirId) -> bool {
cx.tcx
.hir_parent_id_iter(id)
- .any(|id| cx.tcx.hir().attrs(id).iter().any(|attr| attr.has_name(sym::cfg)))
+ .any(|id| cx.tcx.hir_attrs(id).iter().any(|attr| attr.has_name(sym::cfg)))
}
/// Similar to [`clippy_utils::expr_or_init`], but does not go up the chain if the initialization
diff --git a/src/tools/clippy/clippy_lints/src/methods/mod.rs b/src/tools/clippy/clippy_lints/src/methods/mod.rs
index 94d3657d9f123..7dde21d3edb13 100644
--- a/src/tools/clippy/clippy_lints/src/methods/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/mod.rs
@@ -4731,7 +4731,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
}
let name = impl_item.ident.name.as_str();
let parent = cx.tcx.hir_get_parent_item(impl_item.hir_id()).def_id;
- let item = cx.tcx.hir().expect_item(parent);
+ let item = cx.tcx.hir_expect_item(parent);
let self_ty = cx.tcx.type_of(item.owner_id).instantiate_identity();
let implements_trait = matches!(item.kind, hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }));
diff --git a/src/tools/clippy/clippy_lints/src/missing_doc.rs b/src/tools/clippy/clippy_lints/src/missing_doc.rs
index 47a9e17b3cfe1..3470c266c4917 100644
--- a/src/tools/clippy/clippy_lints/src/missing_doc.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_doc.rs
@@ -182,7 +182,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
}
fn check_crate(&mut self, cx: &LateContext<'tcx>) {
- let attrs = cx.tcx.hir().attrs(hir::CRATE_HIR_ID);
+ let attrs = cx.tcx.hir_attrs(hir::CRATE_HIR_ID);
self.check_missing_docs_attrs(cx, CRATE_DEF_ID, attrs, cx.tcx.def_span(CRATE_DEF_ID), "the", "crate");
}
@@ -224,7 +224,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
let (article, desc) = cx.tcx.article_and_description(it.owner_id.to_def_id());
- let attrs = cx.tcx.hir().attrs(it.hir_id());
+ let attrs = cx.tcx.hir_attrs(it.hir_id());
if !is_from_proc_macro(cx, it) {
self.check_missing_docs_attrs(cx, it.owner_id.def_id, attrs, it.span, article, desc);
}
@@ -234,7 +234,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
fn check_trait_item(&mut self, cx: &LateContext<'tcx>, trait_item: &'tcx hir::TraitItem<'_>) {
let (article, desc) = cx.tcx.article_and_description(trait_item.owner_id.to_def_id());
- let attrs = cx.tcx.hir().attrs(trait_item.hir_id());
+ let attrs = cx.tcx.hir_attrs(trait_item.hir_id());
if !is_from_proc_macro(cx, trait_item) {
self.check_missing_docs_attrs(cx, trait_item.owner_id.def_id, attrs, trait_item.span, article, desc);
}
@@ -252,7 +252,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
}
let (article, desc) = cx.tcx.article_and_description(impl_item.owner_id.to_def_id());
- let attrs = cx.tcx.hir().attrs(impl_item.hir_id());
+ let attrs = cx.tcx.hir_attrs(impl_item.hir_id());
if !is_from_proc_macro(cx, impl_item) {
self.check_missing_docs_attrs(cx, impl_item.owner_id.def_id, attrs, impl_item.span, article, desc);
}
@@ -261,7 +261,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
fn check_field_def(&mut self, cx: &LateContext<'tcx>, sf: &'tcx hir::FieldDef<'_>) {
if !sf.is_positional() {
- let attrs = cx.tcx.hir().attrs(sf.hir_id);
+ let attrs = cx.tcx.hir_attrs(sf.hir_id);
if !is_from_proc_macro(cx, sf) {
self.check_missing_docs_attrs(cx, sf.def_id, attrs, sf.span, "a", "struct field");
}
@@ -270,7 +270,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
}
fn check_variant(&mut self, cx: &LateContext<'tcx>, v: &'tcx hir::Variant<'_>) {
- let attrs = cx.tcx.hir().attrs(v.hir_id);
+ let attrs = cx.tcx.hir_attrs(v.hir_id);
if !is_from_proc_macro(cx, v) {
self.check_missing_docs_attrs(cx, v.def_id, attrs, v.span, "a", "variant");
}
diff --git a/src/tools/clippy/clippy_lints/src/missing_inline.rs b/src/tools/clippy/clippy_lints/src/missing_inline.rs
index 3cf1a80607e8b..2c578d816025f 100644
--- a/src/tools/clippy/clippy_lints/src/missing_inline.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_inline.rs
@@ -98,7 +98,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
match it.kind {
hir::ItemKind::Fn { .. } => {
let desc = "a function";
- let attrs = cx.tcx.hir().attrs(it.hir_id());
+ let attrs = cx.tcx.hir_attrs(it.hir_id());
check_missing_inline_attrs(cx, attrs, it.span, desc);
},
hir::ItemKind::Trait(ref _is_auto, ref _unsafe, _generics, _bounds, trait_items) => {
@@ -114,7 +114,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
// an impl is not provided
let desc = "a default trait method";
let item = cx.tcx.hir_trait_item(tit.id);
- let attrs = cx.tcx.hir().attrs(item.hir_id());
+ let attrs = cx.tcx.hir_attrs(item.hir_id());
check_missing_inline_attrs(cx, attrs, item.span, desc);
}
},
@@ -168,7 +168,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
}
}
- let attrs = cx.tcx.hir().attrs(impl_item.hir_id());
+ let attrs = cx.tcx.hir_attrs(impl_item.hir_id());
check_missing_inline_attrs(cx, attrs, impl_item.span, desc);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/mixed_read_write_in_expression.rs b/src/tools/clippy/clippy_lints/src/mixed_read_write_in_expression.rs
index a7452c8a3c84e..be728e6c8b74b 100644
--- a/src/tools/clippy/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/src/tools/clippy/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -334,7 +334,7 @@ impl<'tcx> Visitor<'tcx> for ReadVisitor<'_, 'tcx> {
self.cx,
MIXED_READ_WRITE_IN_EXPRESSION,
expr.span,
- format!("unsequenced read of `{}`", self.cx.tcx.hir().name(self.var)),
+ format!("unsequenced read of `{}`", self.cx.tcx.hir_name(self.var)),
|diag| {
diag.span_note(
self.write_expr.span,
diff --git a/src/tools/clippy/clippy_lints/src/needless_if.rs b/src/tools/clippy/clippy_lints/src/needless_if.rs
index 7eefb016aca98..c90019f6ee161 100644
--- a/src/tools/clippy/clippy_lints/src/needless_if.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_if.rs
@@ -65,7 +65,7 @@ impl LateLintPass<'_> for NeedlessIf {
stmt.span,
"this `if` branch is empty",
"you can remove it",
- if cond.can_have_side_effects() || !cx.tcx.hir().attrs(stmt.hir_id).is_empty() {
+ if cond.can_have_side_effects() || !cx.tcx.hir_attrs(stmt.hir_id).is_empty() {
// `{ foo }` or `{ foo } && bar` placed into a statement position would be
// interpreted as a block statement, force it to be an expression
if cond_snippet.starts_with('{') {
diff --git a/src/tools/clippy/clippy_lints/src/needless_late_init.rs b/src/tools/clippy/clippy_lints/src/needless_late_init.rs
index 863a1f895c937..3efbed0c2365e 100644
--- a/src/tools/clippy/clippy_lints/src/needless_late_init.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_late_init.rs
@@ -261,7 +261,7 @@ fn check<'tcx>(
binding_id: HirId,
) -> Option<()> {
let usage = first_usage(cx, binding_id, local_stmt.hir_id, block)?;
- let binding_name = cx.tcx.hir().opt_name(binding_id)?;
+ let binding_name = cx.tcx.hir_opt_name(binding_id)?;
let let_snippet = local_snippet_without_semicolon(cx, local)?;
match usage.expr.kind {
diff --git a/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs b/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs
index d5c5679c990df..361b001e0e3c3 100644
--- a/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -147,7 +147,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {
// We don't check unsafe functions.
return;
}
- let attrs = cx.tcx.hir().attrs(hir_id);
+ let attrs = cx.tcx.hir_attrs(hir_id);
if header.abi != ExternAbi::Rust || requires_exact_signature(attrs) {
return;
}
diff --git a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
index 380cc380ad0f2..26e227b4c28b9 100644
--- a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
@@ -88,7 +88,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
match kind {
FnKind::ItemFn(.., header) => {
- let attrs = cx.tcx.hir().attrs(hir_id);
+ let attrs = cx.tcx.hir_attrs(hir_id);
if header.abi != ExternAbi::Rust || requires_exact_signature(attrs) {
return;
}
diff --git a/src/tools/clippy/clippy_lints/src/no_mangle_with_rust_abi.rs b/src/tools/clippy/clippy_lints/src/no_mangle_with_rust_abi.rs
index 1baa3cb2f0fdc..fe8a02c64c660 100644
--- a/src/tools/clippy/clippy_lints/src/no_mangle_with_rust_abi.rs
+++ b/src/tools/clippy/clippy_lints/src/no_mangle_with_rust_abi.rs
@@ -40,7 +40,7 @@ impl<'tcx> LateLintPass<'tcx> for NoMangleWithRustAbi {
if let ItemKind::Fn { sig: fn_sig, .. } = &item.kind
&& !item.span.from_expansion()
{
- let attrs = cx.tcx.hir().attrs(item.hir_id());
+ let attrs = cx.tcx.hir_attrs(item.hir_id());
let mut app = Applicability::MaybeIncorrect;
let fn_snippet = snippet_with_applicability(cx, fn_sig.span.with_hi(item.ident.span.lo()), "..", &mut app);
for attr in attrs {
diff --git a/src/tools/clippy/clippy_lints/src/non_copy_const.rs b/src/tools/clippy/clippy_lints/src/non_copy_const.rs
index d4da12451f181..9b53608ae7f3c 100644
--- a/src/tools/clippy/clippy_lints/src/non_copy_const.rs
+++ b/src/tools/clippy/clippy_lints/src/non_copy_const.rs
@@ -351,7 +351,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst<'tcx> {
fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) {
if let ImplItemKind::Const(_, body_id) = &impl_item.kind {
let item_def_id = cx.tcx.hir_get_parent_item(impl_item.hir_id()).def_id;
- let item = cx.tcx.hir().expect_item(item_def_id);
+ let item = cx.tcx.hir_expect_item(item_def_id);
match &item.kind {
ItemKind::Impl(Impl {
diff --git a/src/tools/clippy/clippy_lints/src/operators/op_ref.rs b/src/tools/clippy/clippy_lints/src/operators/op_ref.rs
index c3c09946c27d1..378fed481f4fe 100644
--- a/src/tools/clippy/clippy_lints/src/operators/op_ref.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/op_ref.rs
@@ -181,7 +181,7 @@ fn in_impl<'tcx>(
) -> Option<(&'tcx rustc_hir::Ty<'tcx>, &'tcx rustc_hir::Ty<'tcx>)> {
if let Some(block) = get_enclosing_block(cx, e.hir_id)
&& let Some(impl_def_id) = cx.tcx.impl_of_method(block.hir_id.owner.to_def_id())
- && let item = cx.tcx.hir().expect_item(impl_def_id.expect_local())
+ && let item = cx.tcx.hir_expect_item(impl_def_id.expect_local())
&& let ItemKind::Impl(item) = &item.kind
&& let Some(of_trait) = &item.of_trait
&& let Some(seg) = of_trait.path.segments.last()
@@ -200,7 +200,7 @@ fn in_impl<'tcx>(
fn are_equal(cx: &LateContext<'_>, middle_ty: Ty<'_>, hir_ty: &rustc_hir::Ty<'_>) -> bool {
if let ty::Adt(adt_def, _) = middle_ty.kind()
&& let Some(local_did) = adt_def.did().as_local()
- && let item = cx.tcx.hir().expect_item(local_did)
+ && let item = cx.tcx.hir_expect_item(local_did)
&& let middle_ty_id = item.owner_id.to_def_id()
&& let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind
&& let Res::Def(_, hir_ty_id) = path.res
diff --git a/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs b/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs
index 49bc560834682..320c0286bb7be 100644
--- a/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs
@@ -280,7 +280,7 @@ impl<'tcx> LateLintPass<'tcx> for PassByRefOrValue {
if header.abi != ExternAbi::Rust {
return;
}
- let attrs = cx.tcx.hir().attrs(hir_id);
+ let attrs = cx.tcx.hir_attrs(hir_id);
for a in attrs {
if let Some(meta_items) = a.meta_item_list() {
if a.has_name(sym::proc_macro_derive)
diff --git a/src/tools/clippy/clippy_lints/src/pub_underscore_fields.rs b/src/tools/clippy/clippy_lints/src/pub_underscore_fields.rs
index db03657c9af43..fd21893232dbb 100644
--- a/src/tools/clippy/clippy_lints/src/pub_underscore_fields.rs
+++ b/src/tools/clippy/clippy_lints/src/pub_underscore_fields.rs
@@ -74,7 +74,7 @@ impl<'tcx> LateLintPass<'tcx> for PubUnderscoreFields {
// Only pertains to fields that start with an underscore, and are public.
if field.ident.as_str().starts_with('_') && is_visible(field)
// We ignore fields that have `#[doc(hidden)]`.
- && !is_doc_hidden(cx.tcx.hir().attrs(field.hir_id))
+ && !is_doc_hidden(cx.tcx.hir_attrs(field.hir_id))
// We ignore fields that are `PhantomData`.
&& !is_path_lang_item(cx, field.ty, LangItem::PhantomData)
{
diff --git a/src/tools/clippy/clippy_lints/src/read_zero_byte_vec.rs b/src/tools/clippy/clippy_lints/src/read_zero_byte_vec.rs
index 6bd68dd4109d4..49b522994fbf7 100644
--- a/src/tools/clippy/clippy_lints/src/read_zero_byte_vec.rs
+++ b/src/tools/clippy/clippy_lints/src/read_zero_byte_vec.rs
@@ -93,7 +93,7 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
},
),
VecInitKind::WithExprCapacity(hir_id) => {
- let e = cx.tcx.hir().expect_expr(hir_id);
+ let e = cx.tcx.hir_expect_expr(hir_id);
span_lint_hir_and_then(
cx,
READ_ZERO_BYTE_VEC,
diff --git a/src/tools/clippy/clippy_lints/src/return_self_not_must_use.rs b/src/tools/clippy/clippy_lints/src/return_self_not_must_use.rs
index 5a25483c397c6..07ae92fa98439 100644
--- a/src/tools/clippy/clippy_lints/src/return_self_not_must_use.rs
+++ b/src/tools/clippy/clippy_lints/src/return_self_not_must_use.rs
@@ -74,7 +74,7 @@ fn check_method(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_def: LocalDefId, spa
// We only show this warning for public exported methods.
&& cx.effective_visibilities.is_exported(fn_def)
// We don't want to emit this lint if the `#[must_use]` attribute is already there.
- && !cx.tcx.hir().attrs(owner_id.into()).iter().any(|attr| attr.has_name(sym::must_use))
+ && !cx.tcx.hir_attrs(owner_id.into()).iter().any(|attr| attr.has_name(sym::must_use))
&& cx.tcx.visibility(fn_def.to_def_id()).is_public()
&& let ret_ty = return_ty(cx, owner_id)
&& let self_arg = nth_arg(cx, owner_id, 0)
diff --git a/src/tools/clippy/clippy_lints/src/returns.rs b/src/tools/clippy/clippy_lints/src/returns.rs
index 3ba6d6284592b..4cb73df8b488f 100644
--- a/src/tools/clippy/clippy_lints/src/returns.rs
+++ b/src/tools/clippy/clippy_lints/src/returns.rs
@@ -231,7 +231,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
&& let Some(stmt) = block.stmts.iter().last()
&& let StmtKind::Let(local) = &stmt.kind
&& local.ty.is_none()
- && cx.tcx.hir().attrs(local.hir_id).is_empty()
+ && cx.tcx.hir_attrs(local.hir_id).is_empty()
&& let Some(initexpr) = &local.init
&& let PatKind::Binding(_, local_id, _, _) = local.pat.kind
&& path_to_local_id(retexpr, local_id)
@@ -401,7 +401,7 @@ fn check_final_expr<'tcx>(
// This allows the addition of attributes, like `#[allow]` (See: clippy#9361)
// `#[expect(clippy::needless_return)]` needs to be handled separately to
// actually fulfill the expectation (clippy::#12998)
- match cx.tcx.hir().attrs(expr.hir_id) {
+ match cx.tcx.hir_attrs(expr.hir_id) {
[] => {},
[attr] => {
if matches!(Level::from_attr(attr), Some(Level::Expect(_)))
diff --git a/src/tools/clippy/clippy_lints/src/self_named_constructors.rs b/src/tools/clippy/clippy_lints/src/self_named_constructors.rs
index fc02c3a51716e..8b2d597b9e323 100644
--- a/src/tools/clippy/clippy_lints/src/self_named_constructors.rs
+++ b/src/tools/clippy/clippy_lints/src/self_named_constructors.rs
@@ -52,7 +52,7 @@ impl<'tcx> LateLintPass<'tcx> for SelfNamedConstructors {
}
let parent = cx.tcx.hir_get_parent_item(impl_item.hir_id()).def_id;
- let item = cx.tcx.hir().expect_item(parent);
+ let item = cx.tcx.hir_expect_item(parent);
let self_ty = cx.tcx.type_of(item.owner_id).instantiate_identity();
let ret_ty = return_ty(cx, impl_item.owner_id);
diff --git a/src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs b/src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs
index 746bf018bcc31..be533ca915ed4 100644
--- a/src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -429,8 +429,7 @@ fn block_has_safety_comment(cx: &LateContext<'_>, span: Span) -> bool {
fn include_attrs_in_span(cx: &LateContext<'_>, hir_id: HirId, span: Span) -> Span {
span.to(cx
.tcx
- .hir()
- .attrs(hir_id)
+ .hir_attrs(hir_id)
.iter()
.fold(span, |acc, attr| acc.to(attr.span())))
}
diff --git a/src/tools/clippy/clippy_lints/src/unused_self.rs b/src/tools/clippy/clippy_lints/src/unused_self.rs
index 2c6c75693166f..582aa6e6001e8 100644
--- a/src/tools/clippy/clippy_lints/src/unused_self.rs
+++ b/src/tools/clippy/clippy_lints/src/unused_self.rs
@@ -57,7 +57,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedSelf {
return;
}
let parent = cx.tcx.hir_get_parent_item(impl_item.hir_id()).def_id;
- let parent_item = cx.tcx.hir().expect_item(parent);
+ let parent_item = cx.tcx.hir_expect_item(parent);
let assoc_item = cx.tcx.associated_item(impl_item.owner_id);
let contains_todo = |cx, body: &'_ Body<'_>| -> bool {
clippy_utils::visitors::for_each_expr_without_closures(body.value, |e| {
diff --git a/src/tools/clippy/clippy_lints/src/unwrap.rs b/src/tools/clippy/clippy_lints/src/unwrap.rs
index 76b9bbbd32fde..08a390aa3c1cc 100644
--- a/src/tools/clippy/clippy_lints/src/unwrap.rs
+++ b/src/tools/clippy/clippy_lints/src/unwrap.rs
@@ -316,7 +316,7 @@ impl<'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'_, 'tcx> {
{
if call_to_unwrap == unwrappable.safe_to_unwrap {
let is_entire_condition = unwrappable.is_entire_condition;
- let unwrappable_variable_name = self.cx.tcx.hir().name(unwrappable.local_id);
+ let unwrappable_variable_name = self.cx.tcx.hir_name(unwrappable.local_id);
let suggested_pattern = if call_to_unwrap {
unwrappable.kind.success_variant_pattern()
} else {
diff --git a/src/tools/clippy/clippy_lints/src/utils/author.rs b/src/tools/clippy/clippy_lints/src/utils/author.rs
index 5fc166438e84a..6f5ac9742934a 100644
--- a/src/tools/clippy/clippy_lints/src/utils/author.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/author.rs
@@ -787,7 +787,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
}
fn has_attr(cx: &LateContext<'_>, hir_id: HirId) -> bool {
- let attrs = cx.tcx.hir().attrs(hir_id);
+ let attrs = cx.tcx.hir_attrs(hir_id);
get_attr(cx.sess(), attrs, "author").count() > 0
}
diff --git a/src/tools/clippy/clippy_lints/src/utils/dump_hir.rs b/src/tools/clippy/clippy_lints/src/utils/dump_hir.rs
index b108951978f30..9910be9bc2853 100644
--- a/src/tools/clippy/clippy_lints/src/utils/dump_hir.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/dump_hir.rs
@@ -59,6 +59,6 @@ impl<'tcx> LateLintPass<'tcx> for DumpHir {
}
fn has_attr(cx: &LateContext<'_>, hir_id: hir::HirId) -> bool {
- let attrs = cx.tcx.hir().attrs(hir_id);
+ let attrs = cx.tcx.hir_attrs(hir_id);
get_attr(cx.sess(), attrs, "dump").count() > 0
}
diff --git a/src/tools/clippy/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs b/src/tools/clippy/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
index 89b4c48b8b116..16d51fa09025a 100644
--- a/src/tools/clippy/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
@@ -247,7 +247,7 @@ fn check_invalid_clippy_version_attribute(cx: &LateContext<'_>, item: &'_ Item<'
/// This function extracts the version value of a `clippy::version` attribute if the given value has
/// one
pub(super) fn extract_clippy_version_value(cx: &LateContext<'_>, item: &'_ Item<'_>) -> Option<Symbol> {
- let attrs = cx.tcx.hir().attrs(item.hir_id());
+ let attrs = cx.tcx.hir_attrs(item.hir_id());
attrs.iter().find_map(|attr| {
if let hir::Attribute::Unparsed(attr_kind) = &attr
// Identify attribute
diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs
index d850cc410008d..16d46deefe09e 100644
--- a/src/tools/clippy/clippy_utils/src/lib.rs
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@ -2033,15 +2033,14 @@ pub fn has_attr(attrs: &[hir::Attribute], symbol: Symbol) -> bool {
}
pub fn has_repr_attr(cx: &LateContext<'_>, hir_id: HirId) -> bool {
- find_attr!(cx.tcx.hir().attrs(hir_id), AttributeKind::Repr(..))
+ find_attr!(cx.tcx.hir_attrs(hir_id), AttributeKind::Repr(..))
}
pub fn any_parent_has_attr(tcx: TyCtxt<'_>, node: HirId, symbol: Symbol) -> bool {
- let map = &tcx.hir();
let mut prev_enclosing_node = None;
let mut enclosing_node = node;
while Some(enclosing_node) != prev_enclosing_node {
- if has_attr(map.attrs(enclosing_node), symbol) {
+ if has_attr(tcx.hir_attrs(enclosing_node), symbol) {
return true;
}
prev_enclosing_node = Some(enclosing_node);
@@ -2058,7 +2057,7 @@ pub fn in_automatically_derived(tcx: TyCtxt<'_>, id: HirId) -> bool {
.filter(|(_, node)| matches!(node, OwnerNode::Item(item) if matches!(item.kind, ItemKind::Impl(_))))
.any(|(id, _)| {
has_attr(
- tcx.hir().attrs(tcx.local_def_id_to_hir_id(id.def_id)),
+ tcx.hir_attrs(tcx.local_def_id_to_hir_id(id.def_id)),
sym::automatically_derived,
)
})
@@ -2341,16 +2340,14 @@ pub fn std_or_core(cx: &LateContext<'_>) -> Option<&'static str> {
pub fn is_no_std_crate(cx: &LateContext<'_>) -> bool {
cx.tcx
- .hir()
- .attrs(hir::CRATE_HIR_ID)
+ .hir_attrs(hir::CRATE_HIR_ID)
.iter()
.any(|attr| attr.name_or_empty() == sym::no_std)
}
pub fn is_no_core_crate(cx: &LateContext<'_>) -> bool {
cx.tcx
- .hir()
- .attrs(hir::CRATE_HIR_ID)
+ .hir_attrs(hir::CRATE_HIR_ID)
.iter()
.any(|attr| attr.name_or_empty() == sym::no_core)
}
@@ -2640,8 +2637,7 @@ fn with_test_item_names(tcx: TyCtxt<'_>, module: LocalModDefId, f: impl Fn(&[Sym
// We could also check for the type name `test::TestDescAndFn`
if let Res::Def(DefKind::Struct, _) = path.res {
let has_test_marker = tcx
- .hir()
- .attrs(item.hir_id())
+ .hir_attrs(item.hir_id())
.iter()
.any(|a| a.has_name(sym::rustc_test_marker));
if has_test_marker {
@@ -2685,7 +2681,7 @@ pub fn is_in_test_function(tcx: TyCtxt<'_>, id: HirId) -> bool {
/// This only checks directly applied attributes, to see if a node is inside a `#[cfg(test)]` parent
/// use [`is_in_cfg_test`]
pub fn is_cfg_test(tcx: TyCtxt<'_>, id: HirId) -> bool {
- tcx.hir().attrs(id).iter().any(|attr| {
+ tcx.hir_attrs(id).iter().any(|attr| {
if attr.has_name(sym::cfg)
&& let Some(items) = attr.meta_item_list()
&& let [item] = &*items
@@ -2710,12 +2706,10 @@ pub fn is_in_test(tcx: TyCtxt<'_>, hir_id: HirId) -> bool {
/// Checks if the item of any of its parents has `#[cfg(...)]` attribute applied.
pub fn inherits_cfg(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
- let hir = tcx.hir();
-
tcx.has_attr(def_id, sym::cfg)
|| tcx
.hir_parent_iter(tcx.local_def_id_to_hir_id(def_id))
- .flat_map(|(parent_id, _)| hir.attrs(parent_id))
+ .flat_map(|(parent_id, _)| tcx.hir_attrs(parent_id))
.any(|attr| attr.has_name(sym::cfg))
}
diff --git a/src/tools/clippy/clippy_utils/src/msrvs.rs b/src/tools/clippy/clippy_utils/src/msrvs.rs
index 5bb2b12988a6c..0316de172de7f 100644
--- a/src/tools/clippy/clippy_utils/src/msrvs.rs
+++ b/src/tools/clippy/clippy_utils/src/msrvs.rs
@@ -108,7 +108,7 @@ impl Msrv {
let start = cx.last_node_with_lint_attrs;
if let Some(msrv_attr) = once(start)
.chain(cx.tcx.hir_parent_id_iter(start))
- .find_map(|id| parse_attrs(cx.tcx.sess, cx.tcx.hir().attrs(id)))
+ .find_map(|id| parse_attrs(cx.tcx.sess, cx.tcx.hir_attrs(id)))
{
return Some(msrv_attr);
}
diff --git a/src/tools/clippy/clippy_utils/src/sugg.rs b/src/tools/clippy/clippy_utils/src/sugg.rs
index 4a9ab17d4a609..6621f2540fd76 100644
--- a/src/tools/clippy/clippy_utils/src/sugg.rs
+++ b/src/tools/clippy/clippy_utils/src/sugg.rs
@@ -843,7 +843,7 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
let mut start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
// identifier referring to the variable currently triggered (i.e.: `fp`)
- let ident_str = map.name(id).to_string();
+ let ident_str = self.cx.tcx.hir_name(id).to_string();
// full identifier that includes projection (i.e.: `fp.field`)
let ident_str_with_proj = snippet(self.cx, span, "..").to_string();
@@ -872,7 +872,7 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
// item is used in a call
// i.e.: `Call`: `|x| please(x)` or `MethodCall`: `|x| [1, 2, 3].contains(x)`
ExprKind::Call(_, call_args) | ExprKind::MethodCall(_, _, call_args, _) => {
- let expr = self.cx.tcx.hir().expect_expr(cmt.hir_id);
+ let expr = self.cx.tcx.hir_expect_expr(cmt.hir_id);
let arg_ty_kind = self.cx.typeck_results().expr_ty(expr).kind();
if matches!(arg_ty_kind, ty::Ref(_, _, Mutability::Not)) {
From 9067f7cad6b52a139af3f62c243a94adbf6be9f9 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 9 Mar 2025 19:04:37 +0000
Subject: [PATCH 05/28] Explain weird quirk in user type annotation lowering
---
compiler/rustc_mir_build/src/thir/cx/mod.rs | 2 +-
.../rustc_mir_build/src/thir/pattern/mod.rs | 2 +-
compiler/rustc_mir_build/src/thir/util.rs | 22 ++++++++++++++++++-
3 files changed, 23 insertions(+), 3 deletions(-)
diff --git a/compiler/rustc_mir_build/src/thir/cx/mod.rs b/compiler/rustc_mir_build/src/thir/cx/mod.rs
index 2e069cae4269f..3d55c1401b637 100644
--- a/compiler/rustc_mir_build/src/thir/cx/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/mod.rs
@@ -207,7 +207,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
&self,
hir_id: HirId,
) -> Option<ty::CanonicalUserType<'tcx>> {
- crate::thir::util::user_args_applied_to_ty_of_hir_id(self.typeck_results, hir_id)
+ crate::thir::util::user_args_applied_to_ty_of_hir_id(self.tcx, self.typeck_results, hir_id)
}
}
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
index 8dc3f998e0916..4bfeab44bf4b9 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -539,7 +539,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
&self,
hir_id: hir::HirId,
) -> Option<ty::CanonicalUserType<'tcx>> {
- crate::thir::util::user_args_applied_to_ty_of_hir_id(self.typeck_results, hir_id)
+ crate::thir::util::user_args_applied_to_ty_of_hir_id(self.tcx, self.typeck_results, hir_id)
}
/// Takes a HIR Path. If the path is a constant, evaluates it and feeds
diff --git a/compiler/rustc_mir_build/src/thir/util.rs b/compiler/rustc_mir_build/src/thir/util.rs
index 60a47a94e3a1f..457957f5fce95 100644
--- a/compiler/rustc_mir_build/src/thir/util.rs
+++ b/compiler/rustc_mir_build/src/thir/util.rs
@@ -1,12 +1,16 @@
+use std::assert_matches::assert_matches;
+
use rustc_hir as hir;
+use rustc_hir::def::DefKind;
use rustc_middle::bug;
-use rustc_middle::ty::{self, CanonicalUserType};
+use rustc_middle::ty::{self, CanonicalUserType, TyCtxt};
use tracing::debug;
/// Looks up the type associated with this hir-id and applies the
/// user-given generic parameters; the hir-id must map to a suitable
/// type.
pub(crate) fn user_args_applied_to_ty_of_hir_id<'tcx>(
+ tcx: TyCtxt<'tcx>,
typeck_results: &ty::TypeckResults<'tcx>,
hir_id: hir::HirId,
) -> Option<CanonicalUserType<'tcx>> {
@@ -16,7 +20,23 @@ pub(crate) fn user_args_applied_to_ty_of_hir_id<'tcx>(
let ty = typeck_results.node_type(hir_id);
match ty.kind() {
ty::Adt(adt_def, ..) => {
+ // This "fixes" user type annotations for tupled ctor patterns for ADTs.
+ // That's because `type_of(ctor_did)` returns a FnDef, but we actually
+ // want to be annotating the type of the ADT itself. It's a bit goofy,
+ // but it's easier to adjust this here rather than in the path lowering
+ // code for patterns in HIR.
if let ty::UserTypeKind::TypeOf(did, _) = &mut user_ty.value.kind {
+ // This is either already set up correctly (struct, union, enum, or variant),
+ // or needs adjusting (ctor). Make sure we don't start adjusting other
+ // user annotations like consts or fn calls.
+ assert_matches!(
+ tcx.def_kind(*did),
+ DefKind::Ctor(..)
+ | DefKind::Struct
+ | DefKind::Enum
+ | DefKind::Union
+ | DefKind::Variant
+ );
*did = adt_def.did();
}
Some(user_ty)
From 8ab05adc37667c3169fb120b3a9f53be9a909c3b Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 9 Mar 2025 19:12:42 +0000
Subject: [PATCH 06/28] Do not write user type annotation for const param value
path
---
compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs | 7 +++++++
tests/crashes/138048.rs | 8 --------
.../generic_const_parameter_types/bad-param-in-pat.rs | 10 ++++++++++
.../bad-param-in-pat.stderr | 11 +++++++++++
4 files changed, 28 insertions(+), 8 deletions(-)
delete mode 100644 tests/crashes/138048.rs
create mode 100644 tests/ui/const-generics/generic_const_parameter_types/bad-param-in-pat.rs
create mode 100644 tests/ui/const-generics/generic_const_parameter_types/bad-param-in-pat.stderr
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index c46a42c5de1e3..36ad0ae1c3016 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -220,6 +220,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
) {
debug!("fcx {}", self.tag());
+ // Don't write user type annotations for const param types, since we give them
+ // identity args just so that we can trivially substitute their `EarlyBinder`.
+ // We enforce that they match their type in MIR later on.
+ if matches!(self.tcx.def_kind(def_id), DefKind::ConstParam) {
+ return;
+ }
+
if Self::can_contain_user_lifetime_bounds((args, user_self_ty)) {
let canonicalized = self.canonicalize_user_type_annotation(ty::UserType::new(
ty::UserTypeKind::TypeOf(def_id, UserArgs { args, user_self_ty }),
diff --git a/tests/crashes/138048.rs b/tests/crashes/138048.rs
deleted file mode 100644
index fd59f46c752f7..0000000000000
--- a/tests/crashes/138048.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//@ known-bug: #138048
-struct Foo;
-
-impl<'b> Foo {
- fn bar<const V: u8>() {
- let V;
- }
-}
diff --git a/tests/ui/const-generics/generic_const_parameter_types/bad-param-in-pat.rs b/tests/ui/const-generics/generic_const_parameter_types/bad-param-in-pat.rs
new file mode 100644
index 0000000000000..bc54aad59ba96
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/bad-param-in-pat.rs
@@ -0,0 +1,10 @@
+struct Foo<'a>(&'a ());
+
+// We need a lifetime in scope or else we do not write a user type annotation as a fast-path.
+impl<'a> Foo<'a> {
+ fn bar<const V: u8>() {
+ let V;
+ //~^ ERROR constant parameters cannot be referenced in patterns
+ }
+}
+fn main() {}
diff --git a/tests/ui/const-generics/generic_const_parameter_types/bad-param-in-pat.stderr b/tests/ui/const-generics/generic_const_parameter_types/bad-param-in-pat.stderr
new file mode 100644
index 0000000000000..299ff4165e0d5
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/bad-param-in-pat.stderr
@@ -0,0 +1,11 @@
+error[E0158]: constant parameters cannot be referenced in patterns
+ --> $DIR/bad-param-in-pat.rs:6:13
+ |
+LL | fn bar<const V: u8>() {
+ | ----------- constant defined here
+LL | let V;
+ | ^ can't be used in patterns
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0158`.
From ed6dfddfeb345e0fe94ef735a54d6290d278a6b8 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 9 Mar 2025 18:23:17 +0000
Subject: [PATCH 07/28] Do not feed anon const a type that references generics
that it does not have
---
.../src/hir_ty_lowering/mod.rs | 25 +++++++++++++------
tests/crashes/137865.rs | 5 ----
.../references-parent-generics.feat.stderr | 25 +++++++++++++++++++
.../references-parent-generics.nofeat.stderr | 16 ++++++++++++
.../references-parent-generics.rs | 18 +++++++++++++
5 files changed, 76 insertions(+), 13 deletions(-)
delete mode 100644 tests/crashes/137865.rs
create mode 100644 tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.feat.stderr
create mode 100644 tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.nofeat.stderr
create mode 100644 tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.rs
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index dd6c40bfbb8dc..5f91f1d7b3e1f 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2294,18 +2294,14 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
{
let anon_const_type = tcx.type_of(param_def_id).instantiate(tcx, args);
- // We must error if the instantiated type has any inference variables as we will
- // use this type to feed the `type_of` and query results must not contain inference
- // variables otherwise we will ICE.
- //
+ // FIXME(generic_const_parameter_types): Ideally we remove these errors below when
+ // we have the ability to intermix typeck of anon const const args with the parent
+ // bodies typeck.
+
// We also error if the type contains any regions as effectively any region will wind
// up as a region variable in mir borrowck. It would also be somewhat concerning if
// hir typeck was using equality but mir borrowck wound up using subtyping as that could
// result in a non-infer in hir typeck but a region variable in borrowck.
- //
- // FIXME(generic_const_parameter_types): Ideally we remove these errors one day when
- // we have the ability to intermix typeck of anon const const args with the parent
- // bodies typeck.
if tcx.features().generic_const_parameter_types()
&& (anon_const_type.has_free_regions() || anon_const_type.has_erased_regions())
{
@@ -2316,6 +2312,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
tcx.feed_anon_const_type(anon.def_id, ty::EarlyBinder::bind(Ty::new_error(tcx, e)));
return ty::Const::new_error(tcx, e);
}
+ // We must error if the instantiated type has any inference variables as we will
+ // use this type to feed the `type_of` and query results must not contain inference
+ // variables otherwise we will ICE.
if anon_const_type.has_non_region_infer() {
let e = tcx.dcx().span_err(
const_arg.span(),
@@ -2324,6 +2323,16 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
tcx.feed_anon_const_type(anon.def_id, ty::EarlyBinder::bind(Ty::new_error(tcx, e)));
return ty::Const::new_error(tcx, e);
}
+ // We error when the type contains unsubstituted generics since we do not currently
+ // give the anon const any of the generics from the parent.
+ if anon_const_type.has_non_region_param() {
+ let e = tcx.dcx().span_err(
+ const_arg.span(),
+ "anonymous constants referencing generics are not yet supported",
+ );
+ tcx.feed_anon_const_type(anon.def_id, ty::EarlyBinder::bind(Ty::new_error(tcx, e)));
+ return ty::Const::new_error(tcx, e);
+ }
tcx.feed_anon_const_type(
anon.def_id,
diff --git a/tests/crashes/137865.rs b/tests/crashes/137865.rs
deleted file mode 100644
index 7ecd8c734d322..0000000000000
--- a/tests/crashes/137865.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-//@ known-bug: #137865
-trait Foo {
- type Assoc<const N: Self>;
- fn foo() -> Self::Assoc<3>;
-}
diff --git a/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.feat.stderr b/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.feat.stderr
new file mode 100644
index 0000000000000..29171c8006afb
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.feat.stderr
@@ -0,0 +1,25 @@
+warning: the feature `generic_const_parameter_types` is incomplete and may not be safe to use and/or cause compiler crashes
+ --> $DIR/references-parent-generics.rs:3:27
+ |
+LL | #![cfg_attr(feat, feature(generic_const_parameter_types))]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: see issue #137626 <https://github.com/rust-lang/rust/issues/137626> for more information
+ = note: `#[warn(incomplete_features)]` on by default
+
+error: `Self` is forbidden as the type of a const generic parameter
+ --> $DIR/references-parent-generics.rs:7:25
+ |
+LL | type Assoc<const N: Self>;
+ | ^^^^
+ |
+ = note: the only supported types are integers, `bool`, and `char`
+
+error: anonymous constants referencing generics are not yet supported
+ --> $DIR/references-parent-generics.rs:14:21
+ |
+LL | let x: T::Assoc<3>;
+ | ^
+
+error: aborting due to 2 previous errors; 1 warning emitted
+
diff --git a/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.nofeat.stderr b/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.nofeat.stderr
new file mode 100644
index 0000000000000..64b413188144d
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.nofeat.stderr
@@ -0,0 +1,16 @@
+error: `Self` is forbidden as the type of a const generic parameter
+ --> $DIR/references-parent-generics.rs:7:25
+ |
+LL | type Assoc<const N: Self>;
+ | ^^^^
+ |
+ = note: the only supported types are integers, `bool`, and `char`
+
+error: anonymous constants referencing generics are not yet supported
+ --> $DIR/references-parent-generics.rs:14:21
+ |
+LL | let x: T::Assoc<3>;
+ | ^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.rs b/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.rs
new file mode 100644
index 0000000000000..21994eb83b42c
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/references-parent-generics.rs
@@ -0,0 +1,18 @@
+//@ revisions: feat nofeat
+
+#![cfg_attr(feat, feature(generic_const_parameter_types))]
+//[feat]~^ WARN the feature `generic_const_parameter_types` is incomplete
+
+trait Foo {
+ type Assoc<const N: Self>;
+ //~^ ERROR `Self` is forbidden as the type of a const generic parameter
+}
+
+fn foo<T: Foo>() {
+ // We used to end up feeding the type of this anon const to be `T`, but the anon const
+ // doesn't inherit the generics of `foo`, which led to index oob errors.
+ let x: T::Assoc<3>;
+ //~^ ERROR anonymous constants referencing generics are not yet supported
+}
+
+fn main() {}
From f525b173edd08cf68f025a5b2db38b665887771d Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 10 Mar 2025 02:31:16 +0000
Subject: [PATCH 08/28] Remove AdtFlags::IS_ANONYMOUS and Copy/Clone condition
for anonymous ADT
---
compiler/rustc_middle/src/ty/adt.rs | 8 --------
compiler/rustc_middle/src/ty/mod.rs | 2 +-
compiler/rustc_trait_selection/src/traits/select/mod.rs | 9 ---------
3 files changed, 1 insertion(+), 18 deletions(-)
diff --git a/compiler/rustc_middle/src/ty/adt.rs b/compiler/rustc_middle/src/ty/adt.rs
index 3585f28b4a550..c1dc6a894cae5 100644
--- a/compiler/rustc_middle/src/ty/adt.rs
+++ b/compiler/rustc_middle/src/ty/adt.rs
@@ -53,8 +53,6 @@ bitflags::bitflags! {
const IS_VARIANT_LIST_NON_EXHAUSTIVE = 1 << 8;
/// Indicates whether the type is `UnsafeCell`.
const IS_UNSAFE_CELL = 1 << 9;
- /// Indicates whether the type is anonymous.
- const IS_ANONYMOUS = 1 << 10;
}
}
rustc_data_structures::external_bitflags_debug! { AdtFlags }
@@ -402,12 +400,6 @@ impl<'tcx> AdtDef<'tcx> {
self.flags().contains(AdtFlags::IS_MANUALLY_DROP)
}
- /// Returns `true` if this is an anonymous adt
- #[inline]
- pub fn is_anonymous(self) -> bool {
- self.flags().contains(AdtFlags::IS_ANONYMOUS)
- }
-
/// Returns `true` if this type has a destructor.
pub fn has_dtor(self, tcx: TyCtxt<'tcx>) -> bool {
self.destructor(tcx).is_some()
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index c5509c0a6087e..97cfe5946af15 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -1151,7 +1151,7 @@ pub struct VariantDef {
/// `DefId` that identifies the variant's constructor.
/// If this variant is a struct variant, then this is `None`.
pub ctor: Option<(CtorKind, DefId)>,
- /// Variant or struct name, maybe empty for anonymous adt (struct or union).
+ /// Variant or struct name.
pub name: Symbol,
/// Discriminant of this variant.
pub discr: VariantDiscr,
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index 0a54b8468fe3c..e1adabbeaa662 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -2231,15 +2231,6 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
}
}
- // `Copy` and `Clone` are automatically implemented for an anonymous adt
- // if all of its fields are `Copy` and `Clone`
- ty::Adt(adt, args) if adt.is_anonymous() => {
- // (*) binder moved here
- Where(obligation.predicate.rebind(
- adt.non_enum_variant().fields.iter().map(|f| f.ty(self.tcx(), args)).collect(),
- ))
- }
-
ty::Adt(..) | ty::Alias(..) | ty::Param(..) | ty::Placeholder(..) => {
// Fallback to whatever user-defined impls exist in this case.
None
From 02bb2d4410d4db07c40bed308f8ba0d2af28d069 Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bkersting@google.com>
Date: Tue, 4 Mar 2025 14:31:03 +0000
Subject: [PATCH 09/28] Disable CFI for weakly linked syscalls
Currently, when enabling CFI via -Zsanitizer=cfi and executing e.g.
std::sys::random::getrandom, we can observe a CFI violation. This is
the case for all consumers of the std::sys::pal::weak::weak macro,
as it is defining weak functions which don't show up in LLVM IR
metadata. CFI fails for all these functions.
Similar to other such cases in
https://github.com/rust-lang/rust/issues/115199, this change stops
emitting the CFI typecheck for consumers of the macro via the
\#[no_sanitize(cfi)] attribute.
---
library/std/src/sys/fs/unix.rs | 12 ++++++++++++
library/std/src/sys/pal/unix/fd.rs | 1 +
library/std/src/sys/pal/unix/process/process_unix.rs | 1 +
library/std/src/sys/pal/unix/thread.rs | 1 +
library/std/src/sys/pal/unix/time.rs | 9 +++++++++
library/std/src/sys/pal/unix/weak.rs | 3 +++
6 files changed, 27 insertions(+)
diff --git a/library/std/src/sys/fs/unix.rs b/library/std/src/sys/fs/unix.rs
index 914971934bfb0..d95735978c199 100644
--- a/library/std/src/sys/fs/unix.rs
+++ b/library/std/src/sys/fs/unix.rs
@@ -1454,6 +1454,18 @@ impl File {
Ok(())
}
+ #[cfg_attr(
+ any(
+ target_os = "android",
+ all(
+ target_os = "linux",
+ target_env = "gnu",
+ target_pointer_width = "32",
+ not(target_arch = "riscv32")
+ )
+ ),
+ no_sanitize(cfi)
+ )]
pub fn set_times(&self, times: FileTimes) -> io::Result<()> {
#[cfg(not(any(
target_os = "redox",
diff --git a/library/std/src/sys/pal/unix/fd.rs b/library/std/src/sys/pal/unix/fd.rs
index 2fc33bdfefbf5..6da329288f746 100644
--- a/library/std/src/sys/pal/unix/fd.rs
+++ b/library/std/src/sys/pal/unix/fd.rs
@@ -251,6 +251,7 @@ impl FileDesc {
}
#[cfg(all(target_os = "android", target_pointer_width = "32"))]
+ #[no_sanitize(cfi)]
pub fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
super::weak::weak!(fn preadv64(libc::c_int, *const libc::iovec, libc::c_int, off64_t) -> isize);
diff --git a/library/std/src/sys/pal/unix/process/process_unix.rs b/library/std/src/sys/pal/unix/process/process_unix.rs
index 25d9e9353320f..6d3680d231e6b 100644
--- a/library/std/src/sys/pal/unix/process/process_unix.rs
+++ b/library/std/src/sys/pal/unix/process/process_unix.rs
@@ -434,6 +434,7 @@ impl Command {
target_os = "nto",
target_vendor = "apple",
))]
+ #[cfg_attr(target_os = "linux", no_sanitize(cfi))]
fn posix_spawn(
&mut self,
stdio: &ChildPipes,
diff --git a/library/std/src/sys/pal/unix/thread.rs b/library/std/src/sys/pal/unix/thread.rs
index 11f6998cac118..33db8e6939a4d 100644
--- a/library/std/src/sys/pal/unix/thread.rs
+++ b/library/std/src/sys/pal/unix/thread.rs
@@ -188,6 +188,7 @@ impl Thread {
}
#[cfg(any(target_os = "solaris", target_os = "illumos", target_os = "nto"))]
+ #[no_sanitize(cfi)]
pub fn set_name(name: &CStr) {
weak! {
fn pthread_setname_np(
diff --git a/library/std/src/sys/pal/unix/time.rs b/library/std/src/sys/pal/unix/time.rs
index 0271626380c5f..fc60c307f34e1 100644
--- a/library/std/src/sys/pal/unix/time.rs
+++ b/library/std/src/sys/pal/unix/time.rs
@@ -96,6 +96,15 @@ impl Timespec {
}
}
+ #[cfg_attr(
+ all(
+ target_os = "linux",
+ target_env = "gnu",
+ target_pointer_width = "32",
+ not(target_arch = "riscv32")
+ ),
+ no_sanitize(cfi)
+ )]
pub fn now(clock: libc::clockid_t) -> Timespec {
use crate::mem::MaybeUninit;
use crate::sys::cvt;
diff --git a/library/std/src/sys/pal/unix/weak.rs b/library/std/src/sys/pal/unix/weak.rs
index 7ec4787f1eab7..9a718b71f4696 100644
--- a/library/std/src/sys/pal/unix/weak.rs
+++ b/library/std/src/sys/pal/unix/weak.rs
@@ -144,6 +144,9 @@ unsafe fn fetch(name: &str) -> *mut libc::c_void {
#[cfg(not(any(target_os = "linux", target_os = "android")))]
pub(crate) macro syscall {
(fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => (
+ // FIXME: Rust currently omits weak function definitions
+ // and its metadata from LLVM IR.
+ #[no_sanitize(cfi)]
unsafe fn $name($($arg_name: $t),*) -> $ret {
weak! { fn $name($($t),*) -> $ret }
From e5dc1e378619b11b296a953ca08abb2cdf38f9e0 Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bkersting@google.com>
Date: Mon, 10 Mar 2025 08:59:24 +0000
Subject: [PATCH 10/28] Add comments for #[no_sanitize(cfi)] in stdlib
---
library/std/src/sys/fs/unix.rs | 2 ++
library/std/src/sys/pal/unix/fd.rs | 2 ++
library/std/src/sys/pal/unix/process/process_unix.rs | 2 ++
library/std/src/sys/pal/unix/thread.rs | 2 ++
library/std/src/sys/pal/unix/time.rs | 2 ++
library/std/src/sys/pal/unix/weak.rs | 2 +-
6 files changed, 11 insertions(+), 1 deletion(-)
diff --git a/library/std/src/sys/fs/unix.rs b/library/std/src/sys/fs/unix.rs
index d95735978c199..d944bc9c9a2a0 100644
--- a/library/std/src/sys/fs/unix.rs
+++ b/library/std/src/sys/fs/unix.rs
@@ -1454,6 +1454,8 @@ impl File {
Ok(())
}
+ // FIXME(#115199): Rust currently omits weak function definitions
+ // and its metadata from LLVM IR.
#[cfg_attr(
any(
target_os = "android",
diff --git a/library/std/src/sys/pal/unix/fd.rs b/library/std/src/sys/pal/unix/fd.rs
index 6da329288f746..a08c7ccec2da3 100644
--- a/library/std/src/sys/pal/unix/fd.rs
+++ b/library/std/src/sys/pal/unix/fd.rs
@@ -251,6 +251,8 @@ impl FileDesc {
}
#[cfg(all(target_os = "android", target_pointer_width = "32"))]
+ // FIXME(#115199): Rust currently omits weak function definitions
+ // and its metadata from LLVM IR.
#[no_sanitize(cfi)]
pub fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
super::weak::weak!(fn preadv64(libc::c_int, *const libc::iovec, libc::c_int, off64_t) -> isize);
diff --git a/library/std/src/sys/pal/unix/process/process_unix.rs b/library/std/src/sys/pal/unix/process/process_unix.rs
index 6d3680d231e6b..be9a7e919905f 100644
--- a/library/std/src/sys/pal/unix/process/process_unix.rs
+++ b/library/std/src/sys/pal/unix/process/process_unix.rs
@@ -434,6 +434,8 @@ impl Command {
target_os = "nto",
target_vendor = "apple",
))]
+ // FIXME(#115199): Rust currently omits weak function definitions
+ // and its metadata from LLVM IR.
#[cfg_attr(target_os = "linux", no_sanitize(cfi))]
fn posix_spawn(
&mut self,
diff --git a/library/std/src/sys/pal/unix/thread.rs b/library/std/src/sys/pal/unix/thread.rs
index 33db8e6939a4d..abe8d3fbf681e 100644
--- a/library/std/src/sys/pal/unix/thread.rs
+++ b/library/std/src/sys/pal/unix/thread.rs
@@ -188,6 +188,8 @@ impl Thread {
}
#[cfg(any(target_os = "solaris", target_os = "illumos", target_os = "nto"))]
+ // FIXME(#115199): Rust currently omits weak function definitions
+ // and its metadata from LLVM IR.
#[no_sanitize(cfi)]
pub fn set_name(name: &CStr) {
weak! {
diff --git a/library/std/src/sys/pal/unix/time.rs b/library/std/src/sys/pal/unix/time.rs
index fc60c307f34e1..c0a3044660b7e 100644
--- a/library/std/src/sys/pal/unix/time.rs
+++ b/library/std/src/sys/pal/unix/time.rs
@@ -96,6 +96,8 @@ impl Timespec {
}
}
+ // FIXME(#115199): Rust currently omits weak function definitions
+ // and its metadata from LLVM IR.
#[cfg_attr(
all(
target_os = "linux",
diff --git a/library/std/src/sys/pal/unix/weak.rs b/library/std/src/sys/pal/unix/weak.rs
index 9a718b71f4696..ce3f66a83748b 100644
--- a/library/std/src/sys/pal/unix/weak.rs
+++ b/library/std/src/sys/pal/unix/weak.rs
@@ -144,7 +144,7 @@ unsafe fn fetch(name: &str) -> *mut libc::c_void {
#[cfg(not(any(target_os = "linux", target_os = "android")))]
pub(crate) macro syscall {
(fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => (
- // FIXME: Rust currently omits weak function definitions
+ // FIXME(#115199): Rust currently omits weak function definitions
// and its metadata from LLVM IR.
#[no_sanitize(cfi)]
unsafe fn $name($($arg_name: $t),*) -> $ret {
From f38819ce17a5e2bfcaf58982956597214d5d034f Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Thu, 30 Jan 2025 07:56:43 +0000
Subject: [PATCH 11/28] Add some layout tests for pattern type edge cases
---
tests/ui/type/pattern_types/range_patterns.rs | 21 +-
.../type/pattern_types/range_patterns.stderr | 210 +++++++++++++++++-
2 files changed, 229 insertions(+), 2 deletions(-)
diff --git a/tests/ui/type/pattern_types/range_patterns.rs b/tests/ui/type/pattern_types/range_patterns.rs
index 446a33195c8bd..3aa8426178a17 100644
--- a/tests/ui/type/pattern_types/range_patterns.rs
+++ b/tests/ui/type/pattern_types/range_patterns.rs
@@ -1,4 +1,4 @@
-#![feature(pattern_types, rustc_attrs)]
+#![feature(pattern_types, rustc_attrs, const_trait_impl, pattern_type_range_trait)]
#![feature(pattern_type_macro)]
#![allow(incomplete_features)]
@@ -18,6 +18,25 @@ type A = Option<std::num::NonZeroU32>; //~ ERROR layout_of
#[rustc_layout(debug)]
struct NonZeroU32New(pattern_type!(u32 is 1..)); //~ ERROR layout_of
+#[rustc_layout(debug)]
+type EMPTY = pattern_type!(u32 is 1..1); //~ ERROR layout_of
+
+#[rustc_layout(debug)]
+type WRAP = pattern_type!(u32 is 1..0); //~ ERROR unknown layout
+//~^ ERROR: evaluation of constant value failed
+
+#[rustc_layout(debug)]
+type WRAP2 = pattern_type!(u32 is 5..2); //~ ERROR layout_of
+
+#[rustc_layout(debug)]
+type SIGN = pattern_type!(i8 is -10..=10); //~ ERROR layout_of
+
+#[rustc_layout(debug)]
+type MIN = pattern_type!(i8 is -128..=0); //~ ERROR layout_of
+
+#[rustc_layout(debug)]
+type SignedWrap = pattern_type!(i8 is 120..=-120); //~ ERROR layout_of
+
fn main() {
let x: pattern_type!(u32 is 1..) = unsafe { std::mem::transmute(42_u32) };
}
diff --git a/tests/ui/type/pattern_types/range_patterns.stderr b/tests/ui/type/pattern_types/range_patterns.stderr
index cb24a303404c6..b6abcf462249d 100644
--- a/tests/ui/type/pattern_types/range_patterns.stderr
+++ b/tests/ui/type/pattern_types/range_patterns.stderr
@@ -357,5 +357,213 @@ error: layout_of(NonZeroU32New) = Layout {
LL | struct NonZeroU32New(pattern_type!(u32 is 1..));
| ^^^^^^^^^^^^^^^^^^^^
-error: aborting due to 5 previous errors
+error: layout_of((u32) is 1..=0) = Layout {
+ size: Size(4 bytes),
+ align: AbiAndPrefAlign {
+ abi: Align(4 bytes),
+ pref: $SOME_ALIGN,
+ },
+ backend_repr: Scalar(
+ Initialized {
+ value: Int(
+ I32,
+ false,
+ ),
+ valid_range: (..=0) | (1..),
+ },
+ ),
+ fields: Primitive,
+ largest_niche: Some(
+ Niche {
+ offset: Size(0 bytes),
+ value: Int(
+ I32,
+ false,
+ ),
+ valid_range: (..=0) | (1..),
+ },
+ ),
+ uninhabited: false,
+ variants: Single {
+ index: 0,
+ },
+ max_repr_align: None,
+ unadjusted_abi_align: Align(4 bytes),
+ randomization_seed: $SEED,
+ }
+ --> $DIR/range_patterns.rs:22:1
+ |
+LL | type EMPTY = pattern_type!(u32 is 1..1);
+ | ^^^^^^^^^^
+
+error[E0080]: evaluation of constant value failed
+ --> $DIR/range_patterns.rs:25:37
+ |
+LL | type WRAP = pattern_type!(u32 is 1..0);
+ | ^ evaluation panicked: exclusive range end at minimum value of type
+
+error: the type has an unknown layout
+ --> $DIR/range_patterns.rs:25:1
+ |
+LL | type WRAP = pattern_type!(u32 is 1..0);
+ | ^^^^^^^^^
+
+error: layout_of((u32) is 5..=1) = Layout {
+ size: Size(4 bytes),
+ align: AbiAndPrefAlign {
+ abi: Align(4 bytes),
+ pref: $SOME_ALIGN,
+ },
+ backend_repr: Scalar(
+ Initialized {
+ value: Int(
+ I32,
+ false,
+ ),
+ valid_range: (..=1) | (5..),
+ },
+ ),
+ fields: Primitive,
+ largest_niche: Some(
+ Niche {
+ offset: Size(0 bytes),
+ value: Int(
+ I32,
+ false,
+ ),
+ valid_range: (..=1) | (5..),
+ },
+ ),
+ uninhabited: false,
+ variants: Single {
+ index: 0,
+ },
+ max_repr_align: None,
+ unadjusted_abi_align: Align(4 bytes),
+ randomization_seed: $SEED,
+ }
+ --> $DIR/range_patterns.rs:29:1
+ |
+LL | type WRAP2 = pattern_type!(u32 is 5..2);
+ | ^^^^^^^^^^
+
+error: layout_of((i8) is -10..=10) = Layout {
+ size: Size(1 bytes),
+ align: AbiAndPrefAlign {
+ abi: Align(1 bytes),
+ pref: $SOME_ALIGN,
+ },
+ backend_repr: Scalar(
+ Initialized {
+ value: Int(
+ I8,
+ true,
+ ),
+ valid_range: (..=10) | (246..),
+ },
+ ),
+ fields: Primitive,
+ largest_niche: Some(
+ Niche {
+ offset: Size(0 bytes),
+ value: Int(
+ I8,
+ true,
+ ),
+ valid_range: (..=10) | (246..),
+ },
+ ),
+ uninhabited: false,
+ variants: Single {
+ index: 0,
+ },
+ max_repr_align: None,
+ unadjusted_abi_align: Align(1 bytes),
+ randomization_seed: $SEED,
+ }
+ --> $DIR/range_patterns.rs:32:1
+ |
+LL | type SIGN = pattern_type!(i8 is -10..=10);
+ | ^^^^^^^^^
+
+error: layout_of((i8) is i8::MIN..=0) = Layout {
+ size: Size(1 bytes),
+ align: AbiAndPrefAlign {
+ abi: Align(1 bytes),
+ pref: $SOME_ALIGN,
+ },
+ backend_repr: Scalar(
+ Initialized {
+ value: Int(
+ I8,
+ true,
+ ),
+ valid_range: (..=0) | (128..),
+ },
+ ),
+ fields: Primitive,
+ largest_niche: Some(
+ Niche {
+ offset: Size(0 bytes),
+ value: Int(
+ I8,
+ true,
+ ),
+ valid_range: (..=0) | (128..),
+ },
+ ),
+ uninhabited: false,
+ variants: Single {
+ index: 0,
+ },
+ max_repr_align: None,
+ unadjusted_abi_align: Align(1 bytes),
+ randomization_seed: $SEED,
+ }
+ --> $DIR/range_patterns.rs:35:1
+ |
+LL | type MIN = pattern_type!(i8 is -128..=0);
+ | ^^^^^^^^
+
+error: layout_of((i8) is 120..=-120) = Layout {
+ size: Size(1 bytes),
+ align: AbiAndPrefAlign {
+ abi: Align(1 bytes),
+ pref: $SOME_ALIGN,
+ },
+ backend_repr: Scalar(
+ Initialized {
+ value: Int(
+ I8,
+ true,
+ ),
+ valid_range: 120..=136,
+ },
+ ),
+ fields: Primitive,
+ largest_niche: Some(
+ Niche {
+ offset: Size(0 bytes),
+ value: Int(
+ I8,
+ true,
+ ),
+ valid_range: 120..=136,
+ },
+ ),
+ uninhabited: false,
+ variants: Single {
+ index: 0,
+ },
+ max_repr_align: None,
+ unadjusted_abi_align: Align(1 bytes),
+ randomization_seed: $SEED,
+ }
+ --> $DIR/range_patterns.rs:38:1
+ |
+LL | type SignedWrap = pattern_type!(i8 is 120..=-120);
+ | ^^^^^^^^^^^^^^^
+
+error: aborting due to 12 previous errors
+For more information about this error, try `rustc --explain E0080`.
From 916f9552e975287d2bc9aed16d3a1c35b7c52695 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Thu, 30 Jan 2025 08:41:20 +0000
Subject: [PATCH 12/28] Reject wrapping ranges of pattern types
---
compiler/rustc_ty_utils/src/layout.rs | 28 +++++
tests/ui/type/pattern_types/range_patterns.rs | 6 +-
.../type/pattern_types/range_patterns.stderr | 113 ++----------------
3 files changed, 41 insertions(+), 106 deletions(-)
diff --git a/compiler/rustc_ty_utils/src/layout.rs b/compiler/rustc_ty_utils/src/layout.rs
index 5a4bb2c95da6f..7334beb52c9d5 100644
--- a/compiler/rustc_ty_utils/src/layout.rs
+++ b/compiler/rustc_ty_utils/src/layout.rs
@@ -220,6 +220,34 @@ fn layout_of_uncached<'tcx>(
.try_to_bits(tcx, cx.typing_env)
.ok_or_else(|| error(cx, LayoutError::Unknown(ty)))?;
+ // FIXME(pattern_types): create implied bounds from pattern types in signatures
+ // that require that the range end is >= the range start so that we can't hit
+ // this error anymore without first having hit a trait solver error.
+ // Very fuzzy on the details here, but pattern types are an internal impl detail,
+ // so we can just go with this for now
+ if scalar.is_signed() {
+ let range = scalar.valid_range_mut();
+ let start = layout.size.sign_extend(range.start);
+ let end = layout.size.sign_extend(range.end);
+ if end < start {
+ let guar = tcx.dcx().err(format!(
+ "pattern type ranges cannot wrap: {start}..={end}"
+ ));
+
+ return Err(error(cx, LayoutError::ReferencesError(guar)));
+ }
+ } else {
+ let range = scalar.valid_range_mut();
+ if range.end < range.start {
+ let guar = tcx.dcx().err(format!(
+ "pattern type ranges cannot wrap: {}..={}",
+ range.start, range.end
+ ));
+
+ return Err(error(cx, LayoutError::ReferencesError(guar)));
+ }
+ };
+
let niche = Niche {
offset: Size::ZERO,
value: scalar.primitive(),
diff --git a/tests/ui/type/pattern_types/range_patterns.rs b/tests/ui/type/pattern_types/range_patterns.rs
index 3aa8426178a17..dda7eb0ae4eca 100644
--- a/tests/ui/type/pattern_types/range_patterns.rs
+++ b/tests/ui/type/pattern_types/range_patterns.rs
@@ -19,14 +19,14 @@ type A = Option<std::num::NonZeroU32>; //~ ERROR layout_of
struct NonZeroU32New(pattern_type!(u32 is 1..)); //~ ERROR layout_of
#[rustc_layout(debug)]
-type EMPTY = pattern_type!(u32 is 1..1); //~ ERROR layout_of
+type EMPTY = pattern_type!(u32 is 1..1); //~ ERROR unknown layout
#[rustc_layout(debug)]
type WRAP = pattern_type!(u32 is 1..0); //~ ERROR unknown layout
//~^ ERROR: evaluation of constant value failed
#[rustc_layout(debug)]
-type WRAP2 = pattern_type!(u32 is 5..2); //~ ERROR layout_of
+type WRAP2 = pattern_type!(u32 is 5..2); //~ ERROR unknown layout
#[rustc_layout(debug)]
type SIGN = pattern_type!(i8 is -10..=10); //~ ERROR layout_of
@@ -35,7 +35,7 @@ type SIGN = pattern_type!(i8 is -10..=10); //~ ERROR layout_of
type MIN = pattern_type!(i8 is -128..=0); //~ ERROR layout_of
#[rustc_layout(debug)]
-type SignedWrap = pattern_type!(i8 is 120..=-120); //~ ERROR layout_of
+type SignedWrap = pattern_type!(i8 is 120..=-120); //~ ERROR unknown layout
fn main() {
let x: pattern_type!(u32 is 1..) = unsafe { std::mem::transmute(42_u32) };
diff --git a/tests/ui/type/pattern_types/range_patterns.stderr b/tests/ui/type/pattern_types/range_patterns.stderr
index b6abcf462249d..a05995a33f9ba 100644
--- a/tests/ui/type/pattern_types/range_patterns.stderr
+++ b/tests/ui/type/pattern_types/range_patterns.stderr
@@ -357,40 +357,9 @@ error: layout_of(NonZeroU32New) = Layout {
LL | struct NonZeroU32New(pattern_type!(u32 is 1..));
| ^^^^^^^^^^^^^^^^^^^^
-error: layout_of((u32) is 1..=0) = Layout {
- size: Size(4 bytes),
- align: AbiAndPrefAlign {
- abi: Align(4 bytes),
- pref: $SOME_ALIGN,
- },
- backend_repr: Scalar(
- Initialized {
- value: Int(
- I32,
- false,
- ),
- valid_range: (..=0) | (1..),
- },
- ),
- fields: Primitive,
- largest_niche: Some(
- Niche {
- offset: Size(0 bytes),
- value: Int(
- I32,
- false,
- ),
- valid_range: (..=0) | (1..),
- },
- ),
- uninhabited: false,
- variants: Single {
- index: 0,
- },
- max_repr_align: None,
- unadjusted_abi_align: Align(4 bytes),
- randomization_seed: $SEED,
- }
+error: pattern type ranges cannot wrap: 1..=0
+
+error: the type has an unknown layout
--> $DIR/range_patterns.rs:22:1
|
LL | type EMPTY = pattern_type!(u32 is 1..1);
@@ -408,40 +377,9 @@ error: the type has an unknown layout
LL | type WRAP = pattern_type!(u32 is 1..0);
| ^^^^^^^^^
-error: layout_of((u32) is 5..=1) = Layout {
- size: Size(4 bytes),
- align: AbiAndPrefAlign {
- abi: Align(4 bytes),
- pref: $SOME_ALIGN,
- },
- backend_repr: Scalar(
- Initialized {
- value: Int(
- I32,
- false,
- ),
- valid_range: (..=1) | (5..),
- },
- ),
- fields: Primitive,
- largest_niche: Some(
- Niche {
- offset: Size(0 bytes),
- value: Int(
- I32,
- false,
- ),
- valid_range: (..=1) | (5..),
- },
- ),
- uninhabited: false,
- variants: Single {
- index: 0,
- },
- max_repr_align: None,
- unadjusted_abi_align: Align(4 bytes),
- randomization_seed: $SEED,
- }
+error: pattern type ranges cannot wrap: 5..=1
+
+error: the type has an unknown layout
--> $DIR/range_patterns.rs:29:1
|
LL | type WRAP2 = pattern_type!(u32 is 5..2);
@@ -525,45 +463,14 @@ error: layout_of((i8) is i8::MIN..=0) = Layout {
LL | type MIN = pattern_type!(i8 is -128..=0);
| ^^^^^^^^
-error: layout_of((i8) is 120..=-120) = Layout {
- size: Size(1 bytes),
- align: AbiAndPrefAlign {
- abi: Align(1 bytes),
- pref: $SOME_ALIGN,
- },
- backend_repr: Scalar(
- Initialized {
- value: Int(
- I8,
- true,
- ),
- valid_range: 120..=136,
- },
- ),
- fields: Primitive,
- largest_niche: Some(
- Niche {
- offset: Size(0 bytes),
- value: Int(
- I8,
- true,
- ),
- valid_range: 120..=136,
- },
- ),
- uninhabited: false,
- variants: Single {
- index: 0,
- },
- max_repr_align: None,
- unadjusted_abi_align: Align(1 bytes),
- randomization_seed: $SEED,
- }
+error: pattern type ranges cannot wrap: 120..=-120
+
+error: the type has an unknown layout
--> $DIR/range_patterns.rs:38:1
|
LL | type SignedWrap = pattern_type!(i8 is 120..=-120);
| ^^^^^^^^^^^^^^^
-error: aborting due to 12 previous errors
+error: aborting due to 15 previous errors
For more information about this error, try `rustc --explain E0080`.
From 9d87d4e4f5b249312408058fdbb26d99693adf15 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Wed, 29 Jan 2025 16:37:58 +0000
Subject: [PATCH 13/28] Add tests for pattern type literals
---
tests/ui/type/pattern_types/literals.rs | 143 ++++++++++
tests/ui/type/pattern_types/literals.stderr | 276 ++++++++++++++++++++
2 files changed, 419 insertions(+)
create mode 100644 tests/ui/type/pattern_types/literals.rs
create mode 100644 tests/ui/type/pattern_types/literals.stderr
diff --git a/tests/ui/type/pattern_types/literals.rs b/tests/ui/type/pattern_types/literals.rs
new file mode 100644
index 0000000000000..7ff3fdf092052
--- /dev/null
+++ b/tests/ui/type/pattern_types/literals.rs
@@ -0,0 +1,143 @@
+//! Check where literals can be used to initialize pattern types and where not.
+
+#![feature(pattern_types, const_trait_impl, pattern_type_range_trait)]
+#![feature(pattern_type_macro)]
+
+use std::pat::pattern_type;
+
+fn out_of_range() -> pattern_type!(u32 is 1..) {
+ 0
+ //~^ mismatched types
+}
+
+fn at_range_start() -> pattern_type!(u32 is 1..) {
+ 1
+ //~^ mismatched types
+}
+
+fn in_range() -> pattern_type!(u32 is 1..) {
+ 2
+ //~^ mismatched types
+}
+
+fn negative_lit_on_unsigned_ty() -> pattern_type!(u32 is 1..) {
+ -3
+ //~^ mismatched types
+}
+
+fn negative_lit_in_range() -> pattern_type!(i8 is -5..5) {
+ -2
+ //~^ mismatched types
+}
+
+fn positive_lit_in_range_of_signed() -> pattern_type!(i8 is -5..5) {
+ 2
+ //~^ mismatched types
+}
+
+fn negative_lit_at_range_start() -> pattern_type!(i8 is -5..5) {
+ -5
+ //~^ mismatched types
+}
+
+fn positive_lit_at_range_end() -> pattern_type!(i8 is -5..5) {
+ 4
+ //~^ mismatched types
+}
+
+fn lit_one_beyond_range_end() -> pattern_type!(i8 is -5..5) {
+ 5
+ //~^ mismatched types
+}
+
+fn wrong_lit_kind() -> pattern_type!(u32 is 1..) {
+ '3'
+ //~^ mismatched types
+}
+
+fn char_lit_in_range() -> pattern_type!(char is 'a'..'z') {
+ 'b'
+ //~^ mismatched types
+}
+
+fn char_lit_out_of_range() -> pattern_type!(char is 'a'..'z') {
+ 'A'
+ //~^ mismatched types
+}
+
+fn lit_at_unsigned_range_inclusive_end() -> pattern_type!(u32 is 0..=1) {
+ 1
+ //~^ mismatched types
+}
+
+fn single_element_range() -> pattern_type!(u32 is 0..=0) {
+ 0
+ //~^ mismatched types
+}
+
+fn lit_oob_single_element_range() -> pattern_type!(u32 is 0..=0) {
+ 1
+ //~^ mismatched types
+}
+
+fn lit_oob_single_element_range_exclusive() -> pattern_type!(u32 is 0..1) {
+ 1
+ //~^ mismatched types
+}
+
+fn single_element_range_exclusive() -> pattern_type!(u32 is 0..1) {
+ 0
+ //~^ mismatched types
+}
+
+fn empty_range_at_base_type_min() -> pattern_type!(u32 is 0..0) {
+ //~^ evaluation of constant value failed
+ 0
+}
+
+fn empty_range_at_base_type_min2() -> pattern_type!(u32 is 0..0) {
+ //~^ evaluation of constant value failed
+ 1
+}
+
+fn empty_range() -> pattern_type!(u32 is 1..1) {
+ 0
+ //~^ mismatched types
+}
+
+fn empty_range2() -> pattern_type!(u32 is 1..1) {
+ 1
+ //~^ mismatched types
+}
+
+fn wraparound_range_at_base_ty_end() -> pattern_type!(u32 is 1..0) {
+ //~^ evaluation of constant value failed
+ 1
+}
+
+fn wraparound_range_at_base_ty_end2() -> pattern_type!(u32 is 1..0) {
+ //~^ evaluation of constant value failed
+ 0
+}
+
+fn wraparound_range_at_base_ty_end3() -> pattern_type!(u32 is 1..0) {
+ //~^ evaluation of constant value failed
+ 2
+}
+
+fn wraparound_range() -> pattern_type!(u32 is 2..1) {
+ 1
+ //~^ mismatched types
+}
+
+fn lit_in_wraparound_range() -> pattern_type!(u32 is 2..1) {
+ 0
+ //~^ mismatched types
+}
+
+fn lit_at_wraparound_range_start() -> pattern_type!(u32 is 2..1) {
+ 2
+ //~^ mismatched types
+}
+
+fn main() {}
diff --git a/tests/ui/type/pattern_types/literals.stderr b/tests/ui/type/pattern_types/literals.stderr
new file mode 100644
index 0000000000000..ae09872862035
--- /dev/null
+++ b/tests/ui/type/pattern_types/literals.stderr
@@ -0,0 +1,276 @@
+error[E0080]: evaluation of constant value failed
+ --> $DIR/literals.rs:93:62
+ |
+LL | fn empty_range_at_base_type_min() -> pattern_type!(u32 is 0..0) {
+ | ^ evaluation panicked: exclusive range end at minimum value of type
+
+error[E0080]: evaluation of constant value failed
+ --> $DIR/literals.rs:98:63
+ |
+LL | fn empty_range_at_base_type_min2() -> pattern_type!(u32 is 0..0) {
+ | ^ evaluation panicked: exclusive range end at minimum value of type
+
+error[E0080]: evaluation of constant value failed
+ --> $DIR/literals.rs:113:65
+ |
+LL | fn wraparound_range_at_base_ty_end() -> pattern_type!(u32 is 1..0) {
+ | ^ evaluation panicked: exclusive range end at minimum value of type
+
+error[E0080]: evaluation of constant value failed
+ --> $DIR/literals.rs:118:66
+ |
+LL | fn wraparound_range_at_base_ty_end2() -> pattern_type!(u32 is 1..0) {
+ | ^ evaluation panicked: exclusive range end at minimum value of type
+
+error[E0080]: evaluation of constant value failed
+ --> $DIR/literals.rs:123:66
+ |
+LL | fn wraparound_range_at_base_ty_end3() -> pattern_type!(u32 is 1..0) {
+ | ^ evaluation panicked: exclusive range end at minimum value of type
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:9:5
+ |
+LL | fn out_of_range() -> pattern_type!(u32 is 1..) {
+ | ------------------------- expected `(u32) is 1..` because of return type
+LL | 0
+ | ^ expected `(u32) is 1..`, found integer
+ |
+ = note: expected pattern type `(u32) is 1..`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:14:5
+ |
+LL | fn at_range_start() -> pattern_type!(u32 is 1..) {
+ | ------------------------- expected `(u32) is 1..` because of return type
+LL | 1
+ | ^ expected `(u32) is 1..`, found integer
+ |
+ = note: expected pattern type `(u32) is 1..`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:19:5
+ |
+LL | fn in_range() -> pattern_type!(u32 is 1..) {
+ | ------------------------- expected `(u32) is 1..` because of return type
+LL | 2
+ | ^ expected `(u32) is 1..`, found integer
+ |
+ = note: expected pattern type `(u32) is 1..`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:24:5
+ |
+LL | fn negative_lit_on_unsigned_ty() -> pattern_type!(u32 is 1..) {
+ | ------------------------- expected `(u32) is 1..` because of return type
+LL | -3
+ | ^^ expected `(u32) is 1..`, found integer
+ |
+ = note: expected pattern type `(u32) is 1..`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:29:5
+ |
+LL | fn negative_lit_in_range() -> pattern_type!(i8 is -5..5) {
+ | -------------------------- expected `(i8) is -5..=4` because of return type
+LL | -2
+ | ^^ expected `(i8) is -5..=4`, found integer
+ |
+ = note: expected pattern type `(i8) is -5..=4`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:34:5
+ |
+LL | fn positive_lit_in_range_of_signed() -> pattern_type!(i8 is -5..5) {
+ | -------------------------- expected `(i8) is -5..=4` because of return type
+LL | 2
+ | ^ expected `(i8) is -5..=4`, found integer
+ |
+ = note: expected pattern type `(i8) is -5..=4`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:39:5
+ |
+LL | fn negative_lit_at_range_start() -> pattern_type!(i8 is -5..5) {
+ | -------------------------- expected `(i8) is -5..=4` because of return type
+LL | -5
+ | ^^ expected `(i8) is -5..=4`, found integer
+ |
+ = note: expected pattern type `(i8) is -5..=4`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:44:5
+ |
+LL | fn positive_lit_at_range_end() -> pattern_type!(i8 is -5..5) {
+ | -------------------------- expected `(i8) is -5..=4` because of return type
+LL | 4
+ | ^ expected `(i8) is -5..=4`, found integer
+ |
+ = note: expected pattern type `(i8) is -5..=4`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:49:5
+ |
+LL | fn lit_one_beyond_range_end() -> pattern_type!(i8 is -5..5) {
+ | -------------------------- expected `(i8) is -5..=4` because of return type
+LL | 5
+ | ^ expected `(i8) is -5..=4`, found integer
+ |
+ = note: expected pattern type `(i8) is -5..=4`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:54:5
+ |
+LL | fn wrong_lit_kind() -> pattern_type!(u32 is 1..) {
+ | ------------------------- expected `(u32) is 1..` because of return type
+LL | '3'
+ | ^^^ expected `(u32) is 1..`, found `char`
+ |
+ = note: expected pattern type `(u32) is 1..`
+ found type `char`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:59:5
+ |
+LL | fn char_lit_in_range() -> pattern_type!(char is 'a'..'z') {
+ | ------------------------------- expected `(char) is 'a'..='y'` because of return type
+LL | 'b'
+ | ^^^ expected `(char) is 'a'..='y'`, found `char`
+ |
+ = note: expected pattern type `(char) is 'a'..='y'`
+ found type `char`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:64:5
+ |
+LL | fn char_lit_out_of_range() -> pattern_type!(char is 'a'..'z') {
+ | ------------------------------- expected `(char) is 'a'..='y'` because of return type
+LL | 'A'
+ | ^^^ expected `(char) is 'a'..='y'`, found `char`
+ |
+ = note: expected pattern type `(char) is 'a'..='y'`
+ found type `char`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:69:5
+ |
+LL | fn lit_at_unsigned_range_inclusive_end() -> pattern_type!(u32 is 0..=1) {
+ | --------------------------- expected `(u32) is 0..=1` because of return type
+LL | 1
+ | ^ expected `(u32) is 0..=1`, found integer
+ |
+ = note: expected pattern type `(u32) is 0..=1`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:74:5
+ |
+LL | fn single_element_range() -> pattern_type!(u32 is 0..=0) {
+ | --------------------------- expected `(u32) is 0..=0` because of return type
+LL | 0
+ | ^ expected `(u32) is 0..=0`, found integer
+ |
+ = note: expected pattern type `(u32) is 0..=0`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:79:5
+ |
+LL | fn lit_oob_single_element_range() -> pattern_type!(u32 is 0..=0) {
+ | --------------------------- expected `(u32) is 0..=0` because of return type
+LL | 1
+ | ^ expected `(u32) is 0..=0`, found integer
+ |
+ = note: expected pattern type `(u32) is 0..=0`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:84:5
+ |
+LL | fn lit_oob_single_element_range_exclusive() -> pattern_type!(u32 is 0..1) {
+ | -------------------------- expected `(u32) is 0..=0` because of return type
+LL | 1
+ | ^ expected `(u32) is 0..=0`, found integer
+ |
+ = note: expected pattern type `(u32) is 0..=0`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:89:5
+ |
+LL | fn single_element_range_exclusive() -> pattern_type!(u32 is 0..1) {
+ | -------------------------- expected `(u32) is 0..=0` because of return type
+LL | 0
+ | ^ expected `(u32) is 0..=0`, found integer
+ |
+ = note: expected pattern type `(u32) is 0..=0`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:104:5
+ |
+LL | fn empty_range() -> pattern_type!(u32 is 1..1) {
+ | -------------------------- expected `(u32) is 1..=0` because of return type
+LL | 0
+ | ^ expected `(u32) is 1..=0`, found integer
+ |
+ = note: expected pattern type `(u32) is 1..=0`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:109:5
+ |
+LL | fn empty_range2() -> pattern_type!(u32 is 1..1) {
+ | -------------------------- expected `(u32) is 1..=0` because of return type
+LL | 1
+ | ^ expected `(u32) is 1..=0`, found integer
+ |
+ = note: expected pattern type `(u32) is 1..=0`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:129:5
+ |
+LL | fn wraparound_range() -> pattern_type!(u32 is 2..1) {
+ | -------------------------- expected `(u32) is 2..=0` because of return type
+LL | 1
+ | ^ expected `(u32) is 2..=0`, found integer
+ |
+ = note: expected pattern type `(u32) is 2..=0`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:134:5
+ |
+LL | fn lit_in_wraparound_range() -> pattern_type!(u32 is 2..1) {
+ | -------------------------- expected `(u32) is 2..=0` because of return type
+LL | 0
+ | ^ expected `(u32) is 2..=0`, found integer
+ |
+ = note: expected pattern type `(u32) is 2..=0`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/literals.rs:139:5
+ |
+LL | fn lit_at_wraparound_range_start() -> pattern_type!(u32 is 2..1) {
+ | -------------------------- expected `(u32) is 2..=0` because of return type
+LL | 2
+ | ^ expected `(u32) is 2..=0`, found integer
+ |
+ = note: expected pattern type `(u32) is 2..=0`
+ found type `{integer}`
+
+error: aborting due to 27 previous errors
+
+Some errors have detailed explanations: E0080, E0308.
+For more information about an error, try `rustc --explain E0080`.
From f87e58f1948c493aef6d645f339c2b9043e5ba59 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Wed, 29 Jan 2025 16:44:08 +0000
Subject: [PATCH 14/28] Allow int literals for pattern types with int base
types
---
.../rustc_hir_typeck/src/fn_ctxt/checks.rs | 15 +-
.../src/builder/expr/as_constant.rs | 7 +-
tests/ui/type/pattern_types/literals.rs | 11 +-
tests/ui/type/pattern_types/literals.stderr | 139 ++++--------------
tests/ui/type/pattern_types/nested.rs | 4 +-
tests/ui/type/pattern_types/nested.stderr | 9 +-
6 files changed, 55 insertions(+), 130 deletions(-)
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index db947b6744da6..253ba74a19127 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -1647,7 +1647,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
ast::LitKind::Char(_) => tcx.types.char,
ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => Ty::new_int(tcx, ty::int_ty(t)),
ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => Ty::new_uint(tcx, ty::uint_ty(t)),
- ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
+ ast::LitKind::Int(i, ast::LitIntType::Unsuffixed) => {
let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind() {
ty::Int(_) | ty::Uint(_) => Some(ty),
// These exist to direct casts like `0x61 as char` to use
@@ -1656,6 +1656,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
ty::Char => Some(tcx.types.u8),
ty::RawPtr(..) => Some(tcx.types.usize),
ty::FnDef(..) | ty::FnPtr(..) => Some(tcx.types.usize),
+ &ty::Pat(base, _) if base.is_integral() => {
+ let layout = tcx
+ .layout_of(self.typing_env(self.param_env).as_query_input(ty))
+ .ok()?;
+ assert!(!layout.uninhabited);
+
+ match layout.backend_repr {
+ rustc_abi::BackendRepr::Scalar(scalar) => {
+ scalar.valid_range(&tcx).contains(u128::from(i.get())).then_some(ty)
+ }
+ _ => unreachable!(),
+ }
+ }
_ => None,
});
opt_ty.unwrap_or_else(|| self.next_int_var())
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_constant.rs b/compiler/rustc_mir_build/src/builder/expr/as_constant.rs
index 84c9297e65898..f743ea60a456c 100644
--- a/compiler/rustc_mir_build/src/builder/expr/as_constant.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/as_constant.rs
@@ -117,7 +117,12 @@ fn lit_to_mir_constant<'tcx>(tcx: TyCtxt<'tcx>, lit_input: LitToConstInput<'tcx>
ConstValue::Scalar(Scalar::from_uint(result, width))
};
- let value = match (lit, ty.kind()) {
+ let lit_ty = match *ty.kind() {
+ ty::Pat(base, _) => base,
+ _ => ty,
+ };
+
+ let value = match (lit, lit_ty.kind()) {
(ast::LitKind::Str(s, _), ty::Ref(_, inner_ty, _)) if inner_ty.is_str() => {
let s = s.as_str();
let allocation = Allocation::from_bytes_byte_aligned_immutable(s.as_bytes());
diff --git a/tests/ui/type/pattern_types/literals.rs b/tests/ui/type/pattern_types/literals.rs
index 7ff3fdf092052..97a918645f3e5 100644
--- a/tests/ui/type/pattern_types/literals.rs
+++ b/tests/ui/type/pattern_types/literals.rs
@@ -12,27 +12,24 @@ fn out_of_range() -> pattern_type!(u32 is 1..) {
fn at_range_start() -> pattern_type!(u32 is 1..) {
1
- //~^ mismatched types
}
fn in_range() -> pattern_type!(u32 is 1..) {
2
- //~^ mismatched types
}
fn negative_lit_on_unsigned_ty() -> pattern_type!(u32 is 1..) {
-3
- //~^ mismatched types
+ //~^ ERROR: cannot apply unary operator `-` to type `(u32) is 1..`
}
fn negative_lit_in_range() -> pattern_type!(i8 is -5..5) {
-2
- //~^ mismatched types
+ //~^ ERROR: cannot apply unary operator `-` to type `(i8) is -5..=4`
}
fn positive_lit_in_range_of_signed() -> pattern_type!(i8 is -5..5) {
2
- //~^ mismatched types
}
fn negative_lit_at_range_start() -> pattern_type!(i8 is -5..5) {
@@ -42,7 +39,6 @@ fn negative_lit_at_range_start() -> pattern_type!(i8 is -5..5) {
fn positive_lit_at_range_end() -> pattern_type!(i8 is -5..5) {
4
- //~^ mismatched types
}
fn lit_one_beyond_range_end() -> pattern_type!(i8 is -5..5) {
@@ -67,12 +63,10 @@ fn char_lit_out_of_range() -> pattern_type!(char is 'a'..'z') {
fn lit_at_unsigned_range_inclusive_end() -> pattern_type!(u32 is 0..=1) {
1
- //~^ mismatched types
}
fn single_element_range() -> pattern_type!(u32 is 0..=0) {
0
- //~^ mismatched types
}
fn lit_oob_single_element_range() -> pattern_type!(u32 is 0..=0) {
@@ -87,7 +81,6 @@ fn lit_oob_single_element_range_exclusive() -> pattern_type!(u32 is 0..1) {
fn single_element_range_exclusive() -> pattern_type!(u32 is 0..1) {
0
- //~^ mismatched types
}
fn empty_range_at_base_type_min() -> pattern_type!(u32 is 0..0) {
diff --git a/tests/ui/type/pattern_types/literals.stderr b/tests/ui/type/pattern_types/literals.stderr
index ae09872862035..5c926742f3cdb 100644
--- a/tests/ui/type/pattern_types/literals.stderr
+++ b/tests/ui/type/pattern_types/literals.stderr
@@ -1,29 +1,29 @@
error[E0080]: evaluation of constant value failed
- --> $DIR/literals.rs:93:62
+ --> $DIR/literals.rs:86:62
|
LL | fn empty_range_at_base_type_min() -> pattern_type!(u32 is 0..0) {
| ^ evaluation panicked: exclusive range end at minimum value of type
error[E0080]: evaluation of constant value failed
- --> $DIR/literals.rs:98:63
+ --> $DIR/literals.rs:91:63
|
LL | fn empty_range_at_base_type_min2() -> pattern_type!(u32 is 0..0) {
| ^ evaluation panicked: exclusive range end at minimum value of type
error[E0080]: evaluation of constant value failed
- --> $DIR/literals.rs:113:65
+ --> $DIR/literals.rs:106:65
|
LL | fn wraparound_range_at_base_ty_end() -> pattern_type!(u32 is 1..0) {
| ^ evaluation panicked: exclusive range end at minimum value of type
error[E0080]: evaluation of constant value failed
- --> $DIR/literals.rs:118:66
+ --> $DIR/literals.rs:111:66
|
LL | fn wraparound_range_at_base_ty_end2() -> pattern_type!(u32 is 1..0) {
| ^ evaluation panicked: exclusive range end at minimum value of type
error[E0080]: evaluation of constant value failed
- --> $DIR/literals.rs:123:66
+ --> $DIR/literals.rs:116:66
|
LL | fn wraparound_range_at_base_ty_end3() -> pattern_type!(u32 is 1..0) {
| ^ evaluation panicked: exclusive range end at minimum value of type
@@ -39,63 +39,20 @@ LL | 0
= note: expected pattern type `(u32) is 1..`
found type `{integer}`
-error[E0308]: mismatched types
- --> $DIR/literals.rs:14:5
- |
-LL | fn at_range_start() -> pattern_type!(u32 is 1..) {
- | ------------------------- expected `(u32) is 1..` because of return type
-LL | 1
- | ^ expected `(u32) is 1..`, found integer
- |
- = note: expected pattern type `(u32) is 1..`
- found type `{integer}`
-
-error[E0308]: mismatched types
- --> $DIR/literals.rs:19:5
- |
-LL | fn in_range() -> pattern_type!(u32 is 1..) {
- | ------------------------- expected `(u32) is 1..` because of return type
-LL | 2
- | ^ expected `(u32) is 1..`, found integer
- |
- = note: expected pattern type `(u32) is 1..`
- found type `{integer}`
-
-error[E0308]: mismatched types
- --> $DIR/literals.rs:24:5
+error[E0600]: cannot apply unary operator `-` to type `(u32) is 1..`
+ --> $DIR/literals.rs:22:5
|
-LL | fn negative_lit_on_unsigned_ty() -> pattern_type!(u32 is 1..) {
- | ------------------------- expected `(u32) is 1..` because of return type
LL | -3
- | ^^ expected `(u32) is 1..`, found integer
- |
- = note: expected pattern type `(u32) is 1..`
- found type `{integer}`
+ | ^^ cannot apply unary operator `-`
-error[E0308]: mismatched types
- --> $DIR/literals.rs:29:5
+error[E0600]: cannot apply unary operator `-` to type `(i8) is -5..=4`
+ --> $DIR/literals.rs:27:5
|
-LL | fn negative_lit_in_range() -> pattern_type!(i8 is -5..5) {
- | -------------------------- expected `(i8) is -5..=4` because of return type
LL | -2
- | ^^ expected `(i8) is -5..=4`, found integer
- |
- = note: expected pattern type `(i8) is -5..=4`
- found type `{integer}`
+ | ^^ cannot apply unary operator `-`
error[E0308]: mismatched types
- --> $DIR/literals.rs:34:5
- |
-LL | fn positive_lit_in_range_of_signed() -> pattern_type!(i8 is -5..5) {
- | -------------------------- expected `(i8) is -5..=4` because of return type
-LL | 2
- | ^ expected `(i8) is -5..=4`, found integer
- |
- = note: expected pattern type `(i8) is -5..=4`
- found type `{integer}`
-
-error[E0308]: mismatched types
- --> $DIR/literals.rs:39:5
+ --> $DIR/literals.rs:36:5
|
LL | fn negative_lit_at_range_start() -> pattern_type!(i8 is -5..5) {
| -------------------------- expected `(i8) is -5..=4` because of return type
@@ -106,18 +63,7 @@ LL | -5
found type `{integer}`
error[E0308]: mismatched types
- --> $DIR/literals.rs:44:5
- |
-LL | fn positive_lit_at_range_end() -> pattern_type!(i8 is -5..5) {
- | -------------------------- expected `(i8) is -5..=4` because of return type
-LL | 4
- | ^ expected `(i8) is -5..=4`, found integer
- |
- = note: expected pattern type `(i8) is -5..=4`
- found type `{integer}`
-
-error[E0308]: mismatched types
- --> $DIR/literals.rs:49:5
+ --> $DIR/literals.rs:45:5
|
LL | fn lit_one_beyond_range_end() -> pattern_type!(i8 is -5..5) {
| -------------------------- expected `(i8) is -5..=4` because of return type
@@ -128,7 +74,7 @@ LL | 5
found type `{integer}`
error[E0308]: mismatched types
- --> $DIR/literals.rs:54:5
+ --> $DIR/literals.rs:50:5
|
LL | fn wrong_lit_kind() -> pattern_type!(u32 is 1..) {
| ------------------------- expected `(u32) is 1..` because of return type
@@ -139,7 +85,7 @@ LL | '3'
found type `char`
error[E0308]: mismatched types
- --> $DIR/literals.rs:59:5
+ --> $DIR/literals.rs:55:5
|
LL | fn char_lit_in_range() -> pattern_type!(char is 'a'..'z') {
| ------------------------------- expected `(char) is 'a'..='y'` because of return type
@@ -150,7 +96,7 @@ LL | 'b'
found type `char`
error[E0308]: mismatched types
- --> $DIR/literals.rs:64:5
+ --> $DIR/literals.rs:60:5
|
LL | fn char_lit_out_of_range() -> pattern_type!(char is 'a'..'z') {
| ------------------------------- expected `(char) is 'a'..='y'` because of return type
@@ -161,29 +107,7 @@ LL | 'A'
found type `char`
error[E0308]: mismatched types
- --> $DIR/literals.rs:69:5
- |
-LL | fn lit_at_unsigned_range_inclusive_end() -> pattern_type!(u32 is 0..=1) {
- | --------------------------- expected `(u32) is 0..=1` because of return type
-LL | 1
- | ^ expected `(u32) is 0..=1`, found integer
- |
- = note: expected pattern type `(u32) is 0..=1`
- found type `{integer}`
-
-error[E0308]: mismatched types
- --> $DIR/literals.rs:74:5
- |
-LL | fn single_element_range() -> pattern_type!(u32 is 0..=0) {
- | --------------------------- expected `(u32) is 0..=0` because of return type
-LL | 0
- | ^ expected `(u32) is 0..=0`, found integer
- |
- = note: expected pattern type `(u32) is 0..=0`
- found type `{integer}`
-
-error[E0308]: mismatched types
- --> $DIR/literals.rs:79:5
+ --> $DIR/literals.rs:73:5
|
LL | fn lit_oob_single_element_range() -> pattern_type!(u32 is 0..=0) {
| --------------------------- expected `(u32) is 0..=0` because of return type
@@ -194,7 +118,7 @@ LL | 1
found type `{integer}`
error[E0308]: mismatched types
- --> $DIR/literals.rs:84:5
+ --> $DIR/literals.rs:78:5
|
LL | fn lit_oob_single_element_range_exclusive() -> pattern_type!(u32 is 0..1) {
| -------------------------- expected `(u32) is 0..=0` because of return type
@@ -204,19 +128,10 @@ LL | 1
= note: expected pattern type `(u32) is 0..=0`
found type `{integer}`
-error[E0308]: mismatched types
- --> $DIR/literals.rs:89:5
- |
-LL | fn single_element_range_exclusive() -> pattern_type!(u32 is 0..1) {
- | -------------------------- expected `(u32) is 0..=0` because of return type
-LL | 0
- | ^ expected `(u32) is 0..=0`, found integer
- |
- = note: expected pattern type `(u32) is 0..=0`
- found type `{integer}`
+error: pattern type ranges cannot wrap: 1..=0
error[E0308]: mismatched types
- --> $DIR/literals.rs:104:5
+ --> $DIR/literals.rs:97:5
|
LL | fn empty_range() -> pattern_type!(u32 is 1..1) {
| -------------------------- expected `(u32) is 1..=0` because of return type
@@ -227,7 +142,7 @@ LL | 0
found type `{integer}`
error[E0308]: mismatched types
- --> $DIR/literals.rs:109:5
+ --> $DIR/literals.rs:102:5
|
LL | fn empty_range2() -> pattern_type!(u32 is 1..1) {
| -------------------------- expected `(u32) is 1..=0` because of return type
@@ -237,8 +152,10 @@ LL | 1
= note: expected pattern type `(u32) is 1..=0`
found type `{integer}`
+error: pattern type ranges cannot wrap: 2..=0
+
error[E0308]: mismatched types
- --> $DIR/literals.rs:129:5
+ --> $DIR/literals.rs:122:5
|
LL | fn wraparound_range() -> pattern_type!(u32 is 2..1) {
| -------------------------- expected `(u32) is 2..=0` because of return type
@@ -249,7 +166,7 @@ LL | 1
found type `{integer}`
error[E0308]: mismatched types
- --> $DIR/literals.rs:134:5
+ --> $DIR/literals.rs:127:5
|
LL | fn lit_in_wraparound_range() -> pattern_type!(u32 is 2..1) {
| -------------------------- expected `(u32) is 2..=0` because of return type
@@ -260,7 +177,7 @@ LL | 0
found type `{integer}`
error[E0308]: mismatched types
- --> $DIR/literals.rs:139:5
+ --> $DIR/literals.rs:132:5
|
LL | fn lit_at_wraparound_range_start() -> pattern_type!(u32 is 2..1) {
| -------------------------- expected `(u32) is 2..=0` because of return type
@@ -270,7 +187,7 @@ LL | 2
= note: expected pattern type `(u32) is 2..=0`
found type `{integer}`
-error: aborting due to 27 previous errors
+error: aborting due to 22 previous errors
-Some errors have detailed explanations: E0080, E0308.
+Some errors have detailed explanations: E0080, E0308, E0600.
For more information about an error, try `rustc --explain E0080`.
diff --git a/tests/ui/type/pattern_types/nested.rs b/tests/ui/type/pattern_types/nested.rs
index 0d8cd22190e55..fd950d7329148 100644
--- a/tests/ui/type/pattern_types/nested.rs
+++ b/tests/ui/type/pattern_types/nested.rs
@@ -1,6 +1,6 @@
//! Check that pattern types can only have specific base types
-#![feature(pattern_types)]
+#![feature(pattern_types, const_trait_impl, pattern_type_range_trait)]
#![feature(pattern_type_macro)]
use std::pat::pattern_type;
@@ -14,7 +14,7 @@ const BAD_NESTING: pattern_type!(pattern_type!(u32 is 1..) is 0..) = todo!();
// We want to get the most narrowest version that a pattern could be
const BAD_NESTING2: pattern_type!(pattern_type!(i32 is 1..) is ..=-1) = todo!();
//~^ ERROR: not a valid base type for range patterns
-//~| ERROR: mismatched types
+//~| ERROR: cannot apply unary operator `-` to type `(i32) is 1..`
const BAD_NESTING3: pattern_type!(pattern_type!(i32 is 1..) is ..0) = todo!();
//~^ ERROR: not a valid base type for range patterns
diff --git a/tests/ui/type/pattern_types/nested.stderr b/tests/ui/type/pattern_types/nested.stderr
index f79d12bc3f376..bb206d9db3db8 100644
--- a/tests/ui/type/pattern_types/nested.stderr
+++ b/tests/ui/type/pattern_types/nested.stderr
@@ -43,14 +43,11 @@ LL | const BAD_NESTING2: pattern_type!(pattern_type!(i32 is 1..) is ..=-1) = tod
u128
and 5 others
-error[E0308]: mismatched types
+error[E0600]: cannot apply unary operator `-` to type `(i32) is 1..`
--> $DIR/nested.rs:15:67
|
LL | const BAD_NESTING2: pattern_type!(pattern_type!(i32 is 1..) is ..=-1) = todo!();
- | ^^ expected `(i32) is 1..`, found integer
- |
- = note: expected pattern type `(i32) is 1..`
- found type `{integer}`
+ | ^^ cannot apply unary operator `-`
error[E0277]: `(i32) is 1..` is not a valid base type for range patterns
--> $DIR/nested.rs:19:35
@@ -180,5 +177,5 @@ LL | const BAD_NESTING5: pattern_type!(f32 is 1.0 .. 2.0) = todo!();
error: aborting due to 11 previous errors
-Some errors have detailed explanations: E0277, E0308.
+Some errors have detailed explanations: E0277, E0308, E0600.
For more information about an error, try `rustc --explain E0277`.
From 53237c86564deb04def176251a58bd967f941ceb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Wed, 5 Mar 2025 11:00:56 +0100
Subject: [PATCH 15/28] Refactor GCC compilation
---
src/bootstrap/src/core/build_steps/gcc.rs | 217 +++++++++++-----------
1 file changed, 112 insertions(+), 105 deletions(-)
diff --git a/src/bootstrap/src/core/build_steps/gcc.rs b/src/bootstrap/src/core/build_steps/gcc.rs
index 70789fbbeeba0..1382d5b07f919 100644
--- a/src/bootstrap/src/core/build_steps/gcc.rs
+++ b/src/bootstrap/src/core/build_steps/gcc.rs
@@ -14,13 +14,68 @@ use std::sync::OnceLock;
use build_helper::ci::CiEnv;
-use crate::Kind;
-use crate::core::builder::{Builder, Cargo, RunConfig, ShouldRun, Step};
+use crate::Config;
+use crate::core::builder::{Builder, Cargo, Kind, RunConfig, ShouldRun, Step};
use crate::core::config::TargetSelection;
use crate::utils::build_stamp::{BuildStamp, generate_smart_stamp_hash};
use crate::utils::exec::command;
use crate::utils::helpers::{self, t};
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+pub struct Gcc {
+ pub target: TargetSelection,
+}
+
+#[derive(Clone)]
+pub struct GccOutput {
+ pub libgccjit: PathBuf,
+}
+
+impl Step for Gcc {
+ type Output = GccOutput;
+
+ const ONLY_HOSTS: bool = true;
+
+ fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+ run.path("src/gcc").alias("gcc")
+ }
+
+ fn make_run(run: RunConfig<'_>) {
+ run.builder.ensure(Gcc { target: run.target });
+ }
+
+ /// Compile GCC (specifically `libgccjit`) for `target`.
+ fn run(self, builder: &Builder<'_>) -> Self::Output {
+ let target = self.target;
+
+ // If GCC has already been built, we avoid building it again.
+ let metadata = match get_gcc_build_status(builder, target) {
+ GccBuildStatus::AlreadyBuilt(path) => return GccOutput { libgccjit: path },
+ GccBuildStatus::ShouldBuild(m) => m,
+ };
+
+ let _guard = builder.msg_unstaged(Kind::Build, "GCC", target);
+ t!(metadata.stamp.remove());
+ let _time = helpers::timeit(builder);
+
+ let libgccjit_path = libgccjit_built_path(&metadata.install_dir);
+ if builder.config.dry_run() {
+ return GccOutput { libgccjit: libgccjit_path };
+ }
+
+ build_gcc(&metadata, builder, target);
+
+ let lib_alias = metadata.install_dir.join("lib/libgccjit.so.0");
+ if !lib_alias.exists() {
+ t!(builder.symlink_file(&libgccjit_path, lib_alias));
+ }
+
+ t!(metadata.stamp.write());
+
+ GccOutput { libgccjit: libgccjit_path }
+ }
+}
+
pub struct Meta {
stamp: BuildStamp,
out_dir: PathBuf,
@@ -38,7 +93,7 @@ pub enum GccBuildStatus {
///
/// It's used to avoid busting caches during x.py check -- if we've already built
/// GCC, it's fine for us to not try to avoid doing so.
-pub fn prebuilt_gcc_config(builder: &Builder<'_>, target: TargetSelection) -> GccBuildStatus {
+pub fn get_gcc_build_status(builder: &Builder<'_>, target: TargetSelection) -> GccBuildStatus {
// Initialize the gcc submodule if not initialized already.
builder.config.update_submodule("src/gcc");
@@ -87,104 +142,65 @@ fn libgccjit_built_path(install_dir: &Path) -> PathBuf {
install_dir.join("lib/libgccjit.so")
}
-#[derive(Debug, Clone, Hash, PartialEq, Eq)]
-pub struct Gcc {
- pub target: TargetSelection,
-}
-
-#[derive(Clone)]
-pub struct GccOutput {
- pub libgccjit: PathBuf,
-}
-
-impl Step for Gcc {
- type Output = GccOutput;
-
- const ONLY_HOSTS: bool = true;
-
- fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
- run.path("src/gcc").alias("gcc")
- }
-
- fn make_run(run: RunConfig<'_>) {
- run.builder.ensure(Gcc { target: run.target });
- }
-
- /// Compile GCC (specifically `libgccjit`) for `target`.
- fn run(self, builder: &Builder<'_>) -> Self::Output {
- let target = self.target;
-
- // If GCC has already been built, we avoid building it again.
- let Meta { stamp, out_dir, install_dir, root } = match prebuilt_gcc_config(builder, target)
- {
- GccBuildStatus::AlreadyBuilt(path) => return GccOutput { libgccjit: path },
- GccBuildStatus::ShouldBuild(m) => m,
- };
-
- let _guard = builder.msg_unstaged(Kind::Build, "GCC", target);
- t!(stamp.remove());
- let _time = helpers::timeit(builder);
- t!(fs::create_dir_all(&out_dir));
- t!(fs::create_dir_all(&install_dir));
-
- let libgccjit_path = libgccjit_built_path(&install_dir);
- if builder.config.dry_run() {
- return GccOutput { libgccjit: libgccjit_path };
+fn build_gcc(metadata: &Meta, builder: &Builder, target: TargetSelection) {
+ let Meta { stamp: _, out_dir, install_dir, root } = metadata;
+
+ t!(fs::create_dir_all(out_dir));
+ t!(fs::create_dir_all(install_dir));
+
+ // GCC creates files (e.g. symlinks to the downloaded dependencies)
+ // in the source directory, which does not work with our CI setup, where we mount
+ // source directories as read-only on Linux.
+ // Therefore, as a part of the build in CI, we first copy the whole source directory
+ // to the build directory, and perform the build from there.
+ let src_dir = if CiEnv::is_ci() {
+ let src_dir = builder.gcc_out(target).join("src");
+ if src_dir.exists() {
+ builder.remove_dir(&src_dir);
}
-
- // GCC creates files (e.g. symlinks to the downloaded dependencies)
- // in the source directory, which does not work with our CI setup, where we mount
- // source directories as read-only on Linux.
- // Therefore, as a part of the build in CI, we first copy the whole source directory
- // to the build directory, and perform the build from there.
- let src_dir = if CiEnv::is_ci() {
- let src_dir = builder.gcc_out(target).join("src");
- if src_dir.exists() {
- builder.remove_dir(&src_dir);
- }
- builder.create_dir(&src_dir);
- builder.cp_link_r(&root, &src_dir);
- src_dir
- } else {
- root
- };
-
- command(src_dir.join("contrib/download_prerequisites")).current_dir(&src_dir).run(builder);
- let mut configure_cmd = command(src_dir.join("configure"));
- configure_cmd
- .current_dir(&out_dir)
- // On CI, we compile GCC with Clang.
- // The -Wno-everything flag is needed to make GCC compile with Clang 19.
- // `-g -O2` are the default flags that are otherwise used by Make.
- // FIXME(kobzol): change the flags once we have [gcc] configuration in config.toml.
- .env("CXXFLAGS", "-Wno-everything -g -O2")
- .env("CFLAGS", "-Wno-everything -g -O2")
- .arg("--enable-host-shared")
- .arg("--enable-languages=jit")
- .arg("--enable-checking=release")
- .arg("--disable-bootstrap")
- .arg("--disable-multilib")
- .arg(format!("--prefix={}", install_dir.display()));
- let cc = builder.build.cc(target).display().to_string();
- let cc = builder
+ builder.create_dir(&src_dir);
+ builder.cp_link_r(root, &src_dir);
+ src_dir
+ } else {
+ root.clone()
+ };
+
+ command(src_dir.join("contrib/download_prerequisites")).current_dir(&src_dir).run(builder);
+ let mut configure_cmd = command(src_dir.join("configure"));
+ configure_cmd
+ .current_dir(out_dir)
+ // On CI, we compile GCC with Clang.
+ // The -Wno-everything flag is needed to make GCC compile with Clang 19.
+ // `-g -O2` are the default flags that are otherwise used by Make.
+ // FIXME(kobzol): change the flags once we have [gcc] configuration in config.toml.
+ .env("CXXFLAGS", "-Wno-everything -g -O2")
+ .env("CFLAGS", "-Wno-everything -g -O2")
+ .arg("--enable-host-shared")
+ .arg("--enable-languages=jit")
+ .arg("--enable-checking=release")
+ .arg("--disable-bootstrap")
+ .arg("--disable-multilib")
+ .arg(format!("--prefix={}", install_dir.display()));
+ let cc = builder.build.cc(target).display().to_string();
+ let cc = builder
+ .build
+ .config
+ .ccache
+ .as_ref()
+ .map_or_else(|| cc.clone(), |ccache| format!("{ccache} {cc}"));
+ configure_cmd.env("CC", cc);
+
+ if let Ok(ref cxx) = builder.build.cxx(target) {
+ let cxx = cxx.display().to_string();
+ let cxx = builder
.build
.config
.ccache
.as_ref()
- .map_or_else(|| cc.clone(), |ccache| format!("{ccache} {cc}"));
- configure_cmd.env("CC", cc);
-
- if let Ok(ref cxx) = builder.build.cxx(target) {
- let cxx = cxx.display().to_string();
- let cxx = builder
- .build
- .config
- .ccache
- .as_ref()
- .map_or_else(|| cxx.clone(), |ccache| format!("{ccache} {cxx}"));
- configure_cmd.env("CXX", cxx);
- }
- configure_cmd.run(builder);
+ .map_or_else(|| cxx.clone(), |ccache| format!("{ccache} {cxx}"));
+ configure_cmd.env("CXX", cxx);
+ }
+ configure_cmd.run(builder);
command("make")
.current_dir(&out_dir)
@@ -196,15 +212,6 @@ impl Step for Gcc {
.arg("--silent")
.arg("install")
.run_capture_stdout(builder);
-
- let lib_alias = install_dir.join("lib/libgccjit.so.0");
- if !lib_alias.exists() {
- t!(builder.symlink_file(&libgccjit_path, lib_alias));
- }
-
- t!(stamp.write());
-
- GccOutput { libgccjit: libgccjit_path }
}
}
From 009aba0aa3c3e97df5d27dbb722363888c972534 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Wed, 5 Mar 2025 10:16:22 +0100
Subject: [PATCH 16/28] Add `gcc` bootstrap config section
---
config.example.toml | 5 +++++
src/bootstrap/src/core/config/config.rs | 9 ++++++++-
2 files changed, 13 insertions(+), 1 deletion(-)
diff --git a/config.example.toml b/config.example.toml
index ac5e491b4b520..2dddb0099c132 100644
--- a/config.example.toml
+++ b/config.example.toml
@@ -163,6 +163,11 @@
# Custom CMake defines to set when building LLVM.
#build-config = {}
+# =============================================================================
+# Tweaking how GCC is compiled
+# =============================================================================
+[gcc]
+
# =============================================================================
# General build configuration options
# =============================================================================
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index ac24da9f86b25..7fda61b70f9de 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -676,6 +676,7 @@ pub(crate) struct TomlConfig {
build: Option<Build>,
install: Option<Install>,
llvm: Option<Llvm>,
+ gcc: Option<Gcc>,
rust: Option<Rust>,
target: Option<HashMap<String, TomlTarget>>,
dist: Option<Dist>,
@@ -710,7 +711,7 @@ trait Merge {
impl Merge for TomlConfig {
fn merge(
&mut self,
- TomlConfig { build, install, llvm, rust, dist, target, profile, change_id }: Self,
+ TomlConfig { build, install, llvm, gcc, rust, dist, target, profile, change_id }: Self,
replace: ReplaceOpt,
) {
fn do_merge<T: Merge>(x: &mut Option<T>, y: Option<T>, replace: ReplaceOpt) {
@@ -729,6 +730,7 @@ impl Merge for TomlConfig {
do_merge(&mut self.build, build, replace);
do_merge(&mut self.install, install, replace);
do_merge(&mut self.llvm, llvm, replace);
+ do_merge(&mut self.gcc, gcc, replace);
do_merge(&mut self.rust, rust, replace);
do_merge(&mut self.dist, dist, replace);
@@ -995,6 +997,11 @@ define_config! {
}
}
+define_config! {
+ /// TOML representation of how the GCC build is configured.
+ struct Gcc {}
+}
+
define_config! {
struct Dist {
sign_folder: Option<String> = "sign-folder",
From c68a5ec6c36b9ea955968d8fcbf1c65c647a14c9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Wed, 5 Mar 2025 11:26:16 +0100
Subject: [PATCH 17/28] Add `[gcc] download-ci-gcc` option
---
config.example.toml | 5 +++++
src/bootstrap/src/core/config/config.rs | 28 ++++++++++++++++++++++++-
2 files changed, 32 insertions(+), 1 deletion(-)
diff --git a/config.example.toml b/config.example.toml
index 2dddb0099c132..c3d2ad094ceba 100644
--- a/config.example.toml
+++ b/config.example.toml
@@ -167,6 +167,11 @@
# Tweaking how GCC is compiled
# =============================================================================
[gcc]
+# Download GCC from CI instead of building it locally.
+# Note that this will attempt to download GCC even if there are local
+# modifications to the `src/gcc` submodule.
+# Currently, this is only supported for the `x86_64-unknown-linux-gnu` target.
+# download-ci-gcc = false
# =============================================================================
# General build configuration options
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 7fda61b70f9de..e73659773ab2b 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -171,6 +171,17 @@ impl LldMode {
}
}
+/// Determines how will GCC be provided.
+#[derive(Default, Clone)]
+pub enum GccCiMode {
+ /// Build GCC from the local `src/gcc` submodule.
+ #[default]
+ BuildLocally,
+ /// Try to download GCC from CI.
+ /// If it is not available on CI, it will be built locally instead.
+ DownloadFromCi,
+}
+
/// Global configuration for the entire build and/or bootstrap.
///
/// This structure is parsed from `config.toml`, and some of the fields are inferred from `git` or build-time parameters.
@@ -283,6 +294,9 @@ pub struct Config {
pub llvm_ldflags: Option<String>,
pub llvm_use_libcxx: bool,
+ // gcc codegen options
+ pub gcc_ci_mode: GccCiMode,
+
// rust codegen options
pub rust_optimize: RustOptimize,
pub rust_codegen_units: Option<u32>,
@@ -999,7 +1013,9 @@ define_config! {
define_config! {
/// TOML representation of how the GCC build is configured.
- struct Gcc {}
+ struct Gcc {
+ download_ci_gcc: Option<bool> = "download-ci-gcc",
+ }
}
define_config! {
@@ -2143,6 +2159,16 @@ impl Config {
config.llvm_from_ci = config.parse_download_ci_llvm(None, false);
}
+ if let Some(gcc) = toml.gcc {
+ config.gcc_ci_mode = match gcc.download_ci_gcc {
+ Some(value) => match value {
+ true => GccCiMode::DownloadFromCi,
+ false => GccCiMode::BuildLocally,
+ },
+ None => GccCiMode::default(),
+ };
+ }
+
if let Some(t) = toml.target {
for (triple, cfg) in t {
let mut target = Target::from_triple(&triple);
From 3de10b0756bc34a6bf98eb0be5c89b3806466bdb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Wed, 5 Mar 2025 10:35:16 +0100
Subject: [PATCH 18/28] Add `download-ci-gcc-stamp` file
---
src/bootstrap/download-ci-gcc-stamp | 4 ++++
1 file changed, 4 insertions(+)
create mode 100644 src/bootstrap/download-ci-gcc-stamp
diff --git a/src/bootstrap/download-ci-gcc-stamp b/src/bootstrap/download-ci-gcc-stamp
new file mode 100644
index 0000000000000..bbe26afc95269
--- /dev/null
+++ b/src/bootstrap/download-ci-gcc-stamp
@@ -0,0 +1,4 @@
+Change this file to make users of the `download-ci-gcc` configuration download
+a new version of GCC from CI, even if the GCC submodule hasn’t changed.
+
+Last change is for: https://github.com/rust-lang/rust/pull/138051
From bc6302ca6d452e54365bf7a724bf96beffd7280e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Wed, 5 Mar 2025 11:38:05 +0100
Subject: [PATCH 19/28] Implement downloading GCC from CI
---
src/bootstrap/src/core/build_steps/gcc.rs | 96 ++++++++++++++++++-----
src/bootstrap/src/core/download.rs | 28 +++++++
2 files changed, 104 insertions(+), 20 deletions(-)
diff --git a/src/bootstrap/src/core/build_steps/gcc.rs b/src/bootstrap/src/core/build_steps/gcc.rs
index 1382d5b07f919..7e1ec39659a30 100644
--- a/src/bootstrap/src/core/build_steps/gcc.rs
+++ b/src/bootstrap/src/core/build_steps/gcc.rs
@@ -13,10 +13,11 @@ use std::path::{Path, PathBuf};
use std::sync::OnceLock;
use build_helper::ci::CiEnv;
+use build_helper::git::get_closest_merge_commit;
use crate::Config;
use crate::core::builder::{Builder, Cargo, Kind, RunConfig, ShouldRun, Step};
-use crate::core::config::TargetSelection;
+use crate::core::config::{GccCiMode, TargetSelection};
use crate::utils::build_stamp::{BuildStamp, generate_smart_stamp_hash};
use crate::utils::exec::command;
use crate::utils::helpers::{self, t};
@@ -89,17 +90,39 @@ pub enum GccBuildStatus {
ShouldBuild(Meta),
}
-/// This returns whether we've already previously built GCC.
+/// Tries to download GCC from CI if it is enabled and GCC artifacts
+/// are available for the given target.
+/// Returns a path to the libgccjit.so file.
+fn try_download_gcc(builder: &Builder<'_>, target: TargetSelection) -> Option<PathBuf> {
+ // Try to download GCC from CI if configured and available
+ if !matches!(builder.config.gcc_ci_mode, GccCiMode::DownloadFromCi) {
+ return None;
+ }
+ if target != "x86_64-unknown-linux-gnu" {
+ eprintln!("GCC CI download is only available for the `x86_64-unknown-linux-gnu` target");
+ return None;
+ }
+ let sha =
+ detect_gcc_sha(&builder.config, builder.config.rust_info.is_managed_git_subrepository());
+ let root = ci_gcc_root(&builder.config);
+ let gcc_stamp = BuildStamp::new(&root).with_prefix("gcc").add_stamp(&sha);
+ if !gcc_stamp.is_up_to_date() && !builder.config.dry_run() {
+ builder.config.download_ci_gcc(&sha, &root);
+ t!(gcc_stamp.write());
+ }
+ // FIXME: put libgccjit.so into a lib directory in dist::Gcc
+ Some(root.join("libgccjit.so"))
+}
+
+/// This returns information about whether GCC should be built or if it's already built.
+/// It transparently handles downloading GCC from CI if needed.
///
/// It's used to avoid busting caches during x.py check -- if we've already built
/// GCC, it's fine for us to not try to avoid doing so.
pub fn get_gcc_build_status(builder: &Builder<'_>, target: TargetSelection) -> GccBuildStatus {
- // Initialize the gcc submodule if not initialized already.
- builder.config.update_submodule("src/gcc");
-
- let root = builder.src.join("src/gcc");
- let out_dir = builder.gcc_out(target).join("build");
- let install_dir = builder.gcc_out(target).join("install");
+ if let Some(path) = try_download_gcc(builder, target) {
+ return GccBuildStatus::AlreadyBuilt(path);
+ }
static STAMP_HASH_MEMO: OnceLock<String> = OnceLock::new();
let smart_stamp_hash = STAMP_HASH_MEMO.get_or_init(|| {
@@ -110,6 +133,13 @@ pub fn get_gcc_build_status(builder: &Builder<'_>, target: TargetSelection) -> G
)
});
+ // Initialize the gcc submodule if not initialized already.
+ builder.config.update_submodule("src/gcc");
+
+ let root = builder.src.join("src/gcc");
+ let out_dir = builder.gcc_out(target).join("build");
+ let install_dir = builder.gcc_out(target).join("install");
+
let stamp = BuildStamp::new(&out_dir).with_prefix("gcc").add_stamp(smart_stamp_hash);
if stamp.is_up_to_date() {
@@ -142,7 +172,7 @@ fn libgccjit_built_path(install_dir: &Path) -> PathBuf {
install_dir.join("lib/libgccjit.so")
}
-fn build_gcc(metadata: &Meta, builder: &Builder, target: TargetSelection) {
+fn build_gcc(metadata: &Meta, builder: &Builder<'_>, target: TargetSelection) {
let Meta { stamp: _, out_dir, install_dir, root } = metadata;
t!(fs::create_dir_all(out_dir));
@@ -202,17 +232,12 @@ fn build_gcc(metadata: &Meta, builder: &Builder, target: TargetSelection) {
}
configure_cmd.run(builder);
- command("make")
- .current_dir(&out_dir)
- .arg("--silent")
- .arg(format!("-j{}", builder.jobs()))
- .run_capture_stdout(builder);
- command("make")
- .current_dir(&out_dir)
- .arg("--silent")
- .arg("install")
- .run_capture_stdout(builder);
- }
+ command("make")
+ .current_dir(out_dir)
+ .arg("--silent")
+ .arg(format!("-j{}", builder.jobs()))
+ .run_capture_stdout(builder);
+ command("make").current_dir(out_dir).arg("--silent").arg("install").run_capture_stdout(builder);
}
/// Configures a Cargo invocation so that it can build the GCC codegen backend.
@@ -220,3 +245,34 @@ pub fn add_cg_gcc_cargo_flags(cargo: &mut Cargo, gcc: &GccOutput) {
// Add the path to libgccjit.so to the linker search paths.
cargo.rustflag(&format!("-L{}", gcc.libgccjit.parent().unwrap().to_str().unwrap()));
}
+
+/// The absolute path to the downloaded GCC artifacts.
+fn ci_gcc_root(config: &Config) -> PathBuf {
+ config.out.join(config.build).join("ci-gcc")
+}
+
+/// This retrieves the GCC sha we *want* to use, according to git history.
+fn detect_gcc_sha(config: &Config, is_git: bool) -> String {
+ let gcc_sha = if is_git {
+ get_closest_merge_commit(
+ Some(&config.src),
+ &config.git_config(),
+ &[config.src.join("src/gcc"), config.src.join("src/bootstrap/download-ci-gcc-stamp")],
+ )
+ .unwrap()
+ } else if let Some(info) = crate::utils::channel::read_commit_info_file(&config.src) {
+ info.sha.trim().to_owned()
+ } else {
+ "".to_owned()
+ };
+
+ if gcc_sha.is_empty() {
+ eprintln!("error: could not find commit hash for downloading GCC");
+ eprintln!("HELP: maybe your repository history is too shallow?");
+ eprintln!("HELP: consider disabling `download-ci-gcc`");
+ eprintln!("HELP: or fetch enough history to include one upstream commit");
+ panic!();
+ }
+
+ gcc_sha
+}
diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index c477bdb829a91..95feb41ffd0cc 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -826,6 +826,34 @@ download-rustc = false
let llvm_root = self.ci_llvm_root();
self.unpack(&tarball, &llvm_root, "rust-dev");
}
+
+ pub fn download_ci_gcc(&self, gcc_sha: &str, root_dir: &Path) {
+ let cache_prefix = format!("gcc-{gcc_sha}");
+ let cache_dst =
+ self.bootstrap_cache_path.as_ref().cloned().unwrap_or_else(|| self.out.join("cache"));
+
+ let gcc_cache = cache_dst.join(cache_prefix);
+ if !gcc_cache.exists() {
+ t!(fs::create_dir_all(&gcc_cache));
+ }
+ let base = &self.stage0_metadata.config.artifacts_server;
+ let filename = format!("gcc-nightly-{}.tar.xz", self.build.triple);
+ let tarball = gcc_cache.join(&filename);
+ if !tarball.exists() {
+ let help_on_error = "ERROR: failed to download gcc from ci
+
+ HELP: There could be two reasons behind this:
+ 1) The host triple is not supported for `download-ci-gcc`.
+ 2) Old builds get deleted after a certain time.
+ HELP: In either case, disable `download-ci-gcc` in your config.toml:
+
+ [gcc]
+ download-ci-gcc = false
+ ";
+ self.download_file(&format!("{base}/{gcc_sha}/{filename}"), &tarball, help_on_error);
+ }
+ self.unpack(&tarball, root_dir, "gcc");
+ }
}
fn path_is_dylib(path: &Path) -> bool {
From 2b1b09ce0e0143ccf84f91b0691b52e2c8ecb6c9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Wed, 5 Mar 2025 11:39:43 +0100
Subject: [PATCH 20/28] Add change tracker entry
---
src/bootstrap/src/utils/change_tracker.rs | 5 +++++
1 file changed, 5 insertions(+)
diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index 425ffdccad57f..ec27109c117ae 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -370,4 +370,9 @@ pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
severity: ChangeSeverity::Info,
summary: "The rust.description option has moved to build.description and rust.description is now deprecated.",
},
+ ChangeInfo {
+ change_id: 138051,
+ severity: ChangeSeverity::Info,
+ summary: "There is now a new `gcc` config section that can be used to download GCC from CI using `gcc.download-ci-gcc = true`",
+ },
];
From dcc2b307dc3b4807fb9a1fb2ef8c26396bb8649b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Mon, 10 Mar 2025 11:29:04 +0100
Subject: [PATCH 21/28] Add triagebot entry for GCC modifications
---
triagebot.toml | 3 +++
1 file changed, 3 insertions(+)
diff --git a/triagebot.toml b/triagebot.toml
index e4231b2966baa..91d0edbe76289 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -958,6 +958,9 @@ If appropriate, please update `CONFIG_CHANGE_HISTORY` in `src/bootstrap/src/util
[mentions."src/bootstrap/src/core/build_steps/llvm.rs"]
message = "This PR changes how LLVM is built. Consider updating src/bootstrap/download-ci-llvm-stamp."
+[mentions."src/bootstrap/src/core/build_steps/gcc.rs"]
+message = "This PR changes how GCC is built. Consider updating src/bootstrap/download-ci-gcc-stamp."
+
[mentions."tests/crashes"]
message = "This PR changes a file inside `tests/crashes`. If a crash was fixed, please move into the corresponding `ui` subdir and add 'Fixes #<issueNr>' to the PR description to autoclose the issue upon merge."
From bf58a3521f8e5fb0fa693e77ce9ef7e5e3c4a915 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Sun, 9 Mar 2025 01:36:51 +0300
Subject: [PATCH 22/28] stabilize `ci_rustc_if_unchanged_logic` test for local
environments
Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
src/bootstrap/src/core/builder/tests.rs | 10 ++++++++--
src/bootstrap/src/core/config/config.rs | 3 +++
2 files changed, 11 insertions(+), 2 deletions(-)
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 63a1bbc24f16e..1f96ac729e2a3 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -261,8 +261,14 @@ fn ci_rustc_if_unchanged_logic() {
// Make sure "if-unchanged" logic doesn't try to use CI rustc while there are changes
// in compiler and/or library.
if config.download_rustc_commit.is_some() {
- let has_changes =
- config.last_modified_commit(&["compiler", "library"], "download-rustc", true).is_none();
+ let mut paths = vec!["compiler"];
+
+ // Handle library tree the same way as in `Config::download_ci_rustc_commit`.
+ if build_helper::ci::CiEnv::is_ci() {
+ paths.push("library");
+ }
+
+ let has_changes = config.last_modified_commit(&paths, "download-rustc", true).is_none();
assert!(
!has_changes,
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index ac24da9f86b25..09dc9dfbc04ad 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -2985,6 +2985,9 @@ impl Config {
// these changes to speed up the build process for library developers. This provides consistent
// functionality for library developers between `download-rustc=true` and `download-rustc="if-unchanged"`
// options.
+ //
+ // If you update "library" logic here, update `builder::tests::ci_rustc_if_unchanged_logic` test
+ // logic accordingly.
if !CiEnv::is_ci() {
allowed_paths.push(":!library");
}
From cf8e1f5e0faed0a8f50ccfecedb1e4fad8d79191 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Marcelo=20Dom=C3=ADnguez?=
<69964857+Sa4dUs@users.noreply.github.com>
Date: Fri, 7 Mar 2025 17:37:50 +0100
Subject: [PATCH 23/28] Fix ICE for invalid return activity and proper error
handling
---
compiler/rustc_builtin_macros/messages.ftl | 2 +
compiler/rustc_builtin_macros/src/autodiff.rs | 15 +++++-
compiler/rustc_builtin_macros/src/errors.rs | 9 ++++
.../rustc_codegen_ssa/src/codegen_attrs.rs | 19 +------
tests/ui/autodiff/autodiff_illegal.rs | 52 +++++++++++++------
tests/ui/autodiff/autodiff_illegal.stderr | 52 ++++++++++++++-----
6 files changed, 100 insertions(+), 49 deletions(-)
diff --git a/compiler/rustc_builtin_macros/messages.ftl b/compiler/rustc_builtin_macros/messages.ftl
index 4cac7cb93f581..9dac7a8aaf428 100644
--- a/compiler/rustc_builtin_macros/messages.ftl
+++ b/compiler/rustc_builtin_macros/messages.ftl
@@ -75,8 +75,10 @@ builtin_macros_autodiff_mode = unknown Mode: `{$mode}`. Use `Forward` or `Revers
builtin_macros_autodiff_mode_activity = {$act} can not be used in {$mode} Mode
builtin_macros_autodiff_not_build = this rustc version does not support autodiff
builtin_macros_autodiff_number_activities = expected {$expected} activities, but found {$found}
+builtin_macros_autodiff_ret_activity = invalid return activity {$act} in {$mode} Mode
builtin_macros_autodiff_ty_activity = {$act} can not be used for this type
+
builtin_macros_autodiff_unknown_activity = did not recognize Activity: `{$act}`
builtin_macros_bad_derive_target = `derive` may only be applied to `struct`s, `enum`s and `union`s
.label = not applicable here
diff --git a/compiler/rustc_builtin_macros/src/autodiff.rs b/compiler/rustc_builtin_macros/src/autodiff.rs
index 6d9c35756574e..6707ab8edde9f 100644
--- a/compiler/rustc_builtin_macros/src/autodiff.rs
+++ b/compiler/rustc_builtin_macros/src/autodiff.rs
@@ -8,7 +8,8 @@ mod llvm_enzyme {
use std::string::String;
use rustc_ast::expand::autodiff_attrs::{
- AutoDiffAttrs, DiffActivity, DiffMode, valid_input_activity, valid_ty_for_activity,
+ AutoDiffAttrs, DiffActivity, DiffMode, valid_input_activity, valid_ret_activity,
+ valid_ty_for_activity,
};
use rustc_ast::ptr::P;
use rustc_ast::token::{Token, TokenKind};
@@ -632,10 +633,22 @@ mod llvm_enzyme {
errors = true;
}
}
+
+ if has_ret && !valid_ret_activity(x.mode, x.ret_activity) {
+ dcx.emit_err(errors::AutoDiffInvalidRetAct {
+ span,
+ mode: x.mode.to_string(),
+ act: x.ret_activity.to_string(),
+ });
+ // We don't set `errors = true` to avoid annoying type errors relative
+ // to the expanded macro type signature
+ }
+
if errors {
// This is not the right signature, but we can continue parsing.
return (sig.clone(), new_inputs, idents, true);
}
+
let unsafe_activities = x
.input_activity
.iter()
diff --git a/compiler/rustc_builtin_macros/src/errors.rs b/compiler/rustc_builtin_macros/src/errors.rs
index ab1e0d8ee896b..30597944124cb 100644
--- a/compiler/rustc_builtin_macros/src/errors.rs
+++ b/compiler/rustc_builtin_macros/src/errors.rs
@@ -185,6 +185,15 @@ mod autodiff {
pub(crate) act: String,
}
+ #[derive(Diagnostic)]
+ #[diag(builtin_macros_autodiff_ret_activity)]
+ pub(crate) struct AutoDiffInvalidRetAct {
+ #[primary_span]
+ pub(crate) span: Span,
+ pub(crate) mode: String,
+ pub(crate) act: String,
+ }
+
#[derive(Diagnostic)]
#[diag(builtin_macros_autodiff_mode)]
pub(crate) struct AutoDiffInvalidMode {
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index c8f13dc0bae61..a01f5d372a2da 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -1,9 +1,7 @@
use std::str::FromStr;
use rustc_abi::ExternAbi;
-use rustc_ast::expand::autodiff_attrs::{
- AutoDiffAttrs, DiffActivity, DiffMode, valid_input_activity, valid_ret_activity,
-};
+use rustc_ast::expand::autodiff_attrs::{AutoDiffAttrs, DiffActivity, DiffMode};
use rustc_ast::{MetaItem, MetaItemInner, attr};
use rustc_attr_parsing::ReprAttr::ReprAlign;
use rustc_attr_parsing::{AttributeKind, InlineAttr, InstructionSetAttr, OptimizeAttr};
@@ -930,21 +928,6 @@ fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> Option<AutoDiffAttrs> {
}
}
- // Validate input and return activities
- let mut msg = "".to_string();
- for &input in &arg_activities {
- if !valid_input_activity(mode, input) {
- msg = format!("Invalid input activity {} for {} mode", input, mode);
- }
- }
- if !valid_ret_activity(mode, ret_activity) {
- msg = format!("Invalid return activity {} for {} mode", ret_activity, mode);
- }
- if msg != "".to_string() {
- tcx.dcx().struct_span_err(attr.span(), msg).with_note("invalid activity").emit();
- return Some(AutoDiffAttrs::error());
- }
-
Some(AutoDiffAttrs { mode, ret_activity, input_activity: arg_activities })
}
diff --git a/tests/ui/autodiff/autodiff_illegal.rs b/tests/ui/autodiff/autodiff_illegal.rs
index c0548d2bbb8ff..e810b9ba565ba 100644
--- a/tests/ui/autodiff/autodiff_illegal.rs
+++ b/tests/ui/autodiff/autodiff_illegal.rs
@@ -12,41 +12,40 @@ use std::autodiff::autodiff;
// We can't use Duplicated on scalars
#[autodiff(df1, Reverse, Duplicated)]
pub fn f1(x: f64) {
-//~^ ERROR Duplicated can not be used for this type
+ //~^ ERROR Duplicated can not be used for this type
unimplemented!()
}
// Too many activities
#[autodiff(df3, Reverse, Duplicated, Const)]
pub fn f3(x: f64) {
-//~^^ ERROR expected 1 activities, but found 2
+ //~^^ ERROR expected 1 activities, but found 2
unimplemented!()
}
// To few activities
#[autodiff(df4, Reverse)]
pub fn f4(x: f64) {
-//~^^ ERROR expected 1 activities, but found 0
+ //~^^ ERROR expected 1 activities, but found 0
unimplemented!()
}
// We can't use Dual in Reverse mode
#[autodiff(df5, Reverse, Dual)]
pub fn f5(x: f64) {
-//~^^ ERROR Dual can not be used in Reverse Mode
+ //~^^ ERROR Dual can not be used in Reverse Mode
unimplemented!()
}
// We can't use Duplicated in Forward mode
#[autodiff(df6, Forward, Duplicated)]
pub fn f6(x: f64) {
-//~^^ ERROR Duplicated can not be used in Forward Mode
-//~^^ ERROR Duplicated can not be used for this type
+ //~^^ ERROR Duplicated can not be used in Forward Mode
+ //~^^ ERROR Duplicated can not be used for this type
unimplemented!()
}
fn dummy() {
-
#[autodiff(df7, Forward, Dual)]
let mut x = 5;
//~^ ERROR autodiff must be applied to function
@@ -64,21 +63,21 @@ fn dummy() {
// Malformed, where args?
#[autodiff]
pub fn f7(x: f64) {
-//~^ ERROR autodiff must be applied to function
+ //~^ ERROR autodiff must be applied to function
unimplemented!()
}
// Malformed, where args?
#[autodiff()]
pub fn f8(x: f64) {
-//~^ ERROR autodiff requires at least a name and mode
+ //~^ ERROR autodiff requires at least a name and mode
unimplemented!()
}
// Invalid attribute syntax
#[autodiff = ""]
pub fn f9(x: f64) {
-//~^ ERROR autodiff must be applied to function
+ //~^ ERROR autodiff must be applied to function
unimplemented!()
}
@@ -87,21 +86,21 @@ fn fn_exists() {}
// We colide with an already existing function
#[autodiff(fn_exists, Reverse, Active)]
pub fn f10(x: f64) {
-//~^^ ERROR the name `fn_exists` is defined multiple times [E0428]
+ //~^^ ERROR the name `fn_exists` is defined multiple times [E0428]
unimplemented!()
}
// Malformed, missing a mode
#[autodiff(df11)]
pub fn f11() {
-//~^ ERROR autodiff requires at least a name and mode
+ //~^ ERROR autodiff requires at least a name and mode
unimplemented!()
}
// Invalid Mode
#[autodiff(df12, Debug)]
pub fn f12() {
-//~^^ ERROR unknown Mode: `Debug`. Use `Forward` or `Reverse`
+ //~^^ ERROR unknown Mode: `Debug`. Use `Forward` or `Reverse`
unimplemented!()
}
@@ -109,7 +108,7 @@ pub fn f12() {
// or use two autodiff macros.
#[autodiff(df13, Forward, Reverse)]
pub fn f13() {
-//~^^ ERROR did not recognize Activity: `Reverse`
+ //~^^ ERROR did not recognize Activity: `Reverse`
unimplemented!()
}
@@ -130,7 +129,7 @@ type MyFloat = f32;
// like THIR which has type information available.
#[autodiff(df15, Reverse, Active, Active)]
fn f15(x: MyFloat) -> f32 {
-//~^^ ERROR failed to resolve: use of undeclared type `MyFloat` [E0433]
+ //~^^ ERROR failed to resolve: use of undeclared type `MyFloat` [E0433]
unimplemented!()
}
@@ -141,7 +140,9 @@ fn f16(x: f32) -> MyFloat {
}
#[repr(transparent)]
-struct F64Trans { inner: f64 }
+struct F64Trans {
+ inner: f64,
+}
// We would like to support `#[repr(transparent)]` f32/f64 wrapper in return type in the future
#[autodiff(df17, Reverse, Active, Active)]
@@ -156,5 +157,24 @@ fn f18(x: F64Trans) -> f64 {
unimplemented!()
}
+// Invalid return activity
+#[autodiff(df19, Forward, Dual, Active)]
+fn f19(x: f32) -> f32 {
+ //~^^ ERROR invalid return activity Active in Forward Mode
+ unimplemented!()
+}
+
+#[autodiff(df20, Reverse, Active, Dual)]
+fn f20(x: f32) -> f32 {
+ //~^^ ERROR invalid return activity Dual in Reverse Mode
+ unimplemented!()
+}
+
+// Duplicated cannot be used as return activity
+#[autodiff(df21, Reverse, Active, Duplicated)]
+fn f21(x: f32) -> f32 {
+ //~^^ ERROR invalid return activity Duplicated in Reverse Mode
+ unimplemented!()
+}
fn main() {}
diff --git a/tests/ui/autodiff/autodiff_illegal.stderr b/tests/ui/autodiff/autodiff_illegal.stderr
index 3a7242b2f5d95..47d53492700ba 100644
--- a/tests/ui/autodiff/autodiff_illegal.stderr
+++ b/tests/ui/autodiff/autodiff_illegal.stderr
@@ -1,5 +1,5 @@
error[E0658]: attributes on expressions are experimental
- --> $DIR/autodiff_illegal.rs:54:5
+ --> $DIR/autodiff_illegal.rs:53:5
|
LL | #[autodiff(df7, Forward, Dual)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -53,25 +53,25 @@ LL | pub fn f6(x: f64) {
| ^^^
error: autodiff must be applied to function
- --> $DIR/autodiff_illegal.rs:51:5
+ --> $DIR/autodiff_illegal.rs:50:5
|
LL | let mut x = 5;
| ^^^^^^^^^^^^^^
error: autodiff must be applied to function
- --> $DIR/autodiff_illegal.rs:55:5
+ --> $DIR/autodiff_illegal.rs:54:5
|
LL | x = x + 3;
| ^
error: autodiff must be applied to function
- --> $DIR/autodiff_illegal.rs:60:5
+ --> $DIR/autodiff_illegal.rs:59:5
|
LL | let add_one_v2 = |x: u32| -> u32 { x + 1 };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: autodiff must be applied to function
- --> $DIR/autodiff_illegal.rs:66:1
+ --> $DIR/autodiff_illegal.rs:65:1
|
LL | / pub fn f7(x: f64) {
LL | |
@@ -80,7 +80,7 @@ LL | | }
| |_^
error: autodiff requires at least a name and mode
- --> $DIR/autodiff_illegal.rs:73:1
+ --> $DIR/autodiff_illegal.rs:72:1
|
LL | / pub fn f8(x: f64) {
LL | |
@@ -89,7 +89,7 @@ LL | | }
| |_^
error: autodiff must be applied to function
- --> $DIR/autodiff_illegal.rs:80:1
+ --> $DIR/autodiff_illegal.rs:79:1
|
LL | / pub fn f9(x: f64) {
LL | |
@@ -98,7 +98,7 @@ LL | | }
| |_^
error[E0428]: the name `fn_exists` is defined multiple times
- --> $DIR/autodiff_illegal.rs:88:1
+ --> $DIR/autodiff_illegal.rs:87:1
|
LL | fn fn_exists() {}
| -------------- previous definition of the value `fn_exists` here
@@ -110,7 +110,7 @@ LL | #[autodiff(fn_exists, Reverse, Active)]
= note: this error originates in the attribute macro `autodiff` (in Nightly builds, run with -Z macro-backtrace for more info)
error: autodiff requires at least a name and mode
- --> $DIR/autodiff_illegal.rs:96:1
+ --> $DIR/autodiff_illegal.rs:95:1
|
LL | / pub fn f11() {
LL | |
@@ -119,19 +119,43 @@ LL | | }
| |_^
error: unknown Mode: `Debug`. Use `Forward` or `Reverse`
- --> $DIR/autodiff_illegal.rs:102:18
+ --> $DIR/autodiff_illegal.rs:101:18
|
LL | #[autodiff(df12, Debug)]
| ^^^^^
error: did not recognize Activity: `Reverse`
- --> $DIR/autodiff_illegal.rs:110:27
+ --> $DIR/autodiff_illegal.rs:109:27
|
LL | #[autodiff(df13, Forward, Reverse)]
| ^^^^^^^
+error: invalid return activity Active in Forward Mode
+ --> $DIR/autodiff_illegal.rs:161:1
+ |
+LL | #[autodiff(df19, Forward, Dual, Active)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: this error originates in the attribute macro `autodiff` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: invalid return activity Dual in Reverse Mode
+ --> $DIR/autodiff_illegal.rs:167:1
+ |
+LL | #[autodiff(df20, Reverse, Active, Dual)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: this error originates in the attribute macro `autodiff` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: invalid return activity Duplicated in Reverse Mode
+ --> $DIR/autodiff_illegal.rs:174:1
+ |
+LL | #[autodiff(df21, Reverse, Active, Duplicated)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: this error originates in the attribute macro `autodiff` (in Nightly builds, run with -Z macro-backtrace for more info)
+
error[E0433]: failed to resolve: use of undeclared type `MyFloat`
- --> $DIR/autodiff_illegal.rs:131:1
+ --> $DIR/autodiff_illegal.rs:130:1
|
LL | #[autodiff(df15, Reverse, Active, Active)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ use of undeclared type `MyFloat`
@@ -139,14 +163,14 @@ LL | #[autodiff(df15, Reverse, Active, Active)]
= note: this error originates in the attribute macro `autodiff` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0433]: failed to resolve: use of undeclared type `F64Trans`
- --> $DIR/autodiff_illegal.rs:153:1
+ --> $DIR/autodiff_illegal.rs:154:1
|
LL | #[autodiff(df18, Reverse, Active, Active)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ use of undeclared type `F64Trans`
|
= note: this error originates in the attribute macro `autodiff` (in Nightly builds, run with -Z macro-backtrace for more info)
-error: aborting due to 19 previous errors
+error: aborting due to 22 previous errors
Some errors have detailed explanations: E0428, E0433, E0658.
For more information about an error, try `rustc --explain E0428`.
From 33f9a491eb97af0cc72df70fd10724eda2453d45 Mon Sep 17 00:00:00 2001
From: Sa4dUs <dmmarcelo27@gmail.com>
Date: Mon, 10 Mar 2025 13:58:10 +0100
Subject: [PATCH 24/28] Combine autodiff errors together
---
compiler/rustc_builtin_macros/messages.ftl | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/compiler/rustc_builtin_macros/messages.ftl b/compiler/rustc_builtin_macros/messages.ftl
index 9dac7a8aaf428..3f03834f8d781 100644
--- a/compiler/rustc_builtin_macros/messages.ftl
+++ b/compiler/rustc_builtin_macros/messages.ftl
@@ -77,9 +77,8 @@ builtin_macros_autodiff_not_build = this rustc version does not support autodiff
builtin_macros_autodiff_number_activities = expected {$expected} activities, but found {$found}
builtin_macros_autodiff_ret_activity = invalid return activity {$act} in {$mode} Mode
builtin_macros_autodiff_ty_activity = {$act} can not be used for this type
-
-
builtin_macros_autodiff_unknown_activity = did not recognize Activity: `{$act}`
+
builtin_macros_bad_derive_target = `derive` may only be applied to `struct`s, `enum`s and `union`s
.label = not applicable here
.label2 = not a `struct`, `enum` or `union`
From 8546e015b4a04e9c397478ae1e27a5370d2c638b Mon Sep 17 00:00:00 2001
From: Sa4dUs <dmmarcelo27@gmail.com>
Date: Mon, 10 Mar 2025 16:05:27 +0100
Subject: [PATCH 25/28] Add individual activity span availability FIXME
---
compiler/rustc_builtin_macros/src/autodiff.rs | 2 ++
1 file changed, 2 insertions(+)
diff --git a/compiler/rustc_builtin_macros/src/autodiff.rs b/compiler/rustc_builtin_macros/src/autodiff.rs
index 6707ab8edde9f..cae806c6da776 100644
--- a/compiler/rustc_builtin_macros/src/autodiff.rs
+++ b/compiler/rustc_builtin_macros/src/autodiff.rs
@@ -586,6 +586,8 @@ mod llvm_enzyme {
//
// Error handling: If the user provides an invalid configuration (incorrect numbers, types, or
// both), we emit an error and return the original signature. This allows us to continue parsing.
+ // FIXME(Sa4dUs): make individual activities' span available so errors
+ // can point to only the activity instead of the entire attribute
fn gen_enzyme_decl(
ecx: &ExtCtxt<'_>,
sig: &ast::FnSig,
From 3846f942300c4fd8f43a8a8a1324ad5e358b9459 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 11 Mar 2025 14:32:03 +0100
Subject: [PATCH 26/28] miri native_calls: ensure we actually expose *mutable*
provenance to the memory FFI can access
---
compiler/rustc_const_eval/src/interpret/memory.rs | 4 ++++
compiler/rustc_middle/src/mir/interpret/allocation.rs | 5 +++++
src/tools/miri/src/alloc_addresses/mod.rs | 4 ++--
src/tools/miri/src/shims/native_lib.rs | 2 +-
4 files changed, 12 insertions(+), 3 deletions(-)
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index ce0b5a350e030..e5af067362919 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -982,6 +982,10 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
todo.push(id);
}
}
+ // Also expose the provenance of the interpreter-level allocation, so it can
+ // be read by FFI. The `black_box` is defensive programming as LLVM likes
+ // to (incorrectly) optimize away ptr2int casts whose result is unused.
+ std::hint::black_box(alloc.get_bytes_unchecked_raw().expose_provenance());
// Prepare for possible write from native code if mutable.
if info.mutbl.is_mut() {
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation.rs b/compiler/rustc_middle/src/mir/interpret/allocation.rs
index ba65a7118155c..b24f6bc7770dc 100644
--- a/compiler/rustc_middle/src/mir/interpret/allocation.rs
+++ b/compiler/rustc_middle/src/mir/interpret/allocation.rs
@@ -679,6 +679,11 @@ impl<Prov: Provenance, Extra, Bytes: AllocBytes> Allocation<Prov, Extra, Bytes>
// Set provenance of all bytes to wildcard.
self.provenance.write_wildcards(self.len());
+ // Also expose the provenance of the interpreter-level allocation, so it can
+ // be written by FFI. The `black_box` is defensive programming as LLVM likes
+ // to (incorrectly) optimize away ptr2int casts whose result is unused.
+ std::hint::black_box(self.get_bytes_unchecked_raw_mut().expose_provenance());
+
Ok(())
}
diff --git a/src/tools/miri/src/alloc_addresses/mod.rs b/src/tools/miri/src/alloc_addresses/mod.rs
index ff3a25e94bd5d..5d257029a46e5 100644
--- a/src/tools/miri/src/alloc_addresses/mod.rs
+++ b/src/tools/miri/src/alloc_addresses/mod.rs
@@ -198,8 +198,8 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
}
AllocKind::Dead => unreachable!(),
};
- // Ensure this pointer's provenance is exposed, so that it can be used by FFI code.
- return interp_ok(base_ptr.expose_provenance().try_into().unwrap());
+ // We don't have to expose this pointer yet, we do that in `prepare_for_native_call`.
+ return interp_ok(base_ptr.addr().try_into().unwrap());
}
// We are not in native lib mode, so we control the addresses ourselves.
if let Some((reuse_addr, clock)) = global_state.reuse.take_addr(
diff --git a/src/tools/miri/src/shims/native_lib.rs b/src/tools/miri/src/shims/native_lib.rs
index c6fcb0355eb80..0258a76c3e703 100644
--- a/src/tools/miri/src/shims/native_lib.rs
+++ b/src/tools/miri/src/shims/native_lib.rs
@@ -266,7 +266,7 @@ fn imm_to_carg<'tcx>(v: &ImmTy<'tcx>, cx: &impl HasDataLayout) -> InterpResult<'
CArg::USize(v.to_scalar().to_target_usize(cx)?.try_into().unwrap()),
ty::RawPtr(..) => {
let s = v.to_scalar().to_pointer(cx)?.addr();
- // This relies on the `expose_provenance` in `addr_from_alloc_id`.
+ // This relies on the `expose_provenance` in `prepare_for_native_call`.
CArg::RawPtr(std::ptr::with_exposed_provenance_mut(s.bytes_usize()))
}
_ => throw_unsup_format!("unsupported argument type for native call: {}", v.layout.ty),
From ba6c40685418a24334afcb9acd7aa9bcd8b65181 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 11 Mar 2025 15:30:39 +0100
Subject: [PATCH 27/28] let the bodies hit the floor
remove unnecessary `body` arguments
---
.../src/type_check/input_output.rs | 54 +++--
.../src/type_check/liveness/mod.rs | 20 +-
.../src/type_check/liveness/trace.rs | 42 ++--
compiler/rustc_borrowck/src/type_check/mod.rs | 210 +++++++++---------
4 files changed, 153 insertions(+), 173 deletions(-)
diff --git a/compiler/rustc_borrowck/src/type_check/input_output.rs b/compiler/rustc_borrowck/src/type_check/input_output.rs
index f70b17e33624b..c6b29fe36fd9c 100644
--- a/compiler/rustc_borrowck/src/type_check/input_output.rs
+++ b/compiler/rustc_borrowck/src/type_check/input_output.rs
@@ -24,9 +24,9 @@ use crate::universal_regions::DefiningTy;
impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
/// Check explicit closure signature annotation,
/// e.g., `|x: FxIndexMap<_, &'static u32>| ...`.
- #[instrument(skip(self, body), level = "debug")]
- pub(super) fn check_signature_annotation(&mut self, body: &Body<'tcx>) {
- let mir_def_id = body.source.def_id().expect_local();
+ #[instrument(skip(self), level = "debug")]
+ pub(super) fn check_signature_annotation(&mut self) {
+ let mir_def_id = self.body.source.def_id().expect_local();
if !self.tcx().is_closure_like(mir_def_id.to_def_id()) {
return;
@@ -38,9 +38,9 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
// (e.g., the `_` in the code above) with fresh variables.
// Then replace the bound items in the fn sig with fresh variables,
// so that they represent the view from "inside" the closure.
- let user_provided_sig = self.instantiate_canonical(body.span, &user_provided_poly_sig);
+ let user_provided_sig = self.instantiate_canonical(self.body.span, &user_provided_poly_sig);
let mut user_provided_sig = self.infcx.instantiate_binder_with_fresh_vars(
- body.span,
+ self.body.span,
BoundRegionConversionTime::FnCall,
user_provided_sig,
);
@@ -66,12 +66,13 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
Ty::new_tup(self.tcx(), user_provided_sig.inputs()),
args.tupled_upvars_ty(),
args.coroutine_captures_by_ref_ty(),
- self.infcx.next_region_var(RegionVariableOrigin::MiscVariable(body.span), || {
- RegionCtxt::Unknown
- }),
+ self.infcx
+ .next_region_var(RegionVariableOrigin::MiscVariable(self.body.span), || {
+ RegionCtxt::Unknown
+ }),
);
- let next_ty_var = || self.infcx.next_ty_var(body.span);
+ let next_ty_var = || self.infcx.next_ty_var(self.body.span);
let output_ty = Ty::new_coroutine(
self.tcx(),
self.tcx().coroutine_for_closure(mir_def_id),
@@ -107,9 +108,10 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
for (&user_ty, arg_decl) in user_provided_sig.inputs().iter().zip_eq(
// In MIR, closure args begin with an implicit `self`.
// Also, coroutines have a resume type which may be implicitly `()`.
- body.args_iter()
+ self.body
+ .args_iter()
.skip(1 + if is_coroutine_with_implicit_resume_ty { 1 } else { 0 })
- .map(|local| &body.local_decls[local]),
+ .map(|local| &self.body.local_decls[local]),
) {
self.ascribe_user_type_skip_wf(
arg_decl.ty,
@@ -119,7 +121,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
// If the user explicitly annotated the output type, enforce it.
- let output_decl = &body.local_decls[RETURN_PLACE];
+ let output_decl = &self.body.local_decls[RETURN_PLACE];
self.ascribe_user_type_skip_wf(
output_decl.ty,
ty::UserType::new(ty::UserTypeKind::Ty(user_provided_sig.output())),
@@ -127,12 +129,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
);
}
- #[instrument(skip(self, body), level = "debug")]
- pub(super) fn equate_inputs_and_outputs(
- &mut self,
- body: &Body<'tcx>,
- normalized_inputs_and_output: &[Ty<'tcx>],
- ) {
+ #[instrument(skip(self), level = "debug")]
+ pub(super) fn equate_inputs_and_outputs(&mut self, normalized_inputs_and_output: &[Ty<'tcx>]) {
let (&normalized_output_ty, normalized_input_tys) =
normalized_inputs_and_output.split_last().unwrap();
@@ -141,18 +139,18 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
// Equate expected input tys with those in the MIR.
for (argument_index, &normalized_input_ty) in normalized_input_tys.iter().enumerate() {
- if argument_index + 1 >= body.local_decls.len() {
+ if argument_index + 1 >= self.body.local_decls.len() {
self.tcx()
.dcx()
- .span_bug(body.span, "found more normalized_input_ty than local_decls");
+ .span_bug(self.body.span, "found more normalized_input_ty than local_decls");
}
// In MIR, argument N is stored in local N+1.
let local = Local::from_usize(argument_index + 1);
- let mir_input_ty = body.local_decls[local].ty;
+ let mir_input_ty = self.body.local_decls[local].ty;
- let mir_input_span = body.local_decls[local].source_info.span;
+ let mir_input_span = self.body.local_decls[local].source_info.span;
self.equate_normalized_input_or_output(
normalized_input_ty,
mir_input_ty,
@@ -160,8 +158,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
);
}
- if let Some(mir_yield_ty) = body.yield_ty() {
- let yield_span = body.local_decls[RETURN_PLACE].source_info.span;
+ if let Some(mir_yield_ty) = self.body.yield_ty() {
+ let yield_span = self.body.local_decls[RETURN_PLACE].source_info.span;
self.equate_normalized_input_or_output(
self.universal_regions.yield_ty.unwrap(),
mir_yield_ty,
@@ -169,8 +167,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
);
}
- if let Some(mir_resume_ty) = body.resume_ty() {
- let yield_span = body.local_decls[RETURN_PLACE].source_info.span;
+ if let Some(mir_resume_ty) = self.body.resume_ty() {
+ let yield_span = self.body.local_decls[RETURN_PLACE].source_info.span;
self.equate_normalized_input_or_output(
self.universal_regions.resume_ty.unwrap(),
mir_resume_ty,
@@ -179,8 +177,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
// Return types are a bit more complex. They may contain opaque `impl Trait` types.
- let mir_output_ty = body.local_decls[RETURN_PLACE].ty;
- let output_span = body.local_decls[RETURN_PLACE].source_info.span;
+ let mir_output_ty = self.body.local_decls[RETURN_PLACE].ty;
+ let output_span = self.body.local_decls[RETURN_PLACE].source_info.span;
self.equate_normalized_input_or_output(normalized_output_ty, mir_output_ty, output_span);
}
diff --git a/compiler/rustc_borrowck/src/type_check/liveness/mod.rs b/compiler/rustc_borrowck/src/type_check/liveness/mod.rs
index dcc179030020d..f17ad23f4bf64 100644
--- a/compiler/rustc_borrowck/src/type_check/liveness/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/liveness/mod.rs
@@ -31,7 +31,6 @@ mod trace;
/// performed before
pub(super) fn generate<'a, 'tcx>(
typeck: &mut TypeChecker<'_, 'tcx>,
- body: &Body<'tcx>,
location_map: &DenseLocationMap,
flow_inits: ResultsCursor<'a, 'tcx, MaybeInitializedPlaces<'a, 'tcx>>,
move_data: &MoveData<'tcx>,
@@ -51,23 +50,16 @@ pub(super) fn generate<'a, 'tcx>(
// We do record these regions in the polonius context, since they're used to differentiate
// relevant and boring locals, which is a key distinction used later in diagnostics.
if typeck.tcx().sess.opts.unstable_opts.polonius.is_next_enabled() {
- let (_, boring_locals) = compute_relevant_live_locals(typeck.tcx(), &free_regions, body);
+ let (_, boring_locals) =
+ compute_relevant_live_locals(typeck.tcx(), &free_regions, typeck.body);
typeck.polonius_liveness.as_mut().unwrap().boring_nll_locals =
boring_locals.into_iter().collect();
free_regions = typeck.universal_regions.universal_regions_iter().collect();
}
let (relevant_live_locals, boring_locals) =
- compute_relevant_live_locals(typeck.tcx(), &free_regions, body);
-
- trace::trace(
- typeck,
- body,
- location_map,
- flow_inits,
- move_data,
- relevant_live_locals,
- boring_locals,
- );
+ compute_relevant_live_locals(typeck.tcx(), &free_regions, typeck.body);
+
+ trace::trace(typeck, location_map, flow_inits, move_data, relevant_live_locals, boring_locals);
// Mark regions that should be live where they appear within rvalues or within a call: like
// args, regions, and types.
@@ -76,7 +68,7 @@ pub(super) fn generate<'a, 'tcx>(
&mut typeck.constraints.liveness_constraints,
&typeck.universal_regions,
&mut typeck.polonius_liveness,
- body,
+ typeck.body,
);
}
diff --git a/compiler/rustc_borrowck/src/type_check/liveness/trace.rs b/compiler/rustc_borrowck/src/type_check/liveness/trace.rs
index 32d398dc1605c..7718644b9a9a8 100644
--- a/compiler/rustc_borrowck/src/type_check/liveness/trace.rs
+++ b/compiler/rustc_borrowck/src/type_check/liveness/trace.rs
@@ -39,17 +39,15 @@ use crate::type_check::{NormalizeLocation, TypeChecker};
/// this respects `#[may_dangle]` annotations).
pub(super) fn trace<'a, 'tcx>(
typeck: &mut TypeChecker<'_, 'tcx>,
- body: &Body<'tcx>,
location_map: &DenseLocationMap,
flow_inits: ResultsCursor<'a, 'tcx, MaybeInitializedPlaces<'a, 'tcx>>,
move_data: &MoveData<'tcx>,
relevant_live_locals: Vec<Local>,
boring_locals: Vec<Local>,
) {
- let local_use_map = &LocalUseMap::build(&relevant_live_locals, location_map, body);
+ let local_use_map = &LocalUseMap::build(&relevant_live_locals, location_map, typeck.body);
let cx = LivenessContext {
typeck,
- body,
flow_inits,
location_map,
local_use_map,
@@ -69,14 +67,13 @@ pub(super) fn trace<'a, 'tcx>(
/// Contextual state for the type-liveness coroutine.
struct LivenessContext<'a, 'typeck, 'b, 'tcx> {
/// Current type-checker, giving us our inference context etc.
+ ///
+ /// This also stores the body we're currently analyzing.
typeck: &'a mut TypeChecker<'typeck, 'tcx>,
/// Defines the `PointIndex` mapping
location_map: &'a DenseLocationMap,
- /// MIR we are analyzing.
- body: &'a Body<'tcx>,
-
/// Mapping to/from the various indices used for initialization tracking.
move_data: &'a MoveData<'tcx>,
@@ -139,7 +136,7 @@ impl<'a, 'typeck, 'b, 'tcx> LivenessResults<'a, 'typeck, 'b, 'tcx> {
self.compute_use_live_points_for(local);
self.compute_drop_live_points_for(local);
- let local_ty = self.cx.body.local_decls[local].ty;
+ let local_ty = self.cx.body().local_decls[local].ty;
if !self.use_live_at.is_empty() {
self.cx.add_use_live_facts_for(local_ty, &self.use_live_at);
@@ -164,8 +161,8 @@ impl<'a, 'typeck, 'b, 'tcx> LivenessResults<'a, 'typeck, 'b, 'tcx> {
/// and can therefore safely be dropped.
fn dropck_boring_locals(&mut self, boring_locals: Vec<Local>) {
for local in boring_locals {
- let local_ty = self.cx.body.local_decls[local].ty;
- let local_span = self.cx.body.local_decls[local].source_info.span;
+ let local_ty = self.cx.body().local_decls[local].ty;
+ let local_span = self.cx.body().local_decls[local].source_info.span;
let drop_data = self.cx.drop_data.entry(local_ty).or_insert_with({
let typeck = &self.cx.typeck;
move || LivenessContext::compute_drop_data(typeck, local_ty, local_span)
@@ -173,7 +170,7 @@ impl<'a, 'typeck, 'b, 'tcx> LivenessResults<'a, 'typeck, 'b, 'tcx> {
drop_data.dropck_result.report_overflows(
self.cx.typeck.infcx.tcx,
- self.cx.body.local_decls[local].source_info.span,
+ self.cx.typeck.body.local_decls[local].source_info.span,
local_ty,
);
}
@@ -202,7 +199,7 @@ impl<'a, 'typeck, 'b, 'tcx> LivenessResults<'a, 'typeck, 'b, 'tcx> {
.var_dropped_at
.iter()
.filter_map(|&(local, location_index)| {
- let local_ty = self.cx.body.local_decls[local].ty;
+ let local_ty = self.cx.body().local_decls[local].ty;
if relevant_live_locals.contains(&local) || !local_ty.has_free_regions() {
return None;
}
@@ -278,9 +275,9 @@ impl<'a, 'typeck, 'b, 'tcx> LivenessResults<'a, 'typeck, 'b, 'tcx> {
let block = self.cx.location_map.to_location(block_start).block;
self.stack.extend(
- self.cx.body.basic_blocks.predecessors()[block]
+ self.cx.body().basic_blocks.predecessors()[block]
.iter()
- .map(|&pred_bb| self.cx.body.terminator_loc(pred_bb))
+ .map(|&pred_bb| self.cx.body().terminator_loc(pred_bb))
.map(|pred_loc| self.cx.location_map.point_from_location(pred_loc)),
);
}
@@ -305,7 +302,7 @@ impl<'a, 'typeck, 'b, 'tcx> LivenessResults<'a, 'typeck, 'b, 'tcx> {
// Find the drops where `local` is initialized.
for drop_point in self.cx.local_use_map.drops(local) {
let location = self.cx.location_map.to_location(drop_point);
- debug_assert_eq!(self.cx.body.terminator_loc(location.block), location,);
+ debug_assert_eq!(self.cx.body().terminator_loc(location.block), location,);
if self.cx.initialized_at_terminator(location.block, mpi)
&& self.drop_live_at.insert(drop_point)
@@ -351,7 +348,7 @@ impl<'a, 'typeck, 'b, 'tcx> LivenessResults<'a, 'typeck, 'b, 'tcx> {
// block. One of them may be either a definition or use
// live point.
let term_location = self.cx.location_map.to_location(term_point);
- debug_assert_eq!(self.cx.body.terminator_loc(term_location.block), term_location,);
+ debug_assert_eq!(self.cx.body().terminator_loc(term_location.block), term_location,);
let block = term_location.block;
let entry_point = self.cx.location_map.entry_point(term_location.block);
for p in (entry_point..term_point).rev() {
@@ -376,7 +373,7 @@ impl<'a, 'typeck, 'b, 'tcx> LivenessResults<'a, 'typeck, 'b, 'tcx> {
}
}
- let body = self.cx.body;
+ let body = self.cx.typeck.body;
for &pred_block in body.basic_blocks.predecessors()[block].iter() {
debug!("compute_drop_live_points_for_block: pred_block = {:?}", pred_block,);
@@ -403,7 +400,7 @@ impl<'a, 'typeck, 'b, 'tcx> LivenessResults<'a, 'typeck, 'b, 'tcx> {
continue;
}
- let pred_term_loc = self.cx.body.terminator_loc(pred_block);
+ let pred_term_loc = self.cx.body().terminator_loc(pred_block);
let pred_term_point = self.cx.location_map.point_from_location(pred_term_loc);
// If the terminator of this predecessor either *assigns*
@@ -463,6 +460,9 @@ impl<'a, 'typeck, 'b, 'tcx> LivenessResults<'a, 'typeck, 'b, 'tcx> {
}
impl<'tcx> LivenessContext<'_, '_, '_, 'tcx> {
+ fn body(&self) -> &Body<'tcx> {
+ self.typeck.body
+ }
/// Returns `true` if the local variable (or some part of it) is initialized at the current
/// cursor position. Callers should call one of the `seek` methods immediately before to point
/// the cursor to the desired location.
@@ -481,7 +481,7 @@ impl<'tcx> LivenessContext<'_, '_, '_, 'tcx> {
/// DROP of some local variable will have an effect -- note that
/// drops, as they may unwind, are always terminators.
fn initialized_at_terminator(&mut self, block: BasicBlock, mpi: MovePathIndex) -> bool {
- self.flow_inits.seek_before_primary_effect(self.body.terminator_loc(block));
+ self.flow_inits.seek_before_primary_effect(self.body().terminator_loc(block));
self.initialized_at_curr_loc(mpi)
}
@@ -491,7 +491,7 @@ impl<'tcx> LivenessContext<'_, '_, '_, 'tcx> {
/// **Warning:** Does not account for the result of `Call`
/// instructions.
fn initialized_at_exit(&mut self, block: BasicBlock, mpi: MovePathIndex) -> bool {
- self.flow_inits.seek_after_primary_effect(self.body.terminator_loc(block));
+ self.flow_inits.seek_after_primary_effect(self.body().terminator_loc(block));
self.initialized_at_curr_loc(mpi)
}
@@ -526,7 +526,7 @@ impl<'tcx> LivenessContext<'_, '_, '_, 'tcx> {
values::pretty_print_points(self.location_map, live_at.iter()),
);
- let local_span = self.body.local_decls()[dropped_local].source_info.span;
+ let local_span = self.body().local_decls()[dropped_local].source_info.span;
let drop_data = self.drop_data.entry(dropped_ty).or_insert_with({
let typeck = &self.typeck;
move || Self::compute_drop_data(typeck, dropped_ty, local_span)
@@ -544,7 +544,7 @@ impl<'tcx> LivenessContext<'_, '_, '_, 'tcx> {
drop_data.dropck_result.report_overflows(
self.typeck.infcx.tcx,
- self.body.source_info(*drop_locations.first().unwrap()).span,
+ self.typeck.body.source_info(*drop_locations.first().unwrap()).span,
dropped_ty,
);
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index c1e23cb54117b..9d5022f2bef4c 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -174,11 +174,11 @@ pub(crate) fn type_check<'a, 'tcx>(
let mut verifier = TypeVerifier { typeck: &mut typeck, promoted, last_span: body.span };
verifier.visit_body(body);
- typeck.typeck_mir(body);
- typeck.equate_inputs_and_outputs(body, &normalized_inputs_and_output);
- typeck.check_signature_annotation(body);
+ typeck.typeck_mir();
+ typeck.equate_inputs_and_outputs(&normalized_inputs_and_output);
+ typeck.check_signature_annotation();
- liveness::generate(&mut typeck, body, &location_map, flow_inits, move_data);
+ liveness::generate(&mut typeck, &location_map, flow_inits, move_data);
let opaque_type_values =
opaque_types::take_opaques_and_register_member_constraints(&mut typeck);
@@ -485,6 +485,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> {
#[instrument(level = "debug", skip(self))]
fn visit_body(&mut self, body: &Body<'tcx>) {
+ debug_assert!(std::ptr::eq(self.typeck.body, body));
// We intentionally do not recurse into `body.required_consts` or
// `body.mentioned_items` here as the MIR at this phase should still
// refer to all items and we don't want to check them multiple times.
@@ -542,7 +543,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
self.visit_body(promoted_body);
- self.typeck.typeck_mir(promoted_body);
+ self.typeck.typeck_mir();
self.typeck.body = parent_body;
// Merge the outlives constraints back in, at the given location.
@@ -892,8 +893,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
self.infcx.tcx
}
- #[instrument(skip(self, body), level = "debug")]
- fn check_stmt(&mut self, body: &Body<'tcx>, stmt: &Statement<'tcx>, location: Location) {
+ #[instrument(skip(self), level = "debug")]
+ fn check_stmt(&mut self, stmt: &Statement<'tcx>, location: Location) {
let tcx = self.tcx();
debug!("stmt kind: {:?}", stmt.kind);
match &stmt.kind {
@@ -916,11 +917,14 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
}
Some(l)
- if matches!(body.local_decls[l].local_info(), LocalInfo::AggregateTemp) =>
+ if matches!(
+ self.body.local_decls[l].local_info(),
+ LocalInfo::AggregateTemp
+ ) =>
{
ConstraintCategory::Usage
}
- Some(l) if !body.local_decls[l].is_user_variable() => {
+ Some(l) if !self.body.local_decls[l].is_user_variable() => {
ConstraintCategory::Boring
}
_ => ConstraintCategory::Assignment,
@@ -928,14 +932,14 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
debug!(
"assignment category: {:?} {:?}",
category,
- place.as_local().map(|l| &body.local_decls[l])
+ place.as_local().map(|l| &self.body.local_decls[l])
);
- let place_ty = place.ty(body, tcx).ty;
+ let place_ty = place.ty(self.body, tcx).ty;
debug!(?place_ty);
let place_ty = self.normalize(place_ty, location);
debug!("place_ty normalized: {:?}", place_ty);
- let rv_ty = rv.ty(body, tcx);
+ let rv_ty = rv.ty(self.body, tcx);
debug!(?rv_ty);
let rv_ty = self.normalize(rv_ty, location);
debug!("normalized rv_ty: {:?}", rv_ty);
@@ -972,7 +976,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
}
- self.check_rvalue(body, rv, location);
+ self.check_rvalue(rv, location);
if !self.unsized_feature_enabled() {
let trait_ref = ty::TraitRef::new(
tcx,
@@ -987,7 +991,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
}
StatementKind::AscribeUserType(box (place, projection), variance) => {
- let place_ty = place.ty(body, tcx).ty;
+ let place_ty = place.ty(self.body, tcx).ty;
if let Err(terr) = self.relate_type_and_user_type(
place_ty,
*variance,
@@ -1029,13 +1033,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
}
- #[instrument(skip(self, body, term_location), level = "debug")]
- fn check_terminator(
- &mut self,
- body: &Body<'tcx>,
- term: &Terminator<'tcx>,
- term_location: Location,
- ) {
+ #[instrument(skip(self, term_location), level = "debug")]
+ fn check_terminator(&mut self, term: &Terminator<'tcx>, term_location: Location) {
let tcx = self.tcx();
debug!("terminator kind: {:?}", term.kind);
match &term.kind {
@@ -1055,7 +1054,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
TerminatorKind::SwitchInt { discr, .. } => {
self.check_operand(discr, term_location);
- let switch_ty = discr.ty(body, tcx);
+ let switch_ty = discr.ty(self.body, tcx);
if !switch_ty.is_integral() && !switch_ty.is_char() && !switch_ty.is_bool() {
span_mirbug!(self, term, "bad SwitchInt discr ty {:?}", switch_ty);
}
@@ -1074,7 +1073,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
self.check_operand(&arg.node, term_location);
}
- let func_ty = func.ty(body, tcx);
+ let func_ty = func.ty(self.body, tcx);
debug!("func_ty.kind: {:?}", func_ty.kind());
let sig = match func_ty.kind() {
@@ -1142,7 +1141,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
if let TerminatorKind::Call { destination, target, .. } = term.kind {
- self.check_call_dest(body, term, &sig, destination, target, term_location);
+ self.check_call_dest(term, &sig, destination, target, term_location);
}
// The ordinary liveness rules will ensure that all
@@ -1157,21 +1156,21 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
self.constraints.liveness_constraints.add_location(region_vid, term_location);
}
- self.check_call_inputs(body, term, func, &sig, args, term_location, call_source);
+ self.check_call_inputs(term, func, &sig, args, term_location, call_source);
}
TerminatorKind::Assert { cond, msg, .. } => {
self.check_operand(cond, term_location);
- let cond_ty = cond.ty(body, tcx);
+ let cond_ty = cond.ty(self.body, tcx);
if cond_ty != tcx.types.bool {
span_mirbug!(self, term, "bad Assert ({:?}, not bool", cond_ty);
}
if let AssertKind::BoundsCheck { len, index } = &**msg {
- if len.ty(body, tcx) != tcx.types.usize {
+ if len.ty(self.body, tcx) != tcx.types.usize {
span_mirbug!(self, len, "bounds-check length non-usize {:?}", len)
}
- if index.ty(body, tcx) != tcx.types.usize {
+ if index.ty(self.body, tcx) != tcx.types.usize {
span_mirbug!(self, index, "bounds-check index non-usize {:?}", index)
}
}
@@ -1179,10 +1178,10 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
TerminatorKind::Yield { value, resume_arg, .. } => {
self.check_operand(value, term_location);
- match body.yield_ty() {
+ match self.body.yield_ty() {
None => span_mirbug!(self, term, "yield in non-coroutine"),
Some(ty) => {
- let value_ty = value.ty(body, tcx);
+ let value_ty = value.ty(self.body, tcx);
if let Err(terr) = self.sub_types(
value_ty,
ty,
@@ -1201,10 +1200,10 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
}
- match body.resume_ty() {
+ match self.body.resume_ty() {
None => span_mirbug!(self, term, "yield in non-coroutine"),
Some(ty) => {
- let resume_ty = resume_arg.ty(body, tcx);
+ let resume_ty = resume_arg.ty(self.body, tcx);
if let Err(terr) = self.sub_types(
ty,
resume_ty.ty,
@@ -1228,7 +1227,6 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
fn check_call_dest(
&mut self,
- body: &Body<'tcx>,
term: &Terminator<'tcx>,
sig: &ty::FnSig<'tcx>,
destination: Place<'tcx>,
@@ -1238,7 +1236,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
let tcx = self.tcx();
match target {
Some(_) => {
- let dest_ty = destination.ty(body, tcx).ty;
+ let dest_ty = destination.ty(self.body, tcx).ty;
let dest_ty = self.normalize(dest_ty, term_location);
let category = match destination.as_local() {
Some(RETURN_PLACE) => {
@@ -1254,7 +1252,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
ConstraintCategory::Return(ReturnConstraint::Normal)
}
}
- Some(l) if !body.local_decls[l].is_user_variable() => {
+ Some(l) if !self.body.local_decls[l].is_user_variable() => {
ConstraintCategory::Boring
}
// The return type of a call is interesting for diagnostics.
@@ -1295,10 +1293,9 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
}
- #[instrument(level = "debug", skip(self, body, term, func, term_location, call_source))]
+ #[instrument(level = "debug", skip(self, term, func, term_location, call_source))]
fn check_call_inputs(
&mut self,
- body: &Body<'tcx>,
term: &Terminator<'tcx>,
func: &Operand<'tcx>,
sig: &ty::FnSig<'tcx>,
@@ -1310,7 +1307,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
span_mirbug!(self, term, "call to {:?} with wrong # of args", sig);
}
- let func_ty = func.ty(body, self.infcx.tcx);
+ let func_ty = func.ty(self.body, self.infcx.tcx);
if let ty::FnDef(def_id, _) = *func_ty.kind() {
// Some of the SIMD intrinsics are special: they need a particular argument to be a
// constant. (Eventually this should use const-generics, but those are not up for the
@@ -1334,7 +1331,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
debug!(?func_ty);
for (n, (fn_arg, op_arg)) in iter::zip(sig.inputs(), args).enumerate() {
- let op_arg_ty = op_arg.node.ty(body, self.tcx());
+ let op_arg_ty = op_arg.node.ty(self.body, self.tcx());
let op_arg_ty = self.normalize(op_arg_ty, term_location);
let category = if call_source.from_hir_call() {
@@ -1358,16 +1355,16 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
}
- fn check_iscleanup(&mut self, body: &Body<'tcx>, block_data: &BasicBlockData<'tcx>) {
+ fn check_iscleanup(&mut self, block_data: &BasicBlockData<'tcx>) {
let is_cleanup = block_data.is_cleanup;
self.last_span = block_data.terminator().source_info.span;
match block_data.terminator().kind {
TerminatorKind::Goto { target } => {
- self.assert_iscleanup(body, block_data, target, is_cleanup)
+ self.assert_iscleanup(block_data, target, is_cleanup)
}
TerminatorKind::SwitchInt { ref targets, .. } => {
for target in targets.all_targets() {
- self.assert_iscleanup(body, block_data, *target, is_cleanup);
+ self.assert_iscleanup(block_data, *target, is_cleanup);
}
}
TerminatorKind::UnwindResume => {
@@ -1399,55 +1396,48 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
if is_cleanup {
span_mirbug!(self, block_data, "yield in cleanup block")
}
- self.assert_iscleanup(body, block_data, resume, is_cleanup);
+ self.assert_iscleanup(block_data, resume, is_cleanup);
if let Some(drop) = drop {
- self.assert_iscleanup(body, block_data, drop, is_cleanup);
+ self.assert_iscleanup(block_data, drop, is_cleanup);
}
}
TerminatorKind::Unreachable => {}
TerminatorKind::Drop { target, unwind, .. }
| TerminatorKind::Assert { target, unwind, .. } => {
- self.assert_iscleanup(body, block_data, target, is_cleanup);
- self.assert_iscleanup_unwind(body, block_data, unwind, is_cleanup);
+ self.assert_iscleanup(block_data, target, is_cleanup);
+ self.assert_iscleanup_unwind(block_data, unwind, is_cleanup);
}
TerminatorKind::Call { ref target, unwind, .. } => {
if let &Some(target) = target {
- self.assert_iscleanup(body, block_data, target, is_cleanup);
+ self.assert_iscleanup(block_data, target, is_cleanup);
}
- self.assert_iscleanup_unwind(body, block_data, unwind, is_cleanup);
+ self.assert_iscleanup_unwind(block_data, unwind, is_cleanup);
}
TerminatorKind::FalseEdge { real_target, imaginary_target } => {
- self.assert_iscleanup(body, block_data, real_target, is_cleanup);
- self.assert_iscleanup(body, block_data, imaginary_target, is_cleanup);
+ self.assert_iscleanup(block_data, real_target, is_cleanup);
+ self.assert_iscleanup(block_data, imaginary_target, is_cleanup);
}
TerminatorKind::FalseUnwind { real_target, unwind } => {
- self.assert_iscleanup(body, block_data, real_target, is_cleanup);
- self.assert_iscleanup_unwind(body, block_data, unwind, is_cleanup);
+ self.assert_iscleanup(block_data, real_target, is_cleanup);
+ self.assert_iscleanup_unwind(block_data, unwind, is_cleanup);
}
TerminatorKind::InlineAsm { ref targets, unwind, .. } => {
for &target in targets {
- self.assert_iscleanup(body, block_data, target, is_cleanup);
+ self.assert_iscleanup(block_data, target, is_cleanup);
}
- self.assert_iscleanup_unwind(body, block_data, unwind, is_cleanup);
+ self.assert_iscleanup_unwind(block_data, unwind, is_cleanup);
}
}
}
- fn assert_iscleanup(
- &mut self,
- body: &Body<'tcx>,
- ctxt: &dyn fmt::Debug,
- bb: BasicBlock,
- iscleanuppad: bool,
- ) {
- if body[bb].is_cleanup != iscleanuppad {
+ fn assert_iscleanup(&mut self, ctxt: &dyn fmt::Debug, bb: BasicBlock, iscleanuppad: bool) {
+ if self.body[bb].is_cleanup != iscleanuppad {
span_mirbug!(self, ctxt, "cleanuppad mismatch: {:?} should be {:?}", bb, iscleanuppad);
}
}
fn assert_iscleanup_unwind(
&mut self,
- body: &Body<'tcx>,
ctxt: &dyn fmt::Debug,
unwind: UnwindAction,
is_cleanup: bool,
@@ -1457,7 +1447,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
if is_cleanup {
span_mirbug!(self, ctxt, "unwind on cleanup block")
}
- self.assert_iscleanup(body, ctxt, unwind, true);
+ self.assert_iscleanup(ctxt, unwind, true);
}
UnwindAction::Continue => {
if is_cleanup {
@@ -1468,8 +1458,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
}
- fn check_local(&mut self, body: &Body<'tcx>, local: Local, local_decl: &LocalDecl<'tcx>) {
- match body.local_kind(local) {
+ fn check_local(&mut self, local: Local, local_decl: &LocalDecl<'tcx>) {
+ match self.body.local_kind(local) {
LocalKind::ReturnPointer | LocalKind::Arg => {
// return values of normal functions are required to be
// sized by typeck, but return values of ADT constructors are
@@ -1598,23 +1588,23 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
}
- #[instrument(skip(self, body), level = "debug")]
- fn check_rvalue(&mut self, body: &Body<'tcx>, rvalue: &Rvalue<'tcx>, location: Location) {
+ #[instrument(skip(self), level = "debug")]
+ fn check_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
let tcx = self.tcx();
- let span = body.source_info(location).span;
+ let span = self.body.source_info(location).span;
match rvalue {
Rvalue::Aggregate(ak, ops) => {
for op in ops {
self.check_operand(op, location);
}
- self.check_aggregate_rvalue(body, rvalue, ak, ops, location)
+ self.check_aggregate_rvalue(rvalue, ak, ops, location)
}
Rvalue::Repeat(operand, len) => {
self.check_operand(operand, location);
- let array_ty = rvalue.ty(body.local_decls(), tcx);
+ let array_ty = rvalue.ty(self.body.local_decls(), tcx);
self.prove_predicate(
ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(array_ty.into())),
Locations::Single(location),
@@ -1633,7 +1623,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
Operand::Move(place) => {
// Make sure that repeated elements implement `Copy`.
- let ty = place.ty(body, tcx).ty;
+ let ty = place.ty(self.body, tcx).ty;
let trait_ref = ty::TraitRef::new(
tcx,
tcx.require_lang_item(LangItem::Copy, Some(span)),
@@ -1688,7 +1678,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
match *cast_kind {
CastKind::PointerCoercion(PointerCoercion::ReifyFnPointer, coercion_source) => {
let is_implicit_coercion = coercion_source == CoercionSource::Implicit;
- let src_ty = op.ty(body, tcx);
+ let src_ty = op.ty(self.body, tcx);
let mut src_sig = src_ty.fn_sig(tcx);
if let ty::FnDef(def_id, _) = src_ty.kind()
&& let ty::FnPtr(_, target_hdr) = *ty.kind()
@@ -1697,7 +1687,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
&& let Some(safe_sig) = tcx.adjust_target_feature_sig(
*def_id,
src_sig,
- body.source.def_id(),
+ self.body.source.def_id(),
)
{
src_sig = safe_sig;
@@ -1790,7 +1780,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
PointerCoercion::ClosureFnPointer(safety),
coercion_source,
) => {
- let sig = match op.ty(body, tcx).kind() {
+ let sig = match op.ty(self.body, tcx).kind() {
ty::Closure(_, args) => args.as_closure().sig(),
_ => bug!(),
};
@@ -1819,7 +1809,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
PointerCoercion::UnsafeFnPointer,
coercion_source,
) => {
- let fn_sig = op.ty(body, tcx).fn_sig(tcx);
+ let fn_sig = op.ty(self.body, tcx).fn_sig(tcx);
// The type that we see in the fcx is like
// `foo::<'a, 'b>`, where `foo` is the path to a
@@ -1853,7 +1843,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
let trait_ref = ty::TraitRef::new(
tcx,
tcx.require_lang_item(LangItem::CoerceUnsized, Some(span)),
- [op.ty(body, tcx), ty],
+ [op.ty(self.body, tcx), ty],
);
let is_implicit_coercion = coercion_source == CoercionSource::Implicit;
@@ -1879,7 +1869,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
_ => panic!("Invalid dyn* cast_ty"),
};
- let self_ty = op.ty(body, tcx);
+ let self_ty = op.ty(self.body, tcx);
let is_implicit_coercion = coercion_source == CoercionSource::Implicit;
self.prove_predicates(
@@ -1906,7 +1896,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
PointerCoercion::MutToConstPointer,
coercion_source,
) => {
- let ty::RawPtr(ty_from, hir::Mutability::Mut) = op.ty(body, tcx).kind()
+ let ty::RawPtr(ty_from, hir::Mutability::Mut) =
+ op.ty(self.body, tcx).kind()
else {
span_mirbug!(self, rvalue, "unexpected base type for cast {:?}", ty,);
return;
@@ -1934,7 +1925,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
CastKind::PointerCoercion(PointerCoercion::ArrayToPointer, coercion_source) => {
- let ty_from = op.ty(body, tcx);
+ let ty_from = op.ty(self.body, tcx);
let opt_ty_elem_mut = match ty_from.kind() {
ty::RawPtr(array_ty, array_mut) => match array_ty.kind() {
@@ -1997,7 +1988,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
CastKind::PointerExposeProvenance => {
- let ty_from = op.ty(body, tcx);
+ let ty_from = op.ty(self.body, tcx);
let cast_ty_from = CastTy::from_ty(ty_from);
let cast_ty_to = CastTy::from_ty(*ty);
match (cast_ty_from, cast_ty_to) {
@@ -2015,7 +2006,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
CastKind::PointerWithExposedProvenance => {
- let ty_from = op.ty(body, tcx);
+ let ty_from = op.ty(self.body, tcx);
let cast_ty_from = CastTy::from_ty(ty_from);
let cast_ty_to = CastTy::from_ty(*ty);
match (cast_ty_from, cast_ty_to) {
@@ -2032,7 +2023,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
}
CastKind::IntToInt => {
- let ty_from = op.ty(body, tcx);
+ let ty_from = op.ty(self.body, tcx);
let cast_ty_from = CastTy::from_ty(ty_from);
let cast_ty_to = CastTy::from_ty(*ty);
match (cast_ty_from, cast_ty_to) {
@@ -2049,7 +2040,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
}
CastKind::IntToFloat => {
- let ty_from = op.ty(body, tcx);
+ let ty_from = op.ty(self.body, tcx);
let cast_ty_from = CastTy::from_ty(ty_from);
let cast_ty_to = CastTy::from_ty(*ty);
match (cast_ty_from, cast_ty_to) {
@@ -2066,7 +2057,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
}
CastKind::FloatToInt => {
- let ty_from = op.ty(body, tcx);
+ let ty_from = op.ty(self.body, tcx);
let cast_ty_from = CastTy::from_ty(ty_from);
let cast_ty_to = CastTy::from_ty(*ty);
match (cast_ty_from, cast_ty_to) {
@@ -2083,7 +2074,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
}
CastKind::FloatToFloat => {
- let ty_from = op.ty(body, tcx);
+ let ty_from = op.ty(self.body, tcx);
let cast_ty_from = CastTy::from_ty(ty_from);
let cast_ty_to = CastTy::from_ty(*ty);
match (cast_ty_from, cast_ty_to) {
@@ -2100,7 +2091,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
}
CastKind::FnPtrToPtr => {
- let ty_from = op.ty(body, tcx);
+ let ty_from = op.ty(self.body, tcx);
let cast_ty_from = CastTy::from_ty(ty_from);
let cast_ty_to = CastTy::from_ty(*ty);
match (cast_ty_from, cast_ty_to) {
@@ -2117,7 +2108,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
}
CastKind::PtrToPtr => {
- let ty_from = op.ty(body, tcx);
+ let ty_from = op.ty(self.body, tcx);
let cast_ty_from = CastTy::from_ty(ty_from);
let cast_ty_to = CastTy::from_ty(*ty);
match (cast_ty_from, cast_ty_to) {
@@ -2193,7 +2184,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
}
Rvalue::Ref(region, _borrow_kind, borrowed_place) => {
- self.add_reborrow_constraint(body, location, *region, borrowed_place);
+ self.add_reborrow_constraint(location, *region, borrowed_place);
}
Rvalue::BinaryOp(
@@ -2203,12 +2194,13 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
self.check_operand(left, location);
self.check_operand(right, location);
- let ty_left = left.ty(body, tcx);
+ let ty_left = left.ty(self.body, tcx);
match ty_left.kind() {
// Types with regions are comparable if they have a common super-type.
ty::RawPtr(_, _) | ty::FnPtr(..) => {
- let ty_right = right.ty(body, tcx);
- let common_ty = self.infcx.next_ty_var(body.source_info(location).span);
+ let ty_right = right.ty(self.body, tcx);
+ let common_ty =
+ self.infcx.next_ty_var(self.body.source_info(location).span);
self.sub_types(
ty_left,
common_ty,
@@ -2237,7 +2229,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
// For types with no regions we can just check that the
// both operands have the same type.
ty::Int(_) | ty::Uint(_) | ty::Bool | ty::Char | ty::Float(_)
- if ty_left == right.ty(body, tcx) => {}
+ if ty_left == right.ty(self.body, tcx) => {}
// Other types are compared by trait methods, not by
// `Rvalue::BinaryOp`.
_ => span_mirbug!(
@@ -2245,7 +2237,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
rvalue,
"unexpected comparison types {:?} and {:?}",
ty_left,
- right.ty(body, tcx)
+ right.ty(self.body, tcx)
),
}
}
@@ -2326,7 +2318,6 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
fn check_aggregate_rvalue(
&mut self,
- body: &Body<'tcx>,
rvalue: &Rvalue<'tcx>,
aggregate_kind: &AggregateKind<'tcx>,
operands: &IndexSlice<FieldIdx, Operand<'tcx>>,
@@ -2359,7 +2350,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
continue;
}
};
- let operand_ty = operand.ty(body, tcx);
+ let operand_ty = operand.ty(self.body, tcx);
let operand_ty = self.normalize(operand_ty, location);
if let Err(terr) = self.sub_types(
@@ -2389,7 +2380,6 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
/// - `borrowed_place`: the place `P` being borrowed
fn add_reborrow_constraint(
&mut self,
- body: &Body<'tcx>,
location: Location,
borrow_region: ty::Region<'tcx>,
borrowed_place: &Place<'tcx>,
@@ -2428,7 +2418,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
let def = self.body.source.def_id().expect_local();
let upvars = tcx.closure_captures(def);
let field =
- path_utils::is_upvar_field_projection(tcx, upvars, borrowed_place.as_ref(), body);
+ path_utils::is_upvar_field_projection(tcx, upvars, borrowed_place.as_ref(), self.body);
let category = if let Some(field) = field {
ConstraintCategory::ClosureUpvar(field)
} else {
@@ -2440,7 +2430,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
match elem {
ProjectionElem::Deref => {
- let base_ty = base.ty(body, tcx).ty;
+ let base_ty = base.ty(self.body, tcx).ty;
debug!("add_reborrow_constraint - base_ty = {:?}", base_ty);
match base_ty.kind() {
@@ -2449,7 +2439,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
sup: ref_region.as_var(),
sub: borrow_region.as_var(),
locations: location.to_locations(),
- span: location.to_locations().span(body),
+ span: location.to_locations().span(self.body),
category,
variance_info: ty::VarianceDiagInfo::default(),
from_closure: false,
@@ -2634,27 +2624,27 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
tcx.predicates_of(def_id).instantiate(tcx, args)
}
- #[instrument(skip(self, body), level = "debug")]
- fn typeck_mir(&mut self, body: &Body<'tcx>) {
- self.last_span = body.span;
- debug!(?body.span);
+ #[instrument(skip(self), level = "debug")]
+ fn typeck_mir(&mut self) {
+ self.last_span = self.body.span;
+ debug!(?self.body.span);
- for (local, local_decl) in body.local_decls.iter_enumerated() {
- self.check_local(body, local, local_decl);
+ for (local, local_decl) in self.body.local_decls.iter_enumerated() {
+ self.check_local(local, local_decl);
}
- for (block, block_data) in body.basic_blocks.iter_enumerated() {
+ for (block, block_data) in self.body.basic_blocks.iter_enumerated() {
let mut location = Location { block, statement_index: 0 };
for stmt in &block_data.statements {
if !stmt.source_info.span.is_dummy() {
self.last_span = stmt.source_info.span;
}
- self.check_stmt(body, stmt, location);
+ self.check_stmt(stmt, location);
location.statement_index += 1;
}
- self.check_terminator(body, block_data.terminator(), location);
- self.check_iscleanup(body, block_data);
+ self.check_terminator(block_data.terminator(), location);
+ self.check_iscleanup(block_data);
}
}
}
From 75a69a48f3aebaaa7cb3ce2ffcd3816f10895f70 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Tue, 11 Mar 2025 11:53:57 +0100
Subject: [PATCH 28/28] Do not download GCC in tests
---
src/bootstrap/src/core/build_steps/gcc.rs | 20 ++++++++++++++------
1 file changed, 14 insertions(+), 6 deletions(-)
diff --git a/src/bootstrap/src/core/build_steps/gcc.rs b/src/bootstrap/src/core/build_steps/gcc.rs
index 7e1ec39659a30..5a4bc9bdbcba9 100644
--- a/src/bootstrap/src/core/build_steps/gcc.rs
+++ b/src/bootstrap/src/core/build_steps/gcc.rs
@@ -13,11 +13,9 @@ use std::path::{Path, PathBuf};
use std::sync::OnceLock;
use build_helper::ci::CiEnv;
-use build_helper::git::get_closest_merge_commit;
-use crate::Config;
use crate::core::builder::{Builder, Cargo, Kind, RunConfig, ShouldRun, Step};
-use crate::core::config::{GccCiMode, TargetSelection};
+use crate::core::config::TargetSelection;
use crate::utils::build_stamp::{BuildStamp, generate_smart_stamp_hash};
use crate::utils::exec::command;
use crate::utils::helpers::{self, t};
@@ -93,9 +91,10 @@ pub enum GccBuildStatus {
/// Tries to download GCC from CI if it is enabled and GCC artifacts
/// are available for the given target.
/// Returns a path to the libgccjit.so file.
+#[cfg(not(test))]
fn try_download_gcc(builder: &Builder<'_>, target: TargetSelection) -> Option<PathBuf> {
// Try to download GCC from CI if configured and available
- if !matches!(builder.config.gcc_ci_mode, GccCiMode::DownloadFromCi) {
+ if !matches!(builder.config.gcc_ci_mode, crate::core::config::GccCiMode::DownloadFromCi) {
return None;
}
if target != "x86_64-unknown-linux-gnu" {
@@ -114,6 +113,11 @@ fn try_download_gcc(builder: &Builder<'_>, target: TargetSelection) -> Option<Pa
Some(root.join("libgccjit.so"))
}
+#[cfg(test)]
+fn try_download_gcc(_builder: &Builder<'_>, _target: TargetSelection) -> Option<PathBuf> {
+ None
+}
+
/// This returns information about whether GCC should be built or if it's already built.
/// It transparently handles downloading GCC from CI if needed.
///
@@ -247,12 +251,16 @@ pub fn add_cg_gcc_cargo_flags(cargo: &mut Cargo, gcc: &GccOutput) {
}
/// The absolute path to the downloaded GCC artifacts.
-fn ci_gcc_root(config: &Config) -> PathBuf {
+#[cfg(not(test))]
+fn ci_gcc_root(config: &crate::Config) -> PathBuf {
config.out.join(config.build).join("ci-gcc")
}
/// This retrieves the GCC sha we *want* to use, according to git history.
-fn detect_gcc_sha(config: &Config, is_git: bool) -> String {
+#[cfg(not(test))]
+fn detect_gcc_sha(config: &crate::Config, is_git: bool) -> String {
+ use build_helper::git::get_closest_merge_commit;
+
let gcc_sha = if is_git {
get_closest_merge_commit(
Some(&config.src),