Unify lifetime/type arguments error messages for (non-)builtin bounds

src/librustc_typeck/astconv.rs

@@ -305,9 +305,9 @@ fn create_region_substs<'tcx>(
             rscope.anon_regions(span, expected_num_region_params);
 
         if supplied_num_region_params != 0 || anon_regions.is_err() {
-            span_err!(tcx.sess, span, E0107,
-                      "wrong number of lifetime parameters: expected {}, found {}",
-                      expected_num_region_params, supplied_num_region_params);
+            report_lifetime_number_error(tcx, span,
+                                         supplied_num_region_params,
+                                         expected_num_region_params);
         }
 
         match anon_regions {
@@ -355,31 +355,14 @@ fn create_substs_for_ast_path<'tcx>(
                                                .count();
 
     let mut type_substs = types_provided;
+    check_type_argument_count(this.tcx(), span, supplied_ty_param_count,
+                              required_ty_param_count, formal_ty_param_count);
+
     if supplied_ty_param_count < required_ty_param_count {
-        let expected = if required_ty_param_count < formal_ty_param_count {
-            "expected at least"
-        } else {
-            "expected"
-        };
-        span_err!(this.tcx().sess, span, E0243,
-                  "wrong number of type arguments: {} {}, found {}",
-                  expected,
-                  required_ty_param_count,
-                  supplied_ty_param_count);
         while type_substs.len() < required_ty_param_count {
             type_substs.push(tcx.types.err);
         }
     } else if supplied_ty_param_count > formal_ty_param_count {
-        let expected = if required_ty_param_count < formal_ty_param_count {
-            "expected at most"
-        } else {
-            "expected"
-        };
-        span_err!(this.tcx().sess, span, E0244,
-                  "wrong number of type arguments: {} {}, found {}",
-                  expected,
-                  formal_ty_param_count,
-                  supplied_ty_param_count);
         type_substs.truncate(formal_ty_param_count);
     }
     assert!(type_substs.len() >= required_ty_param_count &&
@@ -1849,10 +1832,13 @@ pub fn partition_bounds<'a>(tcx: &ty::ctxt,
                                                      &mut builtin_bounds) {
                             let segments = &b.trait_ref.path.segments;
                             let parameters = &segments[segments.len() - 1].parameters;
-                            if !parameters.is_empty() {
-                                span_err!(tcx.sess, b.trait_ref.path.span, E0316,
-                                          "builtin bounds do not require arguments, {} given",
-                                          parameters.lifetimes().len() + parameters.types().len());
+                            if parameters.types().len() > 0 {
+                                check_type_argument_count(tcx, b.trait_ref.path.span,
+                                                          parameters.types().len(), 0, 0);
+                            }
+                            if parameters.lifetimes().len() > 0{
+                                report_lifetime_number_error(tcx, b.trait_ref.path.span,
+                                                             parameters.lifetimes().len(), 0);
                             }
                             continue; // success
                         }
@@ -1886,3 +1872,34 @@ fn prohibit_projections<'tcx>(tcx: &ty::ctxt<'tcx>,
             "associated type bindings are not allowed here");
     }
 }
+
+fn check_type_argument_count(tcx: &ty::ctxt, span: Span, supplied: usize,
+                             required: usize, accepted: usize) {
+    if supplied < required {
+        let expected = if required < accepted {
+            "expected at least"
+        } else {
+            "expected"
+        };
+        span_err!(tcx.sess, span, E0243,
+                  "wrong number of type arguments: {} {}, found {}",
+                  expected, required, supplied);
+    } else if supplied > accepted {
+        let expected = if required < accepted {
+            "expected at most"
+        } else {
+            "expected"
+        };
+        span_err!(tcx.sess, span, E0244,
+                  "wrong number of type arguments: {} {}, found {}",
+                  expected,
+                  accepted,
+                  supplied);
+    }
+}
+
+fn report_lifetime_number_error(tcx: &ty::ctxt, span: Span, number: usize, expected: usize) {
+    span_err!(tcx.sess, span, E0107,
+              "wrong number of lifetime parameters: expected {}, found {}",
+              expected, number);
+}

src/librustc_typeck/diagnostics.rs

@@ -172,7 +172,6 @@
     E0248, // found value name used as a type
     E0249, // expected constant expr for array length
     E0250, // expected constant expr for array length
-    E0316  // wrong number of type arguments to a built-in trait
 }
 
 __build_diagnostic_array! { DIAGNOSTICS }

src/test/compile-fail/typeck-builtin-bound-type-parameters.rs

@@ -9,19 +9,20 @@
 // except according to those terms.
 
 fn foo1<T:Copy<U>, U>(x: T) {}
-//~^ ERROR: builtin bounds do not require arguments, 1 given
+//~^ ERROR: wrong number of type arguments: expected 0, found 1
 
 trait Trait: Copy<Send> {}
-//~^ ERROR: builtin bounds do not require arguments, 1 given
+//~^ ERROR: wrong number of type arguments: expected 0, found 1
 
 struct MyStruct1<T: Copy<T>>;
-//~^ ERROR builtin bounds do not require arguments, 1 given
+//~^ ERROR wrong number of type arguments: expected 0, found 1
 
 struct MyStruct2<'a, T: Copy<'a>>;
-//~^ ERROR: builtin bounds do not require arguments, 1 given
+//~^ ERROR: wrong number of lifetime parameters: expected 0, found 1
 
 fn foo2<'a, T:Copy<'a, U>, U>(x: T) {}
-//~^ ERROR builtin bounds do not require arguments, 2 given
+//~^ ERROR: wrong number of type arguments: expected 0, found 1
+//~^^ ERROR: wrong number of lifetime parameters: expected 0, found 1
 
 fn main() {
 }