parenthesized_params_in_types_and_modules -> error

Author: Centril

src/doc/rustc/src/lints/listing/deny-by-default.md

@@ -89,31 +89,6 @@ error: literal out of range for u8
   |
 ```
 
-## parenthesized-params-in-types-and-modules
-
-This lint detects incorrect parentheses. Some example code that triggers this
-lint:
-
-```rust,ignore
-let x = 5 as usize();
-```
-
-This will produce:
-
-```text
-error: parenthesized parameters may only be used with a trait
- --> src/main.rs:2:21
-  |
-2 |   let x = 5 as usize();
-  |                     ^^
-  |
-  = note: `#[deny(parenthesized_params_in_types_and_modules)]` on by default
-  = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-  = note: for more information, see issue #42238 <https://github.com/rust-lang/rust/issues/42238>
-```
-
-To fix it, remove the `()`s.
-
 ## pub-use-of-private-extern-crate
 
 This lint detects a specific situation of re-exporting a private `extern crate`;

src/librustc/hir/lowering.rs

@@ -40,8 +40,7 @@ use crate::hir::def_id::{DefId, DefIndex, CRATE_DEF_INDEX};
 use crate::hir::def::{Res, DefKind, PartialRes, PerNS};
 use crate::hir::{GenericArg, ConstArg};
 use crate::hir::ptr::P;
-use crate::lint::builtin::{self, PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES,
-                    ELIDED_LIFETIMES_IN_PATHS};
+use crate::lint::builtin::{self, ELIDED_LIFETIMES_IN_PATHS};
 use crate::middle::cstore::CrateStore;
 use crate::session::Session;
 use crate::session::config::nightly_options;
@@ -286,7 +285,6 @@ enum ParamMode {
 
 enum ParenthesizedGenericArgs {
     Ok,
-    Warn,
     Err,
 }
 
@@ -2057,29 +2055,19 @@ impl<'a> LoweringContext<'a> {
                     };
                     let parenthesized_generic_args = match partial_res.base_res() {
                         // `a::b::Trait(Args)`
-                        Res::Def(DefKind::Trait, _)
-                            if i + 1 == proj_start => ParenthesizedGenericArgs::Ok,
+                        Res::Def(DefKind::Trait, _) if i + 1 == proj_start => {
+                            ParenthesizedGenericArgs::Ok
+                        }
                         // `a::b::Trait(Args)::TraitItem`
-                        Res::Def(DefKind::Method, _)
-                        | Res::Def(DefKind::AssocConst, _)
-                        | Res::Def(DefKind::AssocTy, _)
-                            if i + 2 == proj_start =>
-                        {
+                        Res::Def(DefKind::Method, _) |
+                        Res::Def(DefKind::AssocConst, _) |
+                        Res::Def(DefKind::AssocTy, _) if i + 2 == proj_start => {
                             ParenthesizedGenericArgs::Ok
                         }
                         // Avoid duplicated errors.
                         Res::Err => ParenthesizedGenericArgs::Ok,
                         // An error
-                        Res::Def(DefKind::Struct, _)
-                        | Res::Def(DefKind::Enum, _)
-                        | Res::Def(DefKind::Union, _)
-                        | Res::Def(DefKind::TyAlias, _)
-                        | Res::Def(DefKind::Variant, _) if i + 1 == proj_start =>
-                        {
-                            ParenthesizedGenericArgs::Err
-                        }
-                        // A warning for now, for compatibility reasons.
-                        _ => ParenthesizedGenericArgs::Warn,
+                        _ => ParenthesizedGenericArgs::Err,
                     };
 
                     let num_lifetimes = type_def_id.map_or(0, |def_id| {
@@ -2142,7 +2130,7 @@ impl<'a> LoweringContext<'a> {
                 segment,
                 param_mode,
                 0,
-                ParenthesizedGenericArgs::Warn,
+                ParenthesizedGenericArgs::Err,
                 itctx.reborrow(),
                 None,
             ));
@@ -2218,15 +2206,6 @@ impl<'a> LoweringContext<'a> {
                 }
                 GenericArgs::Parenthesized(ref data) => match parenthesized_generic_args {
                     ParenthesizedGenericArgs::Ok => self.lower_parenthesized_parameter_data(data),
-                    ParenthesizedGenericArgs::Warn => {
-                        self.sess.buffer_lint(
-                            PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES,
-                            CRATE_NODE_ID,
-                            data.span,
-                            msg.into(),
-                        );
-                        (hir::GenericArgs::none(), true)
-                    }
                     ParenthesizedGenericArgs::Err => {
                         let mut err = struct_span_err!(self.sess, data.span, E0214, "{}", msg);
                         err.span_label(data.span, "only `Fn` traits may use parentheses");

src/librustc/lint/builtin.rs

@@ -157,12 +157,6 @@ declare_lint! {
     "patterns in functions without body were erroneously allowed"
 }
 
-declare_lint! {
-    pub PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES,
-    Deny,
-    "detects parenthesized generic parameters in type and module names"
-}
-
 declare_lint! {
     pub LATE_BOUND_LIFETIME_ARGUMENTS,
     Warn,
@@ -393,7 +387,6 @@ declare_lint_pass! {
         RENAMED_AND_REMOVED_LINTS,
         SAFE_PACKED_BORROWS,
         PATTERNS_IN_FNS_WITHOUT_BODY,
-        PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES,
         LATE_BOUND_LIFETIME_ARGUMENTS,
         ORDER_DEPENDENT_TRAIT_OBJECTS,
         DEPRECATED,

src/librustc_lint/lib.rs

@@ -331,11 +331,6 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
             reference: "issue #41686 <https://github.com/rust-lang/rust/issues/41686>",
             edition: Some(Edition::Edition2018),
         },
-        FutureIncompatibleInfo {
-            id: LintId::of(PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES),
-            reference: "issue #42238 <https://github.com/rust-lang/rust/issues/42238>",
-            edition: None,
-        },
         FutureIncompatibleInfo {
             id: LintId::of(LATE_BOUND_LIFETIME_ARGUMENTS),
             reference: "issue #42868 <https://github.com/rust-lang/rust/issues/42868>",
@@ -473,6 +468,8 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
         "converted into hard error, see https://github.com/rust-lang/rust/issues/36887");
     store.register_removed("safe_extern_statics",
         "converted into hard error, see https://github.com/rust-lang/rust/issues/36247");
+    store.register_removed("parenthesized_params_in_types_and_modules",
+        "converted into hard error, see https://github.com/rust-lang/rust/issues/42238");
 }
 
 pub fn register_internals(store: &mut lint::LintStore, sess: Option<&Session>) {

src/test/ui/issues/issue-32995-2.rs

@@ -1,18 +1,13 @@
-#![allow(unused)]
-
 fn main() {
     { fn f<X: ::std::marker()::Send>() {} }
     //~^ ERROR parenthesized type parameters may only be used with a `Fn` trait
-    //~| WARN previously accepted
 
     { fn f() -> impl ::std::marker()::Send { } }
     //~^ ERROR parenthesized type parameters may only be used with a `Fn` trait
-    //~| WARN previously accepted
 }
 
 #[derive(Clone)]
 struct X;
 
 impl ::std::marker()::Copy for X {}
 //~^ ERROR parenthesized type parameters may only be used with a `Fn` trait
-//~| WARN previously accepted

src/test/ui/issues/issue-32995-2.stderr

@@ -1,30 +1,21 @@
-error: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/issue-32995-2.rs:4:28
+error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
+  --> $DIR/issue-32995-2.rs:2:28
    |
 LL |     { fn f<X: ::std::marker()::Send>() {} }
-   |                            ^^
-   |
-   = note: `#[deny(parenthesized_params_in_types_and_modules)]` on by default
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #42238 <https://github.com/rust-lang/rust/issues/42238>
+   |                            ^^ only `Fn` traits may use parentheses
 
