Skip to content

Commit aa5740c

Browse files
borsbors
committed
Auto merge of #90104 - spastorino:coherence-for-negative-trait, r=nikomatsakis
Implement coherence checks for negative trait impls The main purpose of this PR is to be able to [move Error trait to core](rust-lang/project-error-handling#3). This feature is necessary to handle the following from impl on box. ```rust impl From<&str> for Box<dyn Error> { ... } ``` Without having negative traits affect coherence moving the error trait into `core` and moving that `From` impl to `alloc` will cause the from impl to no longer compiler because of a potential future incompatibility. The compiler indicates that `&str` _could_ introduce an `Error` impl in the future, and thus prevents the `From` impl in `alloc` that would cause overlap with `From<E: Error> for Box<dyn Error>`. Adding `impl !Error for &str {}` with the negative trait coherence feature will disable this error by encoding a stability guarantee that `&str` will never implement `Error`, making the `From` impl compile. We would have this in `alloc`: ```rust impl From<&str> for Box<dyn Error> {} // A impl<E> From<E> for Box<dyn Error> where E: Error {} // B ``` and this in `core`: ```rust trait Error {} impl !Error for &str {} ``` r? `@nikomatsakis` This PR was built on top of `@yaahc` PR #85764. Language team proposal: to rust-lang/lang-team#96
2 parents 55ccbd0 + 3287f72 commit aa5740c

38 files changed

+545
-193
lines changed

Diff for: ‎compiler/rustc_borrowck/src/type_check/canonical.rs

+1
Original file line numberDiff line numberDiff line change
@@ -94,6 +94,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
9494
Some(ty::Binder::dummy(ty::PredicateKind::Trait(ty::TraitPredicate {
9595
trait_ref,
9696
constness: ty::BoundConstness::NotConst,
97+
polarity: ty::ImplPolarity::Positive,
9798
}))),
9899
locations,
99100
category,

Diff for: ‎compiler/rustc_const_eval/src/transform/check_consts/check.rs

+1
Original file line numberDiff line numberDiff line change
@@ -854,6 +854,7 @@ impl Visitor<'tcx> for Checker<'mir, 'tcx> {
854854
Binder::dummy(TraitPredicate {
855855
trait_ref,
856856
constness: ty::BoundConstness::ConstIfConst,
857+
polarity: ty::ImplPolarity::Positive,
857858
}),
858859
);
859860

Diff for: ‎compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs

+1
Original file line numberDiff line numberDiff line change
@@ -162,6 +162,7 @@ impl Qualif for NeedsNonConstDrop {
162162
ty::Binder::dummy(ty::TraitPredicate {
163163
trait_ref,
164164
constness: ty::BoundConstness::ConstIfConst,
165+
polarity: ty::ImplPolarity::Positive,
165166
}),
166167
);
167168

Diff for: ‎compiler/rustc_feature/src/builtin_attrs.rs

+1
Original file line numberDiff line numberDiff line change
@@ -556,6 +556,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
556556
rustc_attr!(TEST, rustc_outlives, Normal, template!(Word)),
557557
rustc_attr!(TEST, rustc_capture_analysis, Normal, template!(Word)),
558558
rustc_attr!(TEST, rustc_insignificant_dtor, Normal, template!(Word)),
559+
rustc_attr!(TEST, rustc_strict_coherence, Normal, template!(Word)),
559560
rustc_attr!(TEST, rustc_variance, Normal, template!(Word)),
560561
rustc_attr!(TEST, rustc_layout, Normal, template!(List: "field1, field2, ...")),
561562
rustc_attr!(TEST, rustc_regions, Normal, template!(Word)),

Diff for: ‎compiler/rustc_infer/src/traits/mod.rs

+19-1
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ pub mod util;
1010

