Suggest setting associated type when type argument is given instead

When finding too many type arguments and too few associated types,
suggest using associated types in the appropriate place instead.

Author: estebank

src/librustc_typeck/astconv.rs

@@ -200,8 +200,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
     {
         let tcx = self.tcx();
 
-        debug!("create_substs_for_ast_path(def_id={:?}, self_ty={:?}, \
-               parameters={:?})",
+        debug!("create_substs_for_ast_path(def_id={:?}, self_ty={:?}, parameters={:?})",
                def_id, self_ty, parameters);
 
         // If the type is parameterized by this region, then replace this
@@ -221,10 +220,13 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
         assert_eq!(decl_generics.has_self, self_ty.is_some());
 
         // Check the number of type parameters supplied by the user.
-        let ty_param_defs = &decl_generics.types[self_ty.is_some() as usize..];
-        if !infer_types || num_types_provided > ty_param_defs.len() {
-            check_type_argument_count(tcx, span, num_types_provided, ty_param_defs);
-        }
+        check_type_argument_count(tcx,
+                                  def_id,
+                                  span,
+                                  infer_types,
+                                  self_ty.is_some(),
+                                  &parameters,
+                                  &decl_generics);
 
         let is_object = self_ty.map_or(false, |ty| ty.sty == TRAIT_OBJECT_DUMMY_SELF);
         let default_needs_object_self = |p: &ty::TypeParameterDef| {
@@ -599,7 +601,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
         if !trait_bounds.is_empty() {
             let b = &trait_bounds[0];
             let span = b.trait_ref.path.span;
-            struct_span_err!(self.tcx().sess, span, E0225,
+            struct_span_err!(tcx.sess, span, E0225,
                 "only auto traits can be used as additional traits in a trait object")
                 .span_label(span, "non-auto additional trait")
                 .emit();
@@ -1303,45 +1305,68 @@ fn split_auto_traits<'a, 'b, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
     (auto_traits, trait_bounds)
 }
 
-fn check_type_argument_count(tcx: TyCtxt, span: Span, supplied: usize,
-                             ty_param_defs: &[ty::TypeParameterDef]) {
+fn check_type_argument_count(tcx: TyCtxt,
+                             _def_id: DefId,
+                             span: Span,
+                             infer_types: bool,
+                             has_self_ty: bool,
+                             parameters: &hir::PathParameters,
+                             generics: &ty::Generics) {
+    let supplied = parameters.types.len();
+    let ty_param_defs = &generics.types[has_self_ty as usize..];
     let accepted = ty_param_defs.len();
     let required = ty_param_defs.iter().take_while(|x| !x.has_default).count();
-    if supplied < required {
-        let expected = if required < accepted {
-            "expected at least"
-        } else {
-            "expected"
-        };
-        let arguments_plural = if required == 1 { "" } else { "s" };
-
-        struct_span_err!(tcx.sess, span, E0243,
-                "wrong number of type arguments: {} {}, found {}",
-                expected, required, supplied)
-            .span_label(span,
-                format!("{} {} type argument{}",
-                    expected,
-                    required,
-                    arguments_plural))
-            .emit();
-    } else if supplied > accepted {
-        let expected = if required < accepted {
-            format!("expected at most {}", accepted)
-        } else {
-            format!("expected {}", accepted)
-        };
-        let arguments_plural = if accepted == 1 { "" } else { "s" };
-
-        struct_span_err!(tcx.sess, span, E0244,
-                "wrong number of type arguments: {}, found {}",
-                expected, supplied)
-            .span_label(
-                span,
-                format!("{} type argument{}",
-                    if accepted == 0 { "expected no" } else { &expected },
-                    arguments_plural)
-            )
-            .emit();
+    //let total_expected = parameters.types.len() + parameters.bindings.len();
+    //let total_found = generics.types.len();// + tcx.associated_items(def_id)
+    //     .filter(|item| item.kind == ty::AssociatedKind::Type)
+    //     .count();
+    if !infer_types || supplied > accepted {
+        if supplied < required {
+            let expected = if required < accepted {
+                "expected at least"
+            } else {
+                "expected"
+            };
+            let arguments_plural = if required == 1 { "" } else { "s" };
+
+            let mut err = struct_span_err!(tcx.sess, span, E0243,
+                    "wrong number of type arguments: {} {}, found {}",
+                    expected, required, supplied);
+            err.span_label(span, format!("{} {} type argument{}",
+                                         expected,
+                                         required,
+                                         arguments_plural));
+            err.emit();
+        } else if supplied > accepted {
+            let expected = if required < accepted {
+                format!("expected at most {}", accepted)
+            } else {
+                format!("expected {}", accepted)
+            };
+            let arguments_plural = if accepted == 1 { "" } else { "s" };
+
+            let mut err = struct_span_err!(tcx.sess, span, E0244,
+                    "wrong number of type arguments: {}, found {}",
+                    expected, supplied);
+            err.span_label(
+                    span,
+                    format!("{} type argument{}",
+                        if accepted == 0 { "expected no" } else { &expected },
+                        arguments_plural)
+                );
+            for generic in &parameters.types[accepted..] {
+                if let Ok(snippet) = tcx.sess.codemap().span_to_snippet(generic.span) {
+                    err.span_suggestion(generic.span,
+                                        "if you meant to set an associated type, include the name",
+                                        format!("AssociatedType={}", snippet));
+                } else {
+                    err.help("if you meant to set an associated type, include the name: \
+                              `Trait<AssociatedType=Type>`, not `Trait<Type>`");
+                    break;
+                }
+            }
+            err.emit();
+        }
     }
 }
 

src/test/ui/type-argument-instead-of-item.rs

@@ -0,0 +1,20 @@
+// Copyright 2018 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.
+
+pub trait T<X> {
+    type Item;
+    type OtherItem;
+}
+
+pub struct Foo { i: Box<T<usize, usize, OtherItem=usize>> }
+//~^ ERROR wrong number of type arguments: expected 1, found 2
+//~| ERROR the value of the associated type `Item` (from the trait `T`) must be specified
+
+fn main() {}

src/test/ui/type-argument-instead-of-item.stderr

@@ -0,0 +1,19 @@
+error[E0244]: wrong number of type arguments: expected 1, found 2
+  --> $DIR/type-argument-instead-of-item.rs:16:25
+   |
+16 | pub struct Foo { i: Box<T<usize, usize, OtherItem=usize>> }
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected 1 type argument
+   |
+help: if you meant to set an associated type, include the name
+   |
+16 | pub struct Foo { i: Box<T<usize, AssociatedType="usize", OtherItem=usize>> }
+   |                                  ^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0191]: the value of the associated type `Item` (from the trait `T`) must be specified
+  --> $DIR/type-argument-instead-of-item.rs:16:25
+   |
+16 | pub struct Foo { i: Box<T<usize, usize, OtherItem=usize>> }
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing associated type `Item` value
+
+error: aborting due to 2 previous errors
+