diff options
Diffstat (limited to 'compiler')
21 files changed, 228 insertions, 172 deletions
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs index ac2328a5824..116497109f1 100644 --- a/compiler/rustc_ast/src/ast.rs +++ b/compiler/rustc_ast/src/ast.rs @@ -1111,10 +1111,6 @@ pub struct Expr { pub tokens: Option<LazyTokenStream>, } -// `Expr` is used a lot. Make sure it doesn't unintentionally get bigger. -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -rustc_data_structures::static_assert_size!(Expr, 104); - impl Expr { /// Returns `true` if this expression would be valid somewhere that expects a value; /// for example, an `if` condition. @@ -2883,9 +2879,6 @@ pub enum ItemKind { MacroDef(MacroDef), } -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -rustc_data_structures::static_assert_size!(ItemKind, 112); - impl ItemKind { pub fn article(&self) -> &str { use ItemKind::*; @@ -2957,9 +2950,6 @@ pub enum AssocItemKind { MacCall(MacCall), } -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -rustc_data_structures::static_assert_size!(AssocItemKind, 72); - impl AssocItemKind { pub fn defaultness(&self) -> Defaultness { match *self { @@ -3009,9 +2999,6 @@ pub enum ForeignItemKind { MacCall(MacCall), } -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -rustc_data_structures::static_assert_size!(ForeignItemKind, 72); - impl From<ForeignItemKind> for ItemKind { fn from(foreign_item_kind: ForeignItemKind) -> ItemKind { match foreign_item_kind { @@ -3038,3 +3025,27 @@ impl TryFrom<ItemKind> for ForeignItemKind { } pub type ForeignItem = Item<ForeignItemKind>; + +// Some nodes are used a lot. Make sure they don't unintentionally get bigger. +#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] +mod size_asserts { + use super::*; + // These are in alphabetical order, which is easy to maintain. + rustc_data_structures::static_assert_size!(AssocItemKind, 72); + rustc_data_structures::static_assert_size!(Attribute, 152); + rustc_data_structures::static_assert_size!(Block, 48); + rustc_data_structures::static_assert_size!(Expr, 104); + rustc_data_structures::static_assert_size!(Fn, 192); + rustc_data_structures::static_assert_size!(ForeignItemKind, 72); + rustc_data_structures::static_assert_size!(GenericBound, 88); + rustc_data_structures::static_assert_size!(Generics, 72); + rustc_data_structures::static_assert_size!(Impl, 200); + rustc_data_structures::static_assert_size!(Item, 200); + rustc_data_structures::static_assert_size!(ItemKind, 112); + rustc_data_structures::static_assert_size!(Lit, 48); + rustc_data_structures::static_assert_size!(Pat, 120); + rustc_data_structures::static_assert_size!(Path, 40); + rustc_data_structures::static_assert_size!(PathSegment, 24); + rustc_data_structures::static_assert_size!(Stmt, 32); + rustc_data_structures::static_assert_size!(Ty, 96); +} diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs index eae162fe479..5da260f980f 100644 --- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs +++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs @@ -39,7 +39,7 @@ use crate::{ use super::{ explain_borrow::{BorrowExplanation, LaterUseKind}, - IncludingDowncast, RegionName, RegionNameSource, UseSpans, + DescribePlaceOpt, RegionName, RegionNameSource, UseSpans, }; #[derive(Debug)] @@ -137,7 +137,10 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { span, desired_action.as_noun(), partially_str, - self.describe_place_with_options(moved_place, IncludingDowncast(true)), + self.describe_place_with_options( + moved_place, + DescribePlaceOpt { including_downcast: true, including_tuple_field: true }, + ), ); let reinit_spans = maybe_reinitialized_locations @@ -274,8 +277,10 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { } } - let opt_name = - self.describe_place_with_options(place.as_ref(), IncludingDowncast(true)); + let opt_name = self.describe_place_with_options( + place.as_ref(), + DescribePlaceOpt { including_downcast: true, including_tuple_field: true }, + ); let note_msg = match opt_name { Some(ref name) => format!("`{}`", name), None => "value".to_owned(), @@ -341,12 +346,17 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { } } - let (name, desc) = - match self.describe_place_with_options(moved_place, IncludingDowncast(true)) { - Some(name) => (format!("`{name}`"), format!("`{name}` ")), - None => ("the variable".to_string(), String::new()), - }; - let path = match self.describe_place_with_options(used_place, IncludingDowncast(true)) { + let (name, desc) = match self.describe_place_with_options( + moved_place, + DescribePlaceOpt { including_downcast: true, including_tuple_field: true }, + ) { + Some(name) => (format!("`{name}`"), format!("`{name}` ")), + None => ("the variable".to_string(), String::new()), + }; + let path = match self.describe_place_with_options( + used_place, + DescribePlaceOpt { including_downcast: true, including_tuple_field: true }, + ) { Some(name) => format!("`{name}`"), None => "value".to_string(), }; diff --git a/compiler/rustc_borrowck/src/diagnostics/mod.rs b/compiler/rustc_borrowck/src/diagnostics/mod.rs index 0300180f80a..098e8de9420 100644 --- a/compiler/rustc_borrowck/src/diagnostics/mod.rs +++ b/compiler/rustc_borrowck/src/diagnostics/mod.rs @@ -4,7 +4,7 @@ use itertools::Itertools; use rustc_const_eval::util::{call_kind, CallDesugaringKind}; use rustc_errors::{Applicability, Diagnostic}; use rustc_hir as hir; -use rustc_hir::def::Namespace; +use rustc_hir::def::{CtorKind, Namespace}; use rustc_hir::GeneratorKind; use rustc_infer::infer::TyCtxtInferExt; use rustc_middle::mir::tcx::PlaceTy; @@ -16,7 +16,7 @@ use rustc_middle::ty::print::Print; use rustc_middle::ty::{self, DefIdTree, Instance, Ty, TyCtxt}; use rustc_mir_dataflow::move_paths::{InitLocation, LookupResult}; use rustc_span::def_id::LocalDefId; -use rustc_span::{symbol::sym, Span, DUMMY_SP}; +use rustc_span::{symbol::sym, Span, Symbol, DUMMY_SP}; use rustc_target::abi::VariantIdx; use rustc_trait_selection::traits::type_known_to_meet_bound_modulo_regions; @@ -43,7 +43,15 @@ pub(crate) use region_errors::{ErrorConstraintInfo, RegionErrorKind, RegionError pub(crate) use region_name::{RegionName, RegionNameSource}; pub(crate) use rustc_const_eval::util::CallKind; -pub(super) struct IncludingDowncast(pub(super) bool); +pub(super) struct DescribePlaceOpt { + pub including_downcast: bool, + + /// Enable/Disable tuple fields. + /// For example `x` tuple. if it's `true` `x.0`. Otherwise `x` + pub including_tuple_field: bool, +} + +pub(super) struct IncludingTupleField(pub(super) bool); impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { /// Adds a suggestion when a closure is invoked twice with a moved variable or when a closure @@ -164,7 +172,10 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { /// End-user visible description of `place` if one can be found. /// If the place is a temporary for instance, `None` will be returned. pub(super) fn describe_place(&self, place_ref: PlaceRef<'tcx>) -> Option<String> { - self.describe_place_with_options(place_ref, IncludingDowncast(false)) + self.describe_place_with_options( + place_ref, + DescribePlaceOpt { including_downcast: false, including_tuple_field: true }, + ) } /// End-user visible description of `place` if one can be found. If the place is a temporary @@ -174,7 +185,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { pub(super) fn describe_place_with_options( &self, place: PlaceRef<'tcx>, - including_downcast: IncludingDowncast, + opt: DescribePlaceOpt, ) -> Option<String> { let local = place.local; let mut autoderef_index = None; @@ -224,7 +235,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { } } } - ProjectionElem::Downcast(..) if including_downcast.0 => return None, + ProjectionElem::Downcast(..) if opt.including_downcast => return None, ProjectionElem::Downcast(..) => (), ProjectionElem::Field(field, _ty) => { // FIXME(project-rfc_2229#36): print capture precisely here. @@ -238,9 +249,12 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { let field_name = self.describe_field( PlaceRef { local, projection: place.projection.split_at(index).0 }, *field, + IncludingTupleField(opt.including_tuple_field), ); - buf.push('.'); - buf.push_str(&field_name); + if let Some(field_name_str) = field_name { + buf.push('.'); + buf.push_str(&field_name_str); + } } } ProjectionElem::Index(index) => { @@ -261,6 +275,18 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { ok.ok().map(|_| buf) } + fn describe_name(&self, place: PlaceRef<'tcx>) -> Option<Symbol> { + for elem in place.projection.into_iter() { + match elem { + ProjectionElem::Downcast(Some(name), _) => { + return Some(*name); + } + _ => {} + } + } + None + } + /// Appends end-user visible description of the `local` place to `buf`. If `local` doesn't have /// a name, or its name was generated by the compiler, then `Err` is returned fn append_local_to_string(&self, local: Local, buf: &mut String) -> Result<(), ()> { @@ -275,7 +301,12 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { } /// End-user visible description of the `field`nth field of `base` - fn describe_field(&self, place: PlaceRef<'tcx>, field: Field) -> String { + fn describe_field( + &self, + place: PlaceRef<'tcx>, + field: Field, + including_tuple_field: IncludingTupleField, + ) -> Option<String> { let place_ty = match place { PlaceRef { local, projection: [] } => PlaceTy::from_ty(self.body.local_decls[local].ty), PlaceRef { local, projection: [proj_base @ .., elem] } => match elem { @@ -289,7 +320,12 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { ProjectionElem::Field(_, field_type) => PlaceTy::from_ty(*field_type), }, }; - self.describe_field_from_ty(place_ty.ty, field, place_ty.variant_index) + self.describe_field_from_ty( + place_ty.ty, + field, + place_ty.variant_index, + including_tuple_field, + ) } /// End-user visible description of the `field_index`nth field of `ty` @@ -298,10 +334,11 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { ty: Ty<'_>, field: Field, variant_index: Option<VariantIdx>, - ) -> String { + including_tuple_field: IncludingTupleField, + ) -> Option<String> { if ty.is_box() { // If the type is a box, the field is described from the boxed type - self.describe_field_from_ty(ty.boxed_ty(), field, variant_index) + self.describe_field_from_ty(ty.boxed_ty(), field, variant_index, including_tuple_field) } else { match *ty.kind() { ty::Adt(def, _) => { @@ -311,14 +348,17 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { } else { def.non_enum_variant() }; - variant.fields[field.index()].name.to_string() + if !including_tuple_field.0 && variant.ctor_kind == CtorKind::Fn { + return None; + } + Some(variant.fields[field.index()].name.to_string()) } - ty::Tuple(_) => field.index().to_string(), + ty::Tuple(_) => Some(field.index().to_string()), ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => { - self.describe_field_from_ty(ty, field, variant_index) + self.describe_field_from_ty(ty, field, variant_index, including_tuple_field) } ty::Array(ty, _) | ty::Slice(ty) => { - self.describe_field_from_ty(ty, field, variant_index) + self.describe_field_from_ty(ty, field, variant_index, including_tuple_field) } ty::Closure(def_id, _) | ty::Generator(def_id, _, _) => { // We won't be borrowck'ing here if the closure came from another crate, @@ -335,7 +375,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { .unwrap() .get_root_variable(); - 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 diff --git a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs index becb81b2e26..cb3cd479ae2 100644 --- a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs +++ b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs @@ -6,7 +6,7 @@ use rustc_mir_dataflow::move_paths::{ }; use rustc_span::Span; -use crate::diagnostics::UseSpans; +use crate::diagnostics::{DescribePlaceOpt, UseSpans}; use crate::prefixes::PrefixSet; use crate::MirBorrowckCtxt; @@ -368,13 +368,31 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { } _ => { let source = self.borrowed_content_source(deref_base); - match (self.describe_place(move_place.as_ref()), source.describe_for_named_place()) - { - (Some(place_desc), Some(source_desc)) => self.cannot_move_out_of( + let move_place_ref = move_place.as_ref(); + match ( + self.describe_place_with_options( + move_place_ref, + DescribePlaceOpt { + including_downcast: false, + including_tuple_field: false, + }, + ), + self.describe_name(move_place_ref), + source.describe_for_named_place(), + ) { + (Some(place_desc), Some(name), Some(source_desc)) => self.cannot_move_out_of( + span, + &format!("`{place_desc}` as enum variant `{name}` which is behind a {source_desc}"), + ), + (Some(place_desc), Some(name), None) => self.cannot_move_out_of( + span, + &format!("`{place_desc}` as enum variant `{name}`"), + ), + (Some(place_desc), _, Some(source_desc)) => self.cannot_move_out_of( span, &format!("`{place_desc}` which is behind a {source_desc}"), ), - (_, _) => self.cannot_move_out_of( + (_, _, _) => self.cannot_move_out_of( span, &source.describe_for_unnamed_place(self.infcx.tcx), ), diff --git a/compiler/rustc_const_eval/src/interpret/operand.rs b/compiler/rustc_const_eval/src/interpret/operand.rs index de284bd3bae..94ba62c160c 100644 --- a/compiler/rustc_const_eval/src/interpret/operand.rs +++ b/compiler/rustc_const_eval/src/interpret/operand.rs @@ -37,9 +37,6 @@ pub enum Immediate<Prov: Provenance = AllocId> { Uninit, } -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -rustc_data_structures::static_assert_size!(Immediate, 56); - impl<Prov: Provenance> From<ScalarMaybeUninit<Prov>> for Immediate<Prov> { #[inline(always)] fn from(val: ScalarMaybeUninit<Prov>) -> Self { @@ -117,9 +114,6 @@ pub struct ImmTy<'tcx, Prov: Provenance = AllocId> { pub layout: TyAndLayout<'tcx>, } -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -rustc_data_structures::static_assert_size!(ImmTy<'_>, 72); - impl<Prov: Provenance> std::fmt::Display for ImmTy<'_, Prov> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { /// Helper function for printing a scalar to a FmtPrinter @@ -187,9 +181,6 @@ pub enum Operand<Prov: Provenance = AllocId> { Indirect(MemPlace<Prov>), } -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -rustc_data_structures::static_assert_size!(Operand, 64); - #[derive(Clone, Debug)] pub struct OpTy<'tcx, Prov: Provenance = AllocId> { op: Operand<Prov>, // Keep this private; it helps enforce invariants. @@ -204,9 +195,6 @@ pub struct OpTy<'tcx, Prov: Provenance = AllocId> { pub align: Option<Align>, } -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -rustc_data_structures::static_assert_size!(OpTy<'_>, 88); - impl<'tcx, Prov: Provenance> std::ops::Deref for OpTy<'tcx, Prov> { type Target = Operand<Prov>; #[inline(always)] @@ -830,3 +818,14 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { }) } } + +// Some nodes are used a lot. Make sure they don't unintentionally get bigger. +#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] +mod size_asserts { + use super::*; + // These are in alphabetical order, which is easy to maintain. + rustc_data_structures::static_assert_size!(Immediate, 56); + rustc_data_structures::static_assert_size!(ImmTy<'_>, 72); + rustc_data_structures::static_assert_size!(Operand, 64); + rustc_data_structures::static_assert_size!(OpTy<'_>, 88); +} diff --git a/compiler/rustc_const_eval/src/interpret/place.rs b/compiler/rustc_const_eval/src/interpret/place.rs index 473da71a0ab..f4571a1ca3d 100644 --- a/compiler/rustc_const_eval/src/interpret/place.rs +++ b/compiler/rustc_const_eval/src/interpret/place.rs @@ -25,9 +25,6 @@ pub enum MemPlaceMeta<Prov: Provenance = AllocId> { None, } -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -rustc_data_structures::static_assert_size!(MemPlaceMeta, 24); - impl<Prov: Provenance> MemPlaceMeta<Prov> { pub fn unwrap_meta(self) -> Scalar<Prov> { match self { @@ -56,9 +53,6 @@ pub struct MemPlace<Prov: Provenance = AllocId> { pub meta: MemPlaceMeta<Prov>, } -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -rustc_data_structures::static_assert_size!(MemPlace, 40); - /// A MemPlace with its layout. Constructing it is only possible in this module. #[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)] pub struct MPlaceTy<'tcx, Prov: Provenance = AllocId> { @@ -71,9 +65,6 @@ pub struct MPlaceTy<'tcx, Prov: Provenance = AllocId> { pub align: Align, } -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -rustc_data_structures::static_assert_size!(MPlaceTy<'_>, 64); - #[derive(Copy, Clone, Debug)] pub enum Place<Prov: Provenance = AllocId> { /// A place referring to a value allocated in the `Memory` system. @@ -84,9 +75,6 @@ pub enum Place<Prov: Provenance = AllocId> { Local { frame: usize, local: mir::Local }, } -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -rustc_data_structures::static_assert_size!(Place, 48); - #[derive(Clone, Debug)] pub struct PlaceTy<'tcx, Prov: Provenance = AllocId> { place: Place<Prov>, // Keep this private; it helps enforce invariants. @@ -98,9 +86,6 @@ pub struct PlaceTy<'tcx, Prov: Provenance = AllocId> { pub align: Align, } -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -rustc_data_structures::static_assert_size!(PlaceTy<'_>, 72); - impl<'tcx, Prov: Provenance> std::ops::Deref for PlaceTy<'tcx, Prov> { type Target = Place<Prov>; #[inline(always)] @@ -901,3 +886,15 @@ where Ok(mplace) } } + +// Some nodes are used a lot. Make sure they don't unintentionally get bigger. +#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] +mod size_asserts { + use super::*; + // These are in alphabetical order, which is easy to maintain. + rustc_data_structures::static_assert_size!(MemPlaceMeta, 24); + rustc_data_structures::static_assert_size!(MemPlace, 40); + rustc_data_structures::static_assert_size!(MPlaceTy<'_>, 64); + rustc_data_structures::static_assert_size!(Place, 48); + rustc_data_structures::static_assert_size!(PlaceTy<'_>, 72); +} diff --git a/compiler/rustc_hir/src/definitions.rs b/compiler/rustc_hir/src/definitions.rs index 5f8801cc4e2..c2c551e78a4 100644 --- a/compiler/rustc_hir/src/definitions.rs +++ b/compiler/rustc_hir/src/definitions.rs @@ -338,7 +338,12 @@ impl Definitions { /// Adds a definition with a parent definition. pub fn create_def(&mut self, parent: LocalDefId, data: DefPathData) -> LocalDefId { - debug!("create_def(parent={:?}, data={:?})", parent, data); + // We can't use `Debug` implementation for `LocalDefId` here, since it tries to acquire a + // reference to `Definitions` and we're already holding a mutable reference. + debug!( + "create_def(parent={}, data={data:?})", + self.def_path(parent).to_string_no_crate_verbose(), + ); // The root node must be created with `create_root_def()`. assert!(data != DefPathData::CrateRoot); diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index f71400898e6..7230555e961 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -3489,17 +3489,18 @@ impl<'hir> Node<'hir> { // Some nodes are used a lot. Make sure they don't unintentionally get bigger. #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] mod size_asserts { - rustc_data_structures::static_assert_size!(super::Block<'static>, 48); - rustc_data_structures::static_assert_size!(super::Expr<'static>, 56); - rustc_data_structures::static_assert_size!(super::Pat<'static>, 88); - rustc_data_structures::static_assert_size!(super::QPath<'static>, 24); - rustc_data_structures::static_assert_size!(super::Ty<'static>, 72); - rustc_data_structures::static_assert_size!(super::GenericBound<'_>, 48); - rustc_data_structures::static_assert_size!(super::Generics<'static>, 56); - rustc_data_structures::static_assert_size!(super::Impl<'static>, 80); - - rustc_data_structures::static_assert_size!(super::Item<'static>, 80); - rustc_data_structures::static_assert_size!(super::TraitItem<'static>, 88); - rustc_data_structures::static_assert_size!(super::ImplItem<'static>, 80); - rustc_data_structures::static_assert_size!(super::ForeignItem<'static>, 72); + use super::*; + // These are in alphabetical order, which is easy to maintain. + rustc_data_structures::static_assert_size!(Block<'static>, 48); + rustc_data_structures::static_assert_size!(Expr<'static>, 56); + rustc_data_structures::static_assert_size!(ForeignItem<'static>, 72); + rustc_data_structures::static_assert_size!(GenericBound<'_>, 48); + rustc_data_structures::static_assert_size!(Generics<'static>, 56); + rustc_data_structures::static_assert_size!(ImplItem<'static>, 80); + rustc_data_structures::static_assert_size!(Impl<'static>, 80); + rustc_data_structures::static_assert_size!(Item<'static>, 80); + rustc_data_structures::static_assert_size!(Pat<'static>, 88); + rustc_data_structures::static_assert_size!(QPath<'static>, 24); + rustc_data_structures::static_assert_size!(TraitItem<'static>, 88); + rustc_data_structures::static_assert_size!(Ty<'static>, 72); } diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs index ca3e6ce4d60..bd58021f78f 100644 --- a/compiler/rustc_lint/src/builtin.rs +++ b/compiler/rustc_lint/src/builtin.rs @@ -1364,7 +1364,6 @@ impl UnreachablePub { cx: &LateContext<'_>, what: &str, def_id: LocalDefId, - span: Span, vis_span: Span, exportable: bool, ) { @@ -1373,7 +1372,7 @@ impl UnreachablePub { if vis_span.from_expansion() { applicability = Applicability::MaybeIncorrect; } - let def_span = cx.tcx.sess.source_map().guess_head_span(span); + let def_span = cx.tcx.def_span(def_id); cx.struct_span_lint(UNREACHABLE_PUB, def_span, |lint| { let mut err = lint.build(fluent::lint::builtin_unreachable_pub); err.set_arg("what", what); @@ -1399,36 +1398,22 @@ impl<'tcx> LateLintPass<'tcx> for UnreachablePub { if let hir::ItemKind::Use(_, hir::UseKind::ListStem) = &item.kind { return; } - self.perform_lint(cx, "item", item.def_id, item.span, item.vis_span, true); + self.perform_lint(cx, "item", item.def_id, item.vis_span, true); } fn check_foreign_item(&mut self, cx: &LateContext<'_>, foreign_item: &hir::ForeignItem<'tcx>) { - self.perform_lint( - cx, - "item", - foreign_item.def_id, - foreign_item.span, - foreign_item.vis_span, - true, - ); + self.perform_lint(cx, "item", foreign_item.def_id, foreign_item.vis_span, true); } fn check_field_def(&mut self, cx: &LateContext<'_>, field: &hir::FieldDef<'_>) { let def_id = cx.tcx.hir().local_def_id(field.hir_id); - self.perform_lint(cx, "field", def_id, field.span, field.vis_span, false); + self.perform_lint(cx, "field", def_id, field.vis_span, false); } fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) { // Only lint inherent impl items. if cx.tcx.associated_item(impl_item.def_id).trait_item_def_id.is_none() { - self.perform_lint( - cx, - "item", - impl_item.def_id, - impl_item.span, - impl_item.vis_span, - false, - ); + self.perform_lint(cx, "item", impl_item.def_id, impl_item.vis_span, false); } } } diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs index 8e3c2283efc..eb90169d0e3 100644 --- a/compiler/rustc_middle/src/mir/syntax.rs +++ b/compiler/rustc_middle/src/mir/syntax.rs @@ -800,9 +800,6 @@ pub struct Place<'tcx> { pub projection: &'tcx List<PlaceElem<'tcx>>, } -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -static_assert_size!(Place<'_>, 16); - #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(TyEncodable, TyDecodable, HashStable)] pub enum ProjectionElem<V, T> { @@ -866,11 +863,6 @@ pub enum ProjectionElem<V, T> { /// and the index is a local. pub type PlaceElem<'tcx> = ProjectionElem<Local, Ty<'tcx>>; -// This type is fairly frequently used, so we shouldn't unintentionally increase -// its size. -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -static_assert_size!(PlaceElem<'_>, 24); - /////////////////////////////////////////////////////////////////////////// // Operands @@ -913,9 +905,6 @@ pub enum Operand<'tcx> { Constant(Box<Constant<'tcx>>), } -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -static_assert_size!(Operand<'_>, 24); - /////////////////////////////////////////////////////////////////////////// // Rvalues @@ -1067,9 +1056,6 @@ pub enum Rvalue<'tcx> { CopyForDeref(Place<'tcx>), } -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -static_assert_size!(Rvalue<'_>, 40); - #[derive(Clone, Copy, Debug, PartialEq, Eq, TyEncodable, TyDecodable, Hash, HashStable)] pub enum CastKind { /// An exposing pointer to address cast. A cast between a pointer and an integer type, or @@ -1105,9 +1091,6 @@ pub enum AggregateKind<'tcx> { Generator(LocalDefId, SubstsRef<'tcx>, hir::Movability), } -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -static_assert_size!(AggregateKind<'_>, 48); - #[derive(Copy, Clone, Debug, PartialEq, Eq, TyEncodable, TyDecodable, Hash, HashStable)] pub enum NullOp { /// Returns the size of a value of that type @@ -1171,3 +1154,15 @@ pub enum BinOp { /// The `ptr.offset` operator Offset, } + +// Some nodes are used a lot. Make sure they don't unintentionally get bigger. +#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] +mod size_asserts { + use super::*; + // These are in alphabetical order, which is easy to maintain. + static_assert_size!(AggregateKind<'_>, 48); + static_assert_size!(Operand<'_>, 24); + static_assert_size!(Place<'_>, 16); + static_assert_size!(PlaceElem<'_>, 24); + static_assert_size!(Rvalue<'_>, 40); +} diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs index 8b27ca57046..b856af1d8f8 100644 --- a/compiler/rustc_middle/src/thir.rs +++ b/compiler/rustc_middle/src/thir.rs @@ -190,10 +190,6 @@ pub enum StmtKind<'tcx> { }, } -// `Expr` is used a lot. Make sure it doesn't unintentionally get bigger. -#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -rustc_data_structures::static_assert_size!(Expr<'_>, 104); - #[derive(Clone, Debug, Copy, PartialEq, Eq, Hash, HashStable, TyEncodable, TyDecodable)] #[derive(TypeFoldable, TypeVisitable)] pub struct LocalVarId(pub hir::HirId); @@ -812,3 +808,14 @@ impl<'tcx> fmt::Display for Pat<'tcx> { } } } + +// Some nodes are used a lot. Make sure they don't unintentionally get bigger. +#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] +mod size_asserts { + use super::*; + // These are in alphabetical order, which is easy to maintain. + rustc_data_structures::static_assert_size!(Block, 56); + rustc_data_structures::static_assert_size!(Expr<'_>, 104); + rustc_data_structures::static_assert_size!(Pat<'_>, 24); + rustc_data_structures::static_assert_size!(Stmt<'_>, 120); +} diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs index 2714493b9fc..541763e294f 100644 --- a/compiler/rustc_middle/src/ty/context.rs +++ b/compiler/rustc_middle/src/ty/context.rs @@ -1459,11 +1459,11 @@ impl<'tcx> TyCtxt<'tcx> { }; format!( - "{}[{}]{}", + "{}[{:04x}]{}", crate_name, // Don't print the whole stable crate id. That's just // annoying in debug output. - &(format!("{:08x}", stable_crate_id.to_u64()))[..4], + stable_crate_id.to_u64() >> 8 * 6, self.def_path(def_id).to_string_no_crate_verbose() ) } diff --git a/compiler/rustc_mir_build/src/lints.rs b/compiler/rustc_mir_build/src/lints.rs index d21a8c4f9b9..bc6241b3810 100644 --- a/compiler/rustc_mir_build/src/lints.rs +++ b/compiler/rustc_mir_build/src/lints.rs @@ -1,7 +1,7 @@ use rustc_data_structures::graph::iterate::{ NodeStatus, TriColorDepthFirstSearch, TriColorVisitor, }; -use rustc_hir::intravisit::FnKind; +use rustc_hir::def::DefKind; use rustc_middle::mir::{BasicBlock, BasicBlocks, Body, Operand, TerminatorKind}; use rustc_middle::ty::subst::{GenericArg, InternalSubsts}; use rustc_middle::ty::{self, AssocItem, AssocItemContainer, Instance, TyCtxt}; @@ -12,12 +12,7 @@ use std::ops::ControlFlow; pub(crate) fn check<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>) { let def_id = body.source.def_id().expect_local(); - if let Some(fn_kind) = tcx.hir().get_by_def_id(def_id).fn_kind() { - if let FnKind::Closure = fn_kind { - // closures can't recur, so they don't matter. - return; - } - + if let DefKind::Fn | DefKind::AssocFn = tcx.def_kind(def_id) { // If this is trait/impl method, extract the trait's substs. let trait_substs = match tcx.opt_associated_item(def_id.to_def_id()) { Some(AssocItem { @@ -41,8 +36,8 @@ pub(crate) fn check<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>) { vis.reachable_recursive_calls.sort(); + let sp = tcx.def_span(def_id); let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); - let sp = tcx.sess.source_map().guess_head_span(tcx.hir().span_with_body(hir_id)); tcx.struct_span_lint_hir(UNCONDITIONAL_RECURSION, hir_id, sp, |lint| { let mut db = lint.build("function cannot return without recursing"); db.span_label(sp, "cannot return without recursing"); diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs index 390d6f5a856..43e4d252676 100644 --- a/compiler/rustc_privacy/src/lib.rs +++ b/compiler/rustc_privacy/src/lib.rs @@ -1754,8 +1754,7 @@ impl SearchInterfaceForPrivateItemsVisitor<'_> { || self.in_assoc_ty || self.tcx.resolutions(()).has_pub_restricted { - let vis_span = - self.tcx.sess.source_map().guess_head_span(self.tcx.def_span(def_id)); + let vis_span = self.tcx.def_span(def_id); if kind == "trait" { self.tcx.sess.emit_err(InPublicInterfaceTraits { span, diff --git a/compiler/rustc_query_system/src/query/job.rs b/compiler/rustc_query_system/src/query/job.rs index 9f5779194af..6d2aff38172 100644 --- a/compiler/rustc_query_system/src/query/job.rs +++ b/compiler/rustc_query_system/src/query/job.rs @@ -1,4 +1,3 @@ -use crate::dep_graph::DepContext; use crate::query::plumbing::CycleError; use crate::query::{QueryContext, QueryStackFrame}; use rustc_hir::def::DefKind; @@ -536,17 +535,13 @@ pub(crate) fn report_cycle<'a>( ) -> DiagnosticBuilder<'a, ErrorGuaranteed> { assert!(!stack.is_empty()); - let fix_span = |span: Span, query: &QueryStackFrame| { - sess.source_map().guess_head_span(query.default_span(span)) - }; - - let span = fix_span(stack[1 % stack.len()].span, &stack[0].query); + let span = stack[0].query.default_span(stack[1 % stack.len()].span); let mut err = struct_span_err!(sess, span, E0391, "cycle detected when {}", stack[0].query.description); for i in 1..stack.len() { let query = &stack[i].query; - let span = fix_span(stack[(i + 1) % stack.len()].span, query); + let span = query.default_span(stack[(i + 1) % stack.len()].span); err.span_note(span, &format!("...which requires {}...", query.description)); } @@ -577,7 +572,7 @@ pub(crate) fn report_cycle<'a>( } if let Some((span, query)) = usage { - err.span_note(fix_span(span, &query), &format!("cycle used when {}", query.description)); + err.span_note(query.default_span(span), &format!("cycle used when {}", query.description)); } err @@ -606,8 +601,7 @@ pub fn print_query_stack<CTX: QueryContext>( Level::FailureNote, &format!("#{} [{}] {}", i, query_info.query.name, query_info.query.description), ); - diag.span = - tcx.dep_context().sess().source_map().guess_head_span(query_info.job.span).into(); + diag.span = query_info.job.span.into(); handler.force_print_diagnostic(diag); current_query = query_info.job.parent; diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs index 22a307a15ed..8839fb1a151 100644 --- a/compiler/rustc_resolve/src/diagnostics.rs +++ b/compiler/rustc_resolve/src/diagnostics.rs @@ -1587,11 +1587,7 @@ impl<'a> Resolver<'a> { }; let def_span = suggestion.res.opt_def_id().and_then(|def_id| match def_id.krate { LOCAL_CRATE => self.opt_span(def_id), - _ => Some( - self.session - .source_map() - .guess_head_span(self.cstore().get_span_untracked(def_id, self.session)), - ), + _ => Some(self.cstore().get_span_untracked(def_id, self.session)), }); if let Some(def_span) = def_span { if span.overlaps(def_span) { diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs index 6b49c6b1ac6..2b1f2b88ec4 100644 --- a/compiler/rustc_resolve/src/late/diagnostics.rs +++ b/compiler/rustc_resolve/src/late/diagnostics.rs @@ -136,12 +136,7 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> { fn def_span(&self, def_id: DefId) -> Option<Span> { match def_id.krate { LOCAL_CRATE => self.r.opt_span(def_id), - _ => Some( - self.r - .session - .source_map() - .guess_head_span(self.r.cstore().get_span_untracked(def_id, self.r.session)), - ), + _ => Some(self.r.cstore().get_span_untracked(def_id, self.r.session)), } } diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/on_unimplemented.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/on_unimplemented.rs index 7e8872d9018..e6907637c57 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/on_unimplemented.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/on_unimplemented.rs @@ -223,8 +223,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> { if let Some(def) = aty.ty_adt_def() { // We also want to be able to select the slice's type's original // signature with no type arguments resolved - let type_string = self.tcx.type_of(def.did()).to_string(); - flags.push((sym::_Self, Some(format!("[{type_string}]")))); + flags.push((sym::_Self, Some(format!("[{}]", self.tcx.type_of(def.did()))))); } if aty.is_integral() { flags.push((sym::_Self, Some("[{integral}]".to_string()))); @@ -242,10 +241,10 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> { if let Some(def) = aty.ty_adt_def() { // We also want to be able to select the array's type's original // signature with no type arguments resolved - let type_string = self.tcx.type_of(def.did()).to_string(); - flags.push((sym::_Self, Some(format!("[{type_string}; _]")))); + let def_ty = self.tcx.type_of(def.did()); + flags.push((sym::_Self, Some(format!("[{def_ty}; _]")))); if let Some(n) = len { - flags.push((sym::_Self, Some(format!("[{type_string}; {n}]")))); + flags.push((sym::_Self, Some(format!("[{def_ty}; {n}]")))); } } if aty.is_integral() { diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs index b2eb8fdf8a5..c3abb515b03 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs @@ -1946,7 +1946,6 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> { )); let original_span = err.span.primary_span().unwrap(); - let original_span = self.tcx.sess.source_map().guess_head_span(original_span); let mut span = MultiSpan::from_span(original_span); let message = outer_generator diff --git a/compiler/rustc_typeck/src/check/_match.rs b/compiler/rustc_typeck/src/check/_match.rs index df315b8a3bc..4f15592e6fb 100644 --- a/compiler/rustc_typeck/src/check/_match.rs +++ b/compiler/rustc_typeck/src/check/_match.rs @@ -293,6 +293,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { pub(crate) fn if_cause( &self, span: Span, + cond_span: Span, then_expr: &'tcx hir::Expr<'tcx>, else_expr: &'tcx hir::Expr<'tcx>, then_ty: Ty<'tcx>, @@ -355,10 +356,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // 6 | | }; // | |_____^ expected integer, found `()` // ``` - if block.expr.is_none() && block.stmts.is_empty() - && let Some(outer_span) = &mut outer_span - { - *outer_span = self.tcx.sess.source_map().guess_head_span(*outer_span); + if block.expr.is_none() && block.stmts.is_empty() && outer_span.is_some() { + let sp = if let Some(cs) = cond_span.find_ancestor_inside(span) { + span.with_hi(cs.hi()) + } else { + span + }; + outer_span = Some(sp); } (self.find_block_span(block), block.hir_id) diff --git a/compiler/rustc_typeck/src/check/expr.rs b/compiler/rustc_typeck/src/check/expr.rs index e20c6a2d99a..6e97b0bf2ab 100644 --- a/compiler/rustc_typeck/src/check/expr.rs +++ b/compiler/rustc_typeck/src/check/expr.rs @@ -1003,8 +1003,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let else_diverges = self.diverges.get(); let opt_suggest_box_span = self.opt_suggest_box_span(else_ty, orig_expected); - let if_cause = - self.if_cause(sp, then_expr, else_expr, then_ty, else_ty, opt_suggest_box_span); + let if_cause = self.if_cause( + sp, + cond_expr.span, + then_expr, + else_expr, + then_ty, + else_ty, + opt_suggest_box_span, + ); coerce.coerce(self, &if_cause, else_expr, else_ty); |