2 files changed, 648 insertions, 527 deletions

diff --git a/crates/ra_hir_ty/src/_match.rs b/crates/ra_hir_ty/src/_match.rs
index 3e6e1e333..5495ce284 100644
--- a/crates/ra_hir_ty/src/_match.rs
+++ b/crates/ra_hir_ty/src/_match.rs
@@ -8,11 +8,11 @@
 //! This file includes the logic for exhaustiveness and usefulness checking for
 //! pattern-matching. Specifically, given a list of patterns for a type, we can
 //! tell whether:
-//! (a) the patterns cover every possible constructor for the type [exhaustiveness]
-//! (b) each pattern is necessary [usefulness]
+//! - (a) the patterns cover every possible constructor for the type (exhaustiveness).
+//! - (b) each pattern is necessary (usefulness).
 //!
-//! The algorithm implemented here is a modified version of the one described in:
-//! http://moscova.inria.fr/~maranget/papers/warn/index.html
+//! The algorithm implemented here is a modified version of the one described in
+//! <http://moscova.inria.fr/~maranget/papers/warn/index.html>.
 //! However, to save future implementors from reading the original paper, we
 //! summarise the algorithm here to hopefully save time and be a little clearer
 //! (without being so rigorous).
@@ -37,20 +37,26 @@
 //! new pattern `p`.
 //!
 //! For example, say we have the following:
+//!
+//! ```ignore
+//! // x: (Option<bool>, Result<()>)
+//! match x {
+//!     (Some(true), _) => {}
+//!     (None, Err(())) => {}
+//!     (None, Err(_)) => {}
+//! }
 //! ```
-//!     // x: (Option<bool>, Result<()>)
-//!     match x {
-//!         (Some(true), _) => {}
-//!         (None, Err(())) => {}
-//!         (None, Err(_)) => {}
-//!     }
-//! ```
+//!
 //! Here, the matrix `P` starts as:
+//!
+//! ```text
 //! [
 //!     [(Some(true), _)],
 //!     [(None, Err(()))],
 //!     [(None, Err(_))],
 //! ]
+//! ```
+//!
 //! We can tell it's not exhaustive, because `U(P, _)` is true (we're not covering
 //! `[(Some(false), _)]`, for instance). In addition, row 3 is not useful, because
 //! all the values it covers are already covered by row 2.
@@ -60,53 +66,61 @@
 //! To match the paper, the top of the stack is at the beginning / on the left.
 //!
 //! There are two important operations on pattern-stacks necessary to understand the algorithm:
-//!     1. We can pop a given constructor off the top of a stack. This operation is called
-//!        `specialize`, and is denoted `S(c, p)` where `c` is a constructor (like `Some` or
-//!        `None`) and `p` a pattern-stack.
-//!        If the pattern on top of the stack can cover `c`, this removes the constructor and
-//!        pushes its arguments onto the stack. It also expands OR-patterns into distinct patterns.
-//!        Otherwise the pattern-stack is discarded.
-//!        This essentially filters those pattern-stacks whose top covers the constructor `c` and
-//!        discards the others.
 //!
-//!        For example, the first pattern above initially gives a stack `[(Some(true), _)]`. If we
-//!        pop the tuple constructor, we are left with `[Some(true), _]`, and if we then pop the
-//!        `Some` constructor we get `[true, _]`. If we had popped `None` instead, we would get
-//!        nothing back.
+//! 1. We can pop a given constructor off the top of a stack. This operation is called
+//!    `specialize`, and is denoted `S(c, p)` where `c` is a constructor (like `Some` or
+//!    `None`) and `p` a pattern-stack.
+//!    If the pattern on top of the stack can cover `c`, this removes the constructor and
+//!    pushes its arguments onto the stack. It also expands OR-patterns into distinct patterns.
+//!    Otherwise the pattern-stack is discarded.
+//!    This essentially filters those pattern-stacks whose top covers the constructor `c` and
+//!    discards the others.
+//!
+//!    For example, the first pattern above initially gives a stack `[(Some(true), _)]`. If we
+//!    pop the tuple constructor, we are left with `[Some(true), _]`, and if we then pop the
+//!    `Some` constructor we get `[true, _]`. If we had popped `None` instead, we would get
+//!    nothing back.
+//!
+//!    This returns zero or more new pattern-stacks, as follows. We look at the pattern `p_1`
+//!    on top of the stack, and we have four cases:
+//!
+//!    * 1.1. `p_1 = c(r_1, .., r_a)`, i.e. the top of the stack has constructor `c`. We push onto
+//!           the stack the arguments of this constructor, and return the result:
+//!
+//!          r_1, .., r_a, p_2, .., p_n
 //!
