Skip to content

Commit e45c795

Browse files
soltanmm-googlesoltanmm-google
committed
Replace consider_unification_despite_ambiguity with obligation variant
1 parent 57e5d43 commit e45c795

File tree

19 files changed

+156
-75
lines changed

19 files changed

+156
-75
lines changed

‎src/librustc/diagnostics.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1544,4 +1544,5 @@ register_diagnostics! {
15441544
E0490, // a value of type `..` is borrowed for too long
15451545
E0491, // in type `..`, reference has a longer lifetime than the data it...
15461546
E0495, // cannot infer an appropriate lifetime due to conflicting requirements
1547+
E0524, // the closure implements `..` but not `..`
15471548
}

‎src/librustc/middle/free_region.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -59,6 +59,7 @@ impl FreeRegionMap {
5959
ty::Predicate::Equate(..) |
6060
ty::Predicate::WellFormed(..) |
6161
ty::Predicate::ObjectSafe(..) |
62+
ty::Predicate::ClosureKind(..) |
6263
ty::Predicate::TypeOutlives(..) => {
6364
// No region bounds here
6465
}

‎src/librustc/traits/error_reporting.rs

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -466,6 +466,20 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
466466
err.emit();
467467
}
468468

469+
ty::Predicate::ClosureKind(closure_def_id, kind) => {
470+
let found_kind = infcx.closure_kind(closure_def_id).unwrap();
471+
let closure_span = infcx.tcx.map.span_if_local(closure_def_id).unwrap();
472+
let mut err = struct_span_err!(
473+
infcx.tcx.sess, closure_span, E0524,
474+
"the closure implements `{}` but not `{}`",
475+
found_kind,
476+
kind);
477+
err.span_note(
478+
obligation.cause.span,
479+
&format!("the requirement to implement `{}` derives from here", kind));
480+
err.emit();
481+
}
482+
469483
ty::Predicate::WellFormed(ty) => {
470484
// WF predicates cannot themselves make
471485
// errors. They can only block due to

‎src/librustc/traits/fulfill.rs

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -652,6 +652,21 @@ fn process_predicate1<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>,
652652
}
653653
}
654654

