Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit e24cd91

Browse files
arielb1arielb1
committedDec 3, 2018
add coherence future-compat warnings for marker-only trait objects
The future-compat warnings break code that assumes that `dyn Send + Sync != dyn Sync + Send`, and are the first step in making them equal. cc #33140. It should be possible to revert this commit when we're done with the warnings.
1 parent c152682 commit e24cd91

File tree

21 files changed

+433
-56
lines changed

21 files changed

+433
-56
lines changed
 

‎src/librustc/infer/combine.rs

+4
Original file line numberDiff line numberDiff line change
@@ -347,6 +347,10 @@ impl<'cx, 'gcx, 'tcx> TypeRelation<'cx, 'gcx, 'tcx> for Generalizer<'cx, 'gcx, '
347347
self.infcx.tcx
348348
}
349349

350+
fn trait_object_mode(&self) -> relate::TraitObjectMode {
351+
self.infcx.trait_object_mode()
352+
}
353+
350354
fn tag(&self) -> &'static str {
351355
"Generalizer"
352356
}

‎src/librustc/infer/equate.rs

+4
Original file line numberDiff line numberDiff line change
@@ -39,6 +39,10 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
3939

4040
fn tcx(&self) -> TyCtxt<'infcx, 'gcx, 'tcx> { self.fields.tcx() }
4141

42+
fn trait_object_mode(&self) -> relate::TraitObjectMode {
43+
self.fields.infcx.trait_object_mode()
44+
}
45+
4246
fn a_is_expected(&self) -> bool { self.a_is_expected }
4347

4448
fn relate_item_substs(&mut self,

‎src/librustc/infer/glb.rs

+5-1
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ use super::Subtype;
1515

1616
use traits::ObligationCause;
1717
use ty::{self, Ty, TyCtxt};
18-
use ty::relate::{Relate, RelateResult, TypeRelation};
18+
use ty::relate::{self, Relate, RelateResult, TypeRelation};
1919

2020
/// "Greatest lower bound" (common subtype)
2121
pub struct Glb<'combine, 'infcx: 'combine, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> {
@@ -36,6 +36,10 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
3636
{
3737
fn tag(&self) -> &'static str { "Glb" }
3838

39+
fn trait_object_mode(&self) -> relate::TraitObjectMode {
40+
self.fields.infcx.trait_object_mode()
41+
}
42+
3943
fn tcx(&self) -> TyCtxt<'infcx, 'gcx, 'tcx> { self.fields.tcx() }
4044

4145
fn a_is_expected(&self) -> bool { self.a_is_expected }

‎src/librustc/infer/lub.rs

+5-1
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ use super::Subtype;
1515

1616
use traits::ObligationCause;
1717
use ty::{self, Ty, TyCtxt};
18-
use ty::relate::{Relate, RelateResult, TypeRelation};
18+
use ty::relate::{self, Relate, RelateResult, TypeRelation};
1919

2020
/// "Least upper bound" (common supertype)
2121
pub struct Lub<'combine, 'infcx: 'combine, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> {
@@ -36,6 +36,10 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
3636
{
3737
fn tag(&self) -> &'static str { "Lub" }
3838

39+
fn trait_object_mode(&self) -> relate::TraitObjectMode {
40+
self.fields.infcx.trait_object_mode()
41+
}
42+
3943
fn tcx(&self) -> TyCtxt<'infcx, 'gcx, 'tcx> { self.fields.tcx() }
4044

4145
fn a_is_expected(&self) -> bool { self.a_is_expected }

‎src/librustc/infer/mod.rs

+18-1
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,7 @@ use syntax_pos::{self, Span};
3535
use traits::{self, ObligationCause, PredicateObligations, TraitEngine};
3636
use ty::error::{ExpectedFound, TypeError, UnconstrainedNumeric};
3737
use ty::fold::TypeFoldable;
38-
use ty::relate::RelateResult;
38+
use ty::relate::{RelateResult, TraitObjectMode};
3939
use ty::subst::{Kind, Substs};
4040
use ty::{self, GenericParamDefKind, Ty, TyCtxt};
4141
use ty::{FloatVid, IntVid, TyVid};
@@ -182,6 +182,9 @@ pub struct InferCtxt<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
182182
// This flag is true while there is an active snapshot.
183183
in_snapshot: Cell<bool>,
184184

185+
// The TraitObjectMode used here,
186+
trait_object_mode: TraitObjectMode,
187+
185188
// A set of constraints that regionck must validate. Each
186189
// constraint has the form `T:'a`, meaning "some type `T` must
187190
// outlive the lifetime 'a". These constraints derive from
@@ -472,6 +475,7 @@ pub struct InferCtxtBuilder<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
472475
global_tcx: TyCtxt<'a, 'gcx, 'gcx>,
473476
arena: SyncDroplessArena,
474477
fresh_tables: Option<RefCell<ty::TypeckTables<'tcx>>>,
478+
trait_object_mode: TraitObjectMode,
475479
}
476480

477481
impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'gcx> {
@@ -480,6 +484,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'gcx> {
480484
global_tcx: self,
481485
arena: SyncDroplessArena::default(),
482486
fresh_tables: None,
487+
trait_object_mode: TraitObjectMode::NoSquash,
483488
}
484489
}
485490
}
@@ -492,6 +497,12 @@ impl<'a, 'gcx, 'tcx> InferCtxtBuilder<'a, 'gcx, 'tcx> {
492497
self
493498
}
494499