1111
use rustc_hir as hir;
1212
use rustc_middle::ty::error::{ExpectedFound, TypeError};
13-
use rustc_middle::ty::{self, Const, Ty};
13+
use rustc_middle::ty::{self, Const, Ty, TyCtxt};
1414
use rustc_span::Span;
1515

1616
pub use self::FulfillmentErrorCode::*;
@@ -55,6 +55,20 @@ pub struct Obligation<'tcx, T> {
5555
pub type PredicateObligation<'tcx> = Obligation<'tcx, ty::Predicate<'tcx>>;
5656
pub type TraitObligation<'tcx> = Obligation<'tcx, ty::PolyTraitPredicate<'tcx>>;
5757

58+
impl PredicateObligation<'tcx> {
59+
/// Flips the polarity of the inner predicate.
60+
///
61+
/// Given `T: Trait` predicate it returns `T: !Trait` and given `T: !Trait` returns `T: Trait`.
62+
pub fn flip_polarity(&self, tcx: TyCtxt<'tcx>) -> Option<PredicateObligation<'tcx>> {
63+
Some(PredicateObligation {
64+
cause: self.cause.clone(),
65+
param_env: self.param_env,
66+
predicate: self.predicate.flip_polarity(tcx)?,
67+
recursion_depth: self.recursion_depth,
68+
})
69+
}
70+
}
71+
5872
// `PredicateObligation` is used a lot. Make sure it doesn't unintentionally get bigger.
5973
#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
6074
static_assert_size!(PredicateObligation<'_>, 32);
@@ -129,6 +143,10 @@ impl<'tcx> FulfillmentError<'tcx> {
129143
}
130144

131145
impl<'tcx> TraitObligation<'tcx> {
146+
pub fn polarity(&self) -> ty::ImplPolarity {
147+
self.predicate.skip_binder().polarity
148+
}
149+
132150
pub fn self_ty(&self) -> ty::Binder<'tcx, Ty<'tcx>> {
133151
self.predicate.map_bound(|p| p.self_ty())
134152
}

Diff for: ‎compiler/rustc_middle/src/traits/select.rs

+6-4
Original file line numberDiff line numberDiff line change
@@ -12,12 +12,14 @@ use rustc_hir::def_id::DefId;
1212
use rustc_query_system::cache::Cache;
1313

1414
pub type SelectionCache<'tcx> = Cache<
15-
ty::ConstnessAnd<ty::ParamEnvAnd<'tcx, ty::TraitRef<'tcx>>>,
15+
(ty::ConstnessAnd<ty::ParamEnvAnd<'tcx, ty::TraitRef<'tcx>>>, ty::ImplPolarity),
1616
SelectionResult<'tcx, SelectionCandidate<'tcx>>,
1717
>;
1818

19-
pub type EvaluationCache<'tcx> =
20-
Cache<ty::ParamEnvAnd<'tcx, ty::ConstnessAnd<ty::PolyTraitRef<'tcx>>>, EvaluationResult>;
19+
pub type EvaluationCache<'tcx> = Cache<
20+
(ty::ParamEnvAnd<'tcx, ty::ConstnessAnd<ty::PolyTraitRef<'tcx>>>, ty::ImplPolarity),
21+
EvaluationResult,
22+
>;
2123

2224
/// The selection process begins by considering all impls, where
2325
/// clauses, and so forth that might resolve an obligation. Sometimes
@@ -101,7 +103,7 @@ pub enum SelectionCandidate<'tcx> {
101103
/// `false` if there are no *further* obligations.
102104
has_nested: bool,
103105
},
104-
ParamCandidate(ty::ConstnessAnd<ty::PolyTraitRef<'tcx>>),
106+
ParamCandidate((ty::ConstnessAnd<ty::PolyTraitRef<'tcx>>, ty::ImplPolarity)),
105107
ImplCandidate(DefId),
106108
AutoImplCandidate(DefId),
107109

Diff for: ‎compiler/rustc_middle/src/ty/error.rs

+7-4
Original file line numberDiff line numberDiff line change
@@ -34,6 +34,7 @@ impl<T> ExpectedFound<T> {
3434
pub enum TypeError<'tcx> {
3535
Mismatch,
3636
ConstnessMismatch(ExpectedFound<ty::BoundConstness>),
37+
PolarityMismatch(ExpectedFound<ty::ImplPolarity>),
3738
UnsafetyMismatch(ExpectedFound<hir::Unsafety>),
3839
AbiMismatch(ExpectedFound<abi::Abi>),
3940
Mutability,
@@ -104,6 +105,9 @@ impl<'tcx> fmt::Display for TypeError<'tcx> {
104105
ConstnessMismatch(values) => {
105106
write!(f, "expected {} bound, found {} bound", values.expected, values.found)
106107
}
108+
PolarityMismatch(values) => {
109+
write!(f, "expected {} polarity, found {} polarity", values.expected, values.found)
110+
}
107111
UnsafetyMismatch(values) => {
108112
write!(f, "expected {} fn, found {} fn", values.expected, values.found)
109113
}
@@ -212,10 +216,9 @@ impl<'tcx> TypeError<'tcx> {
212216
use self::TypeError::*;
213217
match self {
214218
CyclicTy(_) | CyclicConst(_) | UnsafetyMismatch(_) | ConstnessMismatch(_)
215-
| Mismatch | AbiMismatch(_) | FixedArraySize(_) | ArgumentSorts(..) | Sorts(_)
216-
| IntMismatch(_) | FloatMismatch(_) | VariadicMismatch(_) | TargetFeatureCast(_) => {
217-
false
218-
}
219+
| PolarityMismatch(_) | Mismatch | AbiMismatch(_) | FixedArraySize(_)
220+
| ArgumentSorts(..) | Sorts(_) | IntMismatch(_) | FloatMismatch(_)
221+
| VariadicMismatch(_) | TargetFeatureCast(_) => false,
219222

220223
Mutability
221224
| ArgumentMutability(_)

Diff for: ‎compiler/rustc_middle/src/ty/mod.rs

+63-2
Original file line numberDiff line numberDiff line change
@@ -164,7 +164,18 @@ pub struct ImplHeader<'tcx> {
164164
pub predicates: Vec<Predicate<'tcx>>,
165165
}
166166

167-
#[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable, Debug)]
167+
#[derive(
168+
Copy,
169+
Clone,
170+
PartialEq,
171+
Eq,
172+
Hash,
173+
TyEncodable,
174+
TyDecodable,
175+
HashStable,
176+
Debug,
177+
TypeFoldable
178+
)]
168179
pub enum ImplPolarity {
169180
/// `impl Trait for Type`
170181
Positive,
@@ -177,6 +188,27 @@ pub enum ImplPolarity {
177188
Reservation,
178189
}
179190

191+
impl ImplPolarity {
192+
/// Flips polarity by turning `Positive` into `Negative` and `Negative` into `Positive`.
193+
pub fn flip(&self) -> Option<ImplPolarity> {
194+
match self {
195+
ImplPolarity::Positive => Some(ImplPolarity::Negative),
196+
ImplPolarity::Negative => Some(ImplPolarity::Positive),
197+
ImplPolarity::Reservation => None,
198+
}
199+
}
200+
}
201+
202+
impl fmt::Display for ImplPolarity {
203+
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
204+
match self {
205+
Self::Positive => f.write_str("positive"),
206+
Self::Negative => f.write_str("negative"),
207+
Self::Reservation => f.write_str("reservation"),
208+
}
209+
}
210+
}
211+
180212
#[derive(Clone, Debug, PartialEq, Eq, Copy, Hash, TyEncodable, TyDecodable, HashStable)]
181213
pub enum Visibility {
182214
/// Visible everywhere (including in other crates).
@@ -459,6 +491,29 @@ impl<'tcx> Predicate<'tcx> {
459491
pub fn kind(self) -> Binder<'tcx, PredicateKind<'tcx>> {
460492
self.inner.kind
461493
}
494+
495+
/// Flips the polarity of a Predicate.
496+
///
497+
/// Given `T: Trait` predicate it returns `T: !Trait` and given `T: !Trait` returns `T: Trait`.
498+
pub fn flip_polarity(&self, tcx: TyCtxt<'tcx>) -> Option<Predicate<'tcx>> {
499+
let kind = self
500+
.inner
501+
.kind
502+
.map_bound(|kind| match kind {
503+
PredicateKind::Trait(TraitPredicate { trait_ref, constness, polarity }) => {
504+
Some(PredicateKind::Trait(TraitPredicate {
505+
trait_ref,
506+
constness,
507+
polarity: polarity.flip()?,
508+
}))
509+
}
510+
511+
_ => None,
512+
})
513+
.transpose()?;
514+
515+
Some(tcx.mk_predicate(kind))
516+
}
462517
}
463518

464519
impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Predicate<'tcx> {
@@ -654,6 +709,8 @@ pub struct TraitPredicate<'tcx> {
654709
pub trait_ref: TraitRef<'tcx>,
655710

656711
pub constness: BoundConstness,
712+
713+
pub polarity: ImplPolarity,
657714
}
658715

659716
pub type PolyTraitPredicate<'tcx> = ty::Binder<'tcx, TraitPredicate<'tcx>>;
@@ -788,7 +845,11 @@ impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<PolyTraitRef<'tcx>> {
788845
fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
789846
self.value
790847
.map_bound(|trait_ref| {
791-
PredicateKind::Trait(ty::TraitPredicate { trait_ref, constness: self.constness })
848+
PredicateKind::Trait(ty::TraitPredicate {
849+
trait_ref,
850+
constness: self.constness,
851+
polarity: ty::ImplPolarity::Positive,
852+
})
792853
})
793854
.to_predicate(tcx)
794855
}

Diff for: ‎compiler/rustc_middle/src/ty/relate.rs

+15
Original file line numberDiff line numberDiff line change
@@ -797,6 +797,20 @@ impl<'tcx> Relate<'tcx> for GenericArg<'tcx> {
797797
}
798798
}
799799

800+
impl<'tcx> Relate<'tcx> for ty::ImplPolarity {
801+
fn relate<R: TypeRelation<'tcx>>(
802+
relation: &mut R,
803+
a: ty::ImplPolarity,
804+
b: ty::ImplPolarity,
805+
) -> RelateResult<'tcx, ty::ImplPolarity> {
806+
if a != b {
807+
Err(TypeError::PolarityMismatch(expected_found(relation, a, b)))
808+
} else {
809+
Ok(a)
810+
}
811+
}
812+
}
813+
800814
impl<'tcx> Relate<'tcx> for ty::TraitPredicate<'tcx> {
801815
fn relate<R: TypeRelation<'tcx>>(
802816
relation: &mut R,
@@ -806,6 +820,7 @@ impl<'tcx> Relate<'tcx> for ty::TraitPredicate<'tcx> {
806820
Ok(ty::TraitPredicate {
807821
trait_ref: relation.relate(a.trait_ref, b.trait_ref)?,
808822
constness: relation.relate(a.constness, b.constness)?,
823+
polarity: relation.relate(a.polarity, b.polarity)?,
809824
})
810825
}
811826
}

