make `ty::Predicate` carry a `ClosureSubsts`

diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs
index e7627b110fae4c3a414958c7d60bd819cf3b20bc..8f2ad98f85885bb1fb7db4c3a1eb2e59044ff95a 100644 (file)
--- a/src/librustc/ich/impls_ty.rs
+++ b/src/librustc/ich/impls_ty.rs
@@ -236,8 +236,9 @@ fn hash_stable<W: StableHasherResult>(&self,
             ty::Predicate::ObjectSafe(def_id) => {
                 def_id.hash_stable(hcx, hasher);
             }
-            ty::Predicate::ClosureKind(def_id, closure_kind) => {
+            ty::Predicate::ClosureKind(def_id, closure_substs, closure_kind) => {
                 def_id.hash_stable(hcx, hasher);
+                closure_substs.hash_stable(hcx, hasher);
                 closure_kind.hash_stable(hcx, hasher);
             }
             ty::Predicate::ConstEvaluatable(def_id, substs) => {

diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs
index 7c38cf75b8d5a4f6bd457b84027c4488d1edd86c..caed3639b56360281aba815bd72cf7656eb31dec 100644 (file)
--- a/src/librustc/traits/error_reporting.rs
+++ b/src/librustc/traits/error_reporting.rs
@@ -643,7 +643,7 @@ pub fn report_selection_error(&self,
                                                             violations)
                     }
 
-                    ty::Predicate::ClosureKind(closure_def_id, kind) => {
+                    ty::Predicate::ClosureKind(closure_def_id, _closure_substs, kind) => {
                         let found_kind = self.closure_kind(closure_def_id).unwrap();
                         let closure_span = self.tcx.hir.span_if_local(closure_def_id).unwrap();
                         let node_id = self.tcx.hir.as_local_node_id(closure_def_id).unwrap();

diff --git a/src/librustc/traits/fulfill.rs b/src/librustc/traits/fulfill.rs
index 297feead61760f6a734aed7b02fb406f6dac5ca3..0dbf7a6a1f0b1d6abe7b28ea72bab86e13740d46 100644 (file)
--- a/src/librustc/traits/fulfill.rs
+++ b/src/librustc/traits/fulfill.rs
@@ -438,7 +438,7 @@ fn process_predicate<'a, 'gcx, 'tcx>(
             }
         }
 
-        ty::Predicate::ClosureKind(closure_def_id, kind) => {
+        ty::Predicate::ClosureKind(closure_def_id, _closure_substs, kind) => {
             match selcx.infcx().closure_kind(closure_def_id) {
                 Some(closure_kind) => {
                     if closure_kind.extends(kind) {

diff --git a/src/librustc/traits/select.rs b/src/librustc/traits/select.rs
index 7716770d318bae1b47bf6d4d763240b73c199607..a0d51101d78947163041b8396fb94849a18bc750 100644 (file)
--- a/src/librustc/traits/select.rs
+++ b/src/librustc/traits/select.rs
@@ -718,7 +718,7 @@ fn evaluate_predicate_recursively<'o>(&mut self,
                 }
             }
 
-            ty::Predicate::ClosureKind(closure_def_id, kind) => {
+            ty::Predicate::ClosureKind(closure_def_id, _closure_substs, kind) => {
                 match self.infcx.closure_kind(closure_def_id) {
                     Some(closure_kind) => {
                         if closure_kind.extends(kind) {
@@ -2726,7 +2726,7 @@ fn confirm_closure_candidate(&mut self,
         obligations.push(Obligation::new(
             obligation.cause.clone(),
             obligation.param_env,
-            ty::Predicate::ClosureKind(closure_def_id, kind)));
+            ty::Predicate::ClosureKind(closure_def_id, substs, kind)));
 
         Ok(VtableClosureData {
             closure_def_id,

diff --git a/src/librustc/traits/util.rs b/src/librustc/traits/util.rs
index 42e0834e8e43b1498e260125fe42d9fe9bc49aec..898accb90215934e4006b3e81a982fa494e4bb75 100644 (file)
--- a/src/librustc/traits/util.rs
+++ b/src/librustc/traits/util.rs
@@ -43,8 +43,8 @@ fn anonymize_predicate<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
         ty::Predicate::ObjectSafe(data) =>
             ty::Predicate::ObjectSafe(data),
 
-        ty::Predicate::ClosureKind(closure_def_id, kind) =>
-            ty::Predicate::ClosureKind(closure_def_id, kind),
+        ty::Predicate::ClosureKind(closure_def_id, closure_substs, kind) =>
+            ty::Predicate::ClosureKind(closure_def_id, closure_substs, kind),
 
         ty::Predicate::Subtype(ref data) =>
             ty::Predicate::Subtype(tcx.anonymize_late_bound_regions(data)),

diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index 93cb4344cb3b047fa53a3f78ec2cfde24e3dd97a..1ae49808d3f5e3548f51edeebe750e43f5d24e19 100644 (file)
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -896,7 +896,7 @@ pub enum Predicate<'tcx> {
     /// No direct syntax. May be thought of as `where T : FnFoo<...>`
     /// for some substitutions `...` and T being a closure type.
     /// Satisfied (or refuted) once we know the closure's kind.
-    ClosureKind(DefId, ClosureKind),
+    ClosureKind(DefId, ClosureSubsts<'tcx>, ClosureKind),
 
     /// `T1 <: T2`
     Subtype(PolySubtypePredicate<'tcx>),
@@ -999,8 +999,8 @@ pub fn subst_supertrait(&self, tcx: TyCtxt<'a, 'gcx, '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),
+            Predicate::ClosureKind(closure_def_id, closure_substs, kind) =>
+                Predicate::ClosureKind(closure_def_id, closure_substs.subst(tcx, substs), kind),
             Predicate::ConstEvaluatable(def_id, const_substs) =>
                 Predicate::ConstEvaluatable(def_id, const_substs.subst(tcx, substs)),
         }
@@ -1182,8 +1182,8 @@ pub fn walk_tys(&self) -> IntoIter<Ty<'tcx>> {
             ty::Predicate::ObjectSafe(_trait_def_id) => {
                 vec![]
             }
-            ty::Predicate::ClosureKind(_closure_def_id, _kind) => {
-                vec![]
+            ty::Predicate::ClosureKind(_closure_def_id, closure_substs, _kind) => {
+                closure_substs.substs.types().collect()
             }
             ty::Predicate::ConstEvaluatable(_, substs) => {
                 substs.types().collect()

diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs
index e5c24b4fcf92139bfc129928e65a3c28437adcb4..73d1b4c3400386d0da84730fb483207b85e6f0e4 100644 (file)
--- a/src/librustc/ty/structural_impls.rs
+++ b/src/librustc/ty/structural_impls.rs
@@ -211,8 +211,11 @@ fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lif
             ty::Predicate::WellFormed(ty) => {
                 tcx.lift(&ty).map(ty::Predicate::WellFormed)
             }
-            ty::Predicate::ClosureKind(closure_def_id, kind) => {
-                Some(ty::Predicate::ClosureKind(closure_def_id, kind))
+            ty::Predicate::ClosureKind(closure_def_id, closure_substs, kind) => {
+                tcx.lift(&closure_substs)
+                   .map(|closure_substs| ty::Predicate::ClosureKind(closure_def_id,
+                                                                    closure_substs,
+                                                                    kind))
             }
             ty::Predicate::ObjectSafe(trait_def_id) => {
                 Some(ty::Predicate::ObjectSafe(trait_def_id))
@@ -966,8 +969,8 @@ fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F)
                 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::ClosureKind(closure_def_id, closure_substs, kind) =>
+                ty::Predicate::ClosureKind(closure_def_id, closure_substs.fold_with(folder), kind),
             ty::Predicate::ObjectSafe(trait_def_id) =>
                 ty::Predicate::ObjectSafe(trait_def_id),
             ty::Predicate::ConstEvaluatable(def_id, substs) =>
@@ -984,7 +987,8 @@ fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
             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::ClosureKind(_closure_def_id, closure_substs, _kind) =>
+                closure_substs.visit_with(visitor),
             ty::Predicate::ObjectSafe(_trait_def_id) => false,
             ty::Predicate::ConstEvaluatable(_def_id, substs) => substs.visit_with(visitor),
         }

diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
index acb929981fbf2ce209f0404d13b2034e2cac2c4a..f130f28153e3ba93bca448cd71946e0c99c03f99 100644 (file)
--- a/src/librustc/util/ppaux.rs
+++ b/src/librustc/util/ppaux.rs
@@ -1257,7 +1257,7 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                     ty::tls::with(|tcx| {
                         write!(f, "the trait `{}` is object-safe", tcx.item_path_str(trait_def_id))
                     }),
-                ty::Predicate::ClosureKind(closure_def_id, kind) =>
+                ty::Predicate::ClosureKind(closure_def_id, _closure_substs, kind) =>
                     ty::tls::with(|tcx| {
                         write!(f, "the closure `{}` implements the trait `{}`",
                                tcx.item_path_str(closure_def_id), kind)
@@ -1281,8 +1281,8 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                 ty::Predicate::ObjectSafe(trait_def_id) => {
                     write!(f, "ObjectSafe({:?})", trait_def_id)
                 }
-                ty::Predicate::ClosureKind(closure_def_id, kind) => {
-                    write!(f, "ClosureKind({:?}, {:?})", closure_def_id, kind)
+                ty::Predicate::ClosureKind(closure_def_id, closure_substs, kind) => {
+                    write!(f, "ClosureKind({:?}, {:?}, {:?})", closure_def_id, closure_substs, kind)
                 }
                 ty::Predicate::ConstEvaluatable(def_id, substs) => {
                     write!(f, "ConstEvaluatable({:?}, {:?})", def_id, substs)