Error for where-clause with unconstrained late-bound lifetimes

Author: nikomatsakis

src/librustc/ty/fold.rs

@@ -387,7 +387,8 @@ impl<'tcx> TyCtxt<'tcx> {
         where T : TypeFoldable<'tcx>
     {
         let mut collector = LateBoundRegionsCollector::new();
-        value.skip_binder().visit_with(&mut collector);
+        let result = value.skip_binder().visit_with(&mut collector);
+        assert!(!result); // should never have stopped early
         collector.regions
     }
 
@@ -667,7 +668,7 @@ impl<'tcx> TypeVisitor<'tcx> for LateBoundRegionsCollector {
             }
             _ => { }
         }
-        true
+        false
     }
 }
 

src/librustc_typeck/astconv.rs

@@ -892,6 +892,10 @@ fn ast_type_binding_to_poly_projection_predicate<'tcx>(
 {
     let tcx = this.tcx();
 
+    debug!("ast_type_binding_to_poly_projection_predicate()");
+    debug!("trait_ref = {:?}", trait_ref);
+    debug!("self_ty = {:?}", self_ty);
+
     // Given something like `U : SomeTrait<T=X>`, we want to produce a
     // predicate like `<U as SomeTrait>::T = X`. This is somewhat
     // subtle in the event that `T` is defined in a supertrait of
@@ -908,6 +912,34 @@ fn ast_type_binding_to_poly_projection_predicate<'tcx>(
     //
     // We want to produce `<B as SuperTrait<int>>::T == foo`.
 
+    // Find any late-bound regions declared in `ty` that are not
+    // declared in the trait-ref. These are not wellformed.
+    //
+    // Example:
+    //
+    //     for<'a> <T as Iterator>::Item = &'a str // <-- 'a is bad
+    //     for<'a> <T as FnMut<(&'a u32,)>>::Output = &'a str // <-- 'a is ok
+    let late_bound_in_trait_ref = tcx.collect_late_bound_regions(&trait_ref);
+    let late_bound_in_ty = tcx.collect_late_bound_regions(&ty::Binder(binding.ty));
+    debug!("late_bound_in_trait_ref = {:?}", late_bound_in_trait_ref);
+    debug!("late_bound_in_ty = {:?}", late_bound_in_ty);
+    for br in late_bound_in_ty.difference(&late_bound_in_trait_ref) {
+        let br_name = match *br {
+            ty::BrNamed(_, name) => name,
+            _ => {
+                this.tcx().sess.span_bug(
+                    binding.span,
+                    &format!("anonymous bound region {:?} in binding but not trait ref",
+                             br));
+            }
+        };
+        this.tcx().sess.span_err(
+            binding.span,
+            &format!("binding for associated type `{}` references lifetime `{}`, \
+                      which does not appear in the trait input types",
+                     binding.item_name, br_name));
+    }
+
     // Simple case: X is defined in the current trait.
     if this.trait_defines_associated_type_named(trait_ref.def_id(), binding.item_name) {
         return Ok(ty::Binder(ty::ProjectionPredicate {      // <-------------------+

src/test/compile-fail/associated-types/bound-lifetime-in-binding-only.rs

@@ -0,0 +1,71 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// revisions: angle paren ok elision
+
+#![allow(dead_code)]
+#![feature(rustc_attrs)]
+#![feature(unboxed_closures)]
+
+trait Foo {
+    type Item;
+}
+
+#[cfg(angle)]
+fn angle<T: for<'a> Foo<Item=&'a i32>>() {
+    //[angle]~^ ERROR binding for associated type `Item` references lifetime `'a`
+}
+
+#[cfg(angle)]
+fn angle1<T>() where T: for<'a> Foo<Item=&'a i32>>() {
+    //[angle]~^ ERROR binding for associated type `Item` references lifetime `'a`
+}
+
+#[cfg(angle)]
+fn angle2<T>() where for<'a> T: Foo<Item=&'a i32>>() {
+    //[angle]~^ ERROR binding for associated type `Item` references lifetime `'a`
+}
+
+#[cfg(paren)]
+fn paren<T: for<'a> Fn() -> &'a i32>() {
+    //[paren]~^ ERROR binding for associated type `Output` references lifetime `'a`
+}
+
+#[cfg(paren)]
+fn paren1<T> where T: for<'a> Fn() -> &'a i32>() {
+    //[paren]~^ ERROR binding for associated type `Output` references lifetime `'a`
+}
+
+#[cfg(paren)]
+fn paren2<T> where for<'a> T: Fn() -> &'a i32>() {
+    //[paren]~^ ERROR binding for associated type `Output` references lifetime `'a`
+}
+
+#[cfg(elision)]
+fn elision<T: Fn() -> &i32>() {
+    //[elision]~^ ERROR E0106
+}
+
+struct Parameterized<'a> { x: &'a str }
+
+#[cfg(ok)]
+fn ok1<T: for<'a> Fn(&Parameterized<'a>) -> &'a i32>() {
+}
+
+#[cfg(ok)]
+fn ok2<T: for<'a,'b> Fn<(&'b Parameterized<'a>,), Output=&'a i32>>() {
+}
+
+#[cfg(ok)]
+fn ok3<T> where for<'a> Parameterized<'a>: Foo<Item=&'a i32> {
+}
+
+#[rustc_error]
+fn main() { } //[ok]~ ERROR compilation successful