mirror of
https://github.com/rust-lang/rust.git
synced 2024-10-31 06:22:00 +00:00
XSimplifiedType to SimplifiedType::X
This commit is contained in:
parent
c67cb3e577
commit
fdaec57a28
@ -568,10 +568,10 @@ fn fast_reject_auto_impl<'tcx>(tcx: TyCtxt<'tcx>, trait_def_id: DefId, self_ty:
|
||||
|
||||
impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for DisableAutoTraitVisitor<'tcx> {
|
||||
type BreakTy = ();
|
||||
fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
|
||||
fn visit_ty(&mut self, ty: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
|
||||
let tcx = self.tcx;
|
||||
if t != self.self_ty_root {
|
||||
for impl_def_id in tcx.non_blanket_impls_for_ty(self.trait_def_id, t) {
|
||||
if ty != self.self_ty_root {
|
||||
for impl_def_id in tcx.non_blanket_impls_for_ty(self.trait_def_id, ty) {
|
||||
match tcx.impl_polarity(impl_def_id) {
|
||||
ImplPolarity::Negative => return ControlFlow::Break(()),
|
||||
ImplPolarity::Reservation => {}
|
||||
@ -584,7 +584,7 @@ fn fast_reject_auto_impl<'tcx>(tcx: TyCtxt<'tcx>, trait_def_id: DefId, self_ty:
|
||||
}
|
||||
}
|
||||
|
||||
match t.kind() {
|
||||
match ty.kind() {
|
||||
ty::Adt(def, args) if def.is_phantom_data() => args.visit_with(self),
|
||||
ty::Adt(def, args) => {
|
||||
// @lcnr: This is the only place where cycles can happen. We avoid this
|
||||
@ -599,7 +599,7 @@ fn fast_reject_auto_impl<'tcx>(tcx: TyCtxt<'tcx>, trait_def_id: DefId, self_ty:
|
||||
|
||||
ControlFlow::Continue(())
|
||||
}
|
||||
_ => t.super_visit_with(self),
|
||||
_ => ty.super_visit_with(self),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -6,35 +6,33 @@ use std::fmt::Debug;
|
||||
use std::hash::Hash;
|
||||
use std::iter;
|
||||
|
||||
use self::SimplifiedType::*;
|
||||
|
||||
/// See `simplify_type`.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable, HashStable)]
|
||||
pub enum SimplifiedType {
|
||||
BoolSimplifiedType,
|
||||
CharSimplifiedType,
|
||||
IntSimplifiedType(ty::IntTy),
|
||||
UintSimplifiedType(ty::UintTy),
|
||||
FloatSimplifiedType(ty::FloatTy),
|
||||
AdtSimplifiedType(DefId),
|
||||
ForeignSimplifiedType(DefId),
|
||||
StrSimplifiedType,
|
||||
ArraySimplifiedType,
|
||||
SliceSimplifiedType,
|
||||
RefSimplifiedType(Mutability),
|
||||
PtrSimplifiedType(Mutability),
|
||||
NeverSimplifiedType,
|
||||
TupleSimplifiedType(usize),
|
||||
Bool,
|
||||
Char,
|
||||
Int(ty::IntTy),
|
||||
Uint(ty::UintTy),
|
||||
Float(ty::FloatTy),
|
||||
Adt(DefId),
|
||||
Foreign(DefId),
|
||||
Str,
|
||||
Array,
|
||||
Slice,
|
||||
Ref(Mutability),
|
||||
Ptr(Mutability),
|
||||
Never,
|
||||
Tuple(usize),
|
||||
/// A trait object, all of whose components are markers
|
||||
/// (e.g., `dyn Send + Sync`).
|
||||
MarkerTraitObjectSimplifiedType,
|
||||
TraitSimplifiedType(DefId),
|
||||
ClosureSimplifiedType(DefId),
|
||||
GeneratorSimplifiedType(DefId),
|
||||
GeneratorWitnessSimplifiedType(usize),
|
||||
GeneratorWitnessMIRSimplifiedType(DefId),
|
||||
FunctionSimplifiedType(usize),
|
||||
PlaceholderSimplifiedType,
|
||||
MarkerTraitObject,
|
||||
Trait(DefId),
|
||||
Closure(DefId),
|
||||
Generator(DefId),
|
||||
GeneratorWitness(usize),
|
||||
GeneratorWitnessMIR(DefId),
|
||||
Function(usize),
|
||||
Placeholder,
|
||||
}
|
||||
|
||||
/// Generic parameters are pretty much just bound variables, e.g.
|
||||
@ -110,34 +108,36 @@ pub fn simplify_type<'tcx>(
|
||||
treat_params: TreatParams,
|
||||
) -> Option<SimplifiedType> {
|
||||
match *ty.kind() {
|
||||
ty::Bool => Some(BoolSimplifiedType),
|
||||
ty::Char => Some(CharSimplifiedType),
|
||||
ty::Int(int_type) => Some(IntSimplifiedType(int_type)),
|
||||
ty::Uint(uint_type) => Some(UintSimplifiedType(uint_type)),
|
||||
ty::Float(float_type) => Some(FloatSimplifiedType(float_type)),
|
||||
ty::Adt(def, _) => Some(AdtSimplifiedType(def.did())),
|
||||
ty::Str => Some(StrSimplifiedType),
|
||||
ty::Array(..) => Some(ArraySimplifiedType),
|
||||
ty::Slice(..) => Some(SliceSimplifiedType),
|
||||
ty::RawPtr(ptr) => Some(PtrSimplifiedType(ptr.mutbl)),
|
||||
ty::Bool => Some(SimplifiedType::Bool),
|
||||
ty::Char => Some(SimplifiedType::Char),
|
||||
ty::Int(int_type) => Some(SimplifiedType::Int(int_type)),
|
||||
ty::Uint(uint_type) => Some(SimplifiedType::Uint(uint_type)),
|
||||
ty::Float(float_type) => Some(SimplifiedType::Float(float_type)),
|
||||
ty::Adt(def, _) => Some(SimplifiedType::Adt(def.did())),
|
||||
ty::Str => Some(SimplifiedType::Str),
|
||||
ty::Array(..) => Some(SimplifiedType::Array),
|
||||
ty::Slice(..) => Some(SimplifiedType::Slice),
|
||||
ty::RawPtr(ptr) => Some(SimplifiedType::Ptr(ptr.mutbl)),
|
||||
ty::Dynamic(trait_info, ..) => match trait_info.principal_def_id() {
|
||||
Some(principal_def_id) if !tcx.trait_is_auto(principal_def_id) => {
|
||||
Some(TraitSimplifiedType(principal_def_id))
|
||||
Some(SimplifiedType::Trait(principal_def_id))
|
||||
}
|
||||
_ => Some(MarkerTraitObjectSimplifiedType),
|
||||
_ => Some(SimplifiedType::MarkerTraitObject),
|
||||
},
|
||||
ty::Ref(_, _, mutbl) => Some(RefSimplifiedType(mutbl)),
|
||||
ty::FnDef(def_id, _) | ty::Closure(def_id, _) => Some(ClosureSimplifiedType(def_id)),
|
||||
ty::Generator(def_id, _, _) => Some(GeneratorSimplifiedType(def_id)),
|
||||
ty::GeneratorWitness(tys) => Some(GeneratorWitnessSimplifiedType(tys.skip_binder().len())),
|
||||
ty::GeneratorWitnessMIR(def_id, _) => Some(GeneratorWitnessMIRSimplifiedType(def_id)),
|
||||
ty::Never => Some(NeverSimplifiedType),
|
||||
ty::Tuple(tys) => Some(TupleSimplifiedType(tys.len())),
|
||||
ty::FnPtr(f) => Some(FunctionSimplifiedType(f.skip_binder().inputs().len())),
|
||||
ty::Placeholder(..) => Some(PlaceholderSimplifiedType),
|
||||
ty::Ref(_, _, mutbl) => Some(SimplifiedType::Ref(mutbl)),
|
||||
ty::FnDef(def_id, _) | ty::Closure(def_id, _) => Some(SimplifiedType::Closure(def_id)),
|
||||
ty::Generator(def_id, _, _) => Some(SimplifiedType::Generator(def_id)),
|
||||
ty::GeneratorWitness(tys) => {
|
||||
Some(SimplifiedType::GeneratorWitness(tys.skip_binder().len()))
|
||||
}
|
||||
ty::GeneratorWitnessMIR(def_id, _) => Some(SimplifiedType::GeneratorWitnessMIR(def_id)),
|
||||
ty::Never => Some(SimplifiedType::Never),
|
||||
ty::Tuple(tys) => Some(SimplifiedType::Tuple(tys.len())),
|
||||
ty::FnPtr(f) => Some(SimplifiedType::Function(f.skip_binder().inputs().len())),
|
||||
ty::Placeholder(..) => Some(SimplifiedType::Placeholder),
|
||||
ty::Param(_) => match treat_params {
|
||||
TreatParams::ForLookup | TreatParams::NextSolverLookup => {
|
||||
Some(PlaceholderSimplifiedType)
|
||||
Some(SimplifiedType::Placeholder)
|
||||
}
|
||||
TreatParams::AsCandidateKey => None,
|
||||
},
|
||||
@ -147,11 +147,13 @@ pub fn simplify_type<'tcx>(
|
||||
//
|
||||
// We will have to be careful with lazy normalization here.
|
||||
// FIXME(lazy_normalization): This is probably not right...
|
||||
TreatParams::ForLookup if !ty.has_non_region_infer() => Some(PlaceholderSimplifiedType),
|
||||
TreatParams::NextSolverLookup => Some(PlaceholderSimplifiedType),
|
||||
TreatParams::ForLookup if !ty.has_non_region_infer() => {
|
||||
Some(SimplifiedType::Placeholder)
|
||||
}
|
||||
TreatParams::NextSolverLookup => Some(SimplifiedType::Placeholder),
|
||||
TreatParams::ForLookup | TreatParams::AsCandidateKey => None,
|
||||
},
|
||||
ty::Foreign(def_id) => Some(ForeignSimplifiedType(def_id)),
|
||||
ty::Foreign(def_id) => Some(SimplifiedType::Foreign(def_id)),
|
||||
ty::Bound(..) | ty::Infer(_) | ty::Error(_) => None,
|
||||
}
|
||||
}
|
||||
@ -159,12 +161,12 @@ pub fn simplify_type<'tcx>(
|
||||
impl SimplifiedType {
|
||||
pub fn def(self) -> Option<DefId> {
|
||||
match self {
|
||||
AdtSimplifiedType(d)
|
||||
| ForeignSimplifiedType(d)
|
||||
| TraitSimplifiedType(d)
|
||||
| ClosureSimplifiedType(d)
|
||||
| GeneratorSimplifiedType(d)
|
||||
| GeneratorWitnessMIRSimplifiedType(d) => Some(d),
|
||||
SimplifiedType::Adt(d)
|
||||
| SimplifiedType::Foreign(d)
|
||||
| SimplifiedType::Trait(d)
|
||||
| SimplifiedType::Closure(d)
|
||||
| SimplifiedType::Generator(d)
|
||||
| SimplifiedType::GeneratorWitnessMIR(d) => Some(d),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
@ -686,7 +686,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
|
||||
| ty::Tuple(_)
|
||||
| ty::Adt(_, _)
|
||||
// FIXME: Handling opaques here is kinda sus. Especially because we
|
||||
// simplify them to PlaceholderSimplifiedType.
|
||||
// simplify them to SimplifiedType::Placeholder.
|
||||
| ty::Alias(ty::Opaque, _) => {
|
||||
let mut disqualifying_impl = None;
|
||||
self.tcx().for_each_relevant_impl_treating_projections(
|
||||
|
@ -12,6 +12,7 @@ use rustc_hir::def::{DefKind, Res};
|
||||
use rustc_hir::def_id::{DefId, DefIdSet, LocalDefId};
|
||||
use rustc_hir::Mutability;
|
||||
use rustc_metadata::creader::{CStore, LoadedMacro};
|
||||
use rustc_middle::ty::fast_reject::SimplifiedType;
|
||||
use rustc_middle::ty::{self, TyCtxt};
|
||||
use rustc_span::hygiene::MacroKind;
|
||||
use rustc_span::symbol::{kw, sym, Symbol};
|
||||
@ -314,9 +315,8 @@ pub(crate) fn build_impls(
|
||||
// * https://github.com/rust-lang/rust/pull/99917 — where the feature got used
|
||||
// * https://github.com/rust-lang/rust/issues/53487 — overall tracking issue for Error
|
||||
if tcx.has_attr(did, sym::rustc_has_incoherent_inherent_impls) {
|
||||
use rustc_middle::ty::fast_reject::SimplifiedType::*;
|
||||
let type_ =
|
||||
if tcx.is_trait(did) { TraitSimplifiedType(did) } else { AdtSimplifiedType(did) };
|
||||
if tcx.is_trait(did) { SimplifiedType::Trait(did) } else { SimplifiedType::Adt(did) };
|
||||
for &did in tcx.incoherent_impls(type_) {
|
||||
build_impl(cx, did, attrs, ret);
|
||||
}
|
||||
|
@ -1776,7 +1776,6 @@ impl PrimitiveType {
|
||||
}
|
||||
|
||||
pub(crate) fn simplified_types() -> &'static SimplifiedTypes {
|
||||
use ty::fast_reject::SimplifiedType::*;
|
||||
use ty::{FloatTy, IntTy, UintTy};
|
||||
use PrimitiveType::*;
|
||||
static CELL: OnceCell<SimplifiedTypes> = OnceCell::new();
|
||||
@ -1784,38 +1783,38 @@ impl PrimitiveType {
|
||||
let single = |x| iter::once(x).collect();
|
||||
CELL.get_or_init(move || {
|
||||
map! {
|
||||
Isize => single(IntSimplifiedType(IntTy::Isize)),
|
||||
I8 => single(IntSimplifiedType(IntTy::I8)),
|
||||
I16 => single(IntSimplifiedType(IntTy::I16)),
|
||||
I32 => single(IntSimplifiedType(IntTy::I32)),
|
||||
I64 => single(IntSimplifiedType(IntTy::I64)),
|
||||
I128 => single(IntSimplifiedType(IntTy::I128)),
|
||||
Usize => single(UintSimplifiedType(UintTy::Usize)),
|
||||
U8 => single(UintSimplifiedType(UintTy::U8)),
|
||||
U16 => single(UintSimplifiedType(UintTy::U16)),
|
||||
U32 => single(UintSimplifiedType(UintTy::U32)),
|
||||
U64 => single(UintSimplifiedType(UintTy::U64)),
|
||||
U128 => single(UintSimplifiedType(UintTy::U128)),
|
||||
F32 => single(FloatSimplifiedType(FloatTy::F32)),
|
||||
F64 => single(FloatSimplifiedType(FloatTy::F64)),
|
||||
Str => single(StrSimplifiedType),
|
||||
Bool => single(BoolSimplifiedType),
|
||||
Char => single(CharSimplifiedType),
|
||||
Array => single(ArraySimplifiedType),
|
||||
Slice => single(SliceSimplifiedType),
|
||||
Isize => single(SimplifiedType::Int(IntTy::Isize)),
|
||||
I8 => single(SimplifiedType::Int(IntTy::I8)),
|
||||
I16 => single(SimplifiedType::Int(IntTy::I16)),
|
||||
I32 => single(SimplifiedType::Int(IntTy::I32)),
|
||||
I64 => single(SimplifiedType::Int(IntTy::I64)),
|
||||
I128 => single(SimplifiedType::Int(IntTy::I128)),
|
||||
Usize => single(SimplifiedType::Uint(UintTy::Usize)),
|
||||
U8 => single(SimplifiedType::Uint(UintTy::U8)),
|
||||
U16 => single(SimplifiedType::Uint(UintTy::U16)),
|
||||
U32 => single(SimplifiedType::Uint(UintTy::U32)),
|
||||
U64 => single(SimplifiedType::Uint(UintTy::U64)),
|
||||
U128 => single(SimplifiedType::Uint(UintTy::U128)),
|
||||
F32 => single(SimplifiedType::Float(FloatTy::F32)),
|
||||
F64 => single(SimplifiedType::Float(FloatTy::F64)),
|
||||
Str => single(SimplifiedType::Str),
|
||||
Bool => single(SimplifiedType::Bool),
|
||||
Char => single(SimplifiedType::Char),
|
||||
Array => single(SimplifiedType::Array),
|
||||
Slice => single(SimplifiedType::Slice),
|
||||
// FIXME: If we ever add an inherent impl for tuples
|
||||
// with different lengths, they won't show in rustdoc.
|
||||
//
|
||||
// Either manually update this arrayvec at this point
|
||||
// or start with a more complex refactoring.
|
||||
Tuple => [TupleSimplifiedType(1), TupleSimplifiedType(2), TupleSimplifiedType(3)].into(),
|
||||
Unit => single(TupleSimplifiedType(0)),
|
||||
RawPointer => [PtrSimplifiedType(Mutability::Not), PtrSimplifiedType(Mutability::Mut)].into_iter().collect(),
|
||||
Reference => [RefSimplifiedType(Mutability::Not), RefSimplifiedType(Mutability::Mut)].into_iter().collect(),
|
||||
Tuple => [SimplifiedType::Tuple(1), SimplifiedType::Tuple(2), SimplifiedType::Tuple(3)].into(),
|
||||
Unit => single(SimplifiedType::Tuple(0)),
|
||||
RawPointer => [SimplifiedType::Ptr(Mutability::Not), SimplifiedType::Ptr(Mutability::Mut)].into_iter().collect(),
|
||||
Reference => [SimplifiedType::Ref(Mutability::Not), SimplifiedType::Ref(Mutability::Mut)].into_iter().collect(),
|
||||
// FIXME: This will be wrong if we ever add inherent impls
|
||||
// for function pointers.
|
||||
Fn => single(FunctionSimplifiedType(1)),
|
||||
Never => single(NeverSimplifiedType),
|
||||
Fn => single(SimplifiedType::Function(1)),
|
||||
Never => single(SimplifiedType::Never),
|
||||
}
|
||||
})
|
||||
}
|
||||
|
@ -74,10 +74,10 @@ pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
|
||||
let lang_items = cx.tcx.lang_items();
|
||||
// This list isn't complete, but good enough for our current list of paths.
|
||||
let incoherent_impls = [
|
||||
SimplifiedType::FloatSimplifiedType(FloatTy::F32),
|
||||
SimplifiedType::FloatSimplifiedType(FloatTy::F64),
|
||||
SimplifiedType::SliceSimplifiedType,
|
||||
SimplifiedType::StrSimplifiedType,
|
||||
SimplifiedType::Float(FloatTy::F32),
|
||||
SimplifiedType::Float(FloatTy::F64),
|
||||
SimplifiedType::Slice,
|
||||
SimplifiedType::Str,
|
||||
]
|
||||
.iter()
|
||||
.flat_map(|&ty| cx.tcx.incoherent_impls(ty).iter().copied());
|
||||
|
@ -100,10 +100,7 @@ use rustc_middle::mir::ConstantKind;
|
||||
use rustc_middle::ty as rustc_ty;
|
||||
use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
|
||||
use rustc_middle::ty::binding::BindingMode;
|
||||
use rustc_middle::ty::fast_reject::SimplifiedType::{
|
||||
ArraySimplifiedType, BoolSimplifiedType, CharSimplifiedType, FloatSimplifiedType, IntSimplifiedType,
|
||||
PtrSimplifiedType, SliceSimplifiedType, StrSimplifiedType, UintSimplifiedType,
|
||||
};
|
||||
use rustc_middle::ty::fast_reject::SimplifiedType;
|
||||
use rustc_middle::ty::layout::IntegerExt;
|
||||
use rustc_middle::ty::{
|
||||
BorrowKind, ClosureKind, FloatTy, IntTy, Ty, TyCtxt, TypeAndMut, TypeVisitableExt, UintTy, UpvarCapture,
|
||||
@ -512,30 +509,30 @@ pub fn path_def_id<'tcx>(cx: &LateContext<'_>, maybe_path: &impl MaybePath<'tcx>
|
||||
|
||||
fn find_primitive_impls<'tcx>(tcx: TyCtxt<'tcx>, name: &str) -> impl Iterator<Item = DefId> + 'tcx {
|
||||
let ty = match name {
|
||||
"bool" => BoolSimplifiedType,
|
||||
"char" => CharSimplifiedType,
|
||||
"str" => StrSimplifiedType,
|
||||
"array" => ArraySimplifiedType,
|
||||
"slice" => SliceSimplifiedType,
|
||||
"bool" => SimplifiedType::Bool,
|
||||
"char" => SimplifiedType::Char,
|
||||
"str" => SimplifiedType::Str,
|
||||
"array" => SimplifiedType::Array,
|
||||
"slice" => SimplifiedType::Slice,
|
||||
// FIXME: rustdoc documents these two using just `pointer`.
|
||||
//
|
||||
// Maybe this is something we should do here too.
|
||||
"const_ptr" => PtrSimplifiedType(Mutability::Not),
|
||||
"mut_ptr" => PtrSimplifiedType(Mutability::Mut),
|
||||
"isize" => IntSimplifiedType(IntTy::Isize),
|
||||
"i8" => IntSimplifiedType(IntTy::I8),
|
||||
"i16" => IntSimplifiedType(IntTy::I16),
|
||||
"i32" => IntSimplifiedType(IntTy::I32),
|
||||
"i64" => IntSimplifiedType(IntTy::I64),
|
||||
"i128" => IntSimplifiedType(IntTy::I128),
|
||||
"usize" => UintSimplifiedType(UintTy::Usize),
|
||||
"u8" => UintSimplifiedType(UintTy::U8),
|
||||
"u16" => UintSimplifiedType(UintTy::U16),
|
||||
"u32" => UintSimplifiedType(UintTy::U32),
|
||||
"u64" => UintSimplifiedType(UintTy::U64),
|
||||
"u128" => UintSimplifiedType(UintTy::U128),
|
||||
"f32" => FloatSimplifiedType(FloatTy::F32),
|
||||
"f64" => FloatSimplifiedType(FloatTy::F64),
|
||||
"const_ptr" => SimplifiedType::Ptr(Mutability::Not),
|
||||
"mut_ptr" => SimplifiedType::Ptr(Mutability::Mut),
|
||||
"isize" => SimplifiedType::Int(IntTy::Isize),
|
||||
"i8" => SimplifiedType::Int(IntTy::I8),
|
||||
"i16" => SimplifiedType::Int(IntTy::I16),
|
||||
"i32" => SimplifiedType::Int(IntTy::I32),
|
||||
"i64" => SimplifiedType::Int(IntTy::I64),
|
||||
"i128" => SimplifiedType::Int(IntTy::I128),
|
||||
"usize" => SimplifiedType::Uint(UintTy::Usize),
|
||||
"u8" => SimplifiedType::Uint(UintTy::U8),
|
||||
"u16" => SimplifiedType::Uint(UintTy::U16),
|
||||
"u32" => SimplifiedType::Uint(UintTy::U32),
|
||||
"u64" => SimplifiedType::Uint(UintTy::U64),
|
||||
"u128" => SimplifiedType::Uint(UintTy::U128),
|
||||
"f32" => SimplifiedType::Float(FloatTy::F32),
|
||||
"f64" => SimplifiedType::Float(FloatTy::F64),
|
||||
_ => return [].iter().copied(),
|
||||
};
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user