8 files changed, 146 insertions, 35 deletions

diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index 3efbce773..a2a4d61db 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -357,17 +357,20 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
             infer: &infer,
             db,
             pattern_arena: &pattern_arena,
-            eprint_panic_context: &|| {
+            panic_context: &|| {
                 use syntax::AstNode;
-                if let Ok(scrutinee_sptr) = source_map.expr_syntax(match_expr) {
-                    let root = scrutinee_sptr.file_syntax(db.upcast());
-                    if let Some(match_ast) = scrutinee_sptr.value.to_node(&root).syntax().parent() {
-                        eprintln!(
-                            "Match checking is about to panic on this expression:\n{}",
-                            match_ast.to_string(),
-                        );
-                    }
-                }
+                let match_expr_text = source_map
+                    .expr_syntax(match_expr)
+                    .ok()
+                    .and_then(|scrutinee_sptr| {
+                        let root = scrutinee_sptr.file_syntax(db.upcast());
+                        scrutinee_sptr.value.to_node(&root).syntax().parent()
+                    })
+                    .map(|node| node.to_string());
+                format!(
+                    "expression:\n{}",
+                    match_expr_text.as_deref().unwrap_or("<synthesized expr>")
+                )
             },
         };
         let report = compute_match_usefulness(&cx, &m_arms);
diff --git a/crates/hir_ty/src/diagnostics/match_check.rs b/crates/hir_ty/src/diagnostics/match_check.rs
index a9a99f57a..c8e1b23de 100644
--- a/crates/hir_ty/src/diagnostics/match_check.rs
+++ b/crates/hir_ty/src/diagnostics/match_check.rs
@@ -100,10 +100,19 @@ impl<'a> PatCtxt<'a> {
     }
 
     pub(crate) fn lower_pattern(&mut self, pat: hir_def::expr::PatId) -> Pat {
-        // FIXME: implement pattern adjustments (implicit pattern dereference; "RFC 2005-match-ergonomics")
+        // XXX(iDawer): Collecting pattern adjustments feels imprecise to me.
+        // When lowering of & and box patterns are implemented this should be tested
+        // in a manner of `match_ergonomics_issue_9095` test.
+        // Pattern adjustment is part of RFC 2005-match-ergonomics.
         // More info https://github.com/rust-lang/rust/issues/42640#issuecomment-313535089
         let unadjusted_pat = self.lower_pattern_unadjusted(pat);
-        unadjusted_pat
+        self.infer.pat_adjustments.get(&pat).map(|it| &**it).unwrap_or_default().iter().rev().fold(
+            unadjusted_pat,
+            |subpattern, ref_ty| Pat {
+                ty: ref_ty.clone(),
+                kind: Box::new(PatKind::Deref { subpattern }),
+            },
+        )
     }
 
     fn lower_pattern_unadjusted(&mut self, pat: hir_def::expr::PatId) -> Pat {
@@ -1236,6 +1245,21 @@ fn main(f: Foo) {
         );
     }
 