500+
pub fn with_trait_object_mode(mut self, mode: TraitObjectMode) -> Self {
501+
debug!("with_trait_object_mode: setting mode to {:?}", mode);
502+
self.trait_object_mode = mode;
503+
self
504+
}
505+
495506
/// Given a canonical value `C` as a starting point, create an
496507
/// inference context that contains each of the bound values
497508
/// within instantiated as a fresh variable. The `f` closure is
@@ -518,6 +529,7 @@ impl<'a, 'gcx, 'tcx> InferCtxtBuilder<'a, 'gcx, 'tcx> {
518529
pub fn enter<R>(&'tcx mut self, f: impl for<'b> FnOnce(InferCtxt<'b, 'gcx, 'tcx>) -> R) -> R {
519530
let InferCtxtBuilder {
520531
global_tcx,
532+
trait_object_mode,
521533
ref arena,
522534
ref fresh_tables,
523535
} = *self;
@@ -526,6 +538,7 @@ impl<'a, 'gcx, 'tcx> InferCtxtBuilder<'a, 'gcx, 'tcx> {
526538
f(InferCtxt {
527539
tcx,
528540
in_progress_tables,
541+
trait_object_mode,
529542
projection_cache: Default::default(),
530543
type_variables: RefCell::new(type_variable::TypeVariableTable::new()),
531544
int_unification_table: RefCell::new(ut::UnificationTable::new()),
@@ -607,6 +620,10 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
607620
self.in_snapshot.get()
608621
}
609622

623+
pub fn trait_object_mode(&self) -> TraitObjectMode {
624+
self.trait_object_mode
625+
}
626+
610627
pub fn freshen<T: TypeFoldable<'tcx>>(&self, t: T) -> T {
611628
t.fold_with(&mut self.freshener())
612629
}

‎src/librustc/infer/nll_relate/mod.rs

+14
Original file line numberDiff line numberDiff line change
@@ -382,6 +382,13 @@ where
382382
self.infcx.tcx
383383
}
384384

385+
fn trait_object_mode(&self) -> relate::TraitObjectMode {
386+
// squashing should only be done in coherence, not NLL
387+
assert_eq!(self.infcx.trait_object_mode(),
388+
relate::TraitObjectMode::NoSquash);
389+
relate::TraitObjectMode::NoSquash
390+
}
391+
385392
fn tag(&self) -> &'static str {
386393
"nll::subtype"
387394
}
@@ -696,6 +703,13 @@ where
696703
self.infcx.tcx
697704
}
698705

706+
fn trait_object_mode(&self) -> relate::TraitObjectMode {
707+
// squashing should only be done in coherence, not NLL
708+
assert_eq!(self.infcx.trait_object_mode(),
709+
relate::TraitObjectMode::NoSquash);
710+
relate::TraitObjectMode::NoSquash
711+
}
712+
699713
fn tag(&self) -> &'static str {
700714
"nll::generalizer"
701715
}

‎src/librustc/infer/sub.rs

+5-1
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ use traits::Obligation;
1515
use ty::{self, Ty, TyCtxt};
1616
use ty::TyVar;
1717
use ty::fold::TypeFoldable;
18-
use ty::relate::{Cause, Relate, RelateResult, TypeRelation};
18+
use ty::relate::{self, Cause, Relate, RelateResult, TypeRelation};
1919
use std::mem;
2020

2121
/// Ensures `a` is made a subtype of `b`. Returns `a` on success.
@@ -43,6 +43,10 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
4343
for Sub<'combine, 'infcx, 'gcx, 'tcx>
4444
{
4545
fn tag(&self) -> &'static str { "Sub" }
46+
fn trait_object_mode(&self) -> relate::TraitObjectMode {
47+
self.fields.infcx.trait_object_mode()
48+
}
49+
4650
fn tcx(&self) -> TyCtxt<'infcx, 'gcx, 'tcx> { self.fields.infcx.tcx }
4751
fn a_is_expected(&self) -> bool { self.a_is_expected }
4852

‎src/librustc/traits/coherence.rs

+8-4
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@ use traits::{self, Normalized, SelectionContext, Obligation, ObligationCause};
2020
use traits::IntercrateMode;
2121
use traits::select::IntercrateAmbiguityCause;
2222
use ty::{self, Ty, TyCtxt};
23+
use ty::relate::TraitObjectMode;
2324
use ty::fold::TypeFoldable;
2425
use ty::subst::Subst;
2526

@@ -52,6 +53,7 @@ pub fn overlapping_impls<'gcx, F1, F2, R>(
5253
impl1_def_id: DefId,
5354
impl2_def_id: DefId,
5455
intercrate_mode: IntercrateMode,
56+
trait_object_mode: TraitObjectMode,
5557
on_overlap: F1,
5658
no_overlap: F2,
5759
) -> R
@@ -62,12 +64,14 @@ where
6264
debug!("overlapping_impls(\
6365
impl1_def_id={:?}, \
6466
impl2_def_id={:?},
65-
intercrate_mode={:?})",
67+
intercrate_mode={:?},
68+
trait_object_mode={:?})",
6669
impl1_def_id,
6770
impl2_def_id,
68-
intercrate_mode);
71+
intercrate_mode,
72+
trait_object_mode);
6973