655+
ty::Predicate::ClosureKind(closure_def_id, kind) => {
656+
match selcx.infcx().closure_kind(closure_def_id) {
657+
Some(closure_kind) => {
658+
if closure_kind.extends(kind) {
659+
Ok(Some(vec![]))
660+
} else {
661+
Err(CodeSelectionError(Unimplemented))
662+
}
663+
}
664+
None => {
665+
Ok(None)
666+
}
667+
}
668+
}
669+
655670
ty::Predicate::WellFormed(ty) => {
656671
match ty::wf::obligations(selcx.infcx(), obligation.cause.body_id,
657672
ty, obligation.cause.span) {

‎src/librustc/traits/object_safety.rs

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -165,6 +165,7 @@ pub fn supertraits_reference_self<'tcx>(tcx: &TyCtxt<'tcx>,
165165
ty::Predicate::ObjectSafe(..) |
166166
ty::Predicate::TypeOutlives(..) |
167167
ty::Predicate::RegionOutlives(..) |
168+
ty::Predicate::ClosureKind(..) |
168169
ty::Predicate::Equate(..) => {
169170
false
170171
}
@@ -207,6 +208,7 @@ fn generics_require_sized_self<'tcx>(tcx: &TyCtxt<'tcx>,
207208
ty::Predicate::RegionOutlives(..) |
208209
ty::Predicate::WellFormed(..) |
209210
ty::Predicate::ObjectSafe(..) |
211+
ty::Predicate::ClosureKind(..) |
210212
ty::Predicate::TypeOutlives(..) => {
211213
false
212214
}

‎src/librustc/traits/select.rs

Lines changed: 31 additions & 74 deletions
Original file line numberDiff line numberDiff line change
@@ -198,9 +198,10 @@ enum SelectionCandidate<'tcx> {
198198
/// we found an applicable bound in the trait definition.
199199
ProjectionCandidate,
200200

201-
/// Implementation of a `Fn`-family trait by one of the
202-
/// anonymous types generated for a `||` expression.
203-
ClosureCandidate(/* closure */ DefId, &'tcx ty::ClosureSubsts<'tcx>),
201+
/// Implementation of a `Fn`-family trait by one of the anonymous types
202+
/// generated for a `||` expression. The ty::ClosureKind informs the
203+
/// confirmation step what ClosureKind obligation to emit.
204+
ClosureCandidate(/* closure */ DefId, &'tcx ty::ClosureSubsts<'tcx>, ty::ClosureKind),
204205

205206
/// Implementation of a `Fn`-family trait by one of the anonymous
206207
/// types generated for a fn pointer type (e.g., `fn(int)->int`)
@@ -321,75 +322,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
321322

322323
let stack = self.push_stack(TraitObligationStackList::empty(), obligation);
323324
match self.candidate_from_obligation(&stack)? {
324-
None => {
325-
self.consider_unification_despite_ambiguity(obligation);
326-
Ok(None)
327-
}
325+
None => Ok(None),
328326
Some(candidate) => Ok(Some(self.confirm_candidate(obligation, candidate)?)),
329327
}
330328
}
331329

332-
/// In the particular case of unboxed closure obligations, we can
333-
/// sometimes do some amount of unification for the
334-
/// argument/return types even though we can't yet fully match obligation.
335-
/// The particular case we are interesting in is an obligation of the form:
336-
///
337-
/// C : FnFoo<A>
338-
///
339-
/// where `C` is an unboxed closure type and `FnFoo` is one of the
340-
/// `Fn` traits. Because we know that users cannot write impls for closure types
341-
/// themselves, the only way that `C : FnFoo` can fail to match is under two
342-
/// conditions:
343-
///
344-
/// 1. The closure kind for `C` is not yet known, because inference isn't complete.
345-
/// 2. The closure kind for `C` *is* known, but doesn't match what is needed.
346-
/// For example, `C` may be a `FnOnce` closure, but a `Fn` closure is needed.
347-
///
348-
/// In either case, we always know what argument types are
349-
/// expected by `C`, no matter what kind of `Fn` trait it
350-
/// eventually matches. So we can go ahead and unify the argument
351-
/// types, even though the end result is ambiguous.
352-
///
353-
/// Note that this is safe *even if* the trait would never be
354-
/// matched (case 2 above). After all, in that case, an error will
355-
/// result, so it kind of doesn't matter what we do --- unifying
356-
/// the argument types can only be helpful to the user, because
357-
/// once they patch up the kind of closure that is expected, the
358-
/// argment types won't really change.
359-
fn consider_unification_despite_ambiguity(&mut self, obligation: &TraitObligation<'tcx>) {
360-
// Is this a `C : FnFoo(...)` trait reference for some trait binding `FnFoo`?
361-
match self.tcx().lang_items.fn_trait_kind(obligation.predicate.0.def_id()) {
362-
Some(_) => { }
363-
None => { return; }
364-
}
365-
366-
// Is the self-type a closure type? We ignore bindings here
367-
// because if it is a closure type, it must be a closure type from
368-
// within this current fn, and hence none of the higher-ranked
369-
// lifetimes can appear inside the self-type.
370-
let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder());
371-
let (closure_def_id, substs) = match self_ty.sty {
372-
ty::TyClosure(id, ref substs) => (id, substs),
373-
_ => { return; }
374-
};
375-
assert!(!substs.has_escaping_regions());
376-
377-
// It is OK to call the unnormalized variant here - this is only
378-
// reached for TyClosure: Fn inputs where the closure kind is
379-
// still unknown, which should only occur in typeck where the
380-
// closure type is already normalized.
381-
let closure_trait_ref = self.closure_trait_ref_unnormalized(obligation,
382-
closure_def_id,
383-
substs);
384-
385-
match self.confirm_poly_trait_refs(obligation.cause.clone(),
386-
obligation.predicate.to_poly_trait_ref(),
387-
closure_trait_ref) {
388-
Ok(()) => { }
389-
Err(_) => { /* Silently ignore errors. */ }
390-
}
391-
}
392-
393330
///////////////////////////////////////////////////////////////////////////
394331
// EVALUATION
395332
//
@@ -532,6 +469,21 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
532469
}
533470
}
534471
}
472+
473+
ty::Predicate::ClosureKind(closure_def_id, kind) => {
474+
match self.infcx.closure_kind(closure_def_id) {
475+
Some(closure_kind) => {
476+
if closure_kind.extends(kind) {
477+
EvaluatedToOk
478+
} else {
479+
EvaluatedToErr
480+
}
481+
}
482+
None => {
483+
EvaluatedToAmbig
484+
}
485+
}
486+
}
535487
}
536488
}
537489

@@ -1282,12 +1234,12 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
12821234
Some(closure_kind) => {
12831235
debug!("assemble_unboxed_candidates: closure_kind = {:?}", closure_kind);
12841236
if closure_kind.extends(kind) {
1285-
candidates.vec.push(ClosureCandidate(closure_def_id, substs));
1237+
candidates.vec.push(ClosureCandidate(closure_def_id, substs, kind));
12861238
}
12871239
}
12881240
None => {
12891241
debug!("assemble_unboxed_candidates: closure_kind not yet known");
1290-
candidates.ambiguous = true;
1242+
candidates.vec.push(ClosureCandidate(closure_def_id, substs, kind));
12911243
}
12921244
}
12931245