+    #[test]
+    fn match_ergonomics_issue_9095() {
+        check_diagnostics(
+            r#"
+enum Foo<T> { A(T) }
+fn main() {
+    match &Foo::A(true) {
+        _ => {}
+        Foo::A(_) => {}
+    }
+}
+"#,
+        );
+    }
+
     mod false_negatives {
         //! The implementation of match checking here is a work in progress. As we roll this out, we
         //! prefer false negatives to false positives (ideally there would be no false positives). This
diff --git a/crates/hir_ty/src/diagnostics/match_check/usefulness.rs b/crates/hir_ty/src/diagnostics/match_check/usefulness.rs
index 83b094a89..bd76a606c 100644
--- a/crates/hir_ty/src/diagnostics/match_check/usefulness.rs
+++ b/crates/hir_ty/src/diagnostics/match_check/usefulness.rs
@@ -295,7 +295,7 @@ pub(crate) struct MatchCheckCtx<'a> {
     pub(crate) db: &'a dyn HirDatabase,
     /// Lowered patterns from arms plus generated by the check.
     pub(crate) pattern_arena: &'a RefCell<PatternArena>,
-    pub(crate) eprint_panic_context: &'a dyn Fn(),
+    pub(crate) panic_context: &'a dyn Fn() -> String,
 }
 
 impl<'a> MatchCheckCtx<'a> {
@@ -331,8 +331,7 @@ impl<'a> MatchCheckCtx<'a> {
 
     #[track_caller]
     pub(super) fn bug(&self, info: &str) -> ! {
-        (self.eprint_panic_context)();
-        panic!("bug: {}", info);
+        panic!("bug: {}\n{}", info, (self.panic_context)());
     }
 }
 
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 7a4268819..0e9f777da 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -150,6 +150,8 @@ pub struct InferenceResult {
     type_mismatches: FxHashMap<ExprOrPatId, TypeMismatch>,
     /// Interned Unknown to return references to.
     standard_types: InternedStandardTypes,
+    /// Stores the types which were implicitly dereferenced in pattern binding modes.
+    pub pat_adjustments: FxHashMap<PatId, Vec<Ty>>,
 }
 
 impl InferenceResult {
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index 83e0a7a9e..25dff7e49 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -101,7 +101,9 @@ impl<'a> InferenceContext<'a> {
         let mut expected = self.resolve_ty_shallow(expected);
 
         if is_non_ref_pat(&body, pat) {
+            let mut pat_adjustments = Vec::new();
             while let Some((inner, _lifetime, mutability)) = expected.as_reference() {
+                pat_adjustments.push(expected.clone());
                 expected = self.resolve_ty_shallow(inner);
                 default_bm = match default_bm {
                     BindingMode::Move => BindingMode::Ref(mutability),
@@ -109,6 +111,11 @@ impl<'a> InferenceContext<'a> {
                     BindingMode::Ref(Mutability::Mut) => BindingMode::Ref(mutability),
                 }
             }
+
+            if !pat_adjustments.is_empty() {
+                pat_adjustments.shrink_to_fit();
+                self.result.pat_adjustments.insert(pat, pat_adjustments);
+            }
         } else if let Pat::Ref { .. } = &body[pat] {
             cov_mark::hit!(match_ergonomics_ref);
             // When you encounter a `&pat` pattern, reset to Move.
@@ -290,6 +297,10 @@ fn is_non_ref_pat(body: &hir_def::body::Body, pat: PatId) -> bool {
             Expr::Literal(Literal::String(..)) => false,
             _ => true,
         },
+        Pat::Bind { mode: BindingAnnotation::Mutable, subpat: Some(subpat), .. }
+        | Pat::Bind { mode: BindingAnnotation::Unannotated, subpat: Some(subpat), .. } => {
+            is_non_ref_pat(body, *subpat)
+        }
         Pat::Wild | Pat::Bind { .. } | Pat::Ref { .. } | Pat::Box { .. } | Pat::Missing => false,
     }
 }
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index af6b6cda7..a23527f7d 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -5,7 +5,7 @@
 use std::{iter, sync::Arc};
 
 use arrayvec::ArrayVec;
-use base_db::CrateId;
+use base_db::{CrateId, Edition};
 use chalk_ir::{cast::Cast, Mutability, UniverseIndex};
 use hir_def::{
     lang_item::LangItemTarget, nameres::DefMap, AssocContainerId, AssocItemId, FunctionId,
@@ -639,6 +639,7 @@ fn iterate_trait_method_candidates(
     receiver_ty: Option<&Canonical<Ty>>,
     callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
 ) -> bool {
+    let receiver_is_array = matches!(self_ty.value.kind(&Interner), chalk_ir::TyKind::Array(..));
     // if ty is `dyn Trait`, the trait doesn't need to be in scope
     let inherent_trait =
         self_ty.value.dyn_trait().into_iter().flat_map(|t| all_super_traits(db.upcast(), t));
@@ -655,6 +656,19 @@ fn iterate_trait_method_candidates(
     'traits: for t in traits {
         let data = db.trait_data(t);
 
+        // Traits annotated with `#[rustc_skip_array_during_method_dispatch]` are skipped during
+        // method resolution, if the receiver is an array, and we're compiling for editions before
+        // 2021.
+        // This is to make `[a].into_iter()` not break code with the new `IntoIterator` impl for
+        // arrays.
+        if data.skip_array_during_method_dispatch && receiver_is_array {
+            // FIXME: this should really be using the edition of the method name's span, in case it
+            // comes from a macro
+            if db.crate_graph()[krate].edition < Edition::Edition2021 {
+                continue;
+            }
+        }
+
         // we'll be lazy about checking whether the type implements the
         // trait, but if we find out it doesn't, we'll skip the rest of the
         // iteration
diff --git a/crates/hir_ty/src/tests/method_resolution.rs b/crates/hir_ty/src/tests/method_resolution.rs
index 058eb9129..f26b2c8a7 100644
--- a/crates/hir_ty/src/tests/method_resolution.rs
+++ b/crates/hir_ty/src/tests/method_resolution.rs
@@ -1349,3 +1349,52 @@ fn f() {
     "#,
     );
 }
+
+#[test]
+fn skip_array_during_method_dispatch() {
+    check_types(
+        r#"
+//- /main2018.rs crate:main2018 deps:core
+use core::IntoIterator;
+
+fn f() {
+    let v = [4].into_iter();
+    v;
+  //^ &i32
+
+    let a = [0, 1].into_iter();
+    a;
+  //^ &i32
+}
+
+//- /main2021.rs crate:main2021 deps:core edition:2021
+use core::IntoIterator;
+
+fn f() {
+    let v = [4].into_iter();
+    v;
+  //^ i32
+
+    let a = [0, 1].into_iter();
+    a;
+  //^ &i32
+}
+
+//- /core.rs crate:core
+#[rustc_skip_array_during_method_dispatch]
+pub trait IntoIterator {
+    type Out;
+    fn into_iter(self) -> Self::Out;
+}
+
+impl<T> IntoIterator for [T; 1] {
+    type Out = T;
+    fn into_iter(self) -> Self::Out {}
+}
+impl<'a, T> IntoIterator for &'a [T] {
+    type Out = &'a T;
+    fn into_iter(self) -> Self::Out {}
+}
+    "#,
+    );
+}
diff --git a/crates/hir_ty/src/tests/patterns.rs b/crates/hir_ty/src/tests/patterns.rs
index cd08b5c7a..7d00cee9b 100644
--- a/crates/hir_ty/src/tests/patterns.rs
+++ b/crates/hir_ty/src/tests/patterns.rs
@@ -20,6 +20,8 @@ fn infer_pattern() {
                 let h = val;
             }
 
+            if let x @ true = &true {}
+
             let lambda = |a: u64, b, c: i32| { a + b; c };
 
             let ref ref_to_x = x;
@@ -30,7 +32,7 @@ fn infer_pattern() {
         "#,
         expect![[r#"
             8..9 'x': &i32
-            17..368 '{     ...o_x; }': ()
+            17..400 '{     ...o_x; }': ()
             27..28 'y': &i32
             31..32 'x': &i32
             42..44 '&z': &i32
@@ -59,24 +61,31 @@ fn infer_pattern() {
             176..204 '{     ...     }': ()
             190..191 'h': {unknown}
             194..197 'val': {unknown}
-            214..220 'lambda': |u64, u64, i32| -> i32
-            223..255 '|a: u6...b; c }': |u64, u64, i32| -> i32
-            224..225 'a': u64
-            232..233 'b': u64
-            235..236 'c': i32
-            243..255 '{ a + b; c }': i32
-            245..246 'a': u64
-            245..250 'a + b': u64
-            249..250 'b': u64
-            252..253 'c': i32
-            266..278 'ref ref_to_x': &&i32
-            281..282 'x': &i32
-            292..301 'mut mut_x': &i32
-            304..305 'x': &i32
-            315..335 'ref mu...f_to_x': &mut &i32
-            338..339 'x': &i32
-            349..350 'k': &mut &i32
-            353..365 'mut_ref_to_x': &mut &i32
+            210..236 'if let...rue {}': ()
+            217..225 'x @ true': &bool
+            221..225 'true': bool
+            221..225 'true': bool
+            228..233 '&true': &bool
+            229..233 'true': bool
+            234..236 '{}': ()
+            246..252 'lambda': |u64, u64, i32| -> i32
+            255..287 '|a: u6...b; c }': |u64, u64, i32| -> i32
+            256..257 'a': u64
+            264..265 'b': u64
+            267..268 'c': i32
+            275..287 '{ a + b; c }': i32
+            277..278 'a': u64
+            277..282 'a + b': u64
+            281..282 'b': u64
+            284..285 'c': i32
+            298..310 'ref ref_to_x': &&i32
+            313..314 'x': &i32
+            324..333 'mut mut_x': &i32
+            336..337 'x': &i32
+            347..367 'ref mu...f_to_x': &mut &i32
+            370..371 'x': &i32
+            381..382 'k': &mut &i32
+            385..397 'mut_ref_to_x': &mut &i32
         "#]],
     );
 }