mathieu/os-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Auto merge of #118126 - Nilstrieb:rollup-5ogh896, r=Nilstrieb

Browse source 
Rollup of 7 pull requests

Successful merges:

 - #117790 (CFI: Add missing use core::ffi::c_int)
 - #118059 (Explicitly unset $CARGO for compiletest)
 - #118081 (`rustc_ty_utils` cleanups)
 - #118094 (feat: specialize `SpecFromElem` for `()`)
 - #118097 (Update books)
 - #118115 (Fix occurrences of old fn names in comment and tracing)
 - #118121 (`rustc_hir` cleanups)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2023-11-21 08:40:39 +00:00
commit c5af061019
25 changed files with 177 additions and 510 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
compiler/rustc_hir/src/arena.rs
View file

@ -5,7 +5,6 @@ macro_rules! arena_types {
($macro:path) => ( ($macro:path) => (
$macro!([ $macro!([
// HIR types // HIR types
[] hir_krate: rustc_hir::Crate<'tcx>,
[] asm_template: rustc_ast::InlineAsmTemplatePiece, [] asm_template: rustc_ast::InlineAsmTemplatePiece,
[] attribute: rustc_ast::Attribute, [] attribute: rustc_ast::Attribute,
[] owner_info: rustc_hir::OwnerInfo<'tcx>, [] owner_info: rustc_hir::OwnerInfo<'tcx>,

17
compiler/rustc_hir/src/def.rs
View file

@ -13,8 +13,7 @@ use std::array::IntoIter;
use std::fmt::Debug; use std::fmt::Debug;
/// Encodes if a `DefKind::Ctor` is the constructor of an enum variant or a struct. /// Encodes if a `DefKind::Ctor` is the constructor of an enum variant or a struct.
#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] #[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug, HashStable_Generic)]
#[derive(HashStable_Generic)]
pub enum CtorOf { pub enum CtorOf {
/// This `DefKind::Ctor` is a synthesized constructor of a tuple or unit struct. /// This `DefKind::Ctor` is a synthesized constructor of a tuple or unit struct.
Struct, Struct,
@ -23,8 +22,7 @@ pub enum CtorOf {
} }
/// What kind of constructor something is. /// What kind of constructor something is.
#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] #[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug, HashStable_Generic)]
#[derive(HashStable_Generic)]
pub enum CtorKind { pub enum CtorKind {
/// Constructor function automatically created by a tuple struct/variant. /// Constructor function automatically created by a tuple struct/variant.
Fn, Fn,
@ -33,8 +31,7 @@ pub enum CtorKind {
} }
/// An attribute that is not a macro; e.g., `#[inline]` or `#[rustfmt::skip]`. /// An attribute that is not a macro; e.g., `#[inline]` or `#[rustfmt::skip]`.
#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] #[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug, HashStable_Generic)]
#[derive(HashStable_Generic)]
pub enum NonMacroAttrKind { pub enum NonMacroAttrKind {
/// Single-segment attribute defined by the language (`#[inline]`) /// Single-segment attribute defined by the language (`#[inline]`)
Builtin(Symbol), Builtin(Symbol),
@ -48,8 +45,7 @@ pub enum NonMacroAttrKind {
} }
/// What kind of definition something is; e.g., `mod` vs `struct`. /// What kind of definition something is; e.g., `mod` vs `struct`.
#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] #[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug, HashStable_Generic)]
#[derive(HashStable_Generic)]
pub enum DefKind { pub enum DefKind {
// Type namespace // Type namespace
Mod, Mod,
@ -299,8 +295,7 @@ impl DefKind {
/// - the call to `str_to_string` will resolve to [`Res::Def`], with the [`DefId`] /// - the call to `str_to_string` will resolve to [`Res::Def`], with the [`DefId`]
/// pointing to the definition of `str_to_string` in the current crate. /// pointing to the definition of `str_to_string` in the current crate.
// //
#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] #[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug, HashStable_Generic)]
#[derive(HashStable_Generic)]
pub enum Res<Id = hir::HirId> { pub enum Res<Id = hir::HirId> {
/// Definition having a unique ID (`DefId`), corresponds to something defined in user code. /// Definition having a unique ID (`DefId`), corresponds to something defined in user code.
/// ///
@ -591,6 +586,8 @@ impl NonMacroAttrKind {
} }
} }
// Currently trivial, but exists in case a new kind is added in the future whose name starts
// with a vowel.
pub fn article(self) -> &'static str { pub fn article(self) -> &'static str {
"a" "a"
} }

547
compiler/rustc_hir/src/hir.rs
View file

@ -13,7 +13,6 @@ use rustc_ast::{InlineAsmOptions, InlineAsmTemplatePiece};
use rustc_data_structures::fingerprint::Fingerprint; use rustc_data_structures::fingerprint::Fingerprint;
use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::sorted_map::SortedMap; use rustc_data_structures::sorted_map::SortedMap;
use rustc_error_messages::MultiSpan;
use rustc_index::IndexVec; use rustc_index::IndexVec;
use rustc_macros::HashStable_Generic; use rustc_macros::HashStable_Generic;
use rustc_span::hygiene::MacroKind; use rustc_span::hygiene::MacroKind;
@ -76,13 +75,6 @@ impl ParamName {
ParamName::Fresh | ParamName::Error => Ident::with_dummy_span(kw::UnderscoreLifetime), ParamName::Fresh | ParamName::Error => Ident::with_dummy_span(kw::UnderscoreLifetime),
} }
} }
pub fn normalize_to_macros_2_0(&self) -> ParamName {
match *self {
ParamName::Plain(ident) => ParamName::Plain(ident.normalize_to_macros_2_0()),
param_name => param_name,
}
}
} }
#[derive(Debug, Copy, Clone, PartialEq, Eq, HashStable_Generic)] #[derive(Debug, Copy, Clone, PartialEq, Eq, HashStable_Generic)]
@ -116,7 +108,7 @@ pub enum LifetimeName {
} }
impl LifetimeName { impl LifetimeName {
pub fn is_elided(&self) -> bool { fn is_elided(&self) -> bool {
match self { match self {
LifetimeName::ImplicitObjectLifetimeDefault | LifetimeName::Infer => true, LifetimeName::ImplicitObjectLifetimeDefault | LifetimeName::Infer => true,
@ -289,10 +281,6 @@ impl GenericArg<'_> {
} }
} }
pub fn is_synthetic(&self) -> bool {
matches!(self, GenericArg::Lifetime(lifetime) if lifetime.ident == Ident::empty())
}
pub fn descr(&self) -> &'static str { pub fn descr(&self) -> &'static str {
match self { match self {
GenericArg::Lifetime(_) => "lifetime", GenericArg::Lifetime(_) => "lifetime",
@ -368,11 +356,6 @@ impl<'hir> GenericArgs<'hir> {
panic!("GenericArgs::inputs: not a `Fn(T) -> U`"); panic!("GenericArgs::inputs: not a `Fn(T) -> U`");
} }
#[inline]
pub fn has_type_params(&self) -> bool {
self.args.iter().any(|arg| matches!(arg, GenericArg::Type(_)))
}
pub fn has_err(&self) -> bool { pub fn has_err(&self) -> bool {
self.args.iter().any(|arg| match arg { self.args.iter().any(|arg| match arg {
GenericArg::Type(ty) => matches!(ty.kind, TyKind::Err(_)), GenericArg::Type(ty) => matches!(ty.kind, TyKind::Err(_)),
@ -383,11 +366,6 @@ impl<'hir> GenericArgs<'hir> {
}) })
} }
#[inline]
pub fn num_type_params(&self) -> usize {
self.args.iter().filter(|arg| matches!(arg, GenericArg::Type(_))).count()
}
#[inline] #[inline]
pub fn num_lifetime_params(&self) -> usize { pub fn num_lifetime_params(&self) -> usize {
self.args.iter().filter(|arg| matches!(arg, GenericArg::Lifetime(_))).count() self.args.iter().filter(|arg| matches!(arg, GenericArg::Lifetime(_))).count()
@ -589,14 +567,6 @@ impl<'hir> Generics<'hir> {
self.params.iter().find(|&param| name == param.name.ident().name) self.params.iter().find(|&param| name == param.name.ident().name)
} }
pub fn spans(&self) -> MultiSpan {
if self.params.is_empty() {
self.span.into()
} else {
self.params.iter().map(|p| p.span).collect::<Vec<Span>>().into()
}
}
/// If there are generic parameters, return where to introduce a new one. /// If there are generic parameters, return where to introduce a new one.
pub fn span_for_lifetime_suggestion(&self) -> Option<Span> { pub fn span_for_lifetime_suggestion(&self) -> Option<Span> {
if let Some(first) = self.params.first() if let Some(first) = self.params.first()
@ -679,7 +649,7 @@ impl<'hir> Generics<'hir> {
) )
} }
pub fn span_for_predicate_removal(&self, pos: usize) -> Span { fn span_for_predicate_removal(&self, pos: usize) -> Span {
let predicate = &self.predicates[pos]; let predicate = &self.predicates[pos];
let span = predicate.span(); let span = predicate.span();
@ -812,7 +782,7 @@ pub struct WhereRegionPredicate<'hir> {
impl<'hir> WhereRegionPredicate<'hir> { impl<'hir> WhereRegionPredicate<'hir> {
/// Returns `true` if `param_def_id` matches the `lifetime` of this predicate. /// Returns `true` if `param_def_id` matches the `lifetime` of this predicate.
pub fn is_param_bound(&self, param_def_id: LocalDefId) -> bool { fn is_param_bound(&self, param_def_id: LocalDefId) -> bool {
self.lifetime.res == LifetimeName::Param(param_def_id) self.lifetime.res == LifetimeName::Param(param_def_id)
} }
} }
@ -869,7 +839,7 @@ pub struct OwnerNodes<'tcx> {
} }
impl<'tcx> OwnerNodes<'tcx> { impl<'tcx> OwnerNodes<'tcx> {
pub fn node(&self) -> OwnerNode<'tcx> { fn node(&self) -> OwnerNode<'tcx> {
use rustc_index::Idx; use rustc_index::Idx;
let node = self.nodes[ItemLocalId::new(0)].as_ref().unwrap().node; let node = self.nodes[ItemLocalId::new(0)].as_ref().unwrap().node;
let node = node.as_owner().unwrap(); // Indexing must ensure it is an OwnerNode. let node = node.as_owner().unwrap(); // Indexing must ensure it is an OwnerNode.
@ -1272,10 +1242,6 @@ impl BinOpKind {
matches!(self, BinOpKind::And | BinOpKind::Or) matches!(self, BinOpKind::And | BinOpKind::Or)
} }
pub fn is_shift(self) -> bool {
matches!(self, BinOpKind::Shl | BinOpKind::Shr)
}
pub fn is_comparison(self) -> bool { pub fn is_comparison(self) -> bool {
match self { match self {
BinOpKind::Eq BinOpKind::Eq
@ -1516,8 +1482,7 @@ impl<'hir> Body<'hir> {
} }
/// The type of source expression that caused this coroutine to be created. /// The type of source expression that caused this coroutine to be created.
#[derive(Clone, PartialEq, Eq, Debug, Copy, Hash)] #[derive(Clone, PartialEq, Eq, Debug, Copy, Hash, HashStable_Generic, Encodable, Decodable)]
#[derive(HashStable_Generic, Encodable, Decodable)]
pub enum CoroutineKind { pub enum CoroutineKind {
/// An explicit `async` block or the body of an async function. /// An explicit `async` block or the body of an async function.
Async(CoroutineSource), Async(CoroutineSource),
@ -1558,8 +1523,7 @@ impl fmt::Display for CoroutineKind {
/// ///
/// This helps error messages but is also used to drive coercions in /// This helps error messages but is also used to drive coercions in
/// type-checking (see #60424). /// type-checking (see #60424).
#[derive(Clone, PartialEq, Eq, Hash, Debug, Copy)] #[derive(Clone, PartialEq, Eq, Hash, Debug, Copy, HashStable_Generic, Encodable, Decodable)]
#[derive(HashStable_Generic, Encodable, Decodable)]
pub enum CoroutineSource { pub enum CoroutineSource {
/// An explicit `async`/`gen` block written by the user. /// An explicit `async`/`gen` block written by the user.
Block, Block,
@ -2117,16 +2081,6 @@ impl<'hir> QPath<'hir> {
QPath::LangItem(_, span, _) => span, QPath::LangItem(_, span, _) => span,
} }
} }
/// Returns the span of the last segment of this `QPath`. For example, `method` in
/// `<() as Trait>::method`.
pub fn last_segment_span(&self) -> Span {
match *self {
QPath::Resolved(_, path) => path.segments.last().unwrap().ident.span,
QPath::TypeRelative(_, segment) => segment.ident.span,
QPath::LangItem(_, span, _) => span,
}
}
} }
/// Hints at the original code for a let statement. /// Hints at the original code for a let statement.
@ -2153,8 +2107,7 @@ pub enum LocalSource {
} }
/// Hints at the original code for a `match _ { .. }`. /// Hints at the original code for a `match _ { .. }`.
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable_Generic, Encodable, Decodable)]
#[derive(HashStable_Generic, Encodable, Decodable)]
pub enum MatchSource { pub enum MatchSource {
/// A `match _ { .. }`. /// A `match _ { .. }`.
Normal, Normal,
@ -2314,6 +2267,35 @@ pub struct TraitItem<'hir> {
pub defaultness: Defaultness, pub defaultness: Defaultness,
} }
macro_rules! expect_methods_self_kind {
( $( $name:ident, $ret_ty:ty, $pat:pat, $ret_val:expr; )* ) => {
$(
#[track_caller]
pub fn $name(&self) -> $ret_ty {
let $pat = &self.kind else { expect_failed(stringify!($ident), self) };
$ret_val
}
)*
}
}
macro_rules! expect_methods_self {
( $( $name:ident, $ret_ty:ty, $pat:pat, $ret_val:expr; )* ) => {
$(
#[track_caller]
pub fn $name(&self) -> $ret_ty {
let $pat = self else { expect_failed(stringify!($ident), self) };
$ret_val
}
)*
}
}
#[track_caller]
fn expect_failed<T: fmt::Debug>(ident: &'static str, found: T) -> ! {
panic!("{ident}: found {found:?}")
}
impl<'hir> TraitItem<'hir> { impl<'hir> TraitItem<'hir> {
#[inline] #[inline]
pub fn hir_id(&self) -> HirId { pub fn hir_id(&self) -> HirId {
@ -2325,30 +2307,15 @@ impl<'hir> TraitItem<'hir> {
TraitItemId { owner_id: self.owner_id } TraitItemId { owner_id: self.owner_id }
} }
/// Expect an [`TraitItemKind::Const`] or panic. expect_methods_self_kind! {
#[track_caller] expect_const, (&'hir Ty<'hir>, Option<BodyId>),
pub fn expect_const(&self) -> (&'hir Ty<'hir>, Option<BodyId>) { TraitItemKind::Const(ty, body), (ty, *body);
let TraitItemKind::Const(ty, body) = self.kind else { self.expect_failed("a constant") };
(ty, body)
}
/// Expect an [`TraitItemKind::Fn`] or panic. expect_fn, (&FnSig<'hir>, &TraitFn<'hir>),
#[track_caller] TraitItemKind::Fn(ty, trfn), (ty, trfn);
pub fn expect_fn(&self) -> (&FnSig<'hir>, &TraitFn<'hir>) {
let TraitItemKind::Fn(ty, trfn) = &self.kind else { self.expect_failed("a function") };
(ty, trfn)
}
/// Expect an [`TraitItemKind::Type`] or panic. expect_type, (GenericBounds<'hir>, Option<&'hir Ty<'hir>>),
#[track_caller] TraitItemKind::Type(bounds, ty), (bounds, *ty);
pub fn expect_type(&self) -> (GenericBounds<'hir>, Option<&'hir Ty<'hir>>) {
let TraitItemKind::Type(bounds, ty) = self.kind else { self.expect_failed("a type") };
(bounds, ty)
}
#[track_caller]
fn expect_failed(&self, expected: &'static str) -> ! {
panic!("expected {expected} item, found {self:?}")
} }
} }
@ -2413,30 +2380,10 @@ impl<'hir> ImplItem<'hir> {
ImplItemId { owner_id: self.owner_id } ImplItemId { owner_id: self.owner_id }
} }
/// Expect an [`ImplItemKind::Const`] or panic. expect_methods_self_kind! {
#[track_caller] expect_const, (&'hir Ty<'hir>, BodyId), ImplItemKind::Const(ty, body), (ty, *body);
pub fn expect_const(&self) -> (&'hir Ty<'hir>, BodyId) { expect_fn, (&FnSig<'hir>, BodyId), ImplItemKind::Fn(ty, body), (ty, *body);
let ImplItemKind::Const(ty, body) = self.kind else { self.expect_failed("a constant") }; expect_type, &'hir Ty<'hir>, ImplItemKind::Type(ty), ty;
(ty, body)
}
/// Expect an [`ImplItemKind::Fn`] or panic.
#[track_caller]
pub fn expect_fn(&self) -> (&FnSig<'hir>, BodyId) {
let ImplItemKind::Fn(ty, body) = &self.kind else { self.expect_failed("a function") };
(ty, *body)
}
/// Expect an [`ImplItemKind::Type`] or panic.
#[track_caller]
pub fn expect_type(&self) -> &'hir Ty<'hir> {
let ImplItemKind::Type(ty) = self.kind else { self.expect_failed("a type") };
ty
}
#[track_caller]
fn expect_failed(&self, expected: &'static str) -> ! {
panic!("expected {expected} item, found {self:?}")
} }
} }
@ -2579,8 +2526,7 @@ impl<'hir> Ty<'hir> {
} }
/// Not represented directly in the AST; referred to by name through a `ty_path`. /// Not represented directly in the AST; referred to by name through a `ty_path`.
#[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] #[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Hash, Debug, HashStable_Generic)]
#[derive(HashStable_Generic)]
pub enum PrimTy { pub enum PrimTy {
Int(IntTy), Int(IntTy),
Uint(UintTy), Uint(UintTy),
@ -2860,8 +2806,7 @@ impl ImplicitSelfKind {
} }
} }
#[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Debug)] #[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Debug, HashStable_Generic)]
#[derive(HashStable_Generic)]
pub enum IsAsync { pub enum IsAsync {
Async(Span), Async(Span),
NotAsync, NotAsync,
@ -3124,134 +3069,51 @@ impl<'hir> Item<'hir> {
ItemId { owner_id: self.owner_id } ItemId { owner_id: self.owner_id }
} }
/// Expect an [`ItemKind::ExternCrate`] or panic. expect_methods_self_kind! {
#[track_caller] expect_extern_crate, Option<Symbol>, ItemKind::ExternCrate(s), *s;
pub fn expect_extern_crate(&self) -> Option<Symbol> {
let ItemKind::ExternCrate(s) = self.kind else { self.expect_failed("an extern crate") };
s
}
/// Expect an [`ItemKind::Use`] or panic. expect_use, (&'hir UsePath<'hir>, UseKind), ItemKind::Use(p, uk), (p, *uk);
#[track_caller]
pub fn expect_use(&self) -> (&'hir UsePath<'hir>, UseKind) {
let ItemKind::Use(p, uk) = self.kind else { self.expect_failed("a use") };
(p, uk)
}
/// Expect an [`ItemKind::Static`] or panic. expect_static, (&'hir Ty<'hir>, Mutability, BodyId),
#[track_caller] ItemKind::Static(ty, mutbl, body), (ty, *mutbl, *body);
pub fn expect_static(&self) -> (&'hir Ty<'hir>, Mutability, BodyId) {
let ItemKind::Static(ty, mutbl, body) = self.kind else { self.expect_failed("a static") };
(ty, mutbl, body)
}
/// Expect an [`ItemKind::Const`] or panic.
#[track_caller]
pub fn expect_const(&self) -> (&'hir Ty<'hir>, &'hir Generics<'hir>, BodyId) {
let ItemKind::Const(ty, gen, body) = self.kind else { self.expect_failed("a constant") };
(ty, gen, body)
}
/// Expect an [`ItemKind::Fn`] or panic.
#[track_caller]
pub fn expect_fn(&self) -> (&FnSig<'hir>, &'hir Generics<'hir>, BodyId) {
let ItemKind::Fn(sig, gen, body) = &self.kind else { self.expect_failed("a function") };
(sig, gen, *body)
}
/// Expect an [`ItemKind::Macro`] or panic. expect_const, (&'hir Ty<'hir>, &'hir Generics<'hir>, BodyId),
#[track_caller] ItemKind::Const(ty, gen, body), (ty, gen, *body);
pub fn expect_macro(&self) -> (&ast::MacroDef, MacroKind) {
let ItemKind::Macro(def, mk) = &self.kind else { self.expect_failed("a macro") };
(def, *mk)
}
/// Expect an [`ItemKind::Mod`] or panic. expect_fn, (&FnSig<'hir>, &'hir Generics<'hir>, BodyId),
#[track_caller] ItemKind::Fn(sig, gen, body), (sig, gen, *body);
pub fn expect_mod(&self) -> &'hir Mod<'hir> {
let ItemKind::Mod(m) = self.kind else { self.expect_failed("a module") };
m
}
/// Expect an [`ItemKind::ForeignMod`] or panic. expect_macro, (&ast::MacroDef, MacroKind), ItemKind::Macro(def, mk), (def, *mk);
#[track_caller]
pub fn expect_foreign_mod(&self) -> (Abi, &'hir [ForeignItemRef]) {
let ItemKind::ForeignMod { abi, items } = self.kind else {
self.expect_failed("a foreign module")
};
(abi, items)
}
/// Expect an [`ItemKind::GlobalAsm`] or panic. expect_mod, &'hir Mod<'hir>, ItemKind::Mod(m), m;
#[track_caller]
pub fn expect_global_asm(&self) -> &'hir InlineAsm<'hir> {
let ItemKind::GlobalAsm(asm) = self.kind else { self.expect_failed("a global asm") };
asm
}
/// Expect an [`ItemKind::TyAlias`] or panic. expect_foreign_mod, (Abi, &'hir [ForeignItemRef]),
#[track_caller] ItemKind::ForeignMod { abi, items }, (*abi, items);
pub fn expect_ty_alias(&self) -> (&'hir Ty<'hir>, &'hir Generics<'hir>) {
let ItemKind::TyAlias(ty, gen) = self.kind else { self.expect_failed("a type alias") };
(ty, gen)
}
/// Expect an [`ItemKind::OpaqueTy`] or panic. expect_global_asm, &'hir InlineAsm<'hir>, ItemKind::GlobalAsm(asm), asm;
#[track_caller]
pub fn expect_opaque_ty(&self) -> &OpaqueTy<'hir> {
let ItemKind::OpaqueTy(ty) = &self.kind else { self.expect_failed("an opaque type") };
ty
}
/// Expect an [`ItemKind::Enum`] or panic. expect_ty_alias, (&'hir Ty<'hir>, &'hir Generics<'hir>),
#[track_caller] ItemKind::TyAlias(ty, gen), (ty, gen);
pub fn expect_enum(&self) -> (&EnumDef<'hir>, &'hir Generics<'hir>) {
let ItemKind::Enum(def, gen) = &self.kind else { self.expect_failed("an enum") };
(def, gen)
}
/// Expect an [`ItemKind::Struct`] or panic. expect_opaque_ty, &OpaqueTy<'hir>, ItemKind::OpaqueTy(ty), ty;
#[track_caller]
pub fn expect_struct(&self) -> (&VariantData<'hir>, &'hir Generics<'hir>) {
let ItemKind::Struct(data, gen) = &self.kind else { self.expect_failed("a struct") };
(data, gen)
}
/// Expect an [`ItemKind::Union`] or panic. expect_enum, (&EnumDef<'hir>, &'hir Generics<'hir>), ItemKind::Enum(def, gen), (def, gen);
#[track_caller]
pub fn expect_union(&self) -> (&VariantData<'hir>, &'hir Generics<'hir>) {
let ItemKind::Union(data, gen) = &self.kind else { self.expect_failed("a union") };
(data, gen)
}
/// Expect an [`ItemKind::Trait`] or panic. expect_struct, (&VariantData<'hir>, &'hir Generics<'hir>),
#[track_caller] ItemKind::Struct(data, gen), (data, gen);
pub fn expect_trait(
self,
) -> (IsAuto, Unsafety, &'hir Generics<'hir>, GenericBounds<'hir>, &'hir [TraitItemRef]) {
let ItemKind::Trait(is_auto, unsafety, gen, bounds, items) = self.kind else {
self.expect_failed("a trait")
};
(is_auto, unsafety, gen, bounds, items)
}
/// Expect an [`ItemKind::TraitAlias`] or panic. expect_union, (&VariantData<'hir>, &'hir Generics<'hir>),
#[track_caller] ItemKind::Union(data, gen), (data, gen);
pub fn expect_trait_alias(&self) -> (&'hir Generics<'hir>, GenericBounds<'hir>) {
let ItemKind::TraitAlias(gen, bounds) = self.kind else {
self.expect_failed("a trait alias")
};
(gen, bounds)
}
/// Expect an [`ItemKind::Impl`] or panic. expect_trait,
#[track_caller] (IsAuto, Unsafety, &'hir Generics<'hir>, GenericBounds<'hir>, &'hir [TraitItemRef]),
pub fn expect_impl(&self) -> &'hir Impl<'hir> { ItemKind::Trait(is_auto, unsafety, gen, bounds, items),
let ItemKind::Impl(imp) = self.kind else { self.expect_failed("an impl") }; (*is_auto, *unsafety, gen, bounds, items);
imp
}
#[track_caller] expect_trait_alias, (&'hir Generics<'hir>, GenericBounds<'hir>),
fn expect_failed(&self, expected: &'static str) -> ! { ItemKind::TraitAlias(gen, bounds), (gen, bounds);
panic!("expected {expected} item, found {self:?}")
expect_impl, &'hir Impl<'hir>, ItemKind::Impl(imp), imp;
} }
} }
@ -3280,8 +3142,7 @@ impl fmt::Display for Unsafety {
} }
} }
#[derive(Copy, Clone, PartialEq, Eq, Debug)] #[derive(Copy, Clone, PartialEq, Eq, Debug, Encodable, Decodable, HashStable_Generic)]
#[derive(Encodable, Decodable, HashStable_Generic)]
pub enum Constness { pub enum Constness {
Const, Const,
NotConst, NotConst,
@ -3624,32 +3485,11 @@ impl<'hir> OwnerNode<'hir> {
} }
} }
pub fn expect_item(self) -> &'hir Item<'hir> { expect_methods_self! {
match self { expect_item, &'hir Item<'hir>, OwnerNode::Item(n), n;
OwnerNode::Item(n) => n, expect_foreign_item, &'hir ForeignItem<'hir>, OwnerNode::ForeignItem(n), n;
_ => panic!(), expect_impl_item, &'hir ImplItem<'hir>, OwnerNode::ImplItem(n), n;
} expect_trait_item, &'hir TraitItem<'hir>, OwnerNode::TraitItem(n), n;
}
pub fn expect_foreign_item(self) -> &'hir ForeignItem<'hir> {
match self {
OwnerNode::ForeignItem(n) => n,
_ => panic!(),
}
}
pub fn expect_impl_item(self) -> &'hir ImplItem<'hir> {
match self {
OwnerNode::ImplItem(n) => n,
_ => panic!(),
}
}
pub fn expect_trait_item(self) -> &'hir TraitItem<'hir> {
match self {
OwnerNode::TraitItem(n) => n,
_ => panic!(),
}
} }
} }
@ -3902,196 +3742,33 @@ impl<'hir> Node<'hir> {
} }
} }
/// Get the fields for the tuple-constructor, expect_methods_self! {
/// if this node is a tuple constructor, otherwise None expect_param, &'hir Param<'hir>, Node::Param(n), n;
pub fn tuple_fields(&self) -> Option<&'hir [FieldDef<'hir>]> { expect_item, &'hir Item<'hir>, Node::Item(n), n;
if let Node::Ctor(&VariantData::Tuple(fields, _, _)) = self { Some(fields) } else { None } expect_foreign_item, &'hir ForeignItem<'hir>, Node::ForeignItem(n), n;
} expect_trait_item, &'hir TraitItem<'hir>, Node::TraitItem(n), n;
expect_impl_item, &'hir ImplItem<'hir>, Node::ImplItem(n), n;
/// Expect a [`Node::Param`] or panic. expect_variant, &'hir Variant<'hir>, Node::Variant(n), n;
#[track_caller] expect_field, &'hir FieldDef<'hir>, Node::Field(n), n;
pub fn expect_param(self) -> &'hir Param<'hir> { expect_anon_const, &'hir AnonConst, Node::AnonConst(n), n;
let Node::Param(this) = self else { self.expect_failed("a parameter") }; expect_inline_const, &'hir ConstBlock, Node::ConstBlock(n), n;
this expect_expr, &'hir Expr<'hir>, Node::Expr(n), n;
} expect_expr_field, &'hir ExprField<'hir>, Node::ExprField(n), n;
expect_stmt, &'hir Stmt<'hir>, Node::Stmt(n), n;
/// Expect a [`Node::Item`] or panic. expect_path_segment, &'hir PathSegment<'hir>, Node::PathSegment(n), n;
#[track_caller] expect_ty, &'hir Ty<'hir>, Node::Ty(n), n;
pub fn expect_item(self) -> &'hir Item<'hir> { expect_type_binding, &'hir TypeBinding<'hir>, Node::TypeBinding(n), n;
let Node::Item(this) = self else { self.expect_failed("a item") }; expect_trait_ref, &'hir TraitRef<'hir>, Node::TraitRef(n), n;
this expect_pat, &'hir Pat<'hir>, Node::Pat(n), n;
} expect_pat_field, &'hir PatField<'hir>, Node::PatField(n), n;
expect_arm, &'hir Arm<'hir>, Node::Arm(n), n;
/// Expect a [`Node::ForeignItem`] or panic. expect_block, &'hir Block<'hir>, Node::Block(n), n;
#[track_caller] expect_local, &'hir Local<'hir>, Node::Local(n), n;
pub fn expect_foreign_item(self) -> &'hir ForeignItem<'hir> { expect_ctor, &'hir VariantData<'hir>, Node::Ctor(n), n;
let Node::ForeignItem(this) = self else { self.expect_failed("a foreign item") }; expect_lifetime, &'hir Lifetime, Node::Lifetime(n), n;
this expect_generic_param, &'hir GenericParam<'hir>, Node::GenericParam(n), n;
} expect_crate, &'hir Mod<'hir>, Node::Crate(n), n;
expect_infer, &'hir InferArg, Node::Infer(n), n;
/// Expect a [`Node::TraitItem`] or panic.
#[track_caller]
pub fn expect_trait_item(self) -> &'hir TraitItem<'hir> {
let Node::TraitItem(this) = self else { self.expect_failed("a trait item") };
this
}
/// Expect a [`Node::ImplItem`] or panic.
#[track_caller]
pub fn expect_impl_item(self) -> &'hir ImplItem<'hir> {
let Node::ImplItem(this) = self else { self.expect_failed("an implementation item") };
this
}
/// Expect a [`Node::Variant`] or panic.
#[track_caller]
pub fn expect_variant(self) -> &'hir Variant<'hir> {
let Node::Variant(this) = self else { self.expect_failed("a variant") };
this
}
/// Expect a [`Node::Field`] or panic.
#[track_caller]
pub fn expect_field(self) -> &'hir FieldDef<'hir> {
let Node::Field(this) = self else { self.expect_failed("a field definition") };
this
}
/// Expect a [`Node::AnonConst`] or panic.
#[track_caller]
pub fn expect_anon_const(self) -> &'hir AnonConst {
let Node::AnonConst(this) = self else { self.expect_failed("an anonymous constant") };
this
}
/// Expect a [`Node::ConstBlock`] or panic.
#[track_caller]
pub fn expect_inline_const(self) -> &'hir ConstBlock {
let Node::ConstBlock(this) = self else { self.expect_failed("an inline constant") };
this
}
/// Expect a [`Node::Expr`] or panic.
#[track_caller]
pub fn expect_expr(self) -> &'hir Expr<'hir> {
let Node::Expr(this) = self else { self.expect_failed("an expression") };
this
}
/// Expect a [`Node::ExprField`] or panic.
#[track_caller]
pub fn expect_expr_field(self) -> &'hir ExprField<'hir> {
let Node::ExprField(this) = self else { self.expect_failed("an expression field") };
this
}
/// Expect a [`Node::Stmt`] or panic.
#[track_caller]
pub fn expect_stmt(self) -> &'hir Stmt<'hir> {
let Node::Stmt(this) = self else { self.expect_failed("a statement") };
this
}
/// Expect a [`Node::PathSegment`] or panic.
#[track_caller]
pub fn expect_path_segment(self) -> &'hir PathSegment<'hir> {
let Node::PathSegment(this) = self else { self.expect_failed("a path segment") };
this
}
/// Expect a [`Node::Ty`] or panic.
#[track_caller]
pub fn expect_ty(self) -> &'hir Ty<'hir> {
let Node::Ty(this) = self else { self.expect_failed("a type") };
this
}
/// Expect a [`Node::TypeBinding`] or panic.
#[track_caller]
pub fn expect_type_binding(self) -> &'hir TypeBinding<'hir> {
let Node::TypeBinding(this) = self else { self.expect_failed("a type binding") };
this
}
/// Expect a [`Node::TraitRef`] or panic.
#[track_caller]
pub fn expect_trait_ref(self) -> &'hir TraitRef<'hir> {
let Node::TraitRef(this) = self else { self.expect_failed("a trait reference") };
this
}
/// Expect a [`Node::Pat`] or panic.
#[track_caller]
pub fn expect_pat(self) -> &'hir Pat<'hir> {
let Node::Pat(this) = self else { self.expect_failed("a pattern") };
this
}
/// Expect a [`Node::PatField`] or panic.
#[track_caller]
pub fn expect_pat_field(self) -> &'hir PatField<'hir> {
let Node::PatField(this) = self else { self.expect_failed("a pattern field") };
this
}
/// Expect a [`Node::Arm`] or panic.
#[track_caller]
pub fn expect_arm(self) -> &'hir Arm<'hir> {
let Node::Arm(this) = self else { self.expect_failed("an arm") };
this
}
/// Expect a [`Node::Block`] or panic.
#[track_caller]
pub fn expect_block(self) -> &'hir Block<'hir> {
let Node::Block(this) = self else { self.expect_failed("a block") };
this
}
/// Expect a [`Node::Local`] or panic.
#[track_caller]
pub fn expect_local(self) -> &'hir Local<'hir> {
let Node::Local(this) = self else { self.expect_failed("a local") };
this
}
/// Expect a [`Node::Ctor`] or panic.
#[track_caller]
pub fn expect_ctor(self) -> &'hir VariantData<'hir> {
let Node::Ctor(this) = self else { self.expect_failed("a constructor") };
this
}
/// Expect a [`Node::Lifetime`] or panic.
#[track_caller]
pub fn expect_lifetime(self) -> &'hir Lifetime {
let Node::Lifetime(this) = self else { self.expect_failed("a lifetime") };
this
}
/// Expect a [`Node::GenericParam`] or panic.
#[track_caller]
pub fn expect_generic_param(self) -> &'hir GenericParam<'hir> {
let Node::GenericParam(this) = self else { self.expect_failed("a generic parameter") };
this
}
/// Expect a [`Node::Crate`] or panic.
#[track_caller]
pub fn expect_crate(self) -> &'hir Mod<'hir> {
let Node::Crate(this) = self else { self.expect_failed("a crate") };
this
}
/// Expect a [`Node::Infer`] or panic.
#[track_caller]
pub fn expect_infer(self) -> &'hir InferArg {
let Node::Infer(this) = self else { self.expect_failed("an infer") };
this
}
#[track_caller]
fn expect_failed(&self, expected: &'static str) -> ! {
panic!("expected {expected} node, found {self:?}")
} }
} }