-error: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/issue-32995-2.rs:8:35
+error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
+  --> $DIR/issue-32995-2.rs:5:35
    |
 LL |     { fn f() -> impl ::std::marker()::Send { } }
-   |                                   ^^
-   |
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #42238 <https://github.com/rust-lang/rust/issues/42238>
+   |                                   ^^ only `Fn` traits may use parentheses
 
-error: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/issue-32995-2.rs:16:19
+error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
+  --> $DIR/issue-32995-2.rs:12:19
    |
 LL | impl ::std::marker()::Copy for X {}
-   |                   ^^
-   |
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #42238 <https://github.com/rust-lang/rust/issues/42238>
+   |                   ^^ only `Fn` traits may use parentheses
 
 error: aborting due to 3 previous errors
 
+For more information about this error, try `rustc --explain E0214`.

src/test/ui/issues/issue-32995.rs

@@ -1,33 +1,24 @@
-#![allow(unused)]
-
 fn main() {
     let x: usize() = 1;
     //~^ ERROR parenthesized type parameters may only be used with a `Fn` trait
-    //~| WARN previously accepted
 
     let b: ::std::boxed()::Box<_> = Box::new(1);
     //~^ ERROR parenthesized type parameters may only be used with a `Fn` trait
-    //~| WARN previously accepted
 
     let p = ::std::str::()::from_utf8(b"foo").unwrap();
     //~^ ERROR parenthesized type parameters may only be used with a `Fn` trait
-    //~| WARN previously accepted
 
     let p = ::std::str::from_utf8::()(b"foo").unwrap();
     //~^ ERROR parenthesized type parameters may only be used with a `Fn` trait
-    //~| WARN previously accepted
 
     let o : Box<dyn (::std::marker()::Send)> = Box::new(1);
     //~^ ERROR parenthesized type parameters may only be used with a `Fn` trait
-    //~| WARN previously accepted
 
     let o : Box<dyn Send + ::std::marker()::Sync> = Box::new(1);
     //~^ ERROR parenthesized type parameters may only be used with a `Fn` trait
-    //~| WARN previously accepted
 }
 
 fn foo<X:Default>() {
     let d : X() = Default::default();
     //~^ ERROR parenthesized type parameters may only be used with a `Fn` trait
-    //~| WARN previously accepted
 }

