refine the warnings to consider projection inputs

Author: nikomatsakis

src/librustc/ty/fold.rs

@@ -394,11 +394,30 @@ impl<'tcx> TyCtxt<'tcx> {
         }
     }
 
-    pub fn collect_late_bound_regions<T>(&self, value: &Binder<T>)
-                                         -> FnvHashSet<ty::BoundRegion>
+    /// Returns a set of all late-bound regions that are constrained
+    /// by `value`, meaning that if we instantiate those LBR with
+    /// variables and equate `value` with something else, those
+    /// variables will also be equated.
+    pub fn collect_constrained_late_bound_regions<T>(&self, value: &Binder<T>)
+                                                     -> FnvHashSet<ty::BoundRegion>
         where T : TypeFoldable<'tcx>
     {
-        let mut collector = LateBoundRegionsCollector::new();
+        self.collect_late_bound_regions(value, true)
+    }
+
+    /// Returns a set of all late-bound regions that appear in `value` anywhere.
+    pub fn collect_referenced_late_bound_regions<T>(&self, value: &Binder<T>)
+                                                    -> FnvHashSet<ty::BoundRegion>
+        where T : TypeFoldable<'tcx>
+    {
+        self.collect_late_bound_regions(value, false)
+    }
+
+    fn collect_late_bound_regions<T>(&self, value: &Binder<T>, just_constraint: bool)
+                                     -> FnvHashSet<ty::BoundRegion>
+        where T : TypeFoldable<'tcx>
+    {
+        let mut collector = LateBoundRegionsCollector::new(just_constraint);
         let result = value.skip_binder().visit_with(&mut collector);
         assert!(!result); // should never have stopped early
         collector.regions
@@ -655,13 +674,15 @@ impl<'tcx> TypeVisitor<'tcx> for HasTypeFlagsVisitor {
 struct LateBoundRegionsCollector {
     current_depth: u32,
     regions: FnvHashSet<ty::BoundRegion>,
+    just_constrained: bool,
 }
 
 impl LateBoundRegionsCollector {
-    fn new() -> Self {
+    fn new(just_constrained: bool) -> Self {
         LateBoundRegionsCollector {
             current_depth: 1,
             regions: FnvHashSet(),
+            just_constrained: just_constrained,
         }
     }
 }
@@ -675,6 +696,20 @@ impl<'tcx> TypeVisitor<'tcx> for LateBoundRegionsCollector {
         self.current_depth -= 1;
     }
 
+    fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
+        // if we are only looking for "constrained" region, we have to
+        // ignore the inputs to a projection, as they may not appear
+        // in the normalized form
+        if self.just_constrained {
+            match t.sty {
+                ty::TyProjection(..) => { return false; }
+                _ => { }
+            }
+        }
+
+        t.super_visit_with(self)
+    }
+
     fn visit_region(&mut self, r: ty::Region) -> bool {
         match r {
             ty::ReLateBound(debruijn, br) if debruijn.depth == self.current_depth => {

src/librustc_typeck/astconv.rs

@@ -922,8 +922,8 @@ fn ast_type_binding_to_poly_projection_predicate<'tcx>(
     //
     //     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));
+    let late_bound_in_trait_ref = tcx.collect_constrained_late_bound_regions(&trait_ref);
+    let late_bound_in_ty = tcx.collect_referenced_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) {
@@ -1702,9 +1702,9 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>,
             // checking for here would be considered early bound
             // anyway.)
             let inputs = bare_fn_ty.sig.inputs();
-            let late_bound_in_args = this.tcx().collect_late_bound_regions(&inputs);
+            let late_bound_in_args = this.tcx().collect_constrained_late_bound_regions(&inputs);
             let output = bare_fn_ty.sig.output();
-            let late_bound_in_ret = this.tcx().collect_late_bound_regions(&output);
+            let late_bound_in_ret = this.tcx().collect_referenced_late_bound_regions(&output);
             for br in late_bound_in_ret.difference(&late_bound_in_args) {
                 let br_name = match *br {
                     ty::BrNamed(_, name) => name,

src/test/compile-fail/associated-types/bound-lifetime-constrained.rs

@@ -0,0 +1,66 @@
+// 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: func object clause 
+
+#![allow(dead_code)]
+#![feature(rustc_attrs)]
+#![feature(unboxed_closures)]
+#![deny(hr_lifetime_in_assoc_type)]
+
+trait Foo<'a> {
+    type Item;
+}
+
+impl<'a> Foo<'a> for() {
+    type Item = ();
+}
+
+// Check that appearing in a projection input in the argument is not enough:
+#[cfg(func)]
+fn func1(_: for<'a> fn(<() as Foo<'a>>::Item) -> &'a i32) {
+    //[func]~^ ERROR return type references lifetime `'a`
+    //[func]~| WARNING previously accepted
+}
+
+// Check that appearing in a projection input in the return still
+// causes an error:
+#[cfg(func)]
+fn func2(_: for<'a> fn() -> <() as Foo<'a>>::Item) {
+    //[func]~^ ERROR return type references lifetime `'a`
+    //[func]~| WARNING previously accepted
+}
+
+#[cfg(object)]
+fn object1(_: Box<for<'a> Fn(<() as Foo<'a>>::Item) -> &'a i32>) {
+    //[object]~^ ERROR return type references lifetime `'a`
+    //[object]~| WARNING previously accepted
+}
+
+#[cfg(object)]
+fn object2(_: Box<for<'a> Fn() -> <() as Foo<'a>>::Item>) {
+    //[object]~^ ERROR return type references lifetime `'a`
+    //[object]~| WARNING previously accepted
+}
+
+#[cfg(clause)]
+fn clause1<T>() where T: for<'a> Fn(<() as Foo<'a>>::Item) -> &'a i32 {
+    //[clause]~^ ERROR return type references lifetime `'a`
+    //[clause]~| WARNING previously accepted
+}
+
+#[cfg(clause)]
+fn clause2<T>() where T: for<'a> Fn() -> <() as Foo<'a>>::Item {
+    //[clause]~^ ERROR return type references lifetime `'a`
+    //[clause]~| WARNING previously accepted
+}
+
+#[rustc_error]
+fn main() { } //[ok]~ ERROR compilation successful