add lint to detect ignored generic bounds; this subsumes the previous 'generic bounds in type aliases are ignored' warning

RalfJung · RalfJung · commit 0c5bc12a3b70 · 2018-02-18T19:57:17.000+01:00
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
@@ -1386,3 +1386,85 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnreachablePub {
         self.perform_lint(cx, "item", impl_item.id, &impl_item.vis, impl_item.span, false);
     }
 }
+
+/// Lint for trait and lifetime bounds that are (accidentally) accepted by the parser, but
+/// ignored later.
+
+pub struct IgnoredGenericBounds;
+
+declare_lint! {
+    IGNORED_GENERIC_BOUNDS,
+    Warn,
+    "these generic bounds are ignored"
+}
+
+impl LintPass for IgnoredGenericBounds {
+    fn get_lints(&self) -> LintArray {
+        lint_array!(IGNORED_GENERIC_BOUNDS)
+    }
+}
+
+impl IgnoredGenericBounds {
+    fn ensure_no_param_bounds(
+        cx: &EarlyContext,
+        span: Span,
+        generics: &Vec<ast::GenericParam>,
+        thing: &'static str,
+    ) {
+        let has_bound = generics.iter().any(|param|
+            match param {
+                &ast::GenericParam::Lifetime(ref lifetime) => {
+                    !lifetime.bounds.is_empty()
+                }
+                &ast::GenericParam::Type(ref ty) => {
+                    !ty.bounds.is_empty()
+                }
+            }
+        );
+
+        if has_bound {
+            cx.span_lint(IGNORED_GENERIC_BOUNDS, span,
+                format!("bounds on generic parameters are ignored in {}", thing).as_ref());
+        }
+    }
+}
+
+impl EarlyLintPass for IgnoredGenericBounds {
+    fn check_item(&mut self, cx: &EarlyContext, item: &ast::Item) {
+        match item.node {
+            ast::ItemKind::Ty(_, ref generics) => {
+                if !generics.where_clause.predicates.is_empty() {
+                    cx.span_lint(IGNORED_GENERIC_BOUNDS, item.span,
+                        "where clauses are ignored in trait bounds");
+                }
+                IgnoredGenericBounds::ensure_no_param_bounds(cx, item.span, &generics.params,
+                    "type aliases");
+            }
+            _ => {}
+        }
+    }
+
+    fn check_where_predicate(&mut self, cx: &EarlyContext, p: &ast::WherePredicate) {
+        if let &ast::WherePredicate::BoundPredicate(ref bound_predicate) = p {
+            // A type binding, eg `for<'c> Foo: Send+Clone+'c`
+            IgnoredGenericBounds::ensure_no_param_bounds(cx, bound_predicate.span,
+                &bound_predicate.bound_generic_params, "higher-ranked trait bounds (i.e., `for`)");
+        }
+    }
+
+    fn check_poly_trait_ref(&mut self, cx: &EarlyContext, t: &ast::PolyTraitRef,
+                            _: &ast::TraitBoundModifier) {
+        IgnoredGenericBounds::ensure_no_param_bounds(cx, t.span, &t.bound_generic_params,
+            "higher-ranked trait bounds (i.e., `for`)");
+    }
+
+    fn check_ty(&mut self, cx: &EarlyContext, ty: &ast::Ty) {
+        match ty.node {
+            ast::TyKind::BareFn(ref fn_ty) => {
+                IgnoredGenericBounds::ensure_no_param_bounds(cx, ty.span, &fn_ty.generic_params,
+                    "higher-ranked function types (i.e., `for`)");
+            }
+            _ => {}
+        }
+    }
+}
diff --git a/src/librustc_lint/lib.rs b/src/librustc_lint/lib.rs
@@ -109,6 +109,7 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
                        AnonymousParameters,
                        IllegalFloatLiteralPattern,
                        UnusedDocComment,
+                       IgnoredGenericBounds,
                        );
 
     add_early_builtin_with_new!(sess,
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
@@ -355,39 +355,6 @@ fn is_param<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     }
 }
 
-fn ensure_no_param_bounds(tcx: TyCtxt,
-                          span: Span,
-                          generics: &hir::Generics,
-                          thing: &'static str) {
-    let mut warn = false;
-
-    for ty_param in generics.ty_params() {
-        if !ty_param.bounds.is_empty() {
-            warn = true;
-        }
-    }
-
-    for lft_param in generics.lifetimes() {
-        if !lft_param.bounds.is_empty() {
-            warn = true;
-        }
-    }
-
-    if !generics.where_clause.predicates.is_empty() {
-        warn = true;
-    }
-
-    if warn {
-        // According to accepted RFC #XXX, we should
-        // eventually accept these, but it will not be
-        // part of this PR. Still, convert to warning to
-        // make bootstrapping easier.
-        span_warn!(tcx.sess, span, E0122,
-                   "generic bounds are ignored in {}",
-                   thing);
-    }
-}
-
 fn convert_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, item_id: ast::NodeId) {
     let it = tcx.hir.expect_item(item_id);
     debug!("convert: item {} with id {}", it.name, it.id);
@@ -448,13 +415,7 @@ fn convert_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, item_id: ast::NodeId) {
                 convert_variant_ctor(tcx, struct_def.id());
             }
         },
