---

yaml
---
r: 277070
b: refs/heads/try
c: 05a3fea
h: refs/heads/master

Author: birkenfeld

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 6dbb0e86aec11050480beb76eade6fb805010ba7
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
-refs/heads/try: 073a09fd63c9b4ec3bb4709986a2517ca4c3cdf1
+refs/heads/try: 05a3fea8f6b425889f905c7b1dca47139e7df63f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/.gitignore

@@ -78,7 +78,6 @@
 /stage3/
 /test/
 /tmp/
-/obj/
 TAGS
 TAGS.emacs
 TAGS.vi

branches/try/RELEASES.md

@@ -150,9 +150,7 @@ fn top_level(build: &Build) -> Vec<Step> {
             src: Source::Llvm { _dummy: () },
             target: &build.config.build,
         };
-        if build.config.docs {
-          targets.push(t.doc(stage));
-        }
+        targets.push(t.doc(stage));
         for host in build.config.host.iter() {
             if !build.flags.host.contains(host) {
                 continue
@@ -358,9 +356,7 @@ impl<'a> Step<'a> {
                     let compiler = self.compiler(stage);
                     for target in build.config.target.iter() {
                         let target = self.target(target);
-                        if build.config.docs {
-                            base.push(target.dist_docs(stage));
-                        }
+                        base.push(target.dist_docs(stage));
                         base.push(target.dist_std(compiler));
                     }
                 }

branches/try/src/bootstrap/build/step.rs

@@ -1539,11 +1539,6 @@ impl<Idx: PartialOrd<Idx>> Range<Idx> {
 ///
 /// See the [`contains()`](#method.contains) method for its characterization.
 ///
-/// Note: Currently, no overflow checking is done for the iterator
-/// implementation; if you use an integer range and the integer overflows, it
-/// might panic in debug mode or create an endless loop in release mode. This
-/// overflow behavior might change in the future.
-///
 /// # Examples
 ///
 /// ```

branches/try/src/libcore/ops.rs

@@ -1543,5 +1543,4 @@ register_diagnostics! {
     E0490, // a value of type `..` is borrowed for too long
     E0491, // in type `..`, reference has a longer lifetime than the data it...
     E0495, // cannot infer an appropriate lifetime due to conflicting requirements
-    E0524, // expected a closure that implements `..` but this closure only implements `..`
 }

branches/try/src/librustc/diagnostics.rs

@@ -59,7 +59,6 @@ impl FreeRegionMap {
                 ty::Predicate::Equate(..) |
                 ty::Predicate::WellFormed(..) |
                 ty::Predicate::ObjectSafe(..) |
-                ty::Predicate::ClosureKind(..) |
                 ty::Predicate::TypeOutlives(..) => {
                     // No region bounds here
                 }

branches/try/src/librustc/middle/free_region.rs

@@ -495,21 +495,6 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
                         err.emit();
                     }
 
-                    ty::Predicate::ClosureKind(closure_def_id, kind) => {
-                        let found_kind = infcx.closure_kind(closure_def_id).unwrap();
-                        let closure_span = infcx.tcx.map.span_if_local(closure_def_id).unwrap();
-                        let mut err = struct_span_err!(
-                            infcx.tcx.sess, closure_span, E0524,
-                            "expected a closure that implements the `{}` trait, but this closure \
-                             only implements `{}`",
-                            kind,
-                            found_kind);
-                        err.span_note(
-                            obligation.cause.span,
-                            &format!("the requirement to implement `{}` derives from here", kind));
-                        err.emit();
-                    }
-
                     ty::Predicate::WellFormed(ty) => {
                         // WF predicates cannot themselves make
                         // errors. They can only block due to

branches/try/src/librustc/traits/error_reporting.rs

@@ -652,21 +652,6 @@ fn process_predicate1<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>,
             }
         }
 
-        ty::Predicate::ClosureKind(closure_def_id, kind) => {
-            match selcx.infcx().closure_kind(closure_def_id) {
-                Some(closure_kind) => {
-                    if closure_kind.extends(kind) {
-                        Ok(Some(vec![]))
-                    } else {
-                        Err(CodeSelectionError(Unimplemented))
-                    }
-                }
-                None => {
-                    Ok(None)
-                }
-            }
-        }
-
         ty::Predicate::WellFormed(ty) => {
             match ty::wf::obligations(selcx.infcx(), obligation.cause.body_id,
                                       ty, obligation.cause.span) {

branches/try/src/librustc/traits/fulfill.rs

@@ -165,7 +165,6 @@ pub fn supertraits_reference_self<'tcx>(tcx: &TyCtxt<'tcx>,
                 ty::Predicate::ObjectSafe(..) |
                 ty::Predicate::TypeOutlives(..) |
                 ty::Predicate::RegionOutlives(..) |
-                ty::Predicate::ClosureKind(..) |
                 ty::Predicate::Equate(..) => {
                     false
                 }
@@ -208,7 +207,6 @@ fn generics_require_sized_self<'tcx>(tcx: &TyCtxt<'tcx>,
                 ty::Predicate::RegionOutlives(..) |
                 ty::Predicate::WellFormed(..) |
                 ty::Predicate::ObjectSafe(..) |
-                ty::Predicate::ClosureKind(..) |
                 ty::Predicate::TypeOutlives(..) => {
                     false
                 }

branches/try/src/librustc/traits/object_safety.rs

@@ -198,10 +198,9 @@ enum SelectionCandidate<'tcx> {
     /// we found an applicable bound in the trait definition.
     ProjectionCandidate,
 
-    /// Implementation of a `Fn`-family trait by one of the anonymous types
-    /// generated for a `||` expression. The ty::ClosureKind informs the
-    /// confirmation step what ClosureKind obligation to emit.
-    ClosureCandidate(/* closure */ DefId, &'tcx ty::ClosureSubsts<'tcx>, ty::ClosureKind),
+    /// Implementation of a `Fn`-family trait by one of the
+    /// anonymous types generated for a `||` expression.
+    ClosureCandidate(/* closure */ DefId, &'tcx ty::ClosureSubsts<'tcx>),
 
     /// Implementation of a `Fn`-family trait by one of the anonymous
     /// types generated for a fn pointer type (e.g., `fn(int)->int`)
@@ -322,11 +321,75 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
         let stack = self.push_stack(TraitObligationStackList::empty(), obligation);
         match self.candidate_from_obligation(&stack)? {
-            None => Ok(None),
+            None => {
+                self.consider_unification_despite_ambiguity(obligation);
+                Ok(None)
+            }
             Some(candidate) => Ok(Some(self.confirm_candidate(obligation, candidate)?)),
         }
     }
 
+    /// In the particular case of unboxed closure obligations, we can
+    /// sometimes do some amount of unification for the
+    /// argument/return types even though we can't yet fully match obligation.
+    /// The particular case we are interesting in is an obligation of the form:
+    ///
+    ///    C : FnFoo<A>
+    ///
+    /// where `C` is an unboxed closure type and `FnFoo` is one of the
+    /// `Fn` traits. Because we know that users cannot write impls for closure types
+    /// themselves, the only way that `C : FnFoo` can fail to match is under two
+    /// conditions:
+    ///
+    /// 1. The closure kind for `C` is not yet known, because inference isn't complete.
+    /// 2. The closure kind for `C` *is* known, but doesn't match what is needed.
+    ///    For example, `C` may be a `FnOnce` closure, but a `Fn` closure is needed.
+    ///
+    /// In either case, we always know what argument types are
+    /// expected by `C`, no matter what kind of `Fn` trait it
+    /// eventually matches. So we can go ahead and unify the argument
+    /// types, even though the end result is ambiguous.
+    ///
+    /// Note that this is safe *even if* the trait would never be
+    /// matched (case 2 above). After all, in that case, an error will
+    /// result, so it kind of doesn't matter what we do --- unifying
+    /// the argument types can only be helpful to the user, because
+    /// once they patch up the kind of closure that is expected, the
+    /// argment types won't really change.
+    fn consider_unification_despite_ambiguity(&mut self, obligation: &TraitObligation<'tcx>) {
+        // Is this a `C : FnFoo(...)` trait reference for some trait binding `FnFoo`?
+        match self.tcx().lang_items.fn_trait_kind(obligation.predicate.0.def_id()) {
+            Some(_) => { }
+            None => { return; }
+        }
+
+        // Is the self-type a closure type? We ignore bindings here
+        // because if it is a closure type, it must be a closure type from
+        // within this current fn, and hence none of the higher-ranked
+        // lifetimes can appear inside the self-type.
+        let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder());
+        let (closure_def_id, substs) = match self_ty.sty {
+            ty::TyClosure(id, ref substs) => (id, substs),
+            _ => { return; }
+        };
+        assert!(!substs.has_escaping_regions());
+
+        // It is OK to call the unnormalized variant here - this is only
+        // reached for TyClosure: Fn inputs where the closure kind is
+        // still unknown, which should only occur in typeck where the
+        // closure type is already normalized.
+        let closure_trait_ref = self.closure_trait_ref_unnormalized(obligation,
+                                                                    closure_def_id,
+                                                                    substs);
+
+        match self.confirm_poly_trait_refs(obligation.cause.clone(),
+                                           obligation.predicate.to_poly_trait_ref(),
+                                           closure_trait_ref) {
+            Ok(()) => { }
+            Err(_) => { /* Silently ignore errors. */ }
+        }
+    }
+
     ///////////////////////////////////////////////////////////////////////////
     // EVALUATION
     //
@@ -469,21 +532,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     }
                 }
             }
