Lint against E::V::<P>, suggest E::<P>::V

Author: estebank

src/librustc_ast_lowering/lib.rs

@@ -1977,6 +1977,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             args: &[],
             bindings: arena_vec![self; self.output_ty_binding(span, output_ty)],
             parenthesized: false,
+            span,
         });
 
         // ::std::future::Future<future_params>
@@ -2655,11 +2656,12 @@ impl<'hir> GenericArgsCtor<'hir> {
         self.args.is_empty() && self.bindings.is_empty() && !self.parenthesized
     }
 
-    fn into_generic_args(self, arena: &'hir Arena<'hir>) -> hir::GenericArgs<'hir> {
+    fn into_generic_args(self, arena: &'hir Arena<'hir>, span: Span) -> hir::GenericArgs<'hir> {
         hir::GenericArgs {
             args: arena.alloc_from_iter(self.args),
             bindings: self.bindings,
             parenthesized: self.parenthesized,
+            span,
         }
     }
 }

src/librustc_ast_lowering/path.rs

@@ -360,6 +360,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             segment.ident, segment.id, id,
         );
 
+        let param_span = path_span.with_lo(segment.ident.span.shrink_to_hi().lo());
         hir::PathSegment {
             ident: segment.ident,
             hir_id: Some(id),
@@ -368,7 +369,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             args: if generic_args.is_empty() {
                 None
             } else {
-                Some(self.arena.alloc(generic_args.into_generic_args(self.arena)))
+                Some(self.arena.alloc(generic_args.into_generic_args(self.arena, param_span)))
             },
         }
     }

src/librustc_hir/hir.rs

@@ -311,11 +311,13 @@ pub struct GenericArgs<'hir> {
     /// This is required mostly for pretty-printing and diagnostics,
     /// but also for changing lifetime elision rules to be "function-like".
     pub parenthesized: bool,
+    /// The `Span` encompassing the entirety of the parameters `<A, B>` or `(A, B)`.
+    pub span: Span,
 }
 
 impl GenericArgs<'_> {
     pub const fn none() -> Self {
-        Self { args: &[], bindings: &[], parenthesized: false }
+        Self { args: &[], bindings: &[], parenthesized: false, span: DUMMY_SP }
     }
 
     pub fn is_empty(&self) -> bool {

src/librustc_session/lint/builtin.rs

@@ -256,6 +256,13 @@ declare_lint! {
     };
 }
 