-//!        This returns zero or more new pattern-stacks, as follows. We look at the pattern `p_1`
-//!        on top of the stack, and we have four cases:
-//!             1.1. `p_1 = c(r_1, .., r_a)`, i.e. the top of the stack has constructor `c`. We
-//!                  push onto the stack the arguments of this constructor, and return the result:
-//!                     r_1, .., r_a, p_2, .., p_n
-//!             1.2. `p_1 = c'(r_1, .., r_a')` where `c ≠ c'`. We discard the current stack and
-//!                  return nothing.
-//!             1.3. `p_1 = _`. We push onto the stack as many wildcards as the constructor `c` has
-//!                  arguments (its arity), and return the resulting stack:
-//!                     _, .., _, p_2, .., p_n
-//!             1.4. `p_1 = r_1 | r_2`. We expand the OR-pattern and then recurse on each resulting
-//!                  stack:
-//!                     S(c, (r_1, p_2, .., p_n))
-//!                     S(c, (r_2, p_2, .., p_n))
+//!    * 1.2. `p_1 = c'(r_1, .., r_a')` where `c ≠ c'`. We discard the current stack and return
+//!           nothing.
+//!    * 1.3. `p_1 = _`. We push onto the stack as many wildcards as the constructor `c` has
+//!           arguments (its arity), and return the resulting stack:
 //!
-//!     2. We can pop a wildcard off the top of the stack. This is called `D(p)`, where `p` is
-//!        a pattern-stack.
-//!        This is used when we know there are missing constructor cases, but there might be
-//!        existing wildcard patterns, so to check the usefulness of the matrix, we have to check
-//!        all its *other* components.
+//!          _, .., _, p_2, .., p_n
 //!
-//!        It is computed as follows. We look at the pattern `p_1` on top of the stack,
-//!        and we have three cases:
-//!             1.1. `p_1 = c(r_1, .., r_a)`. We discard the current stack and return nothing.
-//!             1.2. `p_1 = _`. We return the rest of the stack:
-//!                     p_2, .., p_n
-//!             1.3. `p_1 = r_1 | r_2`. We expand the OR-pattern and then recurse on each resulting
-//!               stack.
-//!                     D((r_1, p_2, .., p_n))
-//!                     D((r_2, p_2, .., p_n))
+//!    * 1.4. `p_1 = r_1 | r_2`. We expand the OR-pattern and then recurse on each resulting stack:
 //!
-//!     Note that the OR-patterns are not always used directly in Rust, but are used to derive the
-//!     exhaustive integer matching rules, so they're written here for posterity.
+//!          S(c, (r_1, p_2, .., p_n))
+//!          S(c, (r_2, p_2, .., p_n))
+//!
+//! 2. We can pop a wildcard off the top of the stack. This is called `D(p)`, where `p` is
+//!    a pattern-stack.
+//!    This is used when we know there are missing constructor cases, but there might be
+//!    existing wildcard patterns, so to check the usefulness of the matrix, we have to check
+//!    all its *other* components.
+//!
+//!    It is computed as follows. We look at the pattern `p_1` on top of the stack,
+//!    and we have three cases:
+//!    * 1.1. `p_1 = c(r_1, .., r_a)`. We discard the current stack and return nothing.
+//!    * 1.2. `p_1 = _`. We return the rest of the stack:
+//!
+//!          p_2, .., p_n
+//!
+//!    * 1.3. `p_1 = r_1 | r_2`. We expand the OR-pattern and then recurse on each resulting stack:
+//!
+//!          D((r_1, p_2, .., p_n))
+//!          D((r_2, p_2, .., p_n))
+//!
+//!    Note that the OR-patterns are not always used directly in Rust, but are used to derive the
+//!    exhaustive integer matching rules, so they're written here for posterity.
 //!
 //! Both those operations extend straightforwardly to a list or pattern-stacks, i.e. a matrix, by
 //! working row-by-row. Popping a constructor ends up keeping only the matrix rows that start with
@@ -120,73 +134,88 @@
 //! operates principally on the first component of the matrix and new pattern-stack `p`.
 //! This algorithm is realised in the `is_useful` function.
 //!
-//! Base case. (`n = 0`, i.e., an empty tuple pattern)
-//!     - If `P` already contains an empty pattern (i.e., if the number of patterns `m > 0`),
-//!       then `U(P, p)` is false.
-//!     - Otherwise, `P` must be empty, so `U(P, p)` is true.
+//! Base case (`n = 0`, i.e., an empty tuple pattern):
+//! - If `P` already contains an empty pattern (i.e., if the number of patterns `m > 0`), then
+//!   `U(P, p)` is false.
+//! - Otherwise, `P` must be empty, so `U(P, p)` is true.
+//!
+//! Inductive step (`n > 0`, i.e., whether there's at least one column [which may then be expanded
+//! into further columns later]). We're going to match on the top of the new pattern-stack, `p_1`:
+//!
+//! - If `p_1 == c(r_1, .., r_a)`, i.e. we have a constructor pattern.
+//!   Then, the usefulness of `p_1` can be reduced to whether it is useful when
+//!   we ignore all the patterns in the first column of `P` that involve other constructors.
+//!   This is where `S(c, P)` comes in:
+//!
+//!   ```text
+//!   U(P, p) := U(S(c, P), S(c, p))
+//!   ```
 //!