-
-            ty::Predicate::ClosureKind(closure_def_id, kind) => {
-                match self.infcx.closure_kind(closure_def_id) {
-                    Some(closure_kind) => {
-                        if closure_kind.extends(kind) {
-                            EvaluatedToOk
-                        } else {
-                            EvaluatedToErr
-                        }
-                    }
-                    None => {
-                        EvaluatedToAmbig
-                    }
-                }
-            }
         }
     }
 
@@ -1234,12 +1282,12 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             Some(closure_kind) => {
                 debug!("assemble_unboxed_candidates: closure_kind = {:?}", closure_kind);
                 if closure_kind.extends(kind) {
-                    candidates.vec.push(ClosureCandidate(closure_def_id, substs, kind));
+                    candidates.vec.push(ClosureCandidate(closure_def_id, substs));
                 }
             }
             None => {
                 debug!("assemble_unboxed_candidates: closure_kind not yet known");
-                candidates.vec.push(ClosureCandidate(closure_def_id, substs, kind));
+                candidates.ambiguous = true;
             }
         }
 
@@ -2023,9 +2071,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 Ok(VtableImpl(vtable_impl))
             }
 
-            ClosureCandidate(closure_def_id, substs, kind) => {
+            ClosureCandidate(closure_def_id, substs) => {
                 let vtable_closure =
-                    self.confirm_closure_candidate(obligation, closure_def_id, substs, kind)?;
+                    self.confirm_closure_candidate(obligation, closure_def_id, substs)?;
                 Ok(VtableClosure(vtable_closure))
             }
 
@@ -2382,8 +2430,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
     fn confirm_closure_candidate(&mut self,
                                  obligation: &TraitObligation<'tcx>,
                                  closure_def_id: DefId,
-                                 substs: &ty::ClosureSubsts<'tcx>,
-                                 kind: ty::ClosureKind)
+                                 substs: &ty::ClosureSubsts<'tcx>)
                                  -> Result<VtableClosureData<'tcx, PredicateObligation<'tcx>>,
                                            SelectionError<'tcx>>
     {
@@ -2394,7 +2441,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
         let Normalized {
             value: trait_ref,
-            mut obligations
+            obligations
         } = self.closure_trait_ref(obligation, closure_def_id, substs);
 
         debug!("confirm_closure_candidate(closure_def_id={:?}, trait_ref={:?}, obligations={:?})",
@@ -2406,10 +2453,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                                      obligation.predicate.to_poly_trait_ref(),
                                      trait_ref)?;
 
-        obligations.push(Obligation::new(
-                obligation.cause.clone(),
-                ty::Predicate::ClosureKind(closure_def_id, kind)));
-
         Ok(VtableClosureData {
             closure_def_id: closure_def_id,
             substs: substs.clone(),

branches/try/src/librustc/traits/select.rs

@@ -60,9 +60,6 @@ impl<'a,'tcx> PredicateSet<'a,'tcx> {
 
             ty::Predicate::ObjectSafe(data) =>
                 ty::Predicate::ObjectSafe(data),
-
-            ty::Predicate::ClosureKind(closure_def_id, kind) =>
-                ty::Predicate::ClosureKind(closure_def_id, kind)
         };
         self.set.insert(normalized_pred)
     }
@@ -159,9 +156,6 @@ impl<'cx, 'tcx> Elaborator<'cx, 'tcx> {
             ty::Predicate::Projection(..) => {
                 // Nothing to elaborate in a projection predicate.
             }
-            ty::Predicate::ClosureKind(..) => {
-                // Nothing to elaborate when waiting for a closure's kind to be inferred.
-            }
             ty::Predicate::RegionOutlives(..) |
             ty::Predicate::TypeOutlives(..) => {
                 // Currently, we do not "elaborate" predicates like

branches/try/src/librustc/traits/util.rs

@@ -832,11 +832,6 @@ pub enum Predicate<'tcx> {
 
     /// trait must be object-safe
     ObjectSafe(DefId),
-
-    /// No direct syntax. May be thought of as `where T : FnFoo<...>` for some 'TypeSpace'
-    /// substitutions `...` and T being a closure type.  Satisfied (or refuted) once we know the
-    /// closure's kind.
-    ClosureKind(DefId, ClosureKind),
 }
 
 impl<'tcx> Predicate<'tcx> {
@@ -926,8 +921,6 @@ impl<'tcx> Predicate<'tcx> {
                 Predicate::WellFormed(data.subst(tcx, substs)),
             Predicate::ObjectSafe(trait_def_id) =>
                 Predicate::ObjectSafe(trait_def_id),
-            Predicate::ClosureKind(closure_def_id, kind) =>
-                Predicate::ClosureKind(closure_def_id, kind),
         }
     }
 }
@@ -1115,9 +1108,6 @@ impl<'tcx> Predicate<'tcx> {
             ty::Predicate::ObjectSafe(_trait_def_id) => {
                 vec![]
             }
-            ty::Predicate::ClosureKind(_closure_def_id, _kind) => {
-                vec![]
-            }
         };
 
         // The only reason to collect into a vector here is that I was
@@ -1138,7 +1128,6 @@ impl<'tcx> Predicate<'tcx> {
             Predicate::RegionOutlives(..) |
             Predicate::WellFormed(..) |
             Predicate::ObjectSafe(..) |
-            Predicate::ClosureKind(..) |
             Predicate::TypeOutlives(..) => {
                 None
             }
@@ -1794,7 +1783,7 @@ pub struct ItemSubsts<'tcx> {
     pub substs: Substs<'tcx>,
 }
 
-#[derive(Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable)]
+#[derive(Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Debug, RustcEncodable, RustcDecodable)]
 pub enum ClosureKind {
     // Warning: Ordering is significant here! The ordering is chosen
     // because the trait Fn is a subtrait of FnMut and so in turn, and

branches/try/src/librustc/ty/mod.rs

@@ -644,8 +644,6 @@ impl<'tcx> TypeFoldable<'tcx> for ty::Predicate<'tcx> {
                 ty::Predicate::Projection(binder.fold_with(folder)),
             ty::Predicate::WellFormed(data) =>
                 ty::Predicate::WellFormed(data.fold_with(folder)),
-            ty::Predicate::ClosureKind(closure_def_id, kind) =>
-                ty::Predicate::ClosureKind(closure_def_id, kind),
             ty::Predicate::ObjectSafe(trait_def_id) =>
                 ty::Predicate::ObjectSafe(trait_def_id),
         }
@@ -659,7 +657,6 @@ impl<'tcx> TypeFoldable<'tcx> for ty::Predicate<'tcx> {
             ty::Predicate::TypeOutlives(ref binder) => binder.visit_with(visitor),
             ty::Predicate::Projection(ref binder) => binder.visit_with(visitor),
             ty::Predicate::WellFormed(data) => data.visit_with(visitor),
-            ty::Predicate::ClosureKind(_closure_def_id, _kind) => false,
             ty::Predicate::ObjectSafe(_trait_def_id) => false,
         }
     }

branches/try/src/librustc/ty/structural_impls.rs

@@ -301,7 +301,6 @@ impl<'tcx> TyCtxt<'tcx> {
                     ty::Predicate::Equate(..) |
                     ty::Predicate::WellFormed(..) |
                     ty::Predicate::ObjectSafe(..) |
-                    ty::Predicate::ClosureKind(..) |
                     ty::Predicate::RegionOutlives(..) => {
                         None
                     }