Diff for: ‎compiler/rustc_middle/src/ty/structural_impls.rs

+7-3
Original file line numberDiff line numberDiff line change
@@ -157,7 +157,7 @@ impl fmt::Debug for ty::TraitPredicate<'tcx> {
157157
if let ty::BoundConstness::ConstIfConst = self.constness {
158158
write!(f, "~const ")?;
159159
}
160-
write!(f, "TraitPredicate({:?})", self.trait_ref)
160+
write!(f, "TraitPredicate({:?}, polarity:{:?})", self.trait_ref, self.polarity)
161161
}
162162
}
163163

@@ -365,8 +365,11 @@ impl<'a, 'tcx> Lift<'tcx> for ty::ExistentialPredicate<'a> {
365365
impl<'a, 'tcx> Lift<'tcx> for ty::TraitPredicate<'a> {
366366
type Lifted = ty::TraitPredicate<'tcx>;
367367
fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<ty::TraitPredicate<'tcx>> {
368-
tcx.lift(self.trait_ref)
369-
.map(|trait_ref| ty::TraitPredicate { trait_ref, constness: self.constness })
368+
tcx.lift(self.trait_ref).map(|trait_ref| ty::TraitPredicate {
369+
trait_ref,
370+
constness: self.constness,
371+
polarity: self.polarity,
372+
})
370373
}
371374
}
372375