-        hir::ItemTy(_, ref generics) => {
-            ensure_no_param_bounds(tcx, it.span, generics, "type aliases");
-            tcx.generics_of(def_id);
-            tcx.type_of(def_id);
-            tcx.predicates_of(def_id);
-        }
-        hir::ItemStatic(..) | hir::ItemConst(..) | hir::ItemFn(..) => {
+        hir::ItemTy(..) | hir::ItemStatic(..) | hir::ItemConst(..) | hir::ItemFn(..) => {
             tcx.generics_of(def_id);
             tcx.type_of(def_id);
             tcx.predicates_of(def_id);
diff --git a/src/librustc_typeck/diagnostics.rs b/src/librustc_typeck/diagnostics.rs
@@ -1524,26 +1524,6 @@ static BAR: _ = "test"; // error, explicitly write out the type instead
 ```
 "##,
 
-E0122: r##"
-An attempt was made to add a generic constraint to a type alias. This constraint
-is entirely ignored. For backwards compatibility, Rust still allows this with a
-warning. Consider the example below:
-
-```
-trait Foo{}
-
-type MyType<R: Foo> = (R, ());
-
-fn main() {
-    let t: MyType<u32>;
-}
-```
-
-We're able to declare a variable of type `MyType<u32>`, despite the fact that
-`u32` does not implement `Foo`. As a result, one should avoid using generic
-constraints in concert with type aliases.
-"##,
-
 E0124: r##"
 You declared two fields of a struct with the same name. Erroneous code
 example:
diff --git a/src/test/ui/param-bounds-ignored.rs b/src/test/ui/param-bounds-ignored.rs
@@ -9,12 +9,14 @@
 // except according to those terms.
 
 // must-compile-successfully
+#![allow(dead_code, non_camel_case_types)]
 
 use std::rc::Rc;
 
 type SVec<T: Send> = Vec<T>;
 type VVec<'b, 'a: 'b> = Vec<&'a i32>;
 type WVec<'b, T: 'b> = Vec<T>;
+type W2Vec<'b, T> where T: 'b = Vec<T>;
 
 fn foo<'a>(y: &'a i32) {
     // If the bounds above would matter, the code below would be rejected.
@@ -26,8 +28,62 @@ fn foo<'a>(y: &'a i32) {
 
     let mut x : WVec<'static, & 'a i32> = Vec::new();
     x.push(y);
+
+    let mut x : W2Vec<'static, & 'a i32> = Vec::new();
+    x.push(y);
+}
+
+fn bar1<'a, 'b>(
+    x: &'a i32,
+    y: &'b i32,
+    f: for<'xa, 'xb: 'xa> fn(&'xa i32, &'xb i32) -> &'xa i32)
+{
+    // If the bound in f's type would matter, the call below would (have to)
+    // be rejected.
+    f(x, y);
 }
 
+fn bar2<'a, 'b, F: for<'xa, 'xb: 'xa> Fn(&'xa i32, &'xb i32) -> &'xa i32>(
+    x: &'a i32,
+    y: &'b i32,
+    f: F)
+{
+    // If the bound in f's type would matter, the call below would (have to)
+    // be rejected.
+    f(x, y);
+}
+
+fn bar3<'a, 'b, F>(
+    x: &'a i32,
+    y: &'b i32,
+    f: F)
+    where F: for<'xa, 'xb: 'xa> Fn(&'xa i32, &'xb i32) -> &'xa i32
+{
+    // If the bound in f's type would matter, the call below would (have to)
+    // be rejected.
+    f(x, y);
+}
+
+fn bar4<'a, 'b, F>(
+    x: &'a i32,
+    y: &'b i32,
+    f: F)
+    where for<'xa, 'xb: 'xa> F: Fn(&'xa i32, &'xb i32) -> &'xa i32
+{
+    // If the bound in f's type would matter, the call below would (have to)
+    // be rejected.
+    f(x, y);
+}
+
+struct S1<F: for<'xa, 'xb: 'xa> Fn(&'xa i32, &'xb i32) -> &'xa i32>(F);
+struct S2<F>(F) where F: for<'xa, 'xb: 'xa> Fn(&'xa i32, &'xb i32) -> &'xa i32;
+struct S3<F>(F) where for<'xa, 'xb: 'xa> F: Fn(&'xa i32, &'xb i32) -> &'xa i32;
+
+struct S_fnty(for<'xa, 'xb: 'xa> fn(&'xa i32, &'xb i32) -> &'xa i32);
+
+type T1 = Box<for<'xa, 'xb: 'xa> Fn(&'xa i32, &'xb i32) -> &'xa i32>;
+
 fn main() {
-    foo(&42);
+    let _ : Option<for<'xa, 'xb: 'xa> fn(&'xa i32, &'xb i32) -> &'xa i32> = None;
+    let _ : Option<Box<for<'xa, 'xb: 'xa> Fn(&'xa i32, &'xb i32) -> &'xa i32>> = None;
 }
diff --git a/src/test/ui/param-bounds-ignored.stderr b/src/test/ui/param-bounds-ignored.stderr
@@ -1,18 +1,92 @@
-warning[E0122]: generic bounds are ignored in type aliases
-  --> $DIR/param-bounds-ignored.rs:15:1
+warning: bounds on generic parameters are ignored in type aliases
+  --> $DIR/param-bounds-ignored.rs:16:1
    |
-15 | type SVec<T: Send> = Vec<T>;
+16 | type SVec<T: Send> = Vec<T>;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: #[warn(ignored_generic_bounds)] on by default
 
-warning[E0122]: generic bounds are ignored in type aliases
-  --> $DIR/param-bounds-ignored.rs:16:1
+warning: bounds on generic parameters are ignored in type aliases
+  --> $DIR/param-bounds-ignored.rs:17:1
    |
-16 | type VVec<'b, 'a: 'b> = Vec<&'a i32>;
+17 | type VVec<'b, 'a: 'b> = Vec<&'a i32>;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-warning[E0122]: generic bounds are ignored in type aliases
-  --> $DIR/param-bounds-ignored.rs:17:1
+warning: bounds on generic parameters are ignored in type aliases
+  --> $DIR/param-bounds-ignored.rs:18:1
    |
-17 | type WVec<'b, T: 'b> = Vec<T>;
+18 | type WVec<'b, T: 'b> = Vec<T>;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+warning: where clauses are ignored in trait bounds
+  --> $DIR/param-bounds-ignored.rs:19:1
+   |
+19 | type W2Vec<'b, T> where T: 'b = Vec<T>;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: bounds on generic parameters are ignored in higher-ranked function types (i.e., `for`)
+  --> $DIR/param-bounds-ignored.rs:39:8
+   |
+39 |     f: for<'xa, 'xb: 'xa> fn(&'xa i32, &'xb i32) -> &'xa i32)
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: bounds on generic parameters are ignored in higher-ranked trait bounds (i.e., `for`)
+  --> $DIR/param-bounds-ignored.rs:46:20
+   |
+46 | fn bar2<'a, 'b, F: for<'xa, 'xb: 'xa> Fn(&'xa i32, &'xb i32) -> &'xa i32>(
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: bounds on generic parameters are ignored in higher-ranked trait bounds (i.e., `for`)
+  --> $DIR/param-bounds-ignored.rs:60:14
+   |
+60 |     where F: for<'xa, 'xb: 'xa> Fn(&'xa i32, &'xb i32) -> &'xa i32
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: bounds on generic parameters are ignored in higher-ranked trait bounds (i.e., `for`)
+  --> $DIR/param-bounds-ignored.rs:71:11
+   |
+71 |     where for<'xa, 'xb: 'xa> F: Fn(&'xa i32, &'xb i32) -> &'xa i32
+   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: bounds on generic parameters are ignored in higher-ranked trait bounds (i.e., `for`)
+  --> $DIR/param-bounds-ignored.rs:78:14
+   |
+78 | struct S1<F: for<'xa, 'xb: 'xa> Fn(&'xa i32, &'xb i32) -> &'xa i32>(F);
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: bounds on generic parameters are ignored in higher-ranked trait bounds (i.e., `for`)
+  --> $DIR/param-bounds-ignored.rs:79:26
+   |
+79 | struct S2<F>(F) where F: for<'xa, 'xb: 'xa> Fn(&'xa i32, &'xb i32) -> &'xa i32;
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: bounds on generic parameters are ignored in higher-ranked trait bounds (i.e., `for`)
+  --> $DIR/param-bounds-ignored.rs:80:23
+   |
+80 | struct S3<F>(F) where for<'xa, 'xb: 'xa> F: Fn(&'xa i32, &'xb i32) -> &'xa i32;
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: bounds on generic parameters are ignored in higher-ranked function types (i.e., `for`)
+  --> $DIR/param-bounds-ignored.rs:82:15
+   |
+82 | struct S_fnty(for<'xa, 'xb: 'xa> fn(&'xa i32, &'xb i32) -> &'xa i32);
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: bounds on generic parameters are ignored in higher-ranked trait bounds (i.e., `for`)
+  --> $DIR/param-bounds-ignored.rs:84:15
+   |
+84 | type T1 = Box<for<'xa, 'xb: 'xa> Fn(&'xa i32, &'xb i32) -> &'xa i32>;
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: bounds on generic parameters are ignored in higher-ranked function types (i.e., `for`)
+  --> $DIR/param-bounds-ignored.rs:87:20
+   |
+87 |     let _ : Option<for<'xa, 'xb: 'xa> fn(&'xa i32, &'xb i32) -> &'xa i32> = None;
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: bounds on generic parameters are ignored in higher-ranked trait bounds (i.e., `for`)
+  --> $DIR/param-bounds-ignored.rs:88:24
+   |
+88 |     let _ : Option<Box<for<'xa, 'xb: 'xa> Fn(&'xa i32, &'xb i32) -> &'xa i32>> = None;
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