@@ -2071,9 +2023,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
20712023
Ok(VtableImpl(vtable_impl))
20722024
}
20732025

2074-
ClosureCandidate(closure_def_id, substs) => {
2026+
ClosureCandidate(closure_def_id, substs, kind) => {
20752027
let vtable_closure =
2076-
self.confirm_closure_candidate(obligation, closure_def_id, substs)?;
2028+
self.confirm_closure_candidate(obligation, closure_def_id, substs, kind)?;
20772029
Ok(VtableClosure(vtable_closure))
20782030
}
20792031

@@ -2430,7 +2382,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
24302382
fn confirm_closure_candidate(&mut self,
24312383
obligation: &TraitObligation<'tcx>,
24322384
closure_def_id: DefId,
2433-
substs: &ty::ClosureSubsts<'tcx>)
2385+
substs: &ty::ClosureSubsts<'tcx>,
2386+
kind: ty::ClosureKind)
24342387
-> Result<VtableClosureData<'tcx, PredicateObligation<'tcx>>,
24352388
SelectionError<'tcx>>
24362389
{
@@ -2441,7 +2394,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
24412394

24422395
let Normalized {
24432396
value: trait_ref,
2444-
obligations
2397+
mut obligations
24452398
} = self.closure_trait_ref(obligation, closure_def_id, substs);
24462399

24472400
debug!("confirm_closure_candidate(closure_def_id={:?}, trait_ref={:?}, obligations={:?})",
@@ -2453,6 +2406,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
24532406
obligation.predicate.to_poly_trait_ref(),
24542407
trait_ref)?;
24552408

2409+
obligations.push(Obligation::new(
2410+
obligation.cause.clone(),
2411+
ty::Predicate::ClosureKind(closure_def_id, kind)));
2412+
24562413
Ok(VtableClosureData {
24572414
closure_def_id: closure_def_id,
24582415
substs: substs.clone(),

‎src/librustc/traits/util.rs

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -60,6 +60,9 @@ impl<'a,'tcx> PredicateSet<'a,'tcx> {
6060

6161
ty::Predicate::ObjectSafe(data) =>
6262
ty::Predicate::ObjectSafe(data),
63+
64+
ty::Predicate::ClosureKind(closure_def_id, kind) =>
65+
ty::Predicate::ClosureKind(closure_def_id, kind)
6366
};
6467
self.set.insert(normalized_pred)
6568
}
@@ -156,6 +159,9 @@ impl<'cx, 'tcx> Elaborator<'cx, 'tcx> {
156159
ty::Predicate::Projection(..) => {
157160
// Nothing to elaborate in a projection predicate.
158161
}
162+
ty::Predicate::ClosureKind(..) => {
163+
// Nothing to elaborate when waiting for a closure's kind to be inferred.
164+
}
159165
ty::Predicate::RegionOutlives(..) |
160166
ty::Predicate::TypeOutlives(..) => {
161167
// Currently, we do not "elaborate" predicates like

‎src/librustc/ty/mod.rs

Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -784,6 +784,11 @@ pub enum Predicate<'tcx> {
784784

785785
/// trait must be object-safe
786786
ObjectSafe(DefId),
787+
788+
/// No direct syntax. May be thought of as `where T : FnFoo<...>` for some 'TypeSpace'
789+
/// substitutions `...` and T being a closure type. Satisfied (or refuted) once we know the
790+
/// closure's kind.
791+
ClosureKind(DefId, ClosureKind),
787792
}
788793

789794
impl<'tcx> Predicate<'tcx> {
@@ -873,6 +878,8 @@ impl<'tcx> Predicate<'tcx> {
873878
Predicate::WellFormed(data.subst(tcx, substs)),
874879
Predicate::ObjectSafe(trait_def_id) =>
875880
Predicate::ObjectSafe(trait_def_id),
881+
Predicate::ClosureKind(closure_def_id, kind) =>
882+
Predicate::ClosureKind(closure_def_id, kind),
876883
}
877884
}
878885
}
@@ -1060,6 +1067,9 @@ impl<'tcx> Predicate<'tcx> {
10601067
ty::Predicate::ObjectSafe(_trait_def_id) => {
10611068
vec![]
10621069
}
1070+
ty::Predicate::ClosureKind(_closure_def_id, _kind) => {
1071+
vec![]
1072+
}
10631073
};
10641074

10651075
// The only reason to collect into a vector here is that I was
@@ -1080,6 +1090,7 @@ impl<'tcx> Predicate<'tcx> {
10801090
Predicate::RegionOutlives(..) |
10811091
Predicate::WellFormed(..) |
10821092
Predicate::ObjectSafe(..) |
1093+
Predicate::ClosureKind(..) |
10831094
Predicate::TypeOutlives(..) => {
10841095
None
10851096
}
@@ -1735,7 +1746,7 @@ pub struct ItemSubsts<'tcx> {
17351746
pub substs: Substs<'tcx>,
17361747
}
17371748

1738-
#[derive(Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Debug, RustcEncodable, RustcDecodable)]
1749+
#[derive(Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable)]
17391750
pub enum ClosureKind {
17401751
// Warning: Ordering is significant here! The ordering is chosen
17411752
// because the trait Fn is a subtrait of FnMut and so in turn, and

‎src/librustc/ty/structural_impls.rs

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -644,6 +644,8 @@ impl<'tcx> TypeFoldable<'tcx> for ty::Predicate<'tcx> {
644644
ty::Predicate::Projection(binder.fold_with(folder)),
645645
ty::Predicate::WellFormed(data) =>
646646
ty::Predicate::WellFormed(data.fold_with(folder)),
647+
ty::Predicate::ClosureKind(closure_def_id, kind) =>
648+
ty::Predicate::ClosureKind(closure_def_id, kind),
647649
ty::Predicate::ObjectSafe(trait_def_id) =>
648650
ty::Predicate::ObjectSafe(trait_def_id),
649651
}
@@ -657,6 +659,7 @@ impl<'tcx> TypeFoldable<'tcx> for ty::Predicate<'tcx> {
657659
ty::Predicate::TypeOutlives(ref binder) => binder.visit_with(visitor),
658660
ty::Predicate::Projection(ref binder) => binder.visit_with(visitor),
659661
ty::Predicate::WellFormed(data) => data.visit_with(visitor),
662+
ty::Predicate::ClosureKind(_closure_def_id, _kind) => false,
660663
ty::Predicate::ObjectSafe(_trait_def_id) => false,
661664
}
662665
}

‎src/librustc/ty/util.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -301,6 +301,7 @@ impl<'tcx> TyCtxt<'tcx> {
301301
ty::Predicate::Equate(..) |
302302
ty::Predicate::WellFormed(..) |
303303
ty::Predicate::ObjectSafe(..) |
304+
ty::Predicate::ClosureKind(..) |
304305
ty::Predicate::RegionOutlives(..) => {
305306
None
306307
}

‎src/librustc/ty/wf.rs

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -92,6 +92,8 @@ pub fn predicate_obligations<'a,'tcx>(infcx: &InferCtxt<'a, 'tcx>,
9292
}
9393
ty::Predicate::ObjectSafe(_) => {
9494
}
95+
ty::Predicate::ClosureKind(..) => {
96+
}
9597
}
9698

9799
wf.normalize()
@@ -155,6 +157,7 @@ pub fn implied_bounds<'a,'tcx>(
155157
ty::Predicate::Trait(..) |
156158
ty::Predicate::Equate(..) |
157159
ty::Predicate::Projection(..) |
160+
ty::Predicate::ClosureKind(..) |
158161
ty::Predicate::ObjectSafe(..) =>
159162
vec![],
160163

‎src/librustc/util/ppaux.rs

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -453,6 +453,9 @@ impl<'tcx> fmt::Debug for ty::Predicate<'tcx> {
453453
ty::Predicate::ObjectSafe(trait_def_id) => {
454454
write!(f, "ObjectSafe({:?})", trait_def_id)
455455
}
456+
ty::Predicate::ClosureKind(closure_def_id, kind) => {
457+
write!(f, "ClosureKind({:?}, {:?})", closure_def_id, kind)
458+
}
456459
}
457460
}
458461
}
@@ -1027,6 +1030,16 @@ impl<'tcx> fmt::Display for ty::ProjectionTy<'tcx> {
10271030
}
10281031
}
10291032

1033+
impl fmt::Display for ty::ClosureKind {
1034+
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1035+
match *self {
1036+
ty::ClosureKind::Fn => write!(f, "Fn"),
1037+
ty::ClosureKind::FnMut => write!(f, "FnMut"),
1038+
ty::ClosureKind::FnOnce => write!(f, "FnOnce"),
1039+
}
1040+
}
1041+
}
1042+
10301043
impl<'tcx> fmt::Display for ty::Predicate<'tcx> {
10311044
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
10321045
match *self {
@@ -1040,6 +1053,11 @@ impl<'tcx> fmt::Display for ty::Predicate<'tcx> {
10401053
ty::tls::with(|tcx| {
10411054
write!(f, "the trait `{}` is object-safe", tcx.item_path_str(trait_def_id))
10421055
}),
1056+
ty::Predicate::ClosureKind(closure_def_id, kind) =>
1057+
ty::tls::with(|tcx| {
1058+
write!(f, "the closure `{}` implements the trait `{}`",
1059+
tcx.item_path_str(closure_def_id), kind)
1060+
}),
10431061
}
10441062
}
10451063
}

0 commit comments

Comments
 (0)