bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

XSimplifiedType to SimplifiedType::X

Browse source
This commit is contained in:
lcnr 2023-07-18 17:03:22 +02:00
parent c67cb3e577
commit fdaec57a28
7 changed files with 116 additions and 118 deletions
Download patch file Download diff file Expand all files Collapse all files

10
compiler/rustc_hir_analysis/src/coherence/orphan.rs
View file

@ -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> { impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for DisableAutoTraitVisitor<'tcx> {
type BreakTy = (); 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; let tcx = self.tcx;
if t != self.self_ty_root { if ty != self.self_ty_root {
for impl_def_id in tcx.non_blanket_impls_for_ty(self.trait_def_id, t) { for impl_def_id in tcx.non_blanket_impls_for_ty(self.trait_def_id, ty) {
match tcx.impl_polarity(impl_def_id) { match tcx.impl_polarity(impl_def_id) {
ImplPolarity::Negative => return ControlFlow::Break(()), ImplPolarity::Negative => return ControlFlow::Break(()),
ImplPolarity::Reservation => {} 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) if def.is_phantom_data() => args.visit_with(self),
ty::Adt(def, args) => { ty::Adt(def, args) => {
// @lcnr: This is the only place where cycles can happen. We avoid this // @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(()) ControlFlow::Continue(())
} }
_ => t.super_visit_with(self), _ => ty.super_visit_with(self),
} }
} }
} }

112
compiler/rustc_middle/src/ty/fast_reject.rs
View file

