Skip to content

Commit 98108dc

Browse files
borsbors
committed
Auto merge of #116993 - compiler-errors:clause-kind, r=jackh726
Uplift `ClauseKind` and `PredicateKind` into `rustc_type_ir` Uplift `ClauseKind` and `PredicateKind` into `rustc_type_ir`. Blocked on #116951 r? `@ghost`
2 parents 2e4e2a8 + 573f475 commit 98108dc

File tree

15 files changed

+735
-217
lines changed

15 files changed

+735
-217
lines changed

‎compiler/rustc_middle/src/ty/codec.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -230,9 +230,9 @@ impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<D>
230230
assert!(pos >= SHORTHAND_OFFSET);
231231
let shorthand = pos - SHORTHAND_OFFSET;
232232

233-
decoder.with_position(shorthand, ty::PredicateKind::decode)
233+
decoder.with_position(shorthand, <ty::PredicateKind<'tcx> as Decodable<D>>::decode)
234234
} else {
235-
ty::PredicateKind::decode(decoder)
235+
<ty::PredicateKind<'tcx> as Decodable<D>>::decode(decoder)
236236
},
237237
bound_vars,
238238
)

‎compiler/rustc_middle/src/ty/context.rs

+15-2
Original file line numberDiff line numberDiff line change
@@ -84,21 +84,24 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
8484
type AdtDef = ty::AdtDef<'tcx>;
8585
type GenericArgs = ty::GenericArgsRef<'tcx>;
8686
type GenericArg = ty::GenericArg<'tcx>;
87+
type Term = ty::Term<'tcx>;
88+
8789
type Binder<T> = Binder<'tcx, T>;
88-
type Predicate = Predicate<'tcx>;
89-
type PredicateKind = ty::PredicateKind<'tcx>;
9090
type TypeAndMut = TypeAndMut<'tcx>;
91+
9192
type Ty = Ty<'tcx>;
9293
type Tys = &'tcx List<Ty<'tcx>>;
9394
type AliasTy = ty::AliasTy<'tcx>;
9495
type ParamTy = ParamTy;
9596
type BoundTy = ty::BoundTy;
9697
type PlaceholderTy = ty::PlaceholderType;
9798
type InferTy = InferTy;
99+
98100
type ErrorGuaranteed = ErrorGuaranteed;
99101
type BoundExistentialPredicates = &'tcx List<PolyExistentialPredicate<'tcx>>;
100102
type PolyFnSig = PolyFnSig<'tcx>;
101103
type AllocId = crate::mir::interpret::AllocId;
104+
102105
type Const = ty::Const<'tcx>;
103106
type InferConst = ty::InferConst;
104107
type AliasConst = ty::UnevaluatedConst<'tcx>;
@@ -107,13 +110,23 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
107110
type BoundConst = ty::BoundVar;
108111
type ValueConst = ty::ValTree<'tcx>;
109112
type ExprConst = ty::Expr<'tcx>;
113+
110114
type Region = Region<'tcx>;
111115
type EarlyBoundRegion = ty::EarlyBoundRegion;
112116
type BoundRegion = ty::BoundRegion;
113117
type FreeRegion = ty::FreeRegion;
114118
type InferRegion = ty::RegionVid;
115119
type PlaceholderRegion = ty::PlaceholderRegion;
116120