src/test/ui/issues/issue-32995.stderr

@@ -1,66 +1,45 @@
-error: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/issue-32995.rs:4:17
+error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
+  --> $DIR/issue-32995.rs:2:17
    |
 LL |     let x: usize() = 1;
-   |                 ^^
-   |
-   = note: `#[deny(parenthesized_params_in_types_and_modules)]` on by default
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #42238 <https://github.com/rust-lang/rust/issues/42238>
+   |                 ^^ only `Fn` traits may use parentheses
 
-error: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/issue-32995.rs:8:24
+error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
+  --> $DIR/issue-32995.rs:5:24
    |
 LL |     let b: ::std::boxed()::Box<_> = Box::new(1);
-   |                        ^^
-   |
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #42238 <https://github.com/rust-lang/rust/issues/42238>
+   |                        ^^ only `Fn` traits may use parentheses
 
-error: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/issue-32995.rs:12:25
+error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
+  --> $DIR/issue-32995.rs:8:25
    |
 LL |     let p = ::std::str::()::from_utf8(b"foo").unwrap();
-   |                         ^^
-   |
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #42238 <https://github.com/rust-lang/rust/issues/42238>
+   |                         ^^ only `Fn` traits may use parentheses
 
-error: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/issue-32995.rs:16:36
+error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
+  --> $DIR/issue-32995.rs:11:36
    |
 LL |     let p = ::std::str::from_utf8::()(b"foo").unwrap();
-   |                                    ^^
-   |
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #42238 <https://github.com/rust-lang/rust/issues/42238>
+   |                                    ^^ only `Fn` traits may use parentheses
 
-error: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/issue-32995.rs:20:35
+error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
+  --> $DIR/issue-32995.rs:14:35
    |
 LL |     let o : Box<dyn (::std::marker()::Send)> = Box::new(1);
-   |                                   ^^
-   |
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #42238 <https://github.com/rust-lang/rust/issues/42238>
+   |                                   ^^ only `Fn` traits may use parentheses
 
-error: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/issue-32995.rs:24:41
+error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
+  --> $DIR/issue-32995.rs:17:41
    |
 LL |     let o : Box<dyn Send + ::std::marker()::Sync> = Box::new(1);
-   |                                         ^^
-   |
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #42238 <https://github.com/rust-lang/rust/issues/42238>
+   |                                         ^^ only `Fn` traits may use parentheses
 
-error: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/issue-32995.rs:30:14
+error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
+  --> $DIR/issue-32995.rs:22:14
    |
 LL |     let d : X() = Default::default();
-   |              ^^
-   |
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #42238 <https://github.com/rust-lang/rust/issues/42238>
+   |              ^^ only `Fn` traits may use parentheses
 
 error: aborting due to 7 previous errors
 
+For more information about this error, try `rustc --explain E0214`.

src/test/ui/type/ascription/issue-34255-1.rs

@@ -8,7 +8,6 @@ impl Reactor {
         //~^ ERROR cannot find value `input_cells` in this scope
         //~| ERROR parenthesized type parameters may only be used with a `Fn` trait
         //~| ERROR wrong number of type arguments: expected 1, found 0
-        //~| WARNING this was previously accepted by the compiler but is being phased out
     }
 }
 

src/test/ui/type/ascription/issue-34255-1.stderr

@@ -4,15 +4,11 @@ error[E0425]: cannot find value `input_cells` in this scope
 LL |         input_cells: Vec::new()
    |         ^^^^^^^^^^^ a field by this name exists in `Self`
 
-error: parenthesized type parameters may only be used with a `Fn` trait
+error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
   --> $DIR/issue-34255-1.rs:7:30
    |
 LL |         input_cells: Vec::new()
-   |                              ^^
-   |
-   = note: `#[deny(parenthesized_params_in_types_and_modules)]` on by default
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #42238 <https://github.com/rust-lang/rust/issues/42238>
+   |                              ^^ only `Fn` traits may use parentheses
 
 error[E0601]: `main` function not found in crate `issue_34255_1`
    |
@@ -26,5 +22,5 @@ LL |         input_cells: Vec::new()
 
 error: aborting due to 4 previous errors
 
-Some errors have detailed explanations: E0107, E0425, E0601.
+Some errors have detailed explanations: E0107, E0214, E0425, E0601.
 For more information about an error, try `rustc --explain E0107`.