6
compiler/rustc_hir/src/hir_id.rs
View file

@ -3,8 +3,7 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableOrd,
use rustc_span::{def_id::DefPathHash, HashStableContext}; use rustc_span::{def_id::DefPathHash, HashStableContext};
use std::fmt::{self, Debug}; use std::fmt::{self, Debug};
#[derive(Copy, Clone, PartialEq, Eq, Hash)] #[derive(Copy, Clone, PartialEq, Eq, Hash, Encodable, Decodable)]
#[derive(Encodable, Decodable)]
pub struct OwnerId { pub struct OwnerId {
pub def_id: LocalDefId, pub def_id: LocalDefId,
} }
@ -73,8 +72,7 @@ impl<CTX: HashStableContext> ToStableHashKey<CTX> for OwnerId {
/// the `local_id` part of the `HirId` changing, which is a very useful property in /// the `local_id` part of the `HirId` changing, which is a very useful property in
/// incremental compilation where we have to persist things through changes to /// incremental compilation where we have to persist things through changes to
/// the code base. /// the code base.
#[derive(Copy, Clone, PartialEq, Eq, Hash)] #[derive(Copy, Clone, PartialEq, Eq, Hash, Encodable, Decodable, HashStable_Generic)]
#[derive(Encodable, Decodable, HashStable_Generic)]
#[rustc_pass_by_value] #[rustc_pass_by_value]
pub struct HirId { pub struct HirId {
pub owner: OwnerId, pub owner: OwnerId,

2
compiler/rustc_hir/src/lang_items.rs
View file

@ -233,7 +233,7 @@ language_item_table! {
PanicFmt, sym::panic_fmt, panic_fmt, Target::Fn, GenericRequirement::None; PanicFmt, sym::panic_fmt, panic_fmt, Target::Fn, GenericRequirement::None;
ConstPanicFmt, sym::const_panic_fmt, const_panic_fmt, Target::Fn, GenericRequirement::None; ConstPanicFmt, sym::const_panic_fmt, const_panic_fmt, Target::Fn, GenericRequirement::None;
PanicBoundsCheck, sym::panic_bounds_check, panic_bounds_check_fn, Target::Fn, GenericRequirement::Exact(0); PanicBoundsCheck, sym::panic_bounds_check, panic_bounds_check_fn, Target::Fn, GenericRequirement::Exact(0);
PanicMisalignedPointerDereference, sym::panic_misaligned_pointer_dereference, panic_misaligned_pointer_dereference_fn, Target::Fn, GenericRequirement::Exact(0); PanicMisalignedPointerDereference, sym::panic_misaligned_pointer_dereference, panic_misaligned_pointer_dereference_fn, Target::Fn, GenericRequirement::Exact(0);
PanicInfo, sym::panic_info, panic_info, Target::Struct, GenericRequirement::None; PanicInfo, sym::panic_info, panic_info, Target::Struct, GenericRequirement::None;
PanicLocation, sym::panic_location, panic_location, Target::Struct, GenericRequirement::None; PanicLocation, sym::panic_location, panic_location, Target::Struct, GenericRequirement::None;
PanicImpl, sym::panic_impl, panic_impl, Target::Fn, GenericRequirement::None; PanicImpl, sym::panic_impl, panic_impl, Target::Fn, GenericRequirement::None;

1
compiler/rustc_hir/src/lib.rs
View file

@ -4,7 +4,6 @@
#![feature(associated_type_defaults)] #![feature(associated_type_defaults)]
#![feature(closure_track_caller)] #![feature(closure_track_caller)]
#![feature(const_btree_len)]
#![feature(let_chains)] #![feature(let_chains)]
#![feature(min_specialization)] #![feature(min_specialization)]
#![feature(never_type)] #![feature(never_type)]

17
compiler/rustc_middle/src/arena.rs
View file

@ -27,19 +27,12 @@ macro_rules! arena_types {
rustc_middle::mir::Promoted, rustc_middle::mir::Promoted,
rustc_middle::mir::Body<'tcx> rustc_middle::mir::Body<'tcx>
>, >,
[decode] closure_debuginfo:
rustc_index::IndexVec<
rustc_target::abi::FieldIdx,
rustc_span::symbol::Symbol,
>,
[decode] typeck_results: rustc_middle::ty::TypeckResults<'tcx>, [decode] typeck_results: rustc_middle::ty::TypeckResults<'tcx>,
[decode] borrowck_result: [decode] borrowck_result: rustc_middle::mir::BorrowCheckResult<'tcx>,
rustc_middle::mir::BorrowCheckResult<'tcx>,
[] resolver: rustc_data_structures::steal::Steal<( [] resolver: rustc_data_structures::steal::Steal<(
rustc_middle::ty::ResolverAstLowering, rustc_middle::ty::ResolverAstLowering,
rustc_data_structures::sync::Lrc<rustc_ast::Crate>, rustc_data_structures::sync::Lrc<rustc_ast::Crate>,
)>, )>,
[] output_filenames: std::sync::Arc<rustc_session::config::OutputFilenames>,
[] crate_for_resolver: rustc_data_structures::steal::Steal<(rustc_ast::Crate, rustc_ast::AttrVec)>, [] crate_for_resolver: rustc_data_structures::steal::Steal<(rustc_ast::Crate, rustc_ast::AttrVec)>,
[] resolutions: rustc_middle::ty::ResolverGlobalCtxt, [] resolutions: rustc_middle::ty::ResolverGlobalCtxt,
[decode] unsafety_check_result: rustc_middle::mir::UnsafetyCheckResult, [decode] unsafety_check_result: rustc_middle::mir::UnsafetyCheckResult,
@ -91,21 +84,16 @@ macro_rules! arena_types {
rustc_middle::infer::canonical::Canonical<'tcx, rustc_middle::infer::canonical::Canonical<'tcx,
rustc_middle::infer::canonical::QueryResponse<'tcx, rustc_middle::ty::Ty<'tcx>> rustc_middle::infer::canonical::QueryResponse<'tcx, rustc_middle::ty::Ty<'tcx>>
>, >,
[] all_traits: Vec<rustc_hir::def_id::DefId>,
[] effective_visibilities: rustc_middle::middle::privacy::EffectiveVisibilities, [] effective_visibilities: rustc_middle::middle::privacy::EffectiveVisibilities,
[] foreign_module: rustc_session::cstore::ForeignModule,
[] foreign_modules: Vec<rustc_session::cstore::ForeignModule>,
[] upvars_mentioned: rustc_data_structures::fx::FxIndexMap<rustc_hir::HirId, rustc_hir::Upvar>, [] upvars_mentioned: rustc_data_structures::fx::FxIndexMap<rustc_hir::HirId, rustc_hir::Upvar>,
[] object_safety_violations: rustc_middle::traits::ObjectSafetyViolation, [] object_safety_violations: rustc_middle::traits::ObjectSafetyViolation,
[] codegen_unit: rustc_middle::mir::mono::CodegenUnit<'tcx>, [] codegen_unit: rustc_middle::mir::mono::CodegenUnit<'tcx>,
[decode] attribute: rustc_ast::Attribute, [decode] attribute: rustc_ast::Attribute,
[] name_set: rustc_data_structures::unord::UnordSet<rustc_span::symbol::Symbol>, [] name_set: rustc_data_structures::unord::UnordSet<rustc_span::symbol::Symbol>,
[] ordered_name_set: rustc_data_structures::fx::FxIndexSet<rustc_span::symbol::Symbol>, [] ordered_name_set: rustc_data_structures::fx::FxIndexSet<rustc_span::symbol::Symbol>,
[] hir_id_set: rustc_hir::HirIdSet,
// Interned types // Interned types
[] tys: rustc_type_ir::WithCachedTypeInfo<rustc_middle::ty::TyKind<'tcx>>, [] tys: rustc_type_ir::WithCachedTypeInfo<rustc_middle::ty::TyKind<'tcx>>,
[] predicates: rustc_type_ir::WithCachedTypeInfo<rustc_middle::ty::PredicateKind<'tcx>>,
[] consts: rustc_middle::ty::ConstData<'tcx>, [] consts: rustc_middle::ty::ConstData<'tcx>,
// Note that this deliberately duplicates items in the `rustc_hir::arena`, // Note that this deliberately duplicates items in the `rustc_hir::arena`,
@ -113,7 +101,6 @@ macro_rules! arena_types {
// (during lowering) and the `librustc_middle` arena (for decoding MIR) // (during lowering) and the `librustc_middle` arena (for decoding MIR)
[decode] asm_template: rustc_ast::InlineAsmTemplatePiece, [decode] asm_template: rustc_ast::InlineAsmTemplatePiece,
[decode] used_trait_imports: rustc_data_structures::unord::UnordSet<rustc_hir::def_id::LocalDefId>, [decode] used_trait_imports: rustc_data_structures::unord::UnordSet<rustc_hir::def_id::LocalDefId>,
[decode] registered_tools: rustc_middle::ty::RegisteredTools,
[decode] is_late_bound_map: rustc_data_structures::fx::FxIndexSet<rustc_hir::ItemLocalId>, [decode] is_late_bound_map: rustc_data_structures::fx::FxIndexSet<rustc_hir::ItemLocalId>,
[decode] impl_source: rustc_middle::traits::ImplSource<'tcx, ()>, [decode] impl_source: rustc_middle::traits::ImplSource<'tcx, ()>,
@ -124,11 +111,9 @@ macro_rules! arena_types {
rustc_hir::def_id::DefId, rustc_hir::def_id::DefId,
rustc_middle::ty::EarlyBinder<rustc_middle::ty::Ty<'tcx>> rustc_middle::ty::EarlyBinder<rustc_middle::ty::Ty<'tcx>>
>, >,
[] bit_set_u32: rustc_index::bit_set::BitSet<u32>,
[] external_constraints: rustc_middle::traits::solve::ExternalConstraintsData<'tcx>, [] external_constraints: rustc_middle::traits::solve::ExternalConstraintsData<'tcx>,
[] predefined_opaques_in_body: rustc_middle::traits::solve::PredefinedOpaquesData<'tcx>, [] predefined_opaques_in_body: rustc_middle::traits::solve::PredefinedOpaquesData<'tcx>,
[decode] doc_link_resolutions: rustc_hir::def::DocLinkResMap, [decode] doc_link_resolutions: rustc_hir::def::DocLinkResMap,
[] closure_kind_origin: (rustc_span::Span, rustc_middle::hir::place::Place<'tcx>),
[] stripped_cfg_items: rustc_ast::expand::StrippedCfgItem, [] stripped_cfg_items: rustc_ast::expand::StrippedCfgItem,
[] mod_child: rustc_middle::metadata::ModChild, [] mod_child: rustc_middle::metadata::ModChild,
[] features: rustc_feature::Features, [] features: rustc_feature::Features,

2
compiler/rustc_trait_selection/src/traits/coherence.rs
View file

@ -1010,7 +1010,7 @@ impl<'a, 'tcx> ProofTreeVisitor<'tcx> for AmbiguityCausesVisitor<'a> {
let Goal { param_env, predicate } = goal.goal(); let Goal { param_env, predicate } = goal.goal();
// For bound predicates we simply call `infcx.replace_bound_vars_with_placeholders` // For bound predicates we simply call `infcx.instantiate_binder_with_placeholders`
// and then prove the resulting predicate as a nested goal. // and then prove the resulting predicate as a nested goal.
let trait_ref = match predicate.kind().no_bound_vars() { let trait_ref = match predicate.kind().no_bound_vars() {
Some(ty::PredicateKind::Clause(ty::ClauseKind::Trait(tr))) => tr.trait_ref, Some(ty::PredicateKind::Clause(ty::ClauseKind::Trait(tr))) => tr.trait_ref,

2
compiler/rustc_ty_utils/src/abi.rs
View file

@ -16,7 +16,7 @@ use rustc_target::spec::abi::Abi as SpecAbi;
use std::iter; use std::iter;
pub fn provide(providers: &mut Providers) { pub(crate) fn provide(providers: &mut Providers) {
*providers = Providers { fn_abi_of_fn_ptr, fn_abi_of_instance, ..*providers }; *providers = Providers { fn_abi_of_fn_ptr, fn_abi_of_instance, ..*providers };
} }

2
compiler/rustc_ty_utils/src/assoc.rs
View file

@ -8,7 +8,7 @@ use rustc_middle::query::Providers;
use rustc_middle::ty::{self, GenericArgs, ImplTraitInTraitData, Ty, TyCtxt}; use rustc_middle::ty::{self, GenericArgs, ImplTraitInTraitData, Ty, TyCtxt};
use rustc_span::symbol::kw; use rustc_span::symbol::kw;
pub fn provide(providers: &mut Providers) { pub(crate) fn provide(providers: &mut Providers) {
*providers = Providers { *providers = Providers {
associated_item, associated_item,
associated_item_def_ids, associated_item_def_ids,

6
compiler/rustc_ty_utils/src/consts.rs
View file

@ -17,7 +17,7 @@ use crate::errors::{GenericConstantTooComplex, GenericConstantTooComplexSub};
/// Destructures array, ADT or tuple constants into the constants /// Destructures array, ADT or tuple constants into the constants
/// of their fields. /// of their fields.
pub(crate) fn destructure_const<'tcx>( fn destructure_const<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
const_: ty::Const<'tcx>, const_: ty::Const<'tcx>,
) -> ty::DestructuredConst<'tcx> { ) -> ty::DestructuredConst<'tcx> {
@ -396,7 +396,7 @@ impl<'a, 'tcx> visit::Visitor<'a, 'tcx> for IsThirPolymorphic<'a, 'tcx> {
} }
/// Builds an abstract const, do not use this directly, but use `AbstractConst::new` instead. /// Builds an abstract const, do not use this directly, but use `AbstractConst::new` instead.
pub fn thir_abstract_const( fn thir_abstract_const(
tcx: TyCtxt<'_>, tcx: TyCtxt<'_>,
def: LocalDefId, def: LocalDefId,
) -> Result<Option<ty::EarlyBinder<ty::Const<'_>>>, ErrorGuaranteed> { ) -> Result<Option<ty::EarlyBinder<ty::Const<'_>>>, ErrorGuaranteed> {
@ -428,6 +428,6 @@ pub fn thir_abstract_const(
Ok(Some(ty::EarlyBinder::bind(recurse_build(tcx, body, body_id, root_span)?))) Ok(Some(ty::EarlyBinder::bind(recurse_build(tcx, body, body_id, root_span)?)))
} }
pub fn provide(providers: &mut Providers) { pub(crate) fn provide(providers: &mut Providers) {
*providers = Providers { destructure_const, thir_abstract_const, ..*providers }; *providers = Providers { destructure_const, thir_abstract_const, ..*providers };
} }

2
compiler/rustc_ty_utils/src/implied_bounds.rs
View file

@ -7,7 +7,7 @@ use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_span::Span; use rustc_span::Span;
use std::iter; use std::iter;
pub fn provide(providers: &mut Providers) { pub(crate) fn provide(providers: &mut Providers) {
*providers = Providers { *providers = Providers {
assumed_wf_types, assumed_wf_types,
assumed_wf_types_for_rpitit: |tcx, def_id| { assumed_wf_types_for_rpitit: |tcx, def_id| {

4
compiler/rustc_ty_utils/src/instance.rs
View file

@ -61,7 +61,7 @@ fn resolve_instance<'tcx>(
Ok(Some(Instance { def, args })) Ok(Some(Instance { def, args }))
}; };
debug!("inner_resolve_instance: result={:?}", result); debug!("resolve_instance: result={:?}", result);
result result
} }
@ -328,6 +328,6 @@ fn resolve_associated_item<'tcx>(
}) })
} }
pub fn provide(providers: &mut Providers) { pub(crate) fn provide(providers: &mut Providers) {
*providers = Providers { resolve_instance, ..*providers }; *providers = Providers { resolve_instance, ..*providers };
} }

22
compiler/rustc_ty_utils/src/layout.rs
View file

@ -24,7 +24,7 @@ use crate::errors::{
}; };
use crate::layout_sanity_check::sanity_check_layout; use crate::layout_sanity_check::sanity_check_layout;
pub fn provide(providers: &mut Providers) { pub(crate) fn provide(providers: &mut Providers) {
*providers = Providers { layout_of, ..*providers }; *providers = Providers { layout_of, ..*providers };
} }
@ -65,7 +65,11 @@ fn layout_of<'tcx>(
let layout = layout_of_uncached(&cx, ty)?; let layout = layout_of_uncached(&cx, ty)?;
let layout = TyAndLayout { ty, layout }; let layout = TyAndLayout { ty, layout };
record_layout_for_printing(&cx, layout); // If we are running with `-Zprint-type-sizes`, maybe record layouts
// for dumping later.
if cx.tcx.sess.opts.unstable_opts.print_type_sizes {
record_layout_for_printing(&cx, layout);
}
sanity_check_layout(&cx, &layout); sanity_check_layout(&cx, &layout);
@ -911,21 +915,7 @@ fn coroutine_layout<'tcx>(
Ok(layout) Ok(layout)
} }
/// This is invoked by the `layout_of` query to record the final
/// layout of each type.
#[inline(always)]
fn record_layout_for_printing<'tcx>(cx: &LayoutCx<'tcx, TyCtxt<'tcx>>, layout: TyAndLayout<'tcx>) { fn record_layout_for_printing<'tcx>(cx: &LayoutCx<'tcx, TyCtxt<'tcx>>, layout: TyAndLayout<'tcx>) {
// If we are running with `-Zprint-type-sizes`, maybe record layouts
// for dumping later.
if cx.tcx.sess.opts.unstable_opts.print_type_sizes {
record_layout_for_printing_outlined(cx, layout)
}
}
fn record_layout_for_printing_outlined<'tcx>(
cx: &LayoutCx<'tcx, TyCtxt<'tcx>>,
layout: TyAndLayout<'tcx>,
) {
// Ignore layouts that are done with non-empty environments or // Ignore layouts that are done with non-empty environments or
// non-monomorphic layouts, as the user only wants to see the stuff // non-monomorphic layouts, as the user only wants to see the stuff
// resulting from the final codegen session. // resulting from the final codegen session.

10
compiler/rustc_ty_utils/src/lib.rs
View file

@ -10,11 +10,11 @@
#![allow(internal_features)] #![allow(internal_features)]
#![feature(assert_matches)] #![feature(assert_matches)]
#![feature(associated_type_defaults)] #![feature(associated_type_defaults)]
#![feature(box_patterns)]
#![feature(if_let_guard)]
#![feature(iterator_try_collect)] #![feature(iterator_try_collect)]
#![feature(let_chains)] #![feature(let_chains)]
#![feature(if_let_guard)]
#![feature(never_type)] #![feature(never_type)]
#![feature(box_patterns)]
#![recursion_limit = "256"] #![recursion_limit = "256"]
#![deny(rustc::untranslatable_diagnostic)] #![deny(rustc::untranslatable_diagnostic)]
#![deny(rustc::diagnostic_outside_of_impl)] #![deny(rustc::diagnostic_outside_of_impl)]
@ -34,13 +34,13 @@ mod common_traits;
mod consts; mod consts;
mod errors; mod errors;
mod implied_bounds; mod implied_bounds;
pub mod instance; mod instance;
mod layout; mod layout;
mod layout_sanity_check; mod layout_sanity_check;
mod needs_drop; mod needs_drop;
mod opaque_types; mod opaque_types;
pub mod representability; mod representability;
pub mod sig_types; mod sig_types;
mod structural_match; mod structural_match;
mod ty; mod ty;

2
compiler/rustc_ty_utils/src/representability.rs
View file

@ -6,7 +6,7 @@ use rustc_middle::query::Providers;
use rustc_middle::ty::{self, Representability, Ty, TyCtxt}; use rustc_middle::ty::{self, Representability, Ty, TyCtxt};
use rustc_span::def_id::LocalDefId; use rustc_span::def_id::LocalDefId;
pub fn provide(providers: &mut Providers) { pub(crate) fn provide(providers: &mut Providers) {
*providers = *providers =
Providers { representability, representability_adt_ty, params_in_repr, ..*providers }; Providers { representability, representability_adt_ty, params_in_repr, ..*providers };
} }

4
compiler/rustc_ty_utils/src/sig_types.rs
View file

@ -8,7 +8,7 @@ use rustc_middle::ty::TyCtxt;
use rustc_span::Span; use rustc_span::Span;
use rustc_type_ir::visit::TypeVisitable; use rustc_type_ir::visit::TypeVisitable;
pub trait SpannedTypeVisitor<'tcx> { pub(crate) trait SpannedTypeVisitor<'tcx> {
type BreakTy = !; type BreakTy = !;
fn visit( fn visit(
&mut self, &mut self,
@ -17,7 +17,7 @@ pub trait SpannedTypeVisitor<'tcx> {
) -> ControlFlow<Self::BreakTy>; ) -> ControlFlow<Self::BreakTy>;
} }
pub fn walk_types<'tcx, V: SpannedTypeVisitor<'tcx>>( pub(crate) fn walk_types<'tcx, V: SpannedTypeVisitor<'tcx>>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
item: LocalDefId, item: LocalDefId,
visitor: &mut V, visitor: &mut V,

2
compiler/rustc_ty_utils/src/structural_match.rs
View file

@ -39,6 +39,6 @@ fn has_structural_eq_impls<'tcx>(tcx: TyCtxt<'tcx>, adt_ty: Ty<'tcx>) -> bool {
ocx.select_all_or_error().is_empty() ocx.select_all_or_error().is_empty()
} }
pub fn provide(providers: &mut Providers) { pub(crate) fn provide(providers: &mut Providers) {
providers.has_structural_eq_impls = has_structural_eq_impls; providers.has_structural_eq_impls = has_structural_eq_impls;
} }

2
compiler/rustc_ty_utils/src/ty.rs
View file

@ -351,7 +351,7 @@ fn unsizing_params_for_adt<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> BitSet<u32
unsizing_params unsizing_params
} }
pub fn provide(providers: &mut Providers) { pub(crate) fn provide(providers: &mut Providers) {
*providers = Providers { *providers = Providers {
asyncness, asyncness,
adt_sized_constraint, adt_sized_constraint,

23
library/alloc/src/vec/spec_from_elem.rs
View file

@ -36,12 +36,12 @@ impl SpecFromElem for i8 {
if elem == 0 { if elem == 0 {
return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n }; return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n };
} }
let mut v = Vec::with_capacity_in(n, alloc);
unsafe { unsafe {
let mut v = Vec::with_capacity_in(n, alloc);
ptr::write_bytes(v.as_mut_ptr(), elem as u8, n); ptr::write_bytes(v.as_mut_ptr(), elem as u8, n);
v.set_len(n); v.set_len(n);
v
} }
v
} }
} }
@ -51,11 +51,26 @@ impl SpecFromElem for u8 {
if elem == 0 { if elem == 0 {
return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n }; return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n };
} }
let mut v = Vec::with_capacity_in(n, alloc);
unsafe { unsafe {
let mut v = Vec::with_capacity_in(n, alloc);
ptr::write_bytes(v.as_mut_ptr(), elem, n); ptr::write_bytes(v.as_mut_ptr(), elem, n);
v.set_len(n); v.set_len(n);
v
} }
v
}
}
// A better way would be to implement this for all ZSTs which are `Copy` and have trivial `Clone`
// but the latter cannot be detected currently
impl SpecFromElem for () {
#[inline]
fn from_elem<A: Allocator>(_elem: (), n: usize, alloc: A) -> Vec<(), A> {
let mut v = Vec::with_capacity_in(n, alloc);
// SAFETY: the capacity has just been set to `n`
// and `()` is a ZST with trivial `Clone` implementation
unsafe {
v.set_len(n);
}
v
} }
} }