@@ -591,6 +594,7 @@ impl<'a, 'tcx> Lift<'tcx> for ty::error::TypeError<'a> {
591594
Some(match self {
592595
Mismatch => Mismatch,
593596
ConstnessMismatch(x) => ConstnessMismatch(x),
597+
PolarityMismatch(x) => PolarityMismatch(x),
594598
UnsafetyMismatch(x) => UnsafetyMismatch(x),
595599
AbiMismatch(x) => AbiMismatch(x),
596600
Mutability => Mutability,

Diff for: ‎compiler/rustc_middle/src/ty/sty.rs

+1
Original file line numberDiff line numberDiff line change
@@ -882,6 +882,7 @@ impl<'tcx> PolyTraitRef<'tcx> {
882882
self.map_bound(|trait_ref| ty::TraitPredicate {
883883
trait_ref,
884884
constness: ty::BoundConstness::NotConst,
885+
polarity: ty::ImplPolarity::Positive,
885886
})
886887
}
887888
}

Diff for: ‎compiler/rustc_privacy/src/lib.rs

+5-3
Original file line numberDiff line numberDiff line change
@@ -124,9 +124,11 @@ where
124124

125125
fn visit_predicate(&mut self, predicate: ty::Predicate<'tcx>) -> ControlFlow<V::BreakTy> {
126126
match predicate.kind().skip_binder() {
127-
ty::PredicateKind::Trait(ty::TraitPredicate { trait_ref, constness: _ }) => {
128-
self.visit_trait(trait_ref)
129-
}
127+
ty::PredicateKind::Trait(ty::TraitPredicate {
128+
trait_ref,
129+
constness: _,
130+
polarity: _,
131+
}) => self.visit_trait(trait_ref),
130132
ty::PredicateKind::Projection(ty::ProjectionPredicate { projection_ty, ty }) => {
131133
ty.visit_with(self)?;
132134
self.visit_projection_ty(projection_ty)

Diff for: ‎compiler/rustc_span/src/symbol.rs

+1
Original file line numberDiff line numberDiff line change
@@ -1141,6 +1141,7 @@ symbols! {
11411141
rustc_specialization_trait,
11421142
rustc_stable,
11431143
rustc_std_internal_symbol,
1144+
rustc_strict_coherence,
11441145
rustc_symbol_name,
11451146
rustc_synthetic,
11461147
rustc_test_marker,

Diff for: ‎compiler/rustc_trait_selection/src/traits/auto_trait.rs

+2
Original file line numberDiff line numberDiff line change
@@ -286,6 +286,8 @@ impl AutoTraitFinder<'tcx> {
286286
substs: infcx.tcx.mk_substs_trait(ty, &[]),
287287
},
288288
constness: ty::BoundConstness::NotConst,
289+
// Auto traits are positive
290+
polarity: ty::ImplPolarity::Positive,
289291
}));
290292

291293
let computed_preds = param_env.caller_bounds().iter();

0 commit comments

Comments
 (0)