-//! Inductive step. (`n > 0`, i.e., whether there's at least one column
-//!                  [which may then be expanded into further columns later])
-//!     We're going to match on the top of the new pattern-stack, `p_1`.
-//!         - If `p_1 == c(r_1, .., r_a)`, i.e. we have a constructor pattern.
-//!           Then, the usefulness of `p_1` can be reduced to whether it is useful when
-//!           we ignore all the patterns in the first column of `P` that involve other constructors.
-//!           This is where `S(c, P)` comes in:
-//!           `U(P, p) := U(S(c, P), S(c, p))`
-//!           This special case is handled in `is_useful_specialized`.
+//!   This special case is handled in `is_useful_specialized`.
 //!
-//!           For example, if `P` is:
-//!           [
-//!               [Some(true), _],
-//!               [None, 0],
-//!           ]
-//!           and `p` is [Some(false), 0], then we don't care about row 2 since we know `p` only
-//!           matches values that row 2 doesn't. For row 1 however, we need to dig into the
-//!           arguments of `Some` to know whether some new value is covered. So we compute
-//!           `U([[true, _]], [false, 0])`.
+//!   For example, if `P` is:
 //!
-//!         - If `p_1 == _`, then we look at the list of constructors that appear in the first
-//!               component of the rows of `P`:
-//!             + If there are some constructors that aren't present, then we might think that the
-//!               wildcard `_` is useful, since it covers those constructors that weren't covered
-//!               before.
-//!               That's almost correct, but only works if there were no wildcards in those first
-//!               components. So we need to check that `p` is useful with respect to the rows that
-//!               start with a wildcard, if there are any. This is where `D` comes in:
-//!               `U(P, p) := U(D(P), D(p))`
+//!   ```text
+//!   [
+//!       [Some(true), _],
+//!       [None, 0],
+//!   ]
+//!   ```
 //!
-//!               For example, if `P` is:
-//!               [
-//!                   [_, true, _],
-//!                   [None, false, 1],
-//!               ]
-//!               and `p` is [_, false, _], the `Some` constructor doesn't appear in `P`. So if we
-//!               only had row 2, we'd know that `p` is useful. However row 1 starts with a
-//!               wildcard, so we need to check whether `U([[true, _]], [false, 1])`.
+//!   and `p` is `[Some(false), 0]`, then we don't care about row 2 since we know `p` only
+//!   matches values that row 2 doesn't. For row 1 however, we need to dig into the
+//!   arguments of `Some` to know whether some new value is covered. So we compute
+//!   `U([[true, _]], [false, 0])`.
 //!
-//!             + Otherwise, all possible constructors (for the relevant type) are present. In this
-//!               case we must check whether the wildcard pattern covers any unmatched value. For
-//!               that, we can think of the `_` pattern as a big OR-pattern that covers all
-//!               possible constructors. For `Option`, that would mean `_ = None | Some(_)` for
-//!               example. The wildcard pattern is useful in this case if it is useful when
-//!               specialized to one of the possible constructors. So we compute:
-//!               `U(P, p) := ∃(k ϵ constructors) U(S(k, P), S(k, p))`
+//! - If `p_1 == _`, then we look at the list of constructors that appear in the first component of
+//!   the rows of `P`:
+//!     - If there are some constructors that aren't present, then we might think that the
+//!       wildcard `_` is useful, since it covers those constructors that weren't covered
+//!       before.
+//!       That's almost correct, but only works if there were no wildcards in those first
+//!       components. So we need to check that `p` is useful with respect to the rows that
+//!       start with a wildcard, if there are any. This is where `D` comes in:
+//!       `U(P, p) := U(D(P), D(p))`
 //!
-//!               For example, if `P` is:
-//!               [
-//!                   [Some(true), _],
-//!                   [None, false],
-//!               ]
-//!               and `p` is [_, false], both `None` and `Some` constructors appear in the first
-//!               components of `P`. We will therefore try popping both constructors in turn: we
-//!               compute U([[true, _]], [_, false]) for the `Some` constructor, and U([[false]],
-//!               [false]) for the `None` constructor. The first case returns true, so we know that
-//!               `p` is useful for `P`. Indeed, it matches `[Some(false), _]` that wasn't matched
-//!               before.
+//!       For example, if `P` is:
+//!       ```text
+//!       [
+//!           [_, true, _],
+//!           [None, false, 1],
+//!       ]
+//!       ```
+//!       and `p` is `[_, false, _]`, the `Some` constructor doesn't appear in `P`. So if we
+//!       only had row 2, we'd know that `p` is useful. However row 1 starts with a
+//!       wildcard, so we need to check whether `U([[true, _]], [false, 1])`.
 //!