70-
let overlaps = tcx.infer_ctxt().enter(|infcx| {
74+
let overlaps = tcx.infer_ctxt().with_trait_object_mode(trait_object_mode).enter(|infcx| {
7175
let selcx = &mut SelectionContext::intercrate(&infcx, intercrate_mode);
7276
overlap(selcx, impl1_def_id, impl2_def_id).is_some()
7377
});
@@ -79,7 +83,7 @@ where
7983
// In the case where we detect an error, run the check again, but
8084
// this time tracking intercrate ambuiguity causes for better
8185
// diagnostics. (These take time and can lead to false errors.)
82-
tcx.infer_ctxt().enter(|infcx| {
86+
tcx.infer_ctxt().with_trait_object_mode(trait_object_mode).enter(|infcx| {
8387
let selcx = &mut SelectionContext::intercrate(&infcx, intercrate_mode);
8488
selcx.enable_tracking_intercrate_ambiguity_causes();
8589
on_overlap(overlap(selcx, impl1_def_id, impl2_def_id).unwrap())

‎src/librustc/traits/error_reporting.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -459,7 +459,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
459459
{
460460
let simp = fast_reject::simplify_type(self.tcx,
461461
trait_ref.skip_binder().self_ty(),
462-
true);
462+
true,);
463463
let all_impls = self.tcx.all_impls(trait_ref.def_id());
464464

465465
match simp {

‎src/librustc/traits/mod.rs

+2
Original file line numberDiff line numberDiff line change
@@ -49,6 +49,8 @@ pub use self::select::{EvaluationCache, SelectionContext, SelectionCache};
4949
pub use self::select::{EvaluationResult, IntercrateAmbiguityCause, OverflowError};
5050
pub use self::specialize::{OverlapError, specialization_graph, translate_substs};
5151
pub use self::specialize::find_associated_item;
52+
pub use self::specialize::specialization_graph::FutureCompatOverlapError;
53+
pub use self::specialize::specialization_graph::FutureCompatOverlapErrorKind;
5254
pub use self::engine::{TraitEngine, TraitEngineExt};
5355
pub use self::util::{elaborate_predicates, elaborate_trait_ref, elaborate_trait_refs};
5456
pub use self::util::{supertraits, supertrait_def_ids, Supertraits, SupertraitDefIds};

‎src/librustc/traits/select.rs

+10-2
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,7 @@ use infer::{InferCtxt, InferOk, TypeFreshener};
4444
use middle::lang_items;
4545
use mir::interpret::GlobalId;
4646
use ty::fast_reject;
47-
use ty::relate::TypeRelation;
47+
use ty::relate::{TypeRelation, TraitObjectMode};
4848
use ty::subst::{Subst, Substs};
4949
use ty::{self, ToPolyTraitRef, ToPredicate, Ty, TyCtxt, TypeFoldable};
5050

@@ -1501,6 +1501,13 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
15011501
return false;
15021502
}
15031503

1504+
// Same idea as the above, but for alt trait object modes. These
1505+
// should only be used in intercrate mode - better safe than sorry.
1506+
if self.infcx.trait_object_mode() != TraitObjectMode::NoSquash {
1507+
bug!("using squashing TraitObjectMode outside of intercrate mode? param_env={:?}",
1508+
param_env);
1509+
}
1510+
15041511
// Otherwise, we can use the global cache.
15051512
true
15061513
}
@@ -3699,7 +3706,8 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
36993706
previous: &ty::PolyTraitRef<'tcx>,
37003707
current: &ty::PolyTraitRef<'tcx>,
37013708
) -> bool {
3702-
let mut matcher = ty::_match::Match::new(self.tcx());
3709+
let mut matcher = ty::_match::Match::new(
3710+
self.tcx(), self.infcx.trait_object_mode());
37033711
matcher.relate(previous, current).is_ok()
37043712
}
37053713

‎src/librustc/traits/specialize/mod.rs

+14-6
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,7 @@ use rustc_data_structures::fx::FxHashSet;
2626
use hir::def_id::DefId;
2727
use infer::{InferCtxt, InferOk};
2828
use ty::subst::{Subst, Substs};
29-
use traits::{self, ObligationCause, TraitEngine};
29+
use traits::{self, FutureCompatOverlapErrorKind, ObligationCause, TraitEngine};
3030
use traits::select::IntercrateAmbiguityCause;
3131
use ty::{self, TyCtxt, TypeFoldable};
3232
use syntax_pos::DUMMY_SP;
@@ -37,6 +37,7 @@ use lint;
3737
pub mod specialization_graph;
3838

3939
/// Information pertinent to an overlapping impl error.
40+
#[derive(Debug)]
4041
pub struct OverlapError {
4142
pub with_impl: DefId,
4243
pub trait_desc: String,
@@ -308,8 +309,9 @@ pub(super) fn specialization_graph_provider<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx
308309
let insert_result = sg.insert(tcx, impl_def_id);
309310
// Report error if there was one.
310311
let (overlap, used_to_be_allowed) = match insert_result {
311-
Err(overlap) => (Some(overlap), false),
312-
Ok(opt_overlap) => (opt_overlap, true)
312+
Err(overlap) => (Some(overlap), None),
313+
Ok(Some(overlap)) => (Some(overlap.error), Some(overlap.kind)),
314+
Ok(None) => (None, None)
313315
};
314316

315317
if let Some(overlap) = overlap {
@@ -319,14 +321,20 @@ pub(super) fn specialization_graph_provider<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx
319321
String::new(), |ty| {
320322
format!(" for type `{}`", ty)
321323
}),
322-
if used_to_be_allowed { " (E0119)" } else { "" }
324+
if used_to_be_allowed.is_some() { " (E0119)" } else { "" }
323325
);
324326
let impl_span = tcx.sess.source_map().def_span(
325327
tcx.span_of_impl(impl_def_id).unwrap()
326328
);
327-
let mut err = if used_to_be_allowed {
329+
let mut err = if let Some(kind) = used_to_be_allowed {
330+
let lint = match kind {
331+
FutureCompatOverlapErrorKind::Issue43355 =>
332+
lint::builtin::INCOHERENT_FUNDAMENTAL_IMPLS,
333+
FutureCompatOverlapErrorKind::Issue33140 =>
334+
lint::builtin::ORDER_DEPENDENT_TRAIT_OBJECTS,
335+
};
328336
tcx.struct_span_lint_node(
329-
lint::builtin::INCOHERENT_FUNDAMENTAL_IMPLS,
337+
lint,
330338
tcx.hir.as_local_node_id(impl_def_id).unwrap(),
331339
impl_span,
332340
&msg)

‎src/librustc/traits/specialize/specialization_graph.rs

+41-3
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,7 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher,
1717
use traits;
1818
use ty::{self, TyCtxt, TypeFoldable};
1919
use ty::fast_reject::{self, SimplifiedType};
20+
use ty::relate::TraitObjectMode;
2021
use rustc_data_structures::sync::Lrc;
2122
use syntax::ast::Ident;
2223
use util::captures::Captures;
@@ -68,10 +69,22 @@ struct Children {
6869
blanket_impls: Vec<DefId>,
6970
}
7071

72+
#[derive(Copy, Clone, Debug)]
73+
pub enum FutureCompatOverlapErrorKind {
74+
Issue43355,
75+
Issue33140,
76+
}
77+
78+
#[derive(Debug)]
79+
pub struct FutureCompatOverlapError {
80+
pub error: OverlapError,
81+
pub kind: FutureCompatOverlapErrorKind
82+
}
83+
7184
/// The result of attempting to insert an impl into a group of children.
7285
enum Inserted {
7386
/// The impl was inserted as a new child in this group of children.
74-
BecameNewSibling(Option<OverlapError>),
87+
BecameNewSibling(Option<FutureCompatOverlapError>),
7588

7689
/// The impl should replace existing impls [X1, ..], because the impl specializes X1, X2, etc.
7790
ReplaceChildren(Vec<DefId>),
@@ -168,6 +181,7 @@ impl<'a, 'gcx, 'tcx> Children {
168181
possible_sibling,
169182
impl_def_id,
170183
traits::IntercrateMode::Issue43355,
184+
TraitObjectMode::NoSquash,
171185
|overlap| {
172186
if tcx.impls_are_allowed_to_overlap(impl_def_id, possible_sibling) {
173187
return Ok((false, false));
@@ -198,12 +212,36 @@ impl<'a, 'gcx, 'tcx> Children {
198212
replace_children.push(possible_sibling);
199213
} else {
200214
if !tcx.impls_are_allowed_to_overlap(impl_def_id, possible_sibling) {
215+
// do future-compat checks for overlap. Have issue #43355
216+
// errors overwrite issue #33140 errors when both are present.
217+
218+
traits::overlapping_impls(
219+
tcx,
220+
possible_sibling,
221+
impl_def_id,
222+
traits::IntercrateMode::Fixed,
223+
TraitObjectMode::SquashAutoTraitsIssue33140,
224+
|overlap| {
225+
last_lint = Some(FutureCompatOverlapError {
226+
error: overlap_error(overlap),
227+
kind: FutureCompatOverlapErrorKind::Issue33140
228+
});
229+
},
230+
|| (),
231+
);
232+
201233
traits::overlapping_impls(
202234
tcx,
203235
possible_sibling,
204236
impl_def_id,
205237
traits::IntercrateMode::Fixed,
206-
|overlap| last_lint = Some(overlap_error(overlap)),
238+
TraitObjectMode::NoSquash,
239+
|overlap| {
240+
last_lint = Some(FutureCompatOverlapError {
241+
error: overlap_error(overlap),
242+
kind: FutureCompatOverlapErrorKind::Issue43355
243+
});
244+
},
207245
|| (),
208246
);
209247
}
@@ -247,7 +285,7 @@ impl<'a, 'gcx, 'tcx> Graph {
247285
pub fn insert(&mut self,
248286
tcx: TyCtxt<'a, 'gcx, 'tcx>,
249287
impl_def_id: DefId)
250-
-> Result<Option<OverlapError>, OverlapError> {
288+
-> Result<Option<FutureCompatOverlapError>, OverlapError> {
251289
assert!(impl_def_id.is_local());
252290

253291
let trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap();

‎src/librustc/ty/_match.rs

+10-3
Original file line numberDiff line numberDiff line change
@@ -29,17 +29,24 @@ use ty::relate::{self, Relate, TypeRelation, RelateResult};
2929
/// important thing about the result is Ok/Err. Also, matching never
3030
/// affects any type variables or unification state.
3131
pub struct Match<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
32-
tcx: TyCtxt<'a, 'gcx, 'tcx>
32+
tcx: TyCtxt<'a, 'gcx, 'tcx>,
33+
trait_object_mode: relate::TraitObjectMode
3334
}
3435

3536
impl<'a, 'gcx, 'tcx> Match<'a, 'gcx, 'tcx> {
36-
pub fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Match<'a, 'gcx, 'tcx> {
37-
Match { tcx }
37+
pub fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>,
38+
trait_object_mode: relate::TraitObjectMode)
39+
-> Match<'a, 'gcx, 'tcx> {
40+
Match { tcx, trait_object_mode }
3841
}
3942
}
4043

4144
impl<'a, 'gcx, 'tcx> TypeRelation<'a, 'gcx, 'tcx> for Match<'a, 'gcx, 'tcx> {
4245
fn tag(&self) -> &'static str { "Match" }
46+
fn trait_object_mode(&self) -> relate::TraitObjectMode {
47+
self.trait_object_mode
48+
}
49+
4350
fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx> { self.tcx }
4451
fn a_is_expected(&self) -> bool { true } // irrelevant
4552

‎src/librustc/ty/fast_reject.rs

+12-2
Original file line numberDiff line numberDiff line change
@@ -43,6 +43,9 @@ pub enum SimplifiedTypeGen<D>
4343
PtrSimplifiedType,
4444
NeverSimplifiedType,
4545
TupleSimplifiedType(usize),
46+
/// A trait object, all of whose components are markers
47+
/// (e.g., `dyn Send + Sync`).
48+
MarkerTraitObjectSimplifiedType,
4649
TraitSimplifiedType(D),
4750
ClosureSimplifiedType(D),
4851
GeneratorSimplifiedType(D),
@@ -78,7 +81,12 @@ pub fn simplify_type<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
7881
ty::Array(..) | ty::Slice(_) => Some(ArraySimplifiedType),
7982
ty::RawPtr(_) => Some(PtrSimplifiedType),
8083
ty::Dynamic(ref trait_info, ..) => {
81-
Some(TraitSimplifiedType(trait_info.principal().def_id()))
84+
let principal_def_id = trait_info.principal().def_id();
85+
if tcx.trait_is_auto(principal_def_id) {
86+
Some(MarkerTraitObjectSimplifiedType)
87+
} else {
88+
Some(TraitSimplifiedType(principal_def_id))
89+
}
8290
}
8391
ty::Ref(_, ty, _) => {
8492
// since we introduce auto-refs during method lookup, we
@@ -144,6 +152,7 @@ impl<D: Copy + Debug + Ord + Eq + Hash> SimplifiedTypeGen<D> {
144152
NeverSimplifiedType => NeverSimplifiedType,
145153
TupleSimplifiedType(n) => TupleSimplifiedType(n),
146154
TraitSimplifiedType(d) => TraitSimplifiedType(map(d)),
155+
MarkerTraitObjectSimplifiedType => MarkerTraitObjectSimplifiedType,
147156
ClosureSimplifiedType(d) => ClosureSimplifiedType(map(d)),
148157
GeneratorSimplifiedType(d) => GeneratorSimplifiedType(map(d)),
149158
GeneratorWitnessSimplifiedType(n) => GeneratorWitnessSimplifiedType(n),
@@ -170,7 +179,8 @@ impl<'a, 'gcx, D> HashStable<StableHashingContext<'a>> for SimplifiedTypeGen<D>
170179
ArraySimplifiedType |
171180
PtrSimplifiedType |
172181
NeverSimplifiedType |
173-
ParameterSimplifiedType => {
182+
ParameterSimplifiedType |
183+
MarkerTraitObjectSimplifiedType => {
174184
// nothing to do
175185
}
176186
IntSimplifiedType(t) => t.hash_stable(hcx, hasher),

‎src/librustc/ty/relate.rs

+45-4
Original file line numberDiff line numberDiff line change
@@ -34,9 +34,20 @@ pub enum Cause {
3434
ExistentialRegionBound, // relating an existential region bound
3535
}
3636

37+
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
38+
pub enum TraitObjectMode {
39+
NoSquash,
40+
/// A temporary mode to treat `Send + Sync = Sync + Send`, should be
41+
/// used only in coherence.
42+
SquashAutoTraitsIssue33140
43+
}
44+
3745
pub trait TypeRelation<'a, 'gcx: 'a+'tcx, 'tcx: 'a> : Sized {
3846
fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx>;
3947

48+
/// Return the trait object mode to be used.
49+
fn trait_object_mode(&self) -> TraitObjectMode;
50+
4051
/// Returns a static string we can use for printouts.
4152
fn tag(&self) -> &'static str;
4253

@@ -595,14 +606,44 @@ impl<'tcx> Relate<'tcx> for &'tcx ty::List<ty::ExistentialPredicate<'tcx>> {
595606
a: &Self,
596607
b: &Self)
597608
-> RelateResult<'tcx, Self>
598-
where R: TypeRelation<'a, 'gcx, 'tcx>, 'gcx: 'a+'tcx, 'tcx: 'a {
609+
where R: TypeRelation<'a, 'gcx, 'tcx>, 'gcx: 'a+'tcx, 'tcx: 'a {
610+
use ty::ExistentialPredicate::*;
599611

600-
if a.len() != b.len() {
612+
let tcx = relation.tcx();
613+
let (a_buf, b_buf);
614+
let (a_norm, b_norm): (&[_], &[_]) = match relation.trait_object_mode() {
615+
TraitObjectMode::NoSquash => {
616+
(a, b)
617+
}
618+
TraitObjectMode::SquashAutoTraitsIssue33140 => {
619+
// Treat auto-trait "principal" components as equal
620+
// to the non-principal components, to make
621+
// `dyn Send+Sync = dyn Sync+Send`.
622+
let normalize = |d: &[ty::ExistentialPredicate<'tcx>]| {
623+
let mut result: Vec<_> = d.iter().map(|pi| match pi {
624+
Trait(ref a) if tcx.trait_is_auto(a.def_id) => {
625+
AutoTrait(a.def_id)
626+
},
627+
other => *other
628+
}).collect();
629+
630+
result.sort_by(|a, b| a.stable_cmp(tcx, b));
631+
result.dedup();
632+
result
633+
};
634+
635+
a_buf = normalize(a);
636+
b_buf = normalize(b);
637+
638+
(&a_buf, &b_buf)
639+
}
640+
};
641+
642+
if a_norm.len() != b_norm.len() {
601643
return Err(TypeError::ExistentialMismatch(expected_found(relation, a, b)));
602644
}
603645

604-
let tcx = relation.tcx();
605-
let v = a.iter().zip(b.iter()).map(|(ep_a, ep_b)| {
646+
let v = a_norm.iter().zip(b_norm.iter()).map(|(ep_a, ep_b)| {
606647
use ty::ExistentialPredicate::*;
607648
match (*ep_a, *ep_b) {
608649
(Trait(ref a), Trait(ref b)) => Ok(Trait(relation.relate(a, b)?)),

‎src/librustc_traits/chalk_context/resolvent_ops.rs

+5-1
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ use rustc::traits::{
1717
};
1818
use rustc::ty::{self, Ty};
1919
use rustc::ty::subst::Kind;
20-
use rustc::ty::relate::{Relate, RelateResult, TypeRelation};
20+
use rustc::ty::relate::{self, Relate, RelateResult, TypeRelation};
2121
use syntax_pos::DUMMY_SP;
2222

2323
use super::{ChalkInferenceContext, ChalkArenas, ChalkExClause, ConstrainedSubst};
@@ -137,6 +137,10 @@ impl TypeRelation<'cx, 'gcx, 'tcx> for AnswerSubstitutor<'cx, 'gcx, 'tcx> {
137137
self.infcx.tcx
138138
}
139139

140+
fn trait_object_mode(&self) -> relate::TraitObjectMode {
141+
self.infcx.trait_object_mode()
142+
}
143+
140144
fn tag(&self) -> &'static str {
141145
"chalk_context::answer_substitutor"
142146
}

‎src/librustc_typeck/coherence/inherent_impls_overlap.rs

+63-26
Original file line numberDiff line numberDiff line change
@@ -12,8 +12,9 @@ use namespace::Namespace;
1212
use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
1313
use rustc::hir;
1414
use rustc::hir::itemlikevisit::ItemLikeVisitor;
15-
use rustc::traits::{self, IntercrateMode};
15+
use rustc::traits::{self, IntercrateMode, FutureCompatOverlapErrorKind};
1616
use rustc::ty::TyCtxt;
17+
use rustc::ty::relate::TraitObjectMode;
1718

1819
use lint;
1920

@@ -29,9 +30,11 @@ struct InherentOverlapChecker<'a, 'tcx: 'a> {
2930
}
3031

3132
impl<'a, 'tcx> InherentOverlapChecker<'a, 'tcx> {
32-
fn check_for_common_items_in_impls(&self, impl1: DefId, impl2: DefId,
33-
overlap: traits::OverlapResult,
34-
used_to_be_allowed: bool) {
33+
fn check_for_common_items_in_impls(
34+
&self, impl1: DefId, impl2: DefId,
35+
overlap: traits::OverlapResult,
36+
used_to_be_allowed: Option<FutureCompatOverlapErrorKind>)
37+
{
3538

3639
let name_and_namespace = |def_id| {
3740
let item = self.tcx.associated_item(def_id);
@@ -47,19 +50,28 @@ impl<'a, 'tcx> InherentOverlapChecker<'a, 'tcx> {
4750
for &item2 in &impl_items2[..] {
4851
if (name, namespace) == name_and_namespace(item2) {
4952
let node_id = self.tcx.hir.as_local_node_id(impl1);
50-
let mut err = if used_to_be_allowed && node_id.is_some() {
51-
self.tcx.struct_span_lint_node(
52-
lint::builtin::INCOHERENT_FUNDAMENTAL_IMPLS,
53-
node_id.unwrap(),
54-
self.tcx.span_of_impl(item1).unwrap(),
55-
&format!("duplicate definitions with name `{}` (E0592)", name)
56-
)
57-
} else {
58-
struct_span_err!(self.tcx.sess,
59-
self.tcx.span_of_impl(item1).unwrap(),
60-
E0592,
61-
"duplicate definitions with name `{}`",
62-
name)
53+
let mut err = match used_to_be_allowed {
54+
Some(kind) if node_id.is_some() => {
55+
let lint = match kind {
56+
FutureCompatOverlapErrorKind::Issue43355 =>
57+
lint::builtin::INCOHERENT_FUNDAMENTAL_IMPLS,
58+
FutureCompatOverlapErrorKind::Issue33140 =>
59+
lint::builtin::ORDER_DEPENDENT_TRAIT_OBJECTS,
60+
};
61+
self.tcx.struct_span_lint_node(
62+
lint,
63+
node_id.unwrap(),
64+
self.tcx.span_of_impl(item1).unwrap(),
65+
&format!("duplicate definitions with name `{}` (E0592)", name)
66+
)
67+
}
68+
_ => {
69+
struct_span_err!(self.tcx.sess,
70+
self.tcx.span_of_impl(item1).unwrap(),
71+
E0592,
72+
"duplicate definitions with name `{}`",
73+
name)
74+
}
6375
};
6476

6577
err.span_label(self.tcx.span_of_impl(item1).unwrap(),
@@ -82,36 +94,61 @@ impl<'a, 'tcx> InherentOverlapChecker<'a, 'tcx> {
8294

8395
for (i, &impl1_def_id) in impls.iter().enumerate() {
8496
for &impl2_def_id in &impls[(i + 1)..] {
85-
let used_to_be_allowed = traits::overlapping_impls(
97+
let mut used_to_be_allowed = traits::overlapping_impls(
8698
self.tcx,
8799
impl1_def_id,
88100
impl2_def_id,
89101
IntercrateMode::Issue43355,
102+
TraitObjectMode::NoSquash,
90103
|overlap| {
91104
self.check_for_common_items_in_impls(
92105
impl1_def_id,
93106
impl2_def_id,
94107
overlap,
95-
false,
108+
Some(FutureCompatOverlapErrorKind::Issue43355),
96109
);
97110
false
98111
},
99112
|| true,
100113
);
101114

115+
if used_to_be_allowed {
116+
used_to_be_allowed = traits::overlapping_impls(
117+
self.tcx,
118+
impl1_def_id,
119+
impl2_def_id,
120+
IntercrateMode::Fixed,
121+
TraitObjectMode::NoSquash,
122+
|overlap| {
123+
self.check_for_common_items_in_impls(
124+
impl1_def_id,
125+
impl2_def_id,
126+
overlap,
127+
None,
128+
);
129+
false
130+
},
131+
|| true,
132+
);
133+
}
134+
102135
if used_to_be_allowed {
103136
traits::overlapping_impls(
104137
self.tcx,
105138
impl1_def_id,
106139
impl2_def_id,
107140
IntercrateMode::Fixed,
108-
|overlap| self.check_for_common_items_in_impls(
109-
impl1_def_id,
110-
impl2_def_id,
111-
overlap,
112-
true,
113-
),
114-
|| (),
141+
TraitObjectMode::SquashAutoTraitsIssue33140,
142+
|overlap| {
143+
self.check_for_common_items_in_impls(
144+
impl1_def_id,
145+
impl2_def_id,
146+
overlap,
147+
Some(FutureCompatOverlapErrorKind::Issue33140),
148+
);
149+
false
150+
},
151+
|| true,
115152
);
116153
}
117154
}

‎src/test/run-pass/issues/issue-33140.rs

+57
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,57 @@
1+
// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
2+
// file at the top-level directory of this distribution and at
3+
// http://rust-lang.org/COPYRIGHT.
4+
//
5+
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6+
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7+
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8+
// option. This file may not be copied, modified, or distributed
9+
// except according to those terms.
10+
11+
#![allow(order_dependent_trait_objects)]
12+
13+
trait Trait {
14+
fn xyz() -> bool;
15+
}
16+
17+
impl Trait for dyn Send + Sync {
18+
fn xyz() -> bool { false }
19+
}
20+
21+
impl Trait for dyn Sync + Send {
22+
fn xyz() -> bool { true }
23+
}
24+
25+
trait Trait2 {
26+
fn uvw() -> bool;
27+
}
28+
29+
impl Trait2 for dyn Send + Sync {
30+
fn uvw() -> bool { false }
31+
}
32+
33+
impl Trait2 for dyn Sync + Send + Sync {
34+
fn uvw() -> bool { true }
35+
}
36+
37+
struct Foo<T: ?Sized>(T);
38+
impl Foo<dyn Send + Sync> {
39+
fn abc() -> bool {
40+
false
41+
}
42+
}
43+
44+
impl Foo<dyn Sync + Send> {
45+
fn abc() -> bool {
46+
true
47+
}
48+
}
49+
50+
fn main() {
51+
assert_eq!(<dyn Send+Sync>::xyz(), false);
52+
assert_eq!(<dyn Sync+Send>::xyz(), true);
53+
assert_eq!(<dyn Send+Sync>::uvw(), false);
54+
assert_eq!(<dyn Sync+Send+Sync>::uvw(), true);
55+
assert_eq!(<Foo<dyn Send+Sync>>::abc(), false);
56+
assert_eq!(<Foo<dyn Sync+Send>>::abc(), true);
57+
}

‎src/test/ui/issues/issue-33140.rs

+62
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
2+
// file at the top-level directory of this distribution and at
3+
// http://rust-lang.org/COPYRIGHT.
4+
//
5+
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6+
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7+
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8+
// option. This file may not be copied, modified, or distributed
9+
// except according to those terms.
10+
11+
#![deny(order_dependent_trait_objects)]
12+
13+
trait Trait {
14+
fn xyz() -> bool;
15+
}
16+
17+
impl Trait for dyn Send + Sync {
18+
fn xyz() -> bool { false }
19+
}
20+
21+
impl Trait for dyn Sync + Send {
22+
//~^ ERROR conflicting implementations
23+
//~| hard error
24+
fn xyz() -> bool { true }
25+
}
26+
27+
trait Trait2 {
28+
fn uvw() -> bool;
29+
}
30+
31+
impl Trait2 for dyn Send + Sync {
32+
fn uvw() -> bool { false }
33+
}
34+
35+
impl Trait2 for dyn Sync + Send + Sync {
36+
//~^ ERROR conflicting implementations
37+
//~| hard error
38+
fn uvw() -> bool { true }
39+
}
40+
41+
struct Foo<T: ?Sized>(T);
42+
impl Foo<dyn Send + Sync> {
43+
fn abc() -> bool { //~ ERROR duplicate definitions with name `abc`
44+
//~| hard error
45+
false
46+
}
47+
}
48+
49+
impl Foo<dyn Sync + Send> {
50+
fn abc() -> bool {
51+
true
52+
}
53+
}
54+
55+
fn main() {
56+
assert_eq!(<Send+Sync>::xyz(), false);
57+
assert_eq!(<Sync+Send>::xyz(), true);
58+
assert_eq!(<Send+Sync>::uvw(), false);
59+
assert_eq!(<Sync+Send+Sync>::uvw(), true);
60+
assert_eq!(<Foo<Send+Sync>>::abc(), false);
61+
assert_eq!(<Foo<Sync+Send>>::abc(), true);
62+
}

‎src/test/ui/issues/issue-33140.stderr

+48
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
1+
error: conflicting implementations of trait `Trait` for type `(dyn std::marker::Send + std::marker::Sync + 'static)`: (E0119)
2+
--> $DIR/issue-33140.rs:21:1
3+
|
4+
LL | impl Trait for dyn Send + Sync {
5+
| ------------------------------ first implementation here
6+
...
7+
LL | impl Trait for dyn Sync + Send {
8+
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `(dyn std::marker::Send + std::marker::Sync + 'static)`
9+
|
10+
note: lint level defined here
11+
--> $DIR/issue-33140.rs:11:9
12+
|
13+
LL | #![deny(order_dependent_trait_objects)]
14+
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
15+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
16+
= note: for more information, see issue #33140 <https://github.com/rust-lang/rust/issues/33140>
17+
18+
error: conflicting implementations of trait `Trait2` for type `(dyn std::marker::Send + std::marker::Sync + 'static)`: (E0119)
19+
--> $DIR/issue-33140.rs:35:1
20+
|
21+
LL | impl Trait2 for dyn Send + Sync {
22+
| ------------------------------- first implementation here
23+
...
24+
LL | impl Trait2 for dyn Sync + Send + Sync {
25+
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `(dyn std::marker::Send + std::marker::Sync + 'static)`
26+
|
27+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
28+
= note: for more information, see issue #33140 <https://github.com/rust-lang/rust/issues/33140>
29+
30+
error: duplicate definitions with name `abc` (E0592)
31+
--> $DIR/issue-33140.rs:43:5
32+
|
33+
LL | / fn abc() -> bool { //~ ERROR duplicate definitions with name `abc`
34+
LL | | //~| hard error
35+
LL | | false
36+
LL | | }
37+
| |_____^ duplicate definitions for `abc`
38+
...
39+
LL | / fn abc() -> bool {
40+
LL | | true
41+
LL | | }
42+
| |_____- other definition for `abc`
43+
|
44+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
45+
= note: for more information, see issue #33140 <https://github.com/rust-lang/rust/issues/33140>
46+
47+
error: aborting due to 3 previous errors
48+

0 commit comments

Comments
 (0)
Please sign in to comment.