@ -6,35 +6,33 @@ use std::fmt::Debug;
use std::hash::Hash; use std::hash::Hash;
use std::iter; use std::iter;
use self::SimplifiedType::*;
/// See `simplify_type`. /// See `simplify_type`.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable, HashStable)] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable, HashStable)]
pub enum SimplifiedType { pub enum SimplifiedType {
BoolSimplifiedType, Bool,
CharSimplifiedType, Char,
IntSimplifiedType(ty::IntTy), Int(ty::IntTy),
UintSimplifiedType(ty::UintTy), Uint(ty::UintTy),
FloatSimplifiedType(ty::FloatTy), Float(ty::FloatTy),
AdtSimplifiedType(DefId), Adt(DefId),
ForeignSimplifiedType(DefId), Foreign(DefId),
StrSimplifiedType, Str,
ArraySimplifiedType, Array,
SliceSimplifiedType, Slice,
RefSimplifiedType(Mutability), Ref(Mutability),
PtrSimplifiedType(Mutability), Ptr(Mutability),
NeverSimplifiedType, Never,
TupleSimplifiedType(usize), Tuple(usize),
/// A trait object, all of whose components are markers /// A trait object, all of whose components are markers
/// (e.g., `dyn Send + Sync`). /// (e.g., `dyn Send + Sync`).
MarkerTraitObjectSimplifiedType, MarkerTraitObject,
TraitSimplifiedType(DefId), Trait(DefId),
ClosureSimplifiedType(DefId), Closure(DefId),
GeneratorSimplifiedType(DefId), Generator(DefId),
GeneratorWitnessSimplifiedType(usize), GeneratorWitness(usize),
GeneratorWitnessMIRSimplifiedType(DefId), GeneratorWitnessMIR(DefId),
FunctionSimplifiedType(usize), Function(usize),
PlaceholderSimplifiedType, Placeholder,
} }
/// Generic parameters are pretty much just bound variables, e.g. /// Generic parameters are pretty much just bound variables, e.g.
@ -110,34 +108,36 @@ pub fn simplify_type<'tcx>(
treat_params: TreatParams, treat_params: TreatParams,
) -> Option<SimplifiedType> { ) -> Option<SimplifiedType> {
match *ty.kind() { match *ty.kind() {
ty::Bool => Some(BoolSimplifiedType), ty::Bool => Some(SimplifiedType::Bool),
ty::Char => Some(CharSimplifiedType), ty::Char => Some(SimplifiedType::Char),
ty::Int(int_type) => Some(IntSimplifiedType(int_type)), ty::Int(int_type) => Some(SimplifiedType::Int(int_type)),
ty::Uint(uint_type) => Some(UintSimplifiedType(uint_type)), ty::Uint(uint_type) => Some(SimplifiedType::Uint(uint_type)),
ty::Float(float_type) => Some(FloatSimplifiedType(float_type)), ty::Float(float_type) => Some(SimplifiedType::Float(float_type)),
ty::Adt(def, _) => Some(AdtSimplifiedType(def.did())), ty::Adt(def, _) => Some(SimplifiedType::Adt(def.did())),
ty::Str => Some(StrSimplifiedType), ty::Str => Some(SimplifiedType::Str),
ty::Array(..) => Some(ArraySimplifiedType), ty::Array(..) => Some(SimplifiedType::Array),
ty::Slice(..) => Some(SliceSimplifiedType), ty::Slice(..) => Some(SimplifiedType::Slice),
ty::RawPtr(ptr) => Some(PtrSimplifiedType(ptr.mutbl)), ty::RawPtr(ptr) => Some(SimplifiedType::Ptr(ptr.mutbl)),
ty::Dynamic(trait_info, ..) => match trait_info.principal_def_id() { ty::Dynamic(trait_info, ..) => match trait_info.principal_def_id() {
Some(principal_def_id) if !tcx.trait_is_auto(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::Ref(_, _, mutbl) => Some(SimplifiedType::Ref(mutbl)),
ty::FnDef(def_id, _) | ty::Closure(def_id, _) => Some(ClosureSimplifiedType(def_id)), ty::FnDef(def_id, _) | ty::Closure(def_id, _) => Some(SimplifiedType::Closure(def_id)),
ty::Generator(def_id, _, _) => Some(GeneratorSimplifiedType(def_id)), ty::Generator(def_id, _, _) => Some(SimplifiedType::Generator(def_id)),
ty::GeneratorWitness(tys) => Some(GeneratorWitnessSimplifiedType(tys.skip_binder().len())), ty::GeneratorWitness(tys) => {
ty::GeneratorWitnessMIR(def_id, _) => Some(GeneratorWitnessMIRSimplifiedType(def_id)), Some(SimplifiedType::GeneratorWitness(tys.skip_binder().len()))
ty::Never => Some(NeverSimplifiedType), }
ty::Tuple(tys) => Some(TupleSimplifiedType(tys.len())), ty::GeneratorWitnessMIR(def_id, _) => Some(SimplifiedType::GeneratorWitnessMIR(def_id)),
ty::FnPtr(f) => Some(FunctionSimplifiedType(f.skip_binder().inputs().len())), ty::Never => Some(SimplifiedType::Never),
ty::Placeholder(..) => Some(PlaceholderSimplifiedType), 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 { ty::Param(_) => match treat_params {
TreatParams::ForLookup | TreatParams::NextSolverLookup => { TreatParams::ForLookup | TreatParams::NextSolverLookup => {
Some(PlaceholderSimplifiedType) Some(SimplifiedType::Placeholder)
} }
TreatParams::AsCandidateKey => None, TreatParams::AsCandidateKey => None,
}, },
@ -147,11 +147,13 @@ pub fn simplify_type<'tcx>(
// //
// We will have to be careful with lazy normalization here. // We will have to be careful with lazy normalization here.
// FIXME(lazy_normalization): This is probably not right... // FIXME(lazy_normalization): This is probably not right...
TreatParams::ForLookup if !ty.has_non_region_infer() => Some(PlaceholderSimplifiedType), TreatParams::ForLookup if !ty.has_non_region_infer() => {
TreatParams::NextSolverLookup => Some(PlaceholderSimplifiedType), Some(SimplifiedType::Placeholder)
}
TreatParams::NextSolverLookup => Some(SimplifiedType::Placeholder),
TreatParams::ForLookup | TreatParams::AsCandidateKey => None, 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, ty::Bound(..) | ty::Infer(_) | ty::Error(_) => None,
} }
} }
@ -159,12 +161,12 @@ pub fn simplify_type<'tcx>(
impl SimplifiedType { impl SimplifiedType {
pub fn def(self) -> Option<DefId> { pub fn def(self) -> Option<DefId> {
match self { match self {
AdtSimplifiedType(d) SimplifiedType::Adt(d)
| ForeignSimplifiedType(d) | SimplifiedType::Foreign(d)
| TraitSimplifiedType(d) | SimplifiedType::Trait(d)
| ClosureSimplifiedType(d) | SimplifiedType::Closure(d)
| GeneratorSimplifiedType(d) | SimplifiedType::Generator(d)
| GeneratorWitnessMIRSimplifiedType(d) => Some(d), | SimplifiedType::GeneratorWitnessMIR(d) => Some(d),
_ => None, _ => None,
} }
} }

2
compiler/rustc_trait_selection/src/solve/trait_goals.rs
View file

@ -686,7 +686,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
| ty::Tuple(_) | ty::Tuple(_)
| ty::Adt(_, _) | ty::Adt(_, _)
// FIXME: Handling opaques here is kinda sus. Especially because we // FIXME: Handling opaques here is kinda sus. Especially because we
// simplify them to PlaceholderSimplifiedType. // simplify them to SimplifiedType::Placeholder.
| ty::Alias(ty::Opaque, _) => { | ty::Alias(ty::Opaque, _) => {
let mut disqualifying_impl = None; let mut disqualifying_impl = None;
self.tcx().for_each_relevant_impl_treating_projections( self.tcx().for_each_relevant_impl_treating_projections(

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

@ -12,6 +12,7 @@ use rustc_hir::def::{DefKind, Res};
use rustc_hir::def_id::{DefId, DefIdSet, LocalDefId}; use rustc_hir::def_id::{DefId, DefIdSet, LocalDefId};
use rustc_hir::Mutability; use rustc_hir::Mutability;
use rustc_metadata::creader::{CStore, LoadedMacro}; use rustc_metadata::creader::{CStore, LoadedMacro};
use rustc_middle::ty::fast_reject::SimplifiedType;
use rustc_middle::ty::{self, TyCtxt}; use rustc_middle::ty::{self, TyCtxt};
use rustc_span::hygiene::MacroKind; use rustc_span::hygiene::MacroKind;
use rustc_span::symbol::{kw, sym, Symbol}; 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/pull/99917 — where the feature got used
// * https://github.com/rust-lang/rust/issues/53487 — overall tracking issue for Error // * https://github.com/rust-lang/rust/issues/53487 — overall tracking issue for Error
if tcx.has_attr(did, sym::rustc_has_incoherent_inherent_impls) { if tcx.has_attr(did, sym::rustc_has_incoherent_inherent_impls) {
use rustc_middle::ty::fast_reject::SimplifiedType::*;
let type_ = 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_) { for &did in tcx.incoherent_impls(type_) {
build_impl(cx, did, attrs, ret); build_impl(cx, did, attrs, ret);
} }

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

@ -1776,7 +1776,6 @@ impl PrimitiveType {
} }
pub(crate) fn simplified_types() -> &'static SimplifiedTypes { pub(crate) fn simplified_types() -> &'static SimplifiedTypes {
use ty::fast_reject::SimplifiedType::*;
use ty::{FloatTy, IntTy, UintTy}; use ty::{FloatTy, IntTy, UintTy};
use PrimitiveType::*; use PrimitiveType::*;
static CELL: OnceCell<SimplifiedTypes> = OnceCell::new(); static CELL: OnceCell<SimplifiedTypes> = OnceCell::new();
@ -1784,38 +1783,38 @@ impl PrimitiveType {
let single = |x| iter::once(x).collect(); let single = |x| iter::once(x).collect();
CELL.get_or_init(move || { CELL.get_or_init(move || {
map! { map! {
Isize => single(IntSimplifiedType(IntTy::Isize)), Isize => single(SimplifiedType::Int(IntTy::Isize)),
I8 => single(IntSimplifiedType(IntTy::I8)), I8 => single(SimplifiedType::Int(IntTy::I8)),
I16 => single(IntSimplifiedType(IntTy::I16)), I16 => single(SimplifiedType::Int(IntTy::I16)),
I32 => single(IntSimplifiedType(IntTy::I32)), I32 => single(SimplifiedType::Int(IntTy::I32)),
I64 => single(IntSimplifiedType(IntTy::I64)), I64 => single(SimplifiedType::Int(IntTy::I64)),
I128 => single(IntSimplifiedType(IntTy::I128)), I128 => single(SimplifiedType::Int(IntTy::I128)),
Usize => single(UintSimplifiedType(UintTy::Usize)), Usize => single(SimplifiedType::Uint(UintTy::Usize)),
U8 => single(UintSimplifiedType(UintTy::U8)), U8 => single(SimplifiedType::Uint(UintTy::U8)),
U16 => single(UintSimplifiedType(UintTy::U16)), U16 => single(SimplifiedType::Uint(UintTy::U16)),
U32 => single(UintSimplifiedType(UintTy::U32)), U32 => single(SimplifiedType::Uint(UintTy::U32)),
U64 => single(UintSimplifiedType(UintTy::U64)), U64 => single(SimplifiedType::Uint(UintTy::U64)),
U128 => single(UintSimplifiedType(UintTy::U128)), U128 => single(SimplifiedType::Uint(UintTy::U128)),
F32 => single(FloatSimplifiedType(FloatTy::F32)), F32 => single(SimplifiedType::Float(FloatTy::F32)),
F64 => single(FloatSimplifiedType(FloatTy::F64)), F64 => single(SimplifiedType::Float(FloatTy::F64)),
Str => single(StrSimplifiedType), Str => single(SimplifiedType::Str),
Bool => single(BoolSimplifiedType), Bool => single(SimplifiedType::Bool),
Char => single(CharSimplifiedType), Char => single(SimplifiedType::Char),
Array => single(ArraySimplifiedType), Array => single(SimplifiedType::Array),
Slice => single(SliceSimplifiedType), Slice => single(SimplifiedType::Slice),
// FIXME: If we ever add an inherent impl for tuples // FIXME: If we ever add an inherent impl for tuples
// with different lengths, they won't show in rustdoc. // with different lengths, they won't show in rustdoc.
// //
// Either manually update this arrayvec at this point // Either manually update this arrayvec at this point
// or start with a more complex refactoring. // or start with a more complex refactoring.
Tuple => [TupleSimplifiedType(1), TupleSimplifiedType(2), TupleSimplifiedType(3)].into(), Tuple => [SimplifiedType::Tuple(1), SimplifiedType::Tuple(2), SimplifiedType::Tuple(3)].into(),
Unit => single(TupleSimplifiedType(0)), Unit => single(SimplifiedType::Tuple(0)),
RawPointer => [PtrSimplifiedType(Mutability::Not), PtrSimplifiedType(Mutability::Mut)].into_iter().collect(), RawPointer => [SimplifiedType::Ptr(Mutability::Not), SimplifiedType::Ptr(Mutability::Mut)].into_iter().collect(),
Reference => [RefSimplifiedType(Mutability::Not), RefSimplifiedType(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 // FIXME: This will be wrong if we ever add inherent impls
// for function pointers. // for function pointers.
Fn => single(FunctionSimplifiedType(1)), Fn => single(SimplifiedType::Function(1)),
Never => single(NeverSimplifiedType), Never => single(SimplifiedType::Never),
} }
}) })
} }

8
src/tools/clippy/clippy_lints/src/utils/internal_lints/invalid_paths.rs
View file

@ -74,10 +74,10 @@ pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
let lang_items = cx.tcx.lang_items(); let lang_items = cx.tcx.lang_items();
// This list isn't complete, but good enough for our current list of paths. // This list isn't complete, but good enough for our current list of paths.
let incoherent_impls = [ let incoherent_impls = [
SimplifiedType::FloatSimplifiedType(FloatTy::F32), SimplifiedType::Float(FloatTy::F32),
SimplifiedType::FloatSimplifiedType(FloatTy::F64), SimplifiedType::Float(FloatTy::F64),
SimplifiedType::SliceSimplifiedType, SimplifiedType::Slice,
SimplifiedType::StrSimplifiedType, SimplifiedType::Str,
] ]
.iter() .iter()
.flat_map(|&ty| cx.tcx.incoherent_impls(ty).iter().copied()); .flat_map(|&ty| cx.tcx.incoherent_impls(ty).iter().copied());

47
src/tools/clippy/clippy_utils/src/lib.rs
View file

@ -100,10 +100,7 @@ use rustc_middle::mir::ConstantKind;
use rustc_middle::ty as rustc_ty; use rustc_middle::ty as rustc_ty;
use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow}; use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
use rustc_middle::ty::binding::BindingMode; use rustc_middle::ty::binding::BindingMode;
use rustc_middle::ty::fast_reject::SimplifiedType::{ use rustc_middle::ty::fast_reject::SimplifiedType;
ArraySimplifiedType, BoolSimplifiedType, CharSimplifiedType, FloatSimplifiedType, IntSimplifiedType,
PtrSimplifiedType, SliceSimplifiedType, StrSimplifiedType, UintSimplifiedType,
};
use rustc_middle::ty::layout::IntegerExt; use rustc_middle::ty::layout::IntegerExt;
use rustc_middle::ty::{ use rustc_middle::ty::{
BorrowKind, ClosureKind, FloatTy, IntTy, Ty, TyCtxt, TypeAndMut, TypeVisitableExt, UintTy, UpvarCapture, 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 { fn find_primitive_impls<'tcx>(tcx: TyCtxt<'tcx>, name: &str) -> impl Iterator<Item = DefId> + 'tcx {
let ty = match name { let ty = match name {
"bool" => BoolSimplifiedType, "bool" => SimplifiedType::Bool,
"char" => CharSimplifiedType, "char" => SimplifiedType::Char,
"str" => StrSimplifiedType, "str" => SimplifiedType::Str,
"array" => ArraySimplifiedType, "array" => SimplifiedType::Array,
"slice" => SliceSimplifiedType, "slice" => SimplifiedType::Slice,
// FIXME: rustdoc documents these two using just `pointer`. // FIXME: rustdoc documents these two using just `pointer`.
// //
// Maybe this is something we should do here too. // Maybe this is something we should do here too.
"const_ptr" => PtrSimplifiedType(Mutability::Not), "const_ptr" => SimplifiedType::Ptr(Mutability::Not),
"mut_ptr" => PtrSimplifiedType(Mutability::Mut), "mut_ptr" => SimplifiedType::Ptr(Mutability::Mut),
"isize" => IntSimplifiedType(IntTy::Isize), "isize" => SimplifiedType::Int(IntTy::Isize),
"i8" => IntSimplifiedType(IntTy::I8), "i8" => SimplifiedType::Int(IntTy::I8),
"i16" => IntSimplifiedType(IntTy::I16), "i16" => SimplifiedType::Int(IntTy::I16),
"i32" => IntSimplifiedType(IntTy::I32), "i32" => SimplifiedType::Int(IntTy::I32),
"i64" => IntSimplifiedType(IntTy::I64), "i64" => SimplifiedType::Int(IntTy::I64),
"i128" => IntSimplifiedType(IntTy::I128), "i128" => SimplifiedType::Int(IntTy::I128),
"usize" => UintSimplifiedType(UintTy::Usize), "usize" => SimplifiedType::Uint(UintTy::Usize),
"u8" => UintSimplifiedType(UintTy::U8), "u8" => SimplifiedType::Uint(UintTy::U8),
"u16" => UintSimplifiedType(UintTy::U16), "u16" => SimplifiedType::Uint(UintTy::U16),
"u32" => UintSimplifiedType(UintTy::U32), "u32" => SimplifiedType::Uint(UintTy::U32),
"u64" => UintSimplifiedType(UintTy::U64), "u64" => SimplifiedType::Uint(UintTy::U64),
"u128" => UintSimplifiedType(UintTy::U128), "u128" => SimplifiedType::Uint(UintTy::U128),
"f32" => FloatSimplifiedType(FloatTy::F32), "f32" => SimplifiedType::Float(FloatTy::F32),
"f64" => FloatSimplifiedType(FloatTy::F64), "f64" => SimplifiedType::Float(FloatTy::F64),
_ => return [].iter().copied(), _ => return [].iter().copied(),
}; };