-//!         - If `p_1 == r_1 | r_2`, then the usefulness depends on each `r_i` separately:
-//!           `U(P, p) := U(P, (r_1, p_2, .., p_n))
-//!                    || U(P, (r_2, p_2, .., p_n))`
+//!     - Otherwise, all possible constructors (for the relevant type) are present. In this
+//!       case we must check whether the wildcard pattern covers any unmatched value. For
+//!       that, we can think of the `_` pattern as a big OR-pattern that covers all
+//!       possible constructors. For `Option`, that would mean `_ = None | Some(_)` for
+//!       example. The wildcard pattern is useful in this case if it is useful when
+//!       specialized to one of the possible constructors. So we compute:
+//!       `U(P, p) := ∃(k ϵ constructors) U(S(k, P), S(k, p))`
+//!
+//!       For example, if `P` is:
+//!       ```text
+//!       [
+//!           [Some(true), _],
+//!           [None, false],
+//!       ]
+//!       ```
+//!       and `p` is `[_, false]`, both `None` and `Some` constructors appear in the first
+//!       components of `P`. We will therefore try popping both constructors in turn: we
+//!       compute `U([[true, _]], [_, false])` for the `Some` constructor, and `U([[false]],
+//!       [false])` for the `None` constructor. The first case returns true, so we know that
+//!       `p` is useful for `P`. Indeed, it matches `[Some(false), _]` that wasn't matched
+//!       before.
+//!
+//! - If `p_1 == r_1 | r_2`, then the usefulness depends on each `r_i` separately:
+//!
+//!   ```text
+//!   U(P, p) := U(P, (r_1, p_2, .., p_n))
+//!            || U(P, (r_2, p_2, .., p_n))
+//!   ```
 use std::sync::Arc;
 
 use smallvec::{smallvec, SmallVec};
@@ -283,20 +312,16 @@ impl PatStack {
         Self(v)
     }
 
-    fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-
-    fn head(&self) -> PatIdOrWild {
-        self.0[0]
-    }
-
     fn get_head(&self) -> Option<PatIdOrWild> {
         self.0.first().copied()
     }
 
+    fn tail(&self) -> &[PatIdOrWild] {
+        self.0.get(1..).unwrap_or(&[])
+    }
+
     fn to_tail(&self) -> PatStack {
-        Self::from_slice(&self.0[1..])
+        Self::from_slice(self.tail())
     }
 
     fn replace_head_with<I, T>(&self, pats: I) -> PatStack
