Add FCW lint trait_method_on_coerced_never_type

Author: JonathanBrouwer

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -12,6 +12,7 @@ use rustc_hir_analysis::autoderef::{self, Autoderef};
 use rustc_infer::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
 use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes, InferOk, TyCtxtInferExt};
 use rustc_infer::traits::{ObligationCauseCode, PredicateObligation, query};
+use rustc_lint::builtin::TRAIT_METHOD_ON_COERCED_NEVER_TYPE;
 use rustc_macros::Diagnostic;
 use rustc_middle::middle::stability;
 use rustc_middle::ty::elaborate::supertrait_def_ids;
@@ -394,6 +395,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         #[diag("type annotations needed")]
         struct MissingTypeAnnot;
 
+        #[derive(Diagnostic)]
+        #[diag("trait method call on a coerced never type")]
+        #[help("consider providing a type annotation")]
+        struct TraitMethodOnCoercedNeverType;
+
         let mut orig_values = OriginalQueryValues::default();
         let predefined_opaques_in_body = if self.next_trait_solver() {
             self.tcx.mk_predefined_opaques_in_body_from_iter(
@@ -503,6 +509,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     .iter()
                     .any(|&candidate_id| self.root_var(candidate_id) == ty_id)
             {
+                self.tcx.emit_node_span_lint(
+                    TRAIT_METHOD_ON_COERCED_NEVER_TYPE,
+                    scope_expr_id,
+                    span,
+                    TraitMethodOnCoercedNeverType,
+                );
                 self.demand_eqtype(span, root_ty, self.tcx.types.never);
             } else {
                 let guar = match *ty.kind() {

compiler/rustc_lint_defs/src/builtin.rs

@@ -114,6 +114,7 @@ declare_lint_pass! {
         TEST_UNSTABLE_LINT,
         TEXT_DIRECTION_CODEPOINT_IN_COMMENT,
         TEXT_DIRECTION_CODEPOINT_IN_LITERAL,
+        TRAIT_METHOD_ON_COERCED_NEVER_TYPE,
         TRIVIAL_CASTS,
         TRIVIAL_NUMERIC_CASTS,
         TYVAR_BEHIND_RAW_POINTER,
@@ -5709,3 +5710,35 @@ declare_lint! {
         report_in_deps: false,
     };
 }
+
+declare_lint! {
+    /// The `trait_method_on_coerced_never_type` lint detects situations in which a never type, which
+    /// was coerced to any, has a trait method on it.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// fn main() {
+    ///     let x = panic!();
+    ///     x.clone();
+    /// }
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// Calling trait methods on a coerced `!` was previously disallowed for the never type,
+    /// but it did work for empty enums such as `Infallible` since these don't coerce.
+    /// This means that changing the definition of `Infallible` to become a type alias to `!` (a long-term goal),
+    /// would break code that called a trait method on `Infallible`, in such a way that the `!` would coerce.
+    ///
+    /// Therefore, to aid in the transition of changing `Infallible` to a type alias, this is temporarily allowed with a FCW.
+    pub TRAIT_METHOD_ON_COERCED_NEVER_TYPE,
+    Warn,
+    "detects trait method calls on an coerced never type",
+    @future_incompatible = FutureIncompatibleInfo {
+        reason: fcw!(FutureReleaseError #156047),
+        report_in_deps: true,
+    };
+}

tests/ui/never_type/basic/clone-never.rs

@@ -4,4 +4,6 @@
 fn main() {
     let x = panic!();
     x.clone();
+    //~^ WARN [trait_method_on_coerced_never_type]
+    //~| WARN previously accepted
 }

tests/ui/never_type/basic/clone-never.stderr

@@ -0,0 +1,25 @@
+warning: trait method call on a coerced never type
+  --> $DIR/clone-never.rs:6:7
+   |
+LL |     x.clone();
+   |       ^^^^^
+   |
+   = help: consider providing a type annotation
+   = 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 #156047 <https://github.com/rust-lang/rust/issues/156047>
+   = note: `#[warn(trait_method_on_coerced_never_type)]` on by default
+
+warning: 1 warning emitted
+
+Future incompatibility report: Future breakage diagnostic:
+warning: trait method call on a coerced never type
+  --> $DIR/clone-never.rs:6:7
+   |
+LL |     x.clone();
+   |       ^^^^^
+   |
+   = help: consider providing a type annotation
+   = 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 #156047 <https://github.com/rust-lang/rust/issues/156047>
+   = note: `#[warn(trait_method_on_coerced_never_type)]` on by default
+

tests/ui/never_type/basic/method-on-never.rs

@@ -15,6 +15,10 @@ impl Trait for ! {
 fn main() {
     let x = loop {};
     x.method();
+    //~^ WARN [trait_method_on_coerced_never_type]
+    //~| WARN previously accepted
 
     { loop {} }.method();
+    //~^ WARN [trait_method_on_coerced_never_type]
+    //~| WARN previously accepted
 }

tests/ui/never_type/basic/method-on-never.stderr

@@ -0,0 +1,47 @@
+warning: trait method call on a coerced never type
+  --> $DIR/method-on-never.rs:17:7
+   |
+LL |     x.method();
+   |       ^^^^^^
+   |
+   = help: consider providing a type annotation
+   = 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 #156047 <https://github.com/rust-lang/rust/issues/156047>
+   = note: `#[warn(trait_method_on_coerced_never_type)]` on by default
+
+warning: trait method call on a coerced never type
+  --> $DIR/method-on-never.rs:21:17
+   |
+LL |     { loop {} }.method();
+   |                 ^^^^^^
+   |
+   = help: consider providing a type annotation
+   = 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 #156047 <https://github.com/rust-lang/rust/issues/156047>
+
+warning: 2 warnings emitted
+
+Future incompatibility report: Future breakage diagnostic:
+warning: trait method call on a coerced never type
+  --> $DIR/method-on-never.rs:17:7
+   |
+LL |     x.method();
+   |       ^^^^^^
+   |
+   = help: consider providing a type annotation
+   = 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 #156047 <https://github.com/rust-lang/rust/issues/156047>
+   = note: `#[warn(trait_method_on_coerced_never_type)]` on by default
+
+Future breakage diagnostic:
+warning: trait method call on a coerced never type
+  --> $DIR/method-on-never.rs:21:17
+   |
+LL |     { loop {} }.method();
+   |                 ^^^^^^
+   |
+   = help: consider providing a type annotation
+   = 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 #156047 <https://github.com/rust-lang/rust/issues/156047>
+   = note: `#[warn(trait_method_on_coerced_never_type)]` on by default
+