Refactor Diverges in typeck

Avoid deriving PartialOrd on Diverges since it includes fields which
should not affect ordering.

Author: camsteffen

compiler/rustc_hir_typeck/src/_match.rs

@@ -1,5 +1,5 @@
 use crate::coercion::{AsCoercionSite, CoerceMany};
-use crate::{Diverges, Expectation, FnCtxt, Needs};
+use crate::{DivergeReason, Diverges, Expectation, FnCtxt, Needs};
 use rustc_errors::{Applicability, Diagnostic, MultiSpan};
 use rustc_hir::{self as hir, ExprKind};
 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
@@ -29,7 +29,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         // If there are no arms, that is a diverging match; a special case.
         if arms.is_empty() {
-            self.diverges.set(self.diverges.get() | Diverges::always(expr.span));
+            self.diverges.set(self.diverges.get() | Diverges::Always(DivergeReason::Other, expr));
             return tcx.types.never;
         }
 
@@ -162,13 +162,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // we can emit a better note. Rather than pointing
         // at a diverging expression in an arbitrary arm,
         // we can point at the entire `match` expression
-        if let (Diverges::Always { .. }, hir::MatchSource::Normal) = (all_arms_diverge, match_src) {
-            all_arms_diverge = Diverges::Always {
-                span: expr.span,
-                custom_note: Some(
-                    "any code following this `match` expression is unreachable, as all arms diverge",
-                ),
-            };
+        if let (Diverges::Always(..), hir::MatchSource::Normal) = (all_arms_diverge, match_src) {
+            all_arms_diverge = Diverges::Always(DivergeReason::AllArmsDiverge, expr);
         }
 
         // We won't diverge unless the scrutinee or all arms diverge.

compiler/rustc_hir_typeck/src/diverges.rs

@@ -1,34 +1,21 @@
-use rustc_span::source_map::DUMMY_SP;
-use rustc_span::{self, Span};
+use rustc_hir as hir;
+
 use std::{cmp, ops};
 
 /// Tracks whether executing a node may exit normally (versus
 /// return/break/panic, which "diverge", leaving dead code in their
 /// wake). Tracked semi-automatically (through type variables marked
 /// as diverging), with some manual adjustments for control-flow
 /// primitives (approximating a CFG).
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub enum Diverges {
+#[derive(Copy, Clone, Debug)]
+pub enum Diverges<'a> {
     /// Potentially unknown, some cases converge,
     /// others require a CFG to determine them.
     Maybe,
 
     /// Definitely known to diverge and therefore
     /// not reach the next sibling or its parent.
-    Always {
-        /// The `Span` points to the expression
-        /// that caused us to diverge
-        /// (e.g. `return`, `break`, etc).
-        span: Span,
-        /// In some cases (e.g. a `match` expression
-        /// where all arms diverge), we may be
-        /// able to provide a more informative
-        /// message to the user.
-        /// If this is `None`, a default message
-        /// will be generated, which is suitable
-        /// for most cases.
-        custom_note: Option<&'static str>,
-    },
+    Always(DivergeReason, &'a hir::Expr<'a>),
 
     /// Same as `Always` but with a reachability
     /// warning already emitted.
@@ -37,42 +24,52 @@ pub enum Diverges {
 
 // Convenience impls for combining `Diverges`.
 
-impl ops::BitAnd for Diverges {
+impl ops::BitAnd for Diverges<'_> {
     type Output = Self;
     fn bitand(self, other: Self) -> Self {
-        cmp::min(self, other)
+        cmp::min_by_key(self, other, Self::ordinal)
     }
 }
 
-impl ops::BitOr for Diverges {
+impl ops::BitOr for Diverges<'_> {
     type Output = Self;
     fn bitor(self, other: Self) -> Self {
-        cmp::max(self, other)
+        // argument order is to prefer `self` if ordinal is equal
+        cmp::max_by_key(other, self, Self::ordinal)
     }
 }
 
-impl ops::BitAndAssign for Diverges {
+impl ops::BitAndAssign for Diverges<'_> {
     fn bitand_assign(&mut self, other: Self) {
         *self = *self & other;
     }
 }
 
-impl ops::BitOrAssign for Diverges {
+impl ops::BitOrAssign for Diverges<'_> {
     fn bitor_assign(&mut self, other: Self) {
         *self = *self | other;
     }
 }
 
-impl Diverges {
-    /// Creates a `Diverges::Always` with the provided `span` and the default note message.
-    pub(super) fn always(span: Span) -> Diverges {
-        Diverges::Always { span, custom_note: None }
+impl Diverges<'_> {
+    pub(super) fn is_always(self) -> bool {
+        match self {
+            Self::Maybe => false,
+            Self::Always(..) | Self::WarnedAlways => true,
+        }
     }
 
-    pub(super) fn is_always(self) -> bool {
-        // Enum comparison ignores the
-        // contents of fields, so we just
-        // fill them in with garbage here.
-        self >= Diverges::Always { span: DUMMY_SP, custom_note: None }
+    fn ordinal(&self) -> u8 {
+        match self {
+            Self::Maybe => 0,
+            Self::Always { .. } => 1,
+            Self::WarnedAlways => 2,
+        }
     }
 }
+
+#[derive(Clone, Copy, Debug)]
+pub enum DivergeReason {
+    AllArmsDiverge,
+    Other,
+}

compiler/rustc_hir_typeck/src/expr.rs

@@ -17,7 +17,7 @@ use crate::method::SelfSource;
 use crate::type_error_struct;
 use crate::Expectation::{self, ExpectCastableToType, ExpectHasType, NoExpectation};
 use crate::{
-    report_unexpected_variant_res, BreakableCtxt, Diverges, FnCtxt, Needs,
+    report_unexpected_variant_res, BreakableCtxt, DivergeReason, Diverges, FnCtxt, Needs,
     TupleArgumentsFlag::DontTupleArguments,
 };
 use rustc_ast as ast;
@@ -262,7 +262,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         // Any expression that produces a value of type `!` must have diverged
         if ty.is_never() {
-            self.diverges.set(self.diverges.get() | Diverges::always(expr.span));
+            self.diverges.set(self.diverges.get() | Diverges::Always(DivergeReason::Other, expr));
         }
 
         // Record the type, which applies it effects.
@@ -1362,7 +1362,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     })
                 });
             let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
-            assert_eq!(self.diverges.get(), Diverges::Maybe);
+            assert!(matches!(self.diverges.get(), Diverges::Maybe));
             for e in args {
                 let e_ty = self.check_expr_with_hint(e, coerce_to);
                 let cause = self.misc(e.span);

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -2,7 +2,7 @@ use crate::callee::{self, DeferredCallResolution};
 use crate::errors::CtorIsPrivate;
 use crate::method::{self, MethodCallee, SelfSource};
 use crate::rvalue_scopes;
-use crate::{BreakableCtxt, Diverges, Expectation, FnCtxt, RawTy};
+use crate::{BreakableCtxt, DivergeReason, Diverges, Expectation, FnCtxt, RawTy};
 use rustc_data_structures::captures::Captures;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::{Applicability, Diagnostic, ErrorGuaranteed, MultiSpan, StashKey};
@@ -47,36 +47,33 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// Produces warning on the given node, if the current point in the
     /// function is unreachable, and there hasn't been another warning.
     pub(in super::super) fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
-        // FIXME: Combine these two 'if' expressions into one once
-        // let chains are implemented
-        if let Diverges::Always { span: orig_span, custom_note } = self.diverges.get() {
-            // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
-            // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
-            // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
-            if !span.is_desugaring(DesugaringKind::CondTemporary)
-                && !span.is_desugaring(DesugaringKind::Async)
-                && !orig_span.is_desugaring(DesugaringKind::Await)
-            {
-                self.diverges.set(Diverges::WarnedAlways);
+        let Diverges::Always(reason, diverging_expr) = self.diverges.get() else {
+            return;
+        };
+        // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
+        // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
+        // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
+        if matches!(
+            span.desugaring_kind(),
+            Some(DesugaringKind::Async | DesugaringKind::Await | DesugaringKind::CondTemporary)
+        ) {
+            return;
+        }
 
-                debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
+        self.diverges.set(Diverges::WarnedAlways);
 
-                let msg = format!("unreachable {}", kind);
-                self.tcx().struct_span_lint_hir(
-                    lint::builtin::UNREACHABLE_CODE,
-                    id,
-                    span,
-                    msg.clone(),
-                    |lint| {
-                        lint.span_label(span, msg).span_label(
-                            orig_span,
-                            custom_note
-                                .unwrap_or("any code following this expression is unreachable"),
-                        )
-                    },
-                )
-            }
-        }
+        debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
+
+        let msg = format!("unreachable {}", kind);
+        self.tcx().struct_span_lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, msg.clone(), |lint| {
+            let label = match reason {
+                DivergeReason::AllArmsDiverge => {
+                    "any code following this `match` expression is unreachable, as all arms diverge"
+                }
+                DivergeReason::Other => "any code following this expression is unreachable",
+            };
+            lint.span_label(span, msg).span_label(diverging_expr.span, label)
+        });
     }
 
     /// Resolves type and const variables in `ty` if possible. Unlike the infcx

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -104,7 +104,7 @@ pub struct FnCtxt<'a, 'tcx> {
     ///
     /// An expression represents dead code if, after checking it,
     /// the diverges flag is set to something other than `Maybe`.
-    pub(super) diverges: Cell<Diverges>,
+    pub(super) diverges: Cell<Diverges<'tcx>>,
 
     pub(super) enclosing_breakables: RefCell<EnclosingBreakables<'tcx>>,
 

compiler/rustc_hir_typeck/src/lib.rs

@@ -50,7 +50,7 @@ pub use inherited::Inherited;
 
 use crate::check::check_fn;
 use crate::coercion::DynamicCoerceMany;
-use crate::diverges::Diverges;
+use crate::diverges::{DivergeReason, Diverges};
 use crate::expectation::Expectation;
 use crate::fn_ctxt::RawTy;
 use crate::gather_locals::GatherLocalsVisitor;