121+
type Predicate = Predicate<'tcx>;
122+
type TraitPredicate = ty::TraitPredicate<'tcx>;
123+
type RegionOutlivesPredicate = ty::RegionOutlivesPredicate<'tcx>;
124+
type TypeOutlivesPredicate = ty::TypeOutlivesPredicate<'tcx>;
125+
type ProjectionPredicate = ty::ProjectionPredicate<'tcx>;
126+
type SubtypePredicate = ty::SubtypePredicate<'tcx>;
127+
type CoercePredicate = ty::CoercePredicate<'tcx>;
128+
type ClosureKind = ty::ClosureKind;
129+
117130
fn ty_and_mut_to_parts(
118131
TypeAndMut { ty, mutbl }: TypeAndMut<'tcx>,
119132
) -> (Self::Ty, ty::Mutability) {

‎compiler/rustc_middle/src/ty/mod.rs

+4-96
Original file line numberDiff line numberDiff line change
@@ -97,12 +97,12 @@ pub use self::rvalue_scopes::RvalueScopes;
9797
pub use self::sty::BoundRegionKind::*;
9898
pub use self::sty::{
9999
AliasTy, Article, Binder, BoundRegion, BoundRegionKind, BoundTy, BoundTyKind, BoundVar,
100-
BoundVariableKind, CanonicalPolyFnSig, ClosureArgs, ClosureArgsParts, ConstKind, ConstVid,
101-
CoroutineArgs, CoroutineArgsParts, EarlyBoundRegion, EffectVid, ExistentialPredicate,
100+
BoundVariableKind, CanonicalPolyFnSig, ClauseKind, ClosureArgs, ClosureArgsParts, ConstKind,
101+
ConstVid, CoroutineArgs, CoroutineArgsParts, EarlyBoundRegion, EffectVid, ExistentialPredicate,
102102
ExistentialProjection, ExistentialTraitRef, FnSig, FreeRegion, GenSig, InlineConstArgs,
103103
InlineConstArgsParts, ParamConst, ParamTy, PolyExistentialPredicate, PolyExistentialProjection,
104-
PolyExistentialTraitRef, PolyFnSig, PolyGenSig, PolyTraitRef, Region, RegionKind, RegionVid,
105-
TraitRef, TyKind, TypeAndMut, UpvarArgs, VarianceDiagInfo,
104+
PolyExistentialTraitRef, PolyFnSig, PolyGenSig, PolyTraitRef, PredicateKind, Region,
105+
RegionKind, RegionVid, TraitRef, TyKind, TypeAndMut, UpvarArgs, VarianceDiagInfo,
106106
};
107107
pub use self::trait_def::TraitDef;
108108
pub use self::typeck_results::{
@@ -626,98 +626,6 @@ impl<'tcx> Clause<'tcx> {
626626
}
627627
}
628628

629-
#[derive(Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
630-
#[derive(HashStable, TypeFoldable, TypeVisitable, Lift)]
631-
/// A clause is something that can appear in where bounds or be inferred
632-
/// by implied bounds.
633-
pub enum ClauseKind<'tcx> {
634-
/// Corresponds to `where Foo: Bar<A, B, C>`. `Foo` here would be
635-
/// the `Self` type of the trait reference and `A`, `B`, and `C`
636-
/// would be the type parameters.
637-
Trait(TraitPredicate<'tcx>),
638-
639-
/// `where 'a: 'b`
640-
RegionOutlives(RegionOutlivesPredicate<'tcx>),
641-
642-
/// `where T: 'a`
643-
TypeOutlives(TypeOutlivesPredicate<'tcx>),
644-
645-
/// `where <T as TraitRef>::Name == X`, approximately.
646-
/// See the `ProjectionPredicate` struct for details.
647-
Projection(ProjectionPredicate<'tcx>),
648-
649-
/// Ensures that a const generic argument to a parameter `const N: u8`
650-
/// is of type `u8`.
651-
ConstArgHasType(Const<'tcx>, Ty<'tcx>),
652-
653-
/// No syntax: `T` well-formed.
654-
WellFormed(GenericArg<'tcx>),
655-
656-
/// Constant initializer must evaluate successfully.
657-
ConstEvaluatable(ty::Const<'tcx>),
658-
}
659-
660-
#[derive(Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
661-
#[derive(HashStable, TypeFoldable, TypeVisitable, Lift)]
662-
pub enum PredicateKind<'tcx> {
663-
/// Prove a clause
664-
Clause(ClauseKind<'tcx>),
665-
666-
/// Trait must be object-safe.
667-
ObjectSafe(DefId),
668-
669-
/// No direct syntax. May be thought of as `where T: FnFoo<...>`
670-
/// for some generic args `...` and `T` being a closure type.
671-
/// Satisfied (or refuted) once we know the closure's kind.
672-
ClosureKind(DefId, GenericArgsRef<'tcx>, ClosureKind),
673-
674-
/// `T1 <: T2`
675-
///
676-
/// This obligation is created most often when we have two
677-
/// unresolved type variables and hence don't have enough
678-
/// information to process the subtyping obligation yet.
679-
Subtype(SubtypePredicate<'tcx>),
680-
681-
/// `T1` coerced to `T2`
682-
///
683-
/// Like a subtyping obligation, this is created most often
684-
/// when we have two unresolved type variables and hence
685-
/// don't have enough information to process the coercion
686-
/// obligation yet. At the moment, we actually process coercions
687-
/// very much like subtyping and don't handle the full coercion
688-
/// logic.
689-
Coerce(CoercePredicate<'tcx>),
690-
691-
/// Constants must be equal. The first component is the const that is expected.
692-
ConstEquate(Const<'tcx>, Const<'tcx>),
693-
694-
/// A marker predicate that is always ambiguous.
695-
/// Used for coherence to mark opaque types as possibly equal to each other but ambiguous.
696-
Ambiguous,
697-
698-
/// Separate from `ClauseKind::Projection` which is used for normalization in new solver.
699-
/// This predicate requires two terms to be equal to eachother.
700-
///
701-
/// Only used for new solver
702-
AliasRelate(Term<'tcx>, Term<'tcx>, AliasRelationDirection),
703-
}
704-
705-
#[derive(Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
706-
#[derive(HashStable, Debug)]
707-
pub enum AliasRelationDirection {
708-
Equate,
709-
Subtype,
710-
}
711-
712-
impl std::fmt::Display for AliasRelationDirection {
713-
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
714-
match self {
715-
AliasRelationDirection::Equate => write!(f, "=="),
716-
AliasRelationDirection::Subtype => write!(f, "<:"),
717-
}
718-
}
719-
}
720-
721629
/// The crate outlives map is computed during typeck and contains the
722630
/// outlives of every item in the local crate. You should not use it
723631
/// directly, because to do so will make your pass dependent on the

‎compiler/rustc_middle/src/ty/print/pretty.rs

+53-45
Original file line numberDiff line numberDiff line change
@@ -2649,6 +2649,13 @@ macro_rules! forward_display_to_print {
26492649
}
26502650

26512651
macro_rules! define_print_and_forward_display {
2652+
(($self:ident, $cx:ident): $($ty:ty $print:block)+) => {
2653+
define_print!(($self, $cx): $($ty $print)*);
2654+
forward_display_to_print!($($ty),+);
2655+
};
2656+
}
2657+
2658+
macro_rules! define_print {
26522659
(($self:ident, $cx:ident): $($ty:ty $print:block)+) => {
26532660
$(impl<'tcx, P: PrettyPrinter<'tcx>> Print<'tcx, P> for $ty {
26542661
fn print(&$self, $cx: &mut P) -> Result<(), PrintError> {
@@ -2660,8 +2667,6 @@ macro_rules! define_print_and_forward_display {
26602667
Ok(())
26612668
}
26622669
})+
2663-
2664-
forward_display_to_print!($($ty),+);
26652670
};
26662671
}
26672672

@@ -2759,6 +2764,51 @@ forward_display_to_print! {
27592764
ty::OutlivesPredicate<ty::Region<'tcx>, ty::Region<'tcx>>
27602765
}
27612766

2767+
define_print! {
2768+
(self, cx):
2769+
2770+
ty::ClauseKind<'tcx> {
2771+
match *self {
2772+
ty::ClauseKind::Trait(ref data) => {
2773+
p!(print(data))
2774+
}
2775+
ty::ClauseKind::RegionOutlives(predicate) => p!(print(predicate)),
2776+
ty::ClauseKind::TypeOutlives(predicate) => p!(print(predicate)),
2777+
ty::ClauseKind::Projection(predicate) => p!(print(predicate)),
2778+
ty::ClauseKind::ConstArgHasType(ct, ty) => {
2779+
p!("the constant `", print(ct), "` has type `", print(ty), "`")
2780+
},
2781+
ty::ClauseKind::WellFormed(arg) => p!(print(arg), " well-formed"),
2782+
ty::ClauseKind::ConstEvaluatable(ct) => {
2783+
p!("the constant `", print(ct), "` can be evaluated")
2784+
}
2785+
}
2786+
}
2787+
2788+
ty::PredicateKind<'tcx> {
2789+
match *self {
2790+
ty::PredicateKind::Clause(data) => {
2791+
p!(print(data))
2792+
}
2793+
ty::PredicateKind::Subtype(predicate) => p!(print(predicate)),
2794+
ty::PredicateKind::Coerce(predicate) => p!(print(predicate)),
2795+
ty::PredicateKind::ObjectSafe(trait_def_id) => {
2796+
p!("the trait `", print_def_path(trait_def_id, &[]), "` is object-safe")
2797+
}
2798+
ty::PredicateKind::ClosureKind(closure_def_id, _closure_args, kind) => p!(
2799+
"the closure `",
2800+
print_value_path(closure_def_id, &[]),
2801+
write("` implements the trait `{}`", kind)
2802+
),
2803+
ty::PredicateKind::ConstEquate(c1, c2) => {
2804+
p!("the constant `", print(c1), "` equals `", print(c2), "`")
2805+
}
2806+
ty::PredicateKind::Ambiguous => p!("ambiguous"),
2807+
ty::PredicateKind::AliasRelate(t1, t2, dir) => p!(print(t1), write(" {} ", dir), print(t2)),
2808+
}
2809+
}
2810+
}
2811+
27622812
define_print_and_forward_display! {
27632813
(self, cx):
27642814

@@ -2887,55 +2937,13 @@ define_print_and_forward_display! {
28872937
}
28882938

28892939
ty::Predicate<'tcx> {
2890-
let binder = self.kind();
2891-
p!(print(binder))
2940+
p!(print(self.kind()))
28922941
}
28932942

28942943
ty::Clause<'tcx> {
28952944
p!(print(self.kind()))
28962945
}
28972946

2898-
ty::ClauseKind<'tcx> {
2899-
match *self {
2900-
ty::ClauseKind::Trait(ref data) => {
2901-
p!(print(data))
2902-
}
2903-
ty::ClauseKind::RegionOutlives(predicate) => p!(print(predicate)),
2904-
ty::ClauseKind::TypeOutlives(predicate) => p!(print(predicate)),
2905-
ty::ClauseKind::Projection(predicate) => p!(print(predicate)),
2906-
ty::ClauseKind::ConstArgHasType(ct, ty) => {
2907-
p!("the constant `", print(ct), "` has type `", print(ty), "`")
2908-
},
2909-
ty::ClauseKind::WellFormed(arg) => p!(print(arg), " well-formed"),
2910-
ty::ClauseKind::ConstEvaluatable(ct) => {
2911-
p!("the constant `", print(ct), "` can be evaluated")
2912-
}
2913-
}
2914-
}
2915-
2916-
ty::PredicateKind<'tcx> {
2917-
match *self {
2918-
ty::PredicateKind::Clause(data) => {
2919-
p!(print(data))
2920-
}
2921-
ty::PredicateKind::Subtype(predicate) => p!(print(predicate)),
2922-
ty::PredicateKind::Coerce(predicate) => p!(print(predicate)),
2923-
ty::PredicateKind::ObjectSafe(trait_def_id) => {
2924-
p!("the trait `", print_def_path(trait_def_id, &[]), "` is object-safe")
2925-
}
2926-
ty::PredicateKind::ClosureKind(closure_def_id, _closure_args, kind) => p!(
2927-
"the closure `",
2928-
print_value_path(closure_def_id, &[]),
2929-
write("` implements the trait `{}`", kind)
2930-
),
2931-
ty::PredicateKind::ConstEquate(c1, c2) => {
2932-
p!("the constant `", print(c1), "` equals `", print(c2), "`")
2933-
}
2934-
ty::PredicateKind::Ambiguous => p!("ambiguous"),
2935-
ty::PredicateKind::AliasRelate(t1, t2, dir) => p!(print(t1), write(" {} ", dir), print(t2)),
2936-
}
2937-
}
2938-
29392947
GenericArg<'tcx> {
29402948
match self.unpack() {
29412949
GenericArgKind::Lifetime(lt) => p!(print(lt)),

‎compiler/rustc_middle/src/ty/structural_impls.rs

-38
Original file line numberDiff line numberDiff line change
@@ -185,43 +185,6 @@ impl<'tcx> fmt::Debug for ty::Clause<'tcx> {
185185
}
186186
}
187187

188-
impl<'tcx> fmt::Debug for ty::ClauseKind<'tcx> {
189-
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
190-
match *self {
191-
ty::ClauseKind::ConstArgHasType(ct, ty) => write!(f, "ConstArgHasType({ct:?}, {ty:?})"),
192-
ty::ClauseKind::Trait(ref a) => a.fmt(f),
193-
ty::ClauseKind::RegionOutlives(ref pair) => pair.fmt(f),
194-
ty::ClauseKind::TypeOutlives(ref pair) => pair.fmt(f),
195-
ty::ClauseKind::Projection(ref pair) => pair.fmt(f),
196-
ty::ClauseKind::WellFormed(ref data) => write!(f, "WellFormed({data:?})"),
197-
ty::ClauseKind::ConstEvaluatable(ct) => {
198-
write!(f, "ConstEvaluatable({ct:?})")
199-
}
200-
}
201-
}
202-
}
203-
204-
impl<'tcx> fmt::Debug for ty::PredicateKind<'tcx> {
205-
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
206-
match *self {
207-
ty::PredicateKind::Clause(ref a) => a.fmt(f),
208-
ty::PredicateKind::Subtype(ref pair) => pair.fmt(f),
209-
ty::PredicateKind::Coerce(ref pair) => pair.fmt(f),
210-
ty::PredicateKind::ObjectSafe(trait_def_id) => {
211-
write!(f, "ObjectSafe({trait_def_id:?})")
212-
}
213-
ty::PredicateKind::ClosureKind(closure_def_id, closure_args, kind) => {
214-
write!(f, "ClosureKind({closure_def_id:?}, {closure_args:?}, {kind:?})")
215-
}
216-
ty::PredicateKind::ConstEquate(c1, c2) => write!(f, "ConstEquate({c1:?}, {c2:?})"),
217-
ty::PredicateKind::Ambiguous => write!(f, "Ambiguous"),
218-
ty::PredicateKind::AliasRelate(t1, t2, dir) => {
219-
write!(f, "AliasRelate({t1:?}, {dir:?}, {t2:?})")
220-
}
221-
}
222-
}
223-
}
224-
225188
impl<'tcx> fmt::Debug for AliasTy<'tcx> {
226189
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
227190
WithInfcx::with_no_infcx(self).fmt(f)
@@ -503,7 +466,6 @@ TrivialTypeTraversalAndLiftImpls! {
503466
::rustc_hir::Mutability,
504467
::rustc_hir::Unsafety,
505468
::rustc_target::spec::abi::Abi,
506-
crate::ty::AliasRelationDirection,
507469
crate::ty::ClosureKind,
508470
crate::ty::ParamConst,
509471
crate::ty::ParamTy,

‎compiler/rustc_middle/src/ty/sty.rs

+4
Original file line numberDiff line numberDiff line change
@@ -32,10 +32,12 @@ use std::fmt;
3232
use std::ops::{ControlFlow, Deref, Range};
3333
use ty::util::IntTypeExt;
3434

35+
use rustc_type_ir::ClauseKind as IrClauseKind;
3536
use rustc_type_ir::CollectAndApply;
3637
use rustc_type_ir::ConstKind as IrConstKind;
3738
use rustc_type_ir::DebugWithInfcx;
3839
use rustc_type_ir::DynKind;
40+
use rustc_type_ir::PredicateKind as IrPredicateKind;
3941
use rustc_type_ir::RegionKind as IrRegionKind;
4042
use rustc_type_ir::TyKind as IrTyKind;
4143
use rustc_type_ir::TyKind::*;
@@ -47,6 +49,8 @@ use super::GenericParamDefKind;
4749
pub type TyKind<'tcx> = IrTyKind<TyCtxt<'tcx>>;
4850
pub type RegionKind<'tcx> = IrRegionKind<TyCtxt<'tcx>>;
4951
pub type ConstKind<'tcx> = IrConstKind<TyCtxt<'tcx>>;
52+
pub type PredicateKind<'tcx> = IrPredicateKind<TyCtxt<'tcx>>;
53+
pub type ClauseKind<'tcx> = IrClauseKind<TyCtxt<'tcx>>;
5054

5155
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)]
5256
#[derive(HashStable, TypeFoldable, TypeVisitable, Lift)]

0 commit comments

Comments
 (0)