Bail on lifetime-y trait bounds in elision lint (fixes #292)

Author: Manishearth

src/lifetimes.rs

@@ -1,7 +1,7 @@
 use syntax::ast::*;
 use rustc::lint::*;
 use syntax::codemap::Span;
-use syntax::visit::{Visitor, walk_ty, walk_ty_param_bound};
+use syntax::visit::{Visitor, walk_ty, walk_ty_param_bound, walk_ty_param_bounds_helper};
 use std::collections::HashSet;
 
 use utils::{in_external_macro, span_lint};
@@ -53,22 +53,25 @@ fn check_fn_inner(cx: &Context, decl: &FnDecl, slf: Option<&ExplicitSelf>,
     if in_external_macro(cx, span) || has_where_lifetimes(&generics.where_clause) {
         return;
     }
-    if could_use_elision(decl, slf, &generics.lifetimes) {
+    if could_use_elision(decl, slf, generics) {
         span_lint(cx, NEEDLESS_LIFETIMES, span,
                   "explicit lifetimes given in parameter types where they could be elided");
     }
 }
 
 fn could_use_elision(func: &FnDecl, slf: Option<&ExplicitSelf>,
-                     named_lts: &[LifetimeDef]) -> bool {
+                     generics: &Generics) -> bool {
     // There are two scenarios where elision works:
     // * no output references, all input references have different LT
     // * output references, exactly one input reference with same LT
     // All lifetimes must be unnamed, 'static or defined without bounds on the
     // level of the current item.
 
     // check named LTs
-    let allowed_lts = allowed_lts_from(named_lts);
+    let Generics {ref lifetimes, ref ty_params, ..} = *generics;
+    let allowed_lts = allowed_lts_from(lifetimes);
+
+    if params_contain_lts(ty_params) {return false;}
 
     // these will collect all the lifetimes for references in arg/return types
     let mut input_visitor = RefVisitor(Vec::new());
@@ -147,6 +150,14 @@ fn allowed_lts_from(named_lts: &[LifetimeDef]) -> HashSet<RefLt> {
     allowed_lts
 }
 
+fn params_contain_lts(params: &[TyParam]) -> bool {
+    let mut param_vis = RefVisitor(Vec::new());
+    for param in params {
+        walk_ty_param_bounds_helper(&mut param_vis, &param.bounds);
+    }
+    !param_vis.0.is_empty()
+}
+
 /// Number of unique lifetimes in the given vector.
 fn unique_lifetimes(lts: &[RefLt]) -> usize {
     lts.iter().collect::<HashSet<_>>().len()
@@ -183,9 +194,6 @@ impl<'v> Visitor<'v> for RefVisitor {
     fn visit_lifetime_ref(&mut self, lifetime: &'v Lifetime) {
         self.record(&Some(*lifetime));
     }
-
-    // for lifetime bounds; the default impl calls visit_lifetime_ref
-    fn visit_lifetime_bound(&mut self, _: &'v Lifetime) { }
 }
 
 /// Are any lifetimes mentioned in the `where` clause? If yes, we don't try to

tests/compile-fail/lifetimes.rs

@@ -3,48 +3,49 @@
 
 #![deny(needless_lifetimes)]
 #![allow(dead_code)]
-fn distinct_lifetimes<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: u8) { }
+#![allow(unused)]
+fn distinct_lifetimes<'a, 'b>(x: &'a u8, y: &'b u8, z: u8) { }
 //~^ERROR explicit lifetimes given
 
-fn distinct_and_static<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: &'static u8) { }
+fn distinct_and_static<'a, 'b>(x: &'a u8, y: &'b u8, z: &'static u8) { }
 //~^ERROR explicit lifetimes given
 
-fn same_lifetime_on_input<'a>(_x: &'a u8, _y: &'a u8) { } // no error, same lifetime on two params
+fn same_lifetime_on_input<'a>(x: &'a u8, y: &'a u8) { } // no error, same lifetime on two params
 
-fn only_static_on_input(_x: &u8, _y: &u8, _z: &'static u8) { } // no error, static involved
+fn only_static_on_input(x: &u8, y: &u8, z: &'static u8) { } // no error, static involved
 
-fn mut_and_static_input(_x: &mut u8, _y: &'static str) { }
+fn mut_and_static_input(x: &mut u8, y: &'static str) { }
 
-fn in_and_out<'a>(x: &'a u8, _y: u8) -> &'a u8 { x }
+fn in_and_out<'a>(x: &'a u8, y: u8) -> &'a u8 { x }
 //~^ERROR explicit lifetimes given
 
-fn multiple_in_and_out_1<'a>(x: &'a u8, _y: &'a u8) -> &'a u8 { x } // no error, multiple input refs
+fn multiple_in_and_out_1<'a>(x: &'a u8, y: &'a u8) -> &'a u8 { x } // no error, multiple input refs
 
-fn multiple_in_and_out_2<'a, 'b>(x: &'a u8, _y: &'b u8) -> &'a u8 { x } // no error, multiple input refs
+fn multiple_in_and_out_2<'a, 'b>(x: &'a u8, y: &'b u8) -> &'a u8 { x } // no error, multiple input refs
 
-fn in_static_and_out<'a>(x: &'a u8, _y: &'static u8) -> &'a u8 { x } // no error, static involved
+fn in_static_and_out<'a>(x: &'a u8, y: &'static u8) -> &'a u8 { x } // no error, static involved
 
-fn deep_reference_1<'a, 'b>(x: &'a u8, _y: &'b u8) -> Result<&'a u8, ()> { Ok(x) } // no error
+fn deep_reference_1<'a, 'b>(x: &'a u8, y: &'b u8) -> Result<&'a u8, ()> { Ok(x) } // no error
 
 fn deep_reference_2<'a>(x: Result<&'a u8, &'a u8>) -> &'a u8 { x.unwrap() } // no error, two input refs
 
-fn deep_reference_3<'a>(x: &'a u8, _y: u8) -> Result<&'a u8, ()> { Ok(x) }
+fn deep_reference_3<'a>(x: &'a u8, y: u8) -> Result<&'a u8, ()> { Ok(x) }
 //~^ERROR explicit lifetimes given
 
 // where clause, but without lifetimes
-fn where_clause_without_lt<'a, T>(x: &'a u8, _y: u8) -> Result<&'a u8, ()> where T: Copy { Ok(x) }
+fn where_clause_without_lt<'a, T>(x: &'a u8, y: u8) -> Result<&'a u8, ()> where T: Copy { Ok(x) }
 //~^ERROR explicit lifetimes given
 
 type Ref<'r> = &'r u8;
 
-fn lifetime_param_1<'a>(_x: Ref<'a>, _y: &'a u8) { } // no error, same lifetime on two params
+fn lifetime_param_1<'a>(x: Ref<'a>, y: &'a u8) { } // no error, same lifetime on two params
 
-fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) { }
+fn lifetime_param_2<'a, 'b>(x: Ref<'a>, y: &'b u8) { }
 //~^ERROR explicit lifetimes given
 
-fn lifetime_param_3<'a, 'b: 'a>(_x: Ref<'a>, _y: &'b u8) { } // no error, bounded lifetime
+fn lifetime_param_3<'a, 'b: 'a>(x: Ref<'a>, y: &'b u8) { } // no error, bounded lifetime
 
-fn lifetime_param_4<'a, 'b>(_x: Ref<'a>, _y: &'b u8) where 'b: 'a { } // no error, bounded lifetime
+fn lifetime_param_4<'a, 'b>(x: Ref<'a>, y: &'b u8) where 'b: 'a { } // no error, bounded lifetime
 
 struct Lt<'a, I: 'static> {
     x: &'a I
@@ -62,16 +63,23 @@ struct X {
     x: u8,
 }
 
+// no errors, bounded lifetimes:
+trait Trait<'a> {}
+fn trait_bound<'a, T: Trait<'a>>(x: &'a u8, y: T) {}
+fn trait_bound_where<'a, T>(x: &'a u8, y: T) where T: Trait<'a> {}
+fn lt_bound<'a, T: 'a>(x: &'a u8, y: T) {}
+fn lt_bound_where<'a, T>(x: &'a u8, y: T) where T : 'a {}
+
 impl X {
     fn self_and_out<'s>(&'s self) -> &'s u8 { &self.x }
     //~^ERROR explicit lifetimes given
 
-    fn self_and_in_out<'s, 't>(&'s self, _x: &'t u8) -> &'s u8 { &self.x } // no error, multiple input refs
+    fn self_and_in_out<'s, 't>(&'s self, x: &'t u8) -> &'s u8 { &self.x } // no error, multiple input refs
 
-    fn distinct_self_and_in<'s, 't>(&'s self, _x: &'t u8) { }
+    fn distinct_self_and_in<'s, 't>(&'s self, x: &'t u8) { }
     //~^ERROR explicit lifetimes given
 
-    fn self_and_same_in<'s>(&'s self, _x: &'s u8) { } // no error, same lifetimes on two params
+    fn self_and_same_in<'s>(&'s self, x: &'s u8) { } // no error, same lifetimes on two params
 }
 
 struct Foo<'a>(&'a u8);