2
library/std/src/sys/unix/thread_local_dtor.rs
View file

@ -23,6 +23,8 @@ pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
/// This is necessary because the __cxa_thread_atexit_impl implementation /// This is necessary because the __cxa_thread_atexit_impl implementation
/// std links to by default may be a C or C++ implementation that was not /// std links to by default may be a C or C++ implementation that was not
/// compiled using the Clang integer normalization option. /// compiled using the Clang integer normalization option.
#[cfg(sanitizer_cfi_normalize_integers)]
use core::ffi::c_int;
#[cfg(not(sanitizer_cfi_normalize_integers))] #[cfg(not(sanitizer_cfi_normalize_integers))]
#[cfi_encoding = "i"] #[cfi_encoding = "i"]
#[repr(transparent)] #[repr(transparent)]

5
src/bootstrap/src/core/build_steps/test.rs
View file

@ -1932,6 +1932,11 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
} }
} }
} }
// Some UI tests trigger behavior in rustc where it reads $CARGO and changes behavior if it exists.
// To make the tests work that rely on it not being set, make sure it is not set.
cmd.env_remove("CARGO");
cmd.env("RUSTC_BOOTSTRAP", "1"); cmd.env("RUSTC_BOOTSTRAP", "1");
// Override the rustc version used in symbol hashes to reduce the amount of normalization // Override the rustc version used in symbol hashes to reduce the amount of normalization
// needed when diffing test output. // needed when diffing test output.

2
src/doc/book

@ -1 +1 @@
Subproject commit 5b6c1ceaa62ecbd6caef08df39b33b3938e99deb Subproject commit 71352deb20727b4dda9ebfe8182709d5bf17dfea

2
src/doc/rust-by-example

@ -1 +1 @@
Subproject commit 311b84962016b28c75525c86e7b3f49fd9101a39 Subproject commit a6581246f96837113968c02187db24f742af3908

2
src/doc/rustc-dev-guide

@ -1 +1 @@
Subproject commit 77dbe5782b2488af3bb489ad702eaff438f465bf Subproject commit ddb8b1309f9e905804cea1e248a4572fed6b464b