@@ -318,7 +343,7 @@ impl PatStack {
     ///
     /// See the module docs and the associated documentation in rustc for details.
     fn specialize_wildcard(&self, cx: &MatchCheckCtx) -> Option<PatStack> {
-        if matches!(self.head().as_pat(cx), Pat::Wild) {
+        if matches!(self.get_head()?.as_pat(cx), Pat::Wild) {
             Some(self.to_tail())
         } else {
             None
@@ -333,7 +358,13 @@ impl PatStack {
         cx: &MatchCheckCtx,
         constructor: &Constructor,
     ) -> MatchCheckResult<Option<PatStack>> {
-        let result = match (self.head().as_pat(cx), constructor) {
+        let head = match self.get_head() {
+            Some(head) => head,
+            None => return Ok(None),
+        };
+
+        let head_pat = head.as_pat(cx);
+        let result = match (head_pat, constructor) {
             (Pat::Tuple { args: ref pat_ids, ellipsis }, Constructor::Tuple { arity: _ }) => {
                 if ellipsis.is_some() {
                     // If there are ellipsis here, we should add the correct number of
@@ -360,7 +391,7 @@ impl PatStack {
             (Pat::Wild, constructor) => Some(self.expand_wildcard(cx, constructor)?),
             (Pat::Path(_), Constructor::Enum(constructor)) => {
                 // unit enum variants become `Pat::Path`
-                let pat_id = self.head().as_id().expect("we know this isn't a wild");
+                let pat_id = head.as_id().expect("we know this isn't a wild");
                 if !enum_variant_matches(cx, pat_id, *constructor) {
                     None
                 } else {
@@ -371,7 +402,7 @@ impl PatStack {
                 Pat::TupleStruct { args: ref pat_ids, ellipsis, .. },
                 Constructor::Enum(enum_constructor),
             ) => {
-                let pat_id = self.head().as_id().expect("we know this isn't a wild");
+                let pat_id = head.as_id().expect("we know this isn't a wild");
                 if !enum_variant_matches(cx, pat_id, *enum_constructor) {
                     None
                 } else {
@@ -411,7 +442,7 @@ impl PatStack {
                 }
             }
             (Pat::Record { args: ref arg_patterns, .. }, Constructor::Enum(e)) => {
-                let pat_id = self.head().as_id().expect("we know this isn't a wild");
+                let pat_id = head.as_id().expect("we know this isn't a wild");
                 if !enum_variant_matches(cx, pat_id, *e) {
                     None
                 } else {
@@ -457,7 +488,7 @@ impl PatStack {
     ) -> MatchCheckResult<PatStack> {
         assert_eq!(
             Pat::Wild,
-            self.head().as_pat(cx),
+            self.get_head().expect("expand_wildcard called on empty PatStack").as_pat(cx),
             "expand_wildcard must only be called on PatStack with wild at head",
         );
 
@@ -475,7 +506,6 @@ impl PatStack {
     }
 }
 
-#[derive(Debug)]
 /// A collection of PatStack.
 ///
 /// This type is modeled from the struct of the same name in `rustc`.
@@ -502,7 +532,7 @@ impl Matrix {
     }
 
     fn heads(&self) -> Vec<PatIdOrWild> {
-        self.0.iter().map(|p| p.head()).collect()
+        self.0.iter().flat_map(|p| p.get_head()).collect()
     }
 
     /// Computes `D(self)` for each contained PatStack.
@@ -589,13 +619,16 @@ pub(crate) fn is_useful(
         _ => (),
     }
 
-    if v.is_empty() {
-        let result = if matrix.is_empty() { Usefulness::Useful } else { Usefulness::NotUseful };
+    let head = match v.get_head() {
+        Some(head) => head,
+        None => {
+            let result = if matrix.is_empty() { Usefulness::Useful } else { Usefulness::NotUseful };
 
-        return Ok(result);
-    }
+            return Ok(result);
+        }
+    };
 
-    if let Pat::Or(pat_ids) = v.head().as_pat(cx) {
+    if let Pat::Or(pat_ids) = head.as_pat(cx) {
         let mut found_unimplemented = false;
         let any_useful = pat_ids.iter().any(|&pat_id| {
             let v = PatStack::from_pattern(pat_id);
@@ -619,7 +652,7 @@ pub(crate) fn is_useful(
         };
     }
 
-    if let Some(constructor) = pat_constructor(cx, v.head())? {
+    if let Some(constructor) = pat_constructor(cx, head)? {
         let matrix = matrix.specialize_constructor(&cx, &constructor)?;
         let v = v
             .specialize_constructor(&cx, &constructor)?
@@ -808,194 +841,193 @@ mod tests {
 
     pub(super) use crate::{diagnostics::MissingMatchArms, test_db::TestDB};
 
-    pub(super) fn check_diagnostic_message(content: &str) -> String {
-        TestDB::with_single_file(content).0.diagnostic::<MissingMatchArms>().0
+    pub(super) fn check_diagnostic_message(ra_fixture: &str) -> String {
+        TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().0
     }
 
-    pub(super) fn check_diagnostic(content: &str) {
+    pub(super) fn check_diagnostic(ra_fixture: &str) {
         let diagnostic_count =
-            TestDB::with_single_file(content).0.diagnostic::<MissingMatchArms>().1;
+            TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().1;
 
         assert_eq!(1, diagnostic_count, "no diagnostic reported");
     }
 
-    pub(super) fn check_no_diagnostic(content: &str) {
-        let diagnostic_count =
-            TestDB::with_single_file(content).0.diagnostic::<MissingMatchArms>().1;
+    pub(super) fn check_no_diagnostic(ra_fixture: &str) {
+        let (s, diagnostic_count) =
+            TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>();
 
-        assert_eq!(0, diagnostic_count, "expected no diagnostic, found one");
+        assert_eq!(0, diagnostic_count, "expected no diagnostic, found one: {}", s);
     }
 
     #[test]
     fn empty_tuple_no_arms_diagnostic_message() {
-        let content = r"
-            fn test_fn() {
-                match () {
-                }
-            }
-        ";
-
         assert_snapshot!(
-            check_diagnostic_message(content),
+            check_diagnostic_message(r"
+                fn test_fn() {
+                    match () {
+                    }
+                }
+            "),
             @"\"()\": Missing match arm\n"
         );
     }
 
     #[test]
     fn empty_tuple_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match () {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn empty_tuple_wild() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match () {
                     _ => {}
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn empty_tuple_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match () {
                     () => {}
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_empty_tuple_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (()) {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_empty_tuple_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (()) {
                     (()) => {}
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_two_empty_tuple_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match ((), ()) {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_two_empty_tuple_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match ((), ()) {
                     ((), ()) => {}
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn bool_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match false {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn bool_missing_arm() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match false {
                     true => {}
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn bool_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match false {
                     true => {}
                     false => {}
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (true, true) => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_missing_arm() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (false, true) => {},
@@ -1003,14 +1035,14 @@ mod tests {
                     (true, false) => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_wilds() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (false, _) => {},
@@ -1018,14 +1050,14 @@ mod tests {
                     (_, true) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (true, true) => {},
@@ -1034,27 +1066,27 @@ mod tests {
                     (false, false) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_binding_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (true, _x) => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_binding_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (true, _x) => {},
@@ -1062,80 +1094,80 @@ mod tests {
                     (false, false) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_ellipsis_at_end_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true, false) {
                     (false, ..) => {},
                     (true, ..) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_ellipsis_at_beginning_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true, false) {
                     (.., false) => {},
                     (.., true) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_ellipsis_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true, false) {
                     (..) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_tuple_and_bools_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, ((), false)) {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_tuple_and_bools_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, ((), false)) {
                     (true, ((), true)) => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_tuple_and_bools_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, ((), false)) {
                     (true, ((), true)) => {},
@@ -1144,27 +1176,27 @@ mod tests {
                     (false, ((), false)) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_tuple_and_bools_wildcard_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, ((), false)) {
                     (true, _) => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_tuple_and_bools_wildcard_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, ((), false)) {
                     (true, ((), true)) => {},
@@ -1172,14 +1204,14 @@ mod tests {
                     (false, _) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1188,14 +1220,14 @@ mod tests {
                 match Either::A {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1205,14 +1237,14 @@ mod tests {
                     Either::A => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1223,14 +1255,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_ref_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1240,14 +1272,14 @@ mod tests {
                     Either::A => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_ref_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1258,14 +1290,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_containing_bool_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B,
@@ -1274,14 +1306,14 @@ mod tests {
                 match Either::B {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_containing_bool_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B,
@@ -1292,14 +1324,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_containing_bool_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B,
@@ -1311,14 +1343,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_containing_bool_with_wild_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B,
@@ -1329,14 +1361,14 @@ mod tests {
                     _ => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_containing_bool_with_wild_2_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B,
@@ -1347,14 +1379,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_different_sizes_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B(bool, bool),
@@ -1365,14 +1397,14 @@ mod tests {
                     Either::B(false, _) => (),
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_different_sizes_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B(bool, bool),
@@ -1384,14 +1416,14 @@ mod tests {
                     Either::B(false, _) => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn or_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B(bool, bool),
@@ -1403,14 +1435,14 @@ mod tests {
                     Either::B(false, _) => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_enum_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B(bool, bool),
@@ -1427,14 +1459,16 @@ mod tests {
                     (Either::B(_, _), Either2::D) => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn mismatched_types() {
-        let content = r"
+        // Match statements with arms that don't match the
+        // expression pattern do not fire this diagnostic.
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1449,47 +1483,47 @@ mod tests {
                     Either2::D => (),
                 }
             }
-        ";
-
-        // Match statements with arms that don't match the
-        // expression pattern do not fire this diagnostic.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn mismatched_types_with_different_arity() {
-        let content = r"
+        // Match statements with arms that don't match the
+        // expression pattern do not fire this diagnostic.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (true, false) {
                     (true, false, true) => (),
                     (true) => (),
                 }
             }
-        ";
-
-        // Match statements with arms that don't match the
-        // expression pattern do not fire this diagnostic.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn malformed_match_arm_tuple_missing_pattern() {
-        let content = r"
+        // Match statements with arms that don't match the
+        // expression pattern do not fire this diagnostic.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (0) {
                     () => (),
                 }
             }
-        ";
-
-        // Match statements with arms that don't match the
-        // expression pattern do not fire this diagnostic.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn malformed_match_arm_tuple_enum_missing_pattern() {
-        let content = r"
+        // We are testing to be sure we don't panic here when the match
+        // arm `Either::B` is missing its pattern.
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B(u32),
@@ -1500,32 +1534,30 @@ mod tests {
                     Either::B() => (),
                 }
             }
-        ";
-
-        // We are testing to be sure we don't panic here when the match
-        // arm `Either::B` is missing its pattern.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_not_in_scope() {
-        let content = r"
+        // The enum is not in scope so we don't perform exhaustiveness
+        // checking, but we want to be sure we don't panic here (and
+        // we don't create a diagnostic).
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match Foo::Bar {
                     Foo::Baz => (),
                 }
             }
-        ";
-
-        // The enum is not in scope so we don't perform exhaustiveness
-        // checking, but we want to be sure we don't panic here (and
-        // we don't create a diagnostic).
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn expr_diverges() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1536,14 +1568,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn expr_loop_with_break() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1554,14 +1586,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn expr_partially_diverges() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either<T> {
                 A(T),
                 B,
@@ -1575,14 +1607,14 @@ mod tests {
                     Either::B => 0,
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1592,14 +1624,14 @@ mod tests {
                 match a {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1610,14 +1642,14 @@ mod tests {
                     Either::A { foo: true } => (),
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1630,14 +1662,17 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_missing_field_no_diagnostic() {
-        let content = r"
+        // When `Either::A` is missing a struct member, we don't want
+        // to fire the missing match arm diagnostic. This should fire
+        // some other diagnostic.
+        check_no_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1649,17 +1684,16 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        // When `Either::A` is missing a struct member, we don't want
-        // to fire the missing match arm diagnostic. This should fire
-        // some other diagnostic.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_missing_field_missing_match_arm() {
-        let content = r"
+        // Even though `Either::A` is missing fields, we still want to fire
+        // the missing arm diagnostic here, since we know `Either::B` is missing.
+        check_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1670,16 +1704,14 @@ mod tests {
                     Either::A { } => (),
                 }
             }
-        ";
-
-        // Even though `Either::A` is missing fields, we still want to fire
-        // the missing arm diagnostic here, since we know `Either::B` is missing.
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_no_diagnostic_wild() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1691,14 +1723,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_fields_out_of_order_missing_arm() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A { foo: bool, bar: () },
                 B,
@@ -1710,14 +1742,14 @@ mod tests {
                     Either::A { foo: true, bar: () } => (),
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_fields_out_of_order_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A { foo: bool, bar: () },
                 B,
@@ -1730,89 +1762,89 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_ellipsis_missing_arm() {
-        let content = r"
-             enum Either {
-                 A { foo: bool, bar: bool },
-                 B,
-             }
-             fn test_fn() {
-                 match Either::B {
-                     Either::A { foo: true, .. } => (),
-                     Either::B => (),
-                 }
-             }
-         ";
-
-        check_diagnostic(content);
+        check_diagnostic(
+            r"
+            enum Either {
+                A { foo: bool, bar: bool },
+                B,
+            }
+            fn test_fn() {
+                match Either::B {
+                    Either::A { foo: true, .. } => (),
+                    Either::B => (),
+                }
+            }
+        ",
+        );
     }
 
     #[test]
     fn enum_record_ellipsis_no_diagnostic() {
-        let content = r"
-             enum Either {
-                 A { foo: bool, bar: bool },
-                 B,
-             }
-             fn test_fn() {
-                 let a = Either::A { foo: true };
-                 match a {
-                     Either::A { foo: true, .. } => (),
-                     Either::A { foo: false, .. } => (),
-                     Either::B => (),
-                 }
-             }
-         ";
-
-        check_no_diagnostic(content);
+        check_no_diagnostic(
+            r"
+            enum Either {
+                A { foo: bool, bar: bool },
+                B,
+            }
+            fn test_fn() {
+                let a = Either::A { foo: true };
+                match a {
+                    Either::A { foo: true, .. } => (),
+                    Either::A { foo: false, .. } => (),
+                    Either::B => (),
+                }
+            }
+        ",
+        );
     }
 
     #[test]
     fn enum_record_ellipsis_all_fields_missing_arm() {
-        let content = r"
-             enum Either {
-                 A { foo: bool, bar: bool },
-                 B,
-             }
-             fn test_fn() {
-                 let a = Either::B;
-                 match a {
-                     Either::A { .. } => (),
-                 }
-             }
-         ";
-
-        check_diagnostic(content);
+        check_diagnostic(
+            r"
+            enum Either {
+                A { foo: bool, bar: bool },
+                B,
+            }
+            fn test_fn() {
+                let a = Either::B;
+                match a {
+                    Either::A { .. } => (),
+                }
+            }
+        ",
+        );
     }
 
     #[test]
     fn enum_record_ellipsis_all_fields_no_diagnostic() {
-        let content = r"
-             enum Either {
-                 A { foo: bool, bar: bool },
-                 B,
-             }
-             fn test_fn() {
-                 let a = Either::B;
-                 match a {
-                     Either::A { .. } => (),
-                     Either::B => (),
-                 }
-             }
-         ";
-
-        check_no_diagnostic(content);
+        check_no_diagnostic(
+            r"
+            enum Either {
+                A { foo: bool, bar: bool },
+                B,
+            }
+            fn test_fn() {
+                let a = Either::B;
+                match a {
+                    Either::A { .. } => (),
+                    Either::B => (),
+                }
+            }
+        ",
+        );
     }
 
     #[test]
     fn enum_tuple_partial_ellipsis_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool, bool, bool, bool),
                 B,
@@ -1826,14 +1858,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_tuple_partial_ellipsis_2_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool, bool, bool, bool),
                 B,
@@ -1847,14 +1879,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_tuple_partial_ellipsis_missing_arm() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A(bool, bool, bool, bool),
                 B,
@@ -1867,14 +1899,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_tuple_partial_ellipsis_2_missing_arm() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A(bool, bool, bool, bool),
                 B,
@@ -1887,14 +1919,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_tuple_ellipsis_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool, bool, bool, bool),
                 B,
@@ -1905,51 +1937,51 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_never() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Never {}
 
             fn test_fn(never: Never) {
                 match never {}
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn type_never() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn(never: !) {
                 match never {}
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_never_ref() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Never {}
 
             fn test_fn(never: &Never) {
                 match never {}
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn expr_diverges_missing_arm() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1959,9 +1991,49 @@ mod tests {
                     Either::A => (),
                 }
             }
-        ";
+        ",
+        );
+    }
+
+    #[test]
+    fn or_pattern_panic() {
+        check_no_diagnostic(
+            r"
+            pub enum Category {
+                Infinity,
+                Zero,
+            }
+
+            fn panic(a: Category, b: Category) {
+                match (a, b) {
+                    (Category::Zero | Category::Infinity, _) => {}
+                    (_, Category::Zero | Category::Infinity) => {}
+                }
+            }
+        ",
+        );
+    }
 
-        check_no_diagnostic(content);
+    #[test]
+    fn or_pattern_panic_2() {
+        // FIXME: This is a false positive, but the code used to cause a panic in the match checker,
+        // so this acts as a regression test for that.
+        check_diagnostic(
+            r"
+            pub enum Category {
+                Infinity,
+                Zero,
+            }
+
+            fn panic(a: Category, b: Category) {
+                match (a, b) {
+                    (Category::Infinity, Category::Infinity) | (Category::Zero, Category::Zero) => {}
+
+                    (Category::Infinity | Category::Zero, _) => {}
+                }
+            }
+        ",
+        );
     }
 }
 
@@ -1981,23 +2053,26 @@ mod false_negatives {
 
     #[test]
     fn integers() {
-        let content = r"
+        // This is a false negative.
+        // We don't currently check integer exhaustiveness.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match 5 {
                     10 => (),
                     11..20 => (),
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We don't currently check integer exhaustiveness.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn internal_or() {
-        let content = r"
+        // This is a false negative.
+        // We do not currently handle patterns with internal `or`s.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 enum Either {
                     A(bool),
@@ -2007,16 +2082,18 @@ mod false_negatives {
                     Either::A(true | false) => (),
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We do not currently handle patterns with internal `or`s.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn expr_loop_missing_arm() {
-        let content = r"
+        // This is a false negative.
+        // We currently infer the type of `loop { break Foo::A }` to `!`, which
+        // causes us to skip the diagnostic since `Either::A` doesn't type check
+        // with `!`.
+        check_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -2026,48 +2103,46 @@ mod false_negatives {
                     Either::A => (),
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We currently infer the type of `loop { break Foo::A }` to `!`, which
-        // causes us to skip the diagnostic since `Either::A` doesn't type check
-        // with `!`.
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
-        let content = r"
+        // This is a false negative.
+        // We don't currently handle tuple patterns with ellipsis.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true, false) {
                     (false, ..) => {},
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We don't currently handle tuple patterns with ellipsis.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
-        let content = r"
+        // This is a false negative.
+        // We don't currently handle tuple patterns with ellipsis.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true, false) {
                     (.., false) => {},
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We don't currently handle tuple patterns with ellipsis.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn struct_missing_arm() {
-        let content = r"
+        // This is a false negative.
+        // We don't currently handle structs.
+        check_no_diagnostic(
+            r"
             struct Foo {
                 a: bool,
             }
@@ -2076,10 +2151,7 @@ mod false_negatives {
                     Foo { a: true } => {},
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We don't currently handle structs.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 }
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index 2b9372b4b..f22232324 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -73,6 +73,7 @@ pub use lower::{
 pub use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironment};
 
 pub use chalk_ir::{BoundVar, DebruijnIndex};
+use itertools::Itertools;
 
 /// A type constructor or type name: this might be something like the primitive
 /// type `bool`, a struct like `Vec`, or things like function pointers or
@@ -815,6 +816,11 @@ impl Ty {
         }
     }
 
+    /// If this is a `dyn Trait`, returns that trait.
+    pub fn dyn_trait(&self) -> Option<TraitId> {
+        self.dyn_trait_ref().map(|it| it.trait_)
+    }
+
     fn builtin_deref(&self) -> Option<Ty> {
         match self {
             Ty::Apply(a_ty) => match a_ty.ctor {
@@ -867,13 +873,56 @@ impl Ty {
         }
     }
 
-    /// If this is a `dyn Trait`, returns that trait.
-    pub fn dyn_trait(&self) -> Option<TraitId> {
+    pub fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<GenericPredicate>> {
         match self {
-            Ty::Dyn(predicates) => predicates.iter().find_map(|pred| match pred {
-                GenericPredicate::Implemented(tr) => Some(tr.trait_),
-                _ => None,
-            }),
+            Ty::Opaque(opaque_ty) => {
+                let predicates = match opaque_ty.opaque_ty_id {
+                    OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
+                        db.return_type_impl_traits(func).map(|it| {
+                            let data = (*it)
+                                .as_ref()
+                                .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
+                            data.clone().subst(&opaque_ty.parameters)
+                        })
+                    }
+                };
+
+                predicates.map(|it| it.value)
+            }
+            Ty::Placeholder(id) => {
+                let generic_params = db.generic_params(id.parent);
+                let param_data = &generic_params.types[id.local_id];
+                match param_data.provenance {
+                    hir_def::generics::TypeParamProvenance::ArgumentImplTrait => {
+                        let predicates = db
+                            .generic_predicates_for_param(*id)
+                            .into_iter()
+                            .map(|pred| pred.value.clone())
+                            .collect_vec();
+
+                        Some(predicates)
+                    }
+                    _ => None,
+                }
+            }
+            _ => None,
+        }
+    }
+
+    pub fn associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<TraitId> {
+        match self {
+            Ty::Apply(ApplicationTy { ctor: TypeCtor::AssociatedType(type_alias_id), .. }) => {
+                match type_alias_id.lookup(db.upcast()).container {
+                    AssocContainerId::TraitId(trait_id) => Some(trait_id),
+                    _ => None,
+                }
+            }
+            Ty::Projection(projection_ty) => {
+                match projection_ty.associated_ty.lookup(db.upcast()).container {
+                    AssocContainerId::TraitId(trait_id) => Some(trait_id),
+                    _ => None,
+                }
+            }
             _ => None,
         }
     }
@@ -1057,5 +1106,5 @@ pub struct ReturnTypeImplTraits {
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub(crate) struct ReturnTypeImplTrait {
-    pub(crate) bounds: Binders<Vec<GenericPredicate>>,
+    pub bounds: Binders<Vec<GenericPredicate>>,
 }