+declare_lint! {
+    pub TYPE_PARAM_ON_VARIANT_CTOR,
+    Warn,
+    "detects generic arguments in path segments corresponding to an enum variant instead of the \
+     enum itself",
+}
+
 declare_lint! {
     pub ORDER_DEPENDENT_TRAIT_OBJECTS,
     Deny,
@@ -531,6 +538,7 @@ declare_lint_pass! {
         PATTERNS_IN_FNS_WITHOUT_BODY,
         MISSING_FRAGMENT_SPECIFIER,
         LATE_BOUND_LIFETIME_ARGUMENTS,
+        TYPE_PARAM_ON_VARIANT_CTOR,
         ORDER_DEPENDENT_TRAIT_OBJECTS,
         COHERENCE_LEAK_CHECK,
         DEPRECATED,

src/librustc_typeck/astconv.rs

@@ -2500,8 +2500,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                     let enum_def_id = tcx.parent(def_id).unwrap();
                     (enum_def_id, last - 1)
                 } else {
-                    // FIXME: lint here recommending `Enum::<...>::Variant` form
-                    // instead of `Enum::Variant::<...>` form.
+                    self.lint_type_param_on_variant_ctor(segments);
 
                     // Everything but the final segment should have no
                     // parameters at all.
@@ -2535,6 +2534,37 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         path_segs
     }
 
+    fn lint_type_param_on_variant_ctor(&self, segments: &[hir::PathSegment<'_>]) {
+        // Doing this to get around rustfmt-caused line too long.
+        use hir::PathSegment as P;
+        if let [.., prev, P { hir_id: Some(hir_id), args: Some(args), .. }] = segments {
+            let span = args.span;
+            if span.hi() == span.lo() {
+                // The params were not written by the user, but rather derived. These are expected.
+                return;
+            }
+            self.tcx().struct_span_lint_hir(
+                lint::builtin::TYPE_PARAM_ON_VARIANT_CTOR,
+                *hir_id,
+                span,
+                |lint| {
+                    let mut err = lint.build("type parameter on variant");
+                    let sugg_span = prev.ident.span.shrink_to_hi();
+                    let msg = "set the type parameter on the enum";
+                    match self.tcx().sess.source_map().span_to_snippet(span) {
+                        Ok(snippet) => err.multipart_suggestion(
+                            msg,
+                            vec![(sugg_span, snippet), (span, "".to_string())],
+                            Applicability::MachineApplicable,
+                        ),
+                        Err(_) => err.span_label(sugg_span, msg),
+                    };
+                    err.emit();
+                },
+            );
+        }
+    }
+
     // Check a type `Path` and convert it to a `Ty`.
     pub fn res_to_ty(
         &self,

src/test/ui/binding/simple-generic-match.rs

@@ -1,5 +1,5 @@
 // run-pass
-#![allow(non_camel_case_types)]
+#![allow(non_camel_case_types, type_param_on_variant_ctor)]
 
 // pretty-expanded FIXME #23616
 

src/test/ui/binding/use-uninit-match.rs

@@ -1,13 +1,15 @@
 // run-pass
-#![allow(dead_code)]
-#![allow(non_camel_case_types)]
-
+#![allow(dead_code, non_camel_case_types, type_param_on_variant_ctor)]
 
 fn foo<T>(o: myoption<T>) -> isize {
     let mut x: isize = 5;
     match o {
         myoption::none::<T> => { }
-        myoption::some::<T>(_t) => { x += 1; }
+        myoption::some::<T>(_) => { x += 1; }
+    }
+    match o {
+        myoption::<T>::none => { }
+        myoption::<T>::some(_t) => { x += 1; }
     }
     return x;
 }

src/test/ui/binding/use-uninit-match2.rs

@@ -1,14 +1,17 @@
 // run-pass
-#![allow(dead_code)]
-#![allow(unused_mut)]
-#![allow(non_camel_case_types)]
+#![allow(dead_code, unused_mut, non_camel_case_types, type_param_on_variant_ctor)]
 
 
 fn foo<T>(o: myoption<T>) -> isize {
     let mut x: isize;
     match o {
         myoption::none::<T> => { panic!(); }
-        myoption::some::<T>(_t) => { x = 5; }
+        myoption::some::<T>(_) => { x = 5; }
+    }
+    let _ = x;
+    match o {
+        myoption::<T>::none => { panic!(); }
+        myoption::<T>::some(_t) => { x = 5; }
     }
     return x;
 }

src/test/ui/constructor-lifetime-args.rs

@@ -21,6 +21,12 @@ fn main() {
     E::V(&0); // OK
     E::V::<'static>(&0);
     //~^ ERROR wrong number of lifetime arguments: expected 2, found 1
+    //~| WARNING type parameter on variant
     E::V::<'static, 'static, 'static>(&0);
     //~^ ERROR wrong number of lifetime arguments: expected 2, found 3
+    //~| WARNING type parameter on variant
+    E::<'static>::V(&0);
+    //~^ ERROR wrong number of lifetime arguments: expected 2, found 1
+    E::<'static, 'static, 'static>::V(&0);
+    //~^ ERROR wrong number of lifetime arguments: expected 2, found 3
 }

src/test/ui/constructor-lifetime-args.stderr

@@ -10,18 +10,53 @@ error[E0107]: wrong number of lifetime arguments: expected 2, found 3
 LL |     S::<'static, 'static, 'static>(&0, &0);
    |                           ^^^^^^^ unexpected lifetime argument
 
+warning: type parameter on variant
+  --> $DIR/constructor-lifetime-args.rs:22:9
+   |
+LL |     E::V::<'static>(&0);
+   |         ^^^^^^^^^^^
+   |
+   = note: `#[warn(type_param_on_variant_ctor)]` on by default
+help: set the type parameter on the enum
+   |
+LL |     E::<'static>::V(&0);
+   |      ^^^^^^^^^^^  --
+
 error[E0107]: wrong number of lifetime arguments: expected 2, found 1
   --> $DIR/constructor-lifetime-args.rs:22:5
    |
 LL |     E::V::<'static>(&0);
    |     ^^^^^^^^^^^^^^^ expected 2 lifetime arguments
 
+warning: type parameter on variant
+  --> $DIR/constructor-lifetime-args.rs:25:9
+   |
+LL |     E::V::<'static, 'static, 'static>(&0);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: set the type parameter on the enum
+   |
+LL |     E::<'static, 'static, 'static>::V(&0);
+   |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  --
+
 error[E0107]: wrong number of lifetime arguments: expected 2, found 3
-  --> $DIR/constructor-lifetime-args.rs:24:30
+  --> $DIR/constructor-lifetime-args.rs:25:30
    |
 LL |     E::V::<'static, 'static, 'static>(&0);
    |                              ^^^^^^^ unexpected lifetime argument
 
-error: aborting due to 4 previous errors
+error[E0107]: wrong number of lifetime arguments: expected 2, found 1
+  --> $DIR/constructor-lifetime-args.rs:28:5
+   |
+LL |     E::<'static>::V(&0);
+   |     ^^^^^^^^^^^^^^^ expected 2 lifetime arguments
+
+error[E0107]: wrong number of lifetime arguments: expected 2, found 3
+  --> $DIR/constructor-lifetime-args.rs:30:27
+   |
+LL |     E::<'static, 'static, 'static>::V(&0);
+   |                           ^^^^^^^ unexpected lifetime argument
+
+error: aborting due to 6 previous errors
 
 For more information about this error, try `rustc --explain E0107`.