user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rollup merge of #144713 - nnethercote:rustc_middle-ty-cleanups, r=lcnr

Browse source 
`rustc_middle::ty` cleanups

r? `@davidtwco`
This commit is contained in:
Stuart Cook 2025-07-31 18:52:11 +10:00 • committed by GitHub
commit 017586c93a
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
22 changed files with 141 additions and 149 deletions
Download patch file Download diff file Expand all files Collapse all files

4
compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs
View file

@ -277,7 +277,7 @@ where
// `QueryNormalizeExt::query_normalize` used in the query and `normalize` called below:
// the former fails to normalize the `nll/relate_tys/impl-fn-ignore-binder-via-bottom.rs`
// test. Check after #85499 lands to see if its fixes have erased this difference.
let (param_env, value) = key.into_parts();
let ty::ParamEnvAnd { param_env, value } = key;
let _ = ocx.normalize(&cause, param_env, value.value);
let diag = try_extract_error_from_fulfill_cx(
@ -324,7 +324,7 @@ where
mbcx.infcx.tcx.infer_ctxt().build_with_canonical(cause.span, &self.canonical_query);
let ocx = ObligationCtxt::new(&infcx);
let (param_env, value) = key.into_parts();
let ty::ParamEnvAnd { param_env, value } = key;
let _ = ocx.deeply_normalize(&cause, param_env, value.value);
let diag = try_extract_error_from_fulfill_cx(

3
compiler/rustc_hir_typeck/src/fallback.rs
View file

@ -18,6 +18,7 @@ use rustc_span::{DUMMY_SP, Span};
use rustc_trait_selection::traits::{ObligationCause, ObligationCtxt};
use tracing::debug;
use crate::typeck_root_ctxt::InferVarInfo;
use crate::{FnCtxt, errors};
#[derive(Copy, Clone)]
@ -345,7 +346,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
.map(|(_, info)| *info)
.collect();
let found_infer_var_info = ty::InferVarInfo {
let found_infer_var_info = InferVarInfo {
self_in_trait: infer_var_infos.items().any(|info| info.self_in_trait),
output: infer_var_infos.items().any(|info| info.output),
};

25
compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs
View file

@ -17,6 +17,21 @@ enum ClauseFlavor {
Const,
}
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
enum ParamTerm {
Ty(ty::ParamTy),
Const(ty::ParamConst),
}
impl ParamTerm {
fn index(self) -> usize {
match self {
ParamTerm::Ty(ty) => ty.index as usize,
ParamTerm::Const(ct) => ct.index as usize,
}
}
}
impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
pub(crate) fn adjust_fulfillment_error_for_expr_obligation(
&self,
@ -77,17 +92,17 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
_ => return false,
};
let find_param_matching = |matches: &dyn Fn(ty::ParamTerm) -> bool| {
let find_param_matching = |matches: &dyn Fn(ParamTerm) -> bool| {
predicate_args.iter().find_map(|arg| {
arg.walk().find_map(|arg| {
if let ty::GenericArgKind::Type(ty) = arg.kind()
&& let ty::Param(param_ty) = *ty.kind()
&& matches(ty::ParamTerm::Ty(param_ty))
&& matches(ParamTerm::Ty(param_ty))
{
Some(arg)
} else if let ty::GenericArgKind::Const(ct) = arg.kind()
&& let ty::ConstKind::Param(param_ct) = ct.kind()
&& matches(ty::ParamTerm::Const(param_ct))
&& matches(ParamTerm::Const(param_ct))
{
Some(arg)
} else {
@ -106,14 +121,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// from a trait or impl, for example.
let mut fallback_param_to_point_at = find_param_matching(&|param_term| {
self.tcx.parent(generics.param_at(param_term.index(), self.tcx).def_id) != def_id
&& !matches!(param_term, ty::ParamTerm::Ty(ty) if ty.name == kw::SelfUpper)
&& !matches!(param_term, ParamTerm::Ty(ty) if ty.name == kw::SelfUpper)
});
// Finally, the `Self` parameter is possibly the reason that the predicate
// is unsatisfied. This is less likely to be true for methods, because
// method probe means that we already kinda check that the predicates due
// to the `Self` type are true.
let mut self_param_to_point_at = find_param_matching(
&|param_term| matches!(param_term, ty::ParamTerm::Ty(ty) if ty.name == kw::SelfUpper),
&|param_term| matches!(param_term, ParamTerm::Ty(ty) if ty.name == kw::SelfUpper),
);
// Finally, for ambiguity-related errors, we actually want to look

15
compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs
View file

@ -17,6 +17,19 @@ use tracing::{debug, instrument};
use super::callee::DeferredCallResolution;
#[derive(Debug, Default, Copy, Clone)]
pub(crate) struct InferVarInfo {
/// This is true if we identified that this Ty (`?T`) is found in a `?T: Foo`
/// obligation, where:
///
/// * `Foo` is not `Sized`
/// * `(): Foo` may be satisfied
pub self_in_trait: bool,
/// This is true if we identified that this Ty (`?T`) is found in a `<_ as
/// _>::AssocType = ?T`
pub output: bool,
}
/// Data shared between a "typeck root" and its nested bodies,
/// e.g. closures defined within the function. For example:
/// ```ignore (illustrative)
@ -71,7 +84,7 @@ pub(crate) struct TypeckRootCtxt<'tcx> {
/// fallback. See the `fallback` module for details.
pub(super) diverging_type_vars: RefCell<UnordSet<Ty<'tcx>>>,
pub(super) infer_var_info: RefCell<UnordMap<ty::TyVid, ty::InferVarInfo>>,
pub(super) infer_var_info: RefCell<UnordMap<ty::TyVid, InferVarInfo>>,
}
impl<'tcx> Deref for TypeckRootCtxt<'tcx> {

2
compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
View file

@ -44,7 +44,7 @@ impl<'tcx> InferCtxt<'tcx> {
where
V: TypeFoldable<TyCtxt<'tcx>>,
{
let (param_env, value) = value.into_parts();
let ty::ParamEnvAnd { param_env, value } = value;
let canonical_param_env = self.tcx.canonical_param_env_cache.get_or_insert(
self.tcx,
param_env,

36
compiler/rustc_infer/src/infer/relate/generalize.rs
View file

@ -19,6 +19,24 @@ use crate::infer::type_variable::TypeVariableValue;
use crate::infer::unify_key::ConstVariableValue;
use crate::infer::{InferCtxt, RegionVariableOrigin, relate};
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
enum TermVid {
Ty(ty::TyVid),
Const(ty::ConstVid),
}
impl From<ty::TyVid> for TermVid {
fn from(value: ty::TyVid) -> Self {
TermVid::Ty(value)
}
}
impl From<ty::ConstVid> for TermVid {
fn from(value: ty::ConstVid) -> Self {
TermVid::Const(value)
}
}
impl<'tcx> InferCtxt<'tcx> {
/// The idea is that we should ensure that the type variable `target_vid`
/// is equal to, a subtype of, or a supertype of `source_ty`.
@ -238,20 +256,18 @@ impl<'tcx> InferCtxt<'tcx> {
&self,
span: Span,
structurally_relate_aliases: StructurallyRelateAliases,
target_vid: impl Into<ty::TermVid>,
target_vid: impl Into<TermVid>,
ambient_variance: ty::Variance,
source_term: T,
) -> RelateResult<'tcx, Generalization<T>> {
assert!(!source_term.has_escaping_bound_vars());
let (for_universe, root_vid) = match target_vid.into() {
ty::TermVid::Ty(ty_vid) => {
(self.probe_ty_var(ty_vid).unwrap_err(), ty::TermVid::Ty(self.root_var(ty_vid)))
TermVid::Ty(ty_vid) => {
(self.probe_ty_var(ty_vid).unwrap_err(), TermVid::Ty(self.root_var(ty_vid)))
}
ty::TermVid::Const(ct_vid) => (
TermVid::Const(ct_vid) => (
self.probe_const_var(ct_vid).unwrap_err(),
ty::TermVid::Const(
self.inner.borrow_mut().const_unification_table().find(ct_vid).vid,
),
TermVid::Const(self.inner.borrow_mut().const_unification_table().find(ct_vid).vid),
),
};
@ -299,7 +315,7 @@ struct Generalizer<'me, 'tcx> {
/// The vid of the type variable that is in the process of being
/// instantiated. If we find this within the value we are folding,
/// that means we would have created a cyclic value.
root_vid: ty::TermVid,
root_vid: TermVid,
/// The universe of the type variable that is in the process of being
/// instantiated. If we find anything that this universe cannot name,
@ -469,7 +485,7 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
ty::Infer(ty::TyVar(vid)) => {
let mut inner = self.infcx.inner.borrow_mut();
let vid = inner.type_variables().root_var(vid);
if ty::TermVid::Ty(vid) == self.root_vid {
if TermVid::Ty(vid) == self.root_vid {
// If sub-roots are equal, then `root_vid` and
// `vid` are related via subtyping.
Err(self.cyclic_term_error())
@ -621,7 +637,7 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
// If root const vids are equal, then `root_vid` and
// `vid` are related and we'd be inferring an infinitely
// deep const.
if ty::TermVid::Const(
if TermVid::Const(
self.infcx.inner.borrow_mut().const_unification_table().find(vid).vid,
) == self.root_vid
{

4
compiler/rustc_interface/src/passes.rs
View file

@ -29,7 +29,7 @@ use rustc_parse::{
new_parser_from_file, new_parser_from_source_str, unwrap_or_emit_fatal, validate_attr,
};
use rustc_passes::{abi_test, input_stats, layout_test};
use rustc_resolve::Resolver;
use rustc_resolve::{Resolver, ResolverOutputs};
use rustc_session::config::{CrateType, Input, OutFileName, OutputFilenames, OutputType};
use rustc_session::cstore::Untracked;
use rustc_session::output::{collect_crate_types, filename_for_input};
@ -793,7 +793,7 @@ fn resolver_for_lowering_raw<'tcx>(
// Make sure we don't mutate the cstore from here on.
tcx.untracked().cstore.freeze();
let ty::ResolverOutputs {
let ResolverOutputs {
global_ctxt: untracked_resolutions,
ast_lowering: untracked_resolver_for_lowering,
} = resolver.into_outputs();

3
compiler/rustc_middle/src/ty/codec.rs
View file

@ -510,12 +510,9 @@ impl_decodable_via_ref! {
&'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
&'tcx traits::ImplSource<'tcx, ()>,
&'tcx mir::Body<'tcx>,
&'tcx mir::ConcreteOpaqueTypes<'tcx>,
&'tcx ty::List<ty::BoundVariableKind>,
&'tcx ty::List<ty::Pattern<'tcx>>,
&'tcx ty::ListWithCachedTypeInfo<ty::Clause<'tcx>>,
&'tcx ty::List<FieldIdx>,
&'tcx ty::List<(VariantIdx, FieldIdx)>,
}
#[macro_export]

103
compiler/rustc_middle/src/ty/mod.rs
View file

@ -49,7 +49,7 @@ use rustc_serialize::{Decodable, Encodable};
use rustc_session::lint::LintBuffer;
pub use rustc_session::lint::RegisteredTools;
use rustc_span::hygiene::MacroKind;
use rustc_span::{DUMMY_SP, ExpnId, ExpnKind, Ident, Span, Symbol, kw, sym};
use rustc_span::{DUMMY_SP, ExpnId, ExpnKind, Ident, Span, Symbol, sym};
pub use rustc_type_ir::data_structures::{DelayedMap, DelayedSet};
pub use rustc_type_ir::fast_reject::DeepRejectCtxt;
#[allow(
@ -170,11 +170,6 @@ mod visit;
// Data types
pub struct ResolverOutputs {
pub global_ctxt: ResolverGlobalCtxt,
pub ast_lowering: ResolverAstLowering,
}
#[derive(Debug, HashStable)]
pub struct ResolverGlobalCtxt {
pub visibilities_for_hashing: Vec<(LocalDefId, Visibility)>,
@ -255,18 +250,6 @@ impl MainDefinition {
}
}
/// The "header" of an impl is everything outside the body: a Self type, a trait
/// ref (in the case of a trait impl), and a set of predicates (from the
/// bounds / where-clauses).
#[derive(Clone, Debug, TypeFoldable, TypeVisitable)]
pub struct ImplHeader<'tcx> {
pub impl_def_id: DefId,
pub impl_args: ty::GenericArgsRef<'tcx>,
pub self_ty: Ty<'tcx>,
pub trait_ref: Option<TraitRef<'tcx>>,
pub predicates: Vec<Predicate<'tcx>>,
}
#[derive(Copy, Clone, Debug, TyEncodable, TyDecodable, HashStable)]
pub struct ImplTraitHeader<'tcx> {
pub trait_ref: ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>,
@ -470,14 +453,6 @@ impl<'tcx> rustc_type_ir::Flags for Ty<'tcx> {
}
}
impl EarlyParamRegion {
/// Does this early bound region have a name? Early bound regions normally
/// always have names except when using anonymous lifetimes (`'_`).
pub fn is_named(&self) -> bool {
self.name != kw::UnderscoreLifetime
}
}
/// The crate outlives map is computed during typeck and contains the
/// outlives of every item in the local crate. You should not use it
/// directly, because to do so will make your pass dependent on the
@ -698,39 +673,6 @@ impl<'tcx> TermKind<'tcx> {
}
}
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum ParamTerm {
Ty(ParamTy),
Const(ParamConst),
}
impl ParamTerm {
pub fn index(self) -> usize {
match self {
ParamTerm::Ty(ty) => ty.index as usize,
ParamTerm::Const(ct) => ct.index as usize,
}
}
}
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
pub enum TermVid {
Ty(ty::TyVid),
Const(ty::ConstVid),
}
impl From<ty::TyVid> for TermVid {
fn from(value: ty::TyVid) -> Self {
TermVid::Ty(value)
}
}
impl From<ty::ConstVid> for TermVid {
fn from(value: ty::ConstVid) -> Self {
TermVid::Const(value)
}
}
/// Represents the bounds declared on a particular set of type
/// parameters. Should eventually be generalized into a flag list of
/// where-clauses. You can obtain an `InstantiatedPredicates` list from a
@ -1069,12 +1011,6 @@ pub struct ParamEnvAnd<'tcx, T> {
pub value: T,
}
impl<'tcx, T> ParamEnvAnd<'tcx, T> {
pub fn into_parts(self) -> (ParamEnv<'tcx>, T) {
(self.param_env, self.value)
}
}
/// The environment in which to do trait solving.
///
/// Most of the time you only need to care about the `ParamEnv`
@ -1770,15 +1706,6 @@ 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))
} else {
self.attrs_for_def(did)
}
}
/// Gets all attributes with the given name.
pub fn get_attrs(
self,
@ -1790,7 +1717,8 @@ impl<'tcx> TyCtxt<'tcx> {
/// Gets all attributes.
///
/// To see if an item has a specific attribute, you should use [`rustc_attr_data_structures::find_attr!`] so you can use matching.
/// To see if an item has a specific attribute, you should use
/// [`rustc_attr_data_structures::find_attr!`] so you can use matching.
pub fn get_all_attrs(self, did: impl Into<DefId>) -> &'tcx [hir::Attribute] {
let did: DefId = did.into();
if let Some(did) = did.as_local() {
@ -2304,34 +2232,9 @@ impl<'tcx> fmt::Debug for SymbolName<'tcx> {
}
}
#[derive(Debug, Default, Copy, Clone)]
pub struct InferVarInfo {
/// This is true if we identified that this Ty (`?T`) is found in a `?T: Foo`
/// obligation, where:
///
/// * `Foo` is not `Sized`
/// * `(): Foo` may be satisfied
pub self_in_trait: bool,
/// This is true if we identified that this Ty (`?T`) is found in a `<_ as
/// _>::AssocType = ?T`
pub output: bool,
}
/// The constituent parts of a type level constant of kind ADT or array.
#[derive(Copy, Clone, Debug, HashStable)]
pub struct DestructuredConst<'tcx> {
pub variant: Option<VariantIdx>,
pub fields: &'tcx [ty::Const<'tcx>],
}
// Some types are used a lot. Make sure they don't unintentionally get bigger.
#[cfg(target_pointer_width = "64")]
mod size_asserts {
use rustc_data_structures::static_assert_size;
use super::*;
// tidy-alphabetical-start
static_assert_size!(PredicateKind<'_>, 32);
static_assert_size!(WithCachedTypeInfo<TyKind<'_>>, 48);
// tidy-alphabetical-end
}

12
compiler/rustc_middle/src/ty/predicate.rs
View file

@ -704,3 +704,15 @@ impl<'tcx> Predicate<'tcx> {
}
}
}
// Some types are used a lot. Make sure they don't unintentionally get bigger.
#[cfg(target_pointer_width = "64")]
mod size_asserts {
use rustc_data_structures::static_assert_size;
use super::*;
// tidy-alphabetical-start
static_assert_size!(PredicateKind<'_>, 32);
static_assert_size!(WithCachedTypeInfo<PredicateKind<'_>>, 56);
// tidy-alphabetical-end
}

20
compiler/rustc_middle/src/ty/region.rs
View file

@ -324,6 +324,14 @@ pub struct EarlyParamRegion {
pub name: Symbol,
}
impl EarlyParamRegion {
/// Does this early bound region have a name? Early bound regions normally
/// always have names except when using anonymous lifetimes (`'_`).
pub fn is_named(&self) -> bool {
self.name != kw::UnderscoreLifetime
}
}
impl rustc_type_ir::inherent::ParamLike for EarlyParamRegion {
fn index(self) -> u32 {
self.index
@ -487,3 +495,15 @@ impl BoundRegionKind {
}
}
}
// Some types are used a lot. Make sure they don't unintentionally get bigger.
#[cfg(target_pointer_width = "64")]
mod size_asserts {
use rustc_data_structures::static_assert_size;
use super::*;
// tidy-alphabetical-start
static_assert_size!(RegionKind<'_>, 20);
static_assert_size!(ty::WithCachedTypeInfo<RegionKind<'_>>, 48);
// tidy-alphabetical-end
}

4
compiler/rustc_middle/src/ty/sty.rs
View file

@ -2040,7 +2040,7 @@ mod size_asserts {
use super::*;
// tidy-alphabetical-start
static_assert_size!(ty::RegionKind<'_>, 20);
static_assert_size!(ty::TyKind<'_>, 24);
static_assert_size!(TyKind<'_>, 24);
static_assert_size!(ty::WithCachedTypeInfo<TyKind<'_>>, 48);
// tidy-alphabetical-end
}

9
compiler/rustc_resolve/src/lib.rs
View file

@ -64,8 +64,8 @@ use rustc_middle::middle::privacy::EffectiveVisibilities;
use rustc_middle::query::Providers;
use rustc_middle::span_bug;
use rustc_middle::ty::{
self, DelegationFnSig, Feed, MainDefinition, RegisteredTools, ResolverGlobalCtxt,
ResolverOutputs, TyCtxt, TyCtxtFeed, Visibility,
self, DelegationFnSig, Feed, MainDefinition, RegisteredTools, ResolverAstLowering,
ResolverGlobalCtxt, TyCtxt, TyCtxtFeed, Visibility,
};
use rustc_query_system::ich::StableHashingContext;
use rustc_session::lint::builtin::PRIVATE_MACRO_USE;
@ -1037,6 +1037,11 @@ impl MacroData {
}
}
pub struct ResolverOutputs {
pub global_ctxt: ResolverGlobalCtxt,
pub ast_lowering: ResolverAstLowering,
}
/// The main resolver class.
///
/// This is the visitor that walks the whole crate.

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

@ -12,6 +12,7 @@ use rustc_hir::def::DefKind;
use rustc_hir::def_id::{CRATE_DEF_ID, DefId};
use rustc_infer::infer::{DefineOpaqueTypes, InferCtxt, TyCtxtInferExt};
use rustc_infer::traits::PredicateObligations;
use rustc_macros::{TypeFoldable, TypeVisitable};
use rustc_middle::bug;
use rustc_middle::traits::query::NoSolution;
use rustc_middle::traits::solve::{CandidateSource, Certainty, Goal};
@ -37,8 +38,20 @@ use crate::traits::{
SelectionContext, SkipLeakCheck, util,
};
/// The "header" of an impl is everything outside the body: a Self type, a trait
/// ref (in the case of a trait impl), and a set of predicates (from the
/// bounds / where-clauses).
#[derive(Clone, Debug, TypeFoldable, TypeVisitable)]
pub struct ImplHeader<'tcx> {
pub impl_def_id: DefId,
pub impl_args: ty::GenericArgsRef<'tcx>,
pub self_ty: Ty<'tcx>,
pub trait_ref: Option<ty::TraitRef<'tcx>>,
pub predicates: Vec<ty::Predicate<'tcx>>,
}
pub struct OverlapResult<'tcx> {
pub impl_header: ty::ImplHeader<'tcx>,
pub impl_header: ImplHeader<'tcx>,
pub intercrate_ambiguity_causes: FxIndexSet<IntercrateAmbiguityCause<'tcx>>,
/// `true` if the overlap might've been permitted before the shift
@ -151,11 +164,11 @@ pub fn overlapping_impls(
}
}
fn fresh_impl_header<'tcx>(infcx: &InferCtxt<'tcx>, impl_def_id: DefId) -> ty::ImplHeader<'tcx> {
fn fresh_impl_header<'tcx>(infcx: &InferCtxt<'tcx>, impl_def_id: DefId) -> ImplHeader<'tcx> {
let tcx = infcx.tcx;
let impl_args = infcx.fresh_args_for_item(DUMMY_SP, impl_def_id);
ty::ImplHeader {
ImplHeader {
impl_def_id,
impl_args,
self_ty: tcx.type_of(impl_def_id).instantiate(tcx, impl_args),
@ -173,7 +186,7 @@ fn fresh_impl_header_normalized<'tcx>(
infcx: &InferCtxt<'tcx>,
param_env: ty::ParamEnv<'tcx>,
impl_def_id: DefId,
) -> ty::ImplHeader<'tcx> {
) -> ImplHeader<'tcx> {
let header = fresh_impl_header(infcx, impl_def_id);
let InferOk { value: mut header, obligations } =
@ -287,8 +300,8 @@ fn overlap<'tcx>(
fn equate_impl_headers<'tcx>(
infcx: &InferCtxt<'tcx>,
param_env: ty::ParamEnv<'tcx>,
impl1: &ty::ImplHeader<'tcx>,
impl2: &ty::ImplHeader<'tcx>,
impl1: &ImplHeader<'tcx>,
impl2: &ImplHeader<'tcx>,
) -> Option<PredicateObligations<'tcx>> {
let result =
match (impl1.trait_ref, impl2.trait_ref) {

2
compiler/rustc_trait_selection/src/traits/query/type_op/ascribe_user_type.rs
View file

@ -44,7 +44,7 @@ pub fn type_op_ascribe_user_type_with_span<'tcx>(
key: ParamEnvAnd<'tcx, AscribeUserType<'tcx>>,
span: Span,
) -> Result<(), NoSolution> {
let (param_env, AscribeUserType { mir_ty, user_ty }) = key.into_parts();
let ty::ParamEnvAnd { param_env, value: AscribeUserType { mir_ty, user_ty } } = key;
debug!("type_op_ascribe_user_type: mir_ty={:?} user_ty={:?}", mir_ty, user_ty);
match user_ty.kind {
UserTypeKind::Ty(user_ty) => relate_mir_and_user_ty(ocx, param_env, span, mir_ty, user_ty)?,

4
compiler/rustc_traits/src/implied_outlives_bounds.rs
View file

@ -7,7 +7,7 @@ use rustc_infer::infer::canonical::{self, Canonical};
use rustc_infer::traits::query::OutlivesBound;
use rustc_infer::traits::query::type_op::ImpliedOutlivesBounds;
use rustc_middle::query::Providers;
use rustc_middle::ty::TyCtxt;
use rustc_middle::ty::{ParamEnvAnd, TyCtxt};
use rustc_span::DUMMY_SP;
use rustc_trait_selection::infer::InferCtxtBuilderExt;
use rustc_trait_selection::traits::query::type_op::implied_outlives_bounds::compute_implied_outlives_bounds_inner;
@ -25,7 +25,7 @@ fn implied_outlives_bounds<'tcx>(
NoSolution,
> {
tcx.infer_ctxt().enter_canonical_trait_query(&goal, |ocx, key| {
let (param_env, ImpliedOutlivesBounds { ty }) = key.into_parts();
let ParamEnvAnd { param_env, value: ImpliedOutlivesBounds { ty } } = key;
compute_implied_outlives_bounds_inner(
ocx,
param_env,

4
compiler/rustc_traits/src/type_op.rs
View file

@ -43,7 +43,7 @@ fn type_op_normalize<'tcx, T>(
where
T: fmt::Debug + TypeFoldable<TyCtxt<'tcx>>,
{
let (param_env, Normalize { value }) = key.into_parts();
let ParamEnvAnd { param_env, value: Normalize { value } } = key;
let Normalized { value, obligations } =
ocx.infcx.at(&ObligationCause::dummy(), param_env).query_normalize(value)?;
ocx.register_obligations(obligations);
@ -96,6 +96,6 @@ pub fn type_op_prove_predicate_with_cause<'tcx>(
key: ParamEnvAnd<'tcx, ProvePredicate<'tcx>>,
cause: ObligationCause<'tcx>,
) {
let (param_env, ProvePredicate { predicate }) = key.into_parts();
let ParamEnvAnd { param_env, value: ProvePredicate { predicate } } = key;
ocx.register_obligation(Obligation::new(ocx.infcx.tcx, cause, param_env, predicate));
}

2
src/librustdoc/clean/inline.rs
View file

@ -217,7 +217,7 @@ pub(crate) fn try_inline_glob(
}
pub(crate) fn load_attrs<'hir>(cx: &DocContext<'hir>, did: DefId) -> &'hir [hir::Attribute] {
cx.tcx.get_attrs_unchecked(did)
cx.tcx.get_all_attrs(did)
}
pub(crate) fn item_relative_path(tcx: TyCtxt<'_>, def_id: DefId) -> Vec<Symbol> {

7
src/librustdoc/clean/types.rs
View file

@ -404,10 +404,7 @@ impl Item {
}
pub(crate) fn inner_docs(&self, tcx: TyCtxt<'_>) -> bool {
self.item_id
.as_def_id()
.map(|did| inner_docs(tcx.get_attrs_unchecked(did)))
.unwrap_or(false)
self.item_id.as_def_id().map(|did| inner_docs(tcx.get_all_attrs(did))).unwrap_or(false)
}
pub(crate) fn span(&self, tcx: TyCtxt<'_>) -> Option<Span> {
@ -452,7 +449,7 @@ impl Item {
kind: ItemKind,
cx: &mut DocContext<'_>,
) -> Item {
let hir_attrs = cx.tcx.get_attrs_unchecked(def_id);
let hir_attrs = cx.tcx.get_all_attrs(def_id);
Self::from_def_id_and_attrs_and_parts(
def_id,

2
src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
View file

@ -185,7 +185,7 @@ impl<'a, 'tcx> SigDropChecker<'a, 'tcx> {
if let Some(adt) = ty.ty_adt_def()
&& get_attr(
self.cx.sess(),
self.cx.tcx.get_attrs_unchecked(adt.did()),
self.cx.tcx.get_all_attrs(adt.did()),
sym::has_significant_drop,
)
.count()

2
src/tools/clippy/clippy_lints/src/significant_drop_tightening.rs
View file

@ -168,7 +168,7 @@ impl<'cx, 'others, 'tcx> AttrChecker<'cx, 'others, 'tcx> {
if let Some(adt) = ty.ty_adt_def() {
let mut iter = get_attr(
self.cx.sess(),
self.cx.tcx.get_attrs_unchecked(adt.did()),
self.cx.tcx.get_all_attrs(adt.did()),
sym::has_significant_drop,
);
if iter.next().is_some() {

2
src/tools/clippy/clippy_utils/src/macros.rs
View file

@ -42,7 +42,7 @@ pub fn is_format_macro(cx: &LateContext<'_>, macro_def_id: DefId) -> bool {
} else {
// Allow users to tag any macro as being format!-like
// TODO: consider deleting FORMAT_MACRO_DIAG_ITEMS and using just this method
get_unique_attr(cx.sess(), cx.tcx.get_attrs_unchecked(macro_def_id), sym::format_args).is_some()
get_unique_attr(cx.sess(), cx.tcx.get_all_attrs(macro_def_id), sym::format_args).is_some()
}
}