From 53e24fe49c93024ad9ccbdf5e5cc2065c064b1e8 Mon Sep 17 00:00:00 2001
From: bitgaoshu <bitgaoshu@gmail.com>
Date: Sat, 10 Dec 2022 14:08:12 +0800
Subject: [PATCH] fix: #12247 fully qualified call required to determine trait
 method type

---
 crates/hir-expand/src/name.rs         |  2 +
 crates/hir-ty/src/infer.rs            |  5 ++
 crates/hir-ty/src/infer/coerce.rs     |  1 +
 crates/hir-ty/src/infer/expr.rs       |  8 +++
 crates/hir-ty/src/tests/regression.rs | 85 +++++++++++++++++++++++++++
 5 files changed, 101 insertions(+)

diff --git a/crates/hir-expand/src/name.rs b/crates/hir-expand/src/name.rs
index 0e4d20c07ee9..34c79c62b646 100644
--- a/crates/hir-expand/src/name.rs
+++ b/crates/hir-expand/src/name.rs
@@ -274,11 +274,13 @@ pub mod known {
         IntoIter,
         Try,
         Ok,
+        Err,
         Future,
         IntoFuture,
         Result,
         Option,
         Output,
+        Residual,
         Target,
         Box,
         RangeFrom,
diff --git a/crates/hir-ty/src/infer.rs b/crates/hir-ty/src/infer.rs
index 571b3e968631..50d86a868c79 100644
--- a/crates/hir-ty/src/infer.rs
+++ b/crates/hir-ty/src/infer.rs
@@ -950,6 +950,11 @@ impl<'a> InferenceContext<'a> {
         self.resolve_output_on(self.resolve_lang_trait(LangItem::Try)?)
     }
 
+    fn resolve_ops_try_err(&self) -> Option<TypeAliasId> {
+        let trait_ =  self.resolve_lang_trait(LangItem::Try)?;
+        self.db.trait_data(trait_).associated_type_by_name(&name![Residual])
+    }
+
     fn resolve_ops_neg_output(&self) -> Option<TypeAliasId> {
         self.resolve_output_on(self.resolve_lang_trait(LangItem::Neg)?)
     }
diff --git a/crates/hir-ty/src/infer/coerce.rs b/crates/hir-ty/src/infer/coerce.rs
index 3293534a068b..3bd743dc0615 100644
--- a/crates/hir-ty/src/infer/coerce.rs
+++ b/crates/hir-ty/src/infer/coerce.rs
@@ -252,6 +252,7 @@ impl<'a> InferenceTable<'a> {
             }
             _ => {
                 // Otherwise, just use unification rules.
+                eprintln!("just unification rules");
                 self.unify_and(&from_ty, to_ty, identity)
             }
         }
diff --git a/crates/hir-ty/src/infer/expr.rs b/crates/hir-ty/src/infer/expr.rs
index 7b9bf0c5cf3d..a58eccf43453 100644
--- a/crates/hir-ty/src/infer/expr.rs
+++ b/crates/hir-ty/src/infer/expr.rs
@@ -603,6 +603,14 @@ impl<'a> InferenceContext<'a> {
                             .build();
                         self.write_method_resolution(tgt_expr, func, subst.clone());
                     }
+                    let actual_ret = inner_ty.clone();
+                    let residual = self.resolve_ops_try_err();
+                    let expect_err = self.resolve_associated_type(self.return_ty.clone(), residual);
+                    let actual_err = self.resolve_associated_type(actual_ret, residual);
+                    match self.table.coerce(&actual_err, &expect_err) {
+                        Err(_) => (),
+                        Ok(_) => (),
+                    }
                     let try_output = self.resolve_output_on(trait_);
                     self.resolve_associated_type(inner_ty, try_output)
                 } else {
diff --git a/crates/hir-ty/src/tests/regression.rs b/crates/hir-ty/src/tests/regression.rs
index de6ae7fff8fb..f8a9359eb2ba 100644
--- a/crates/hir-ty/src/tests/regression.rs
+++ b/crates/hir-ty/src/tests/regression.rs
@@ -944,6 +944,91 @@ fn clone_iter<T>(s: Iter<T>) {
     )
 }
 
+#[test]
+fn issue_12247() {
+    check_infer(
+        r#"
+//- minicore: result, try
+fn aa() -> Result<i32, E3> {
+    let a : Result<i32, E1> = Err(E1);
+    let b = a.mapE()?;
+}
+struct E1;
+struct E2;
+struct E3;
+
+impl From<E1> for E2 {
+    fn from(value: E1) -> Self {
+        E2
+    }
+}
+
+impl From<E1> for E3 {
+    fn from(value: E1) -> Self {
+        E3
+    }
+}
+trait MapErr<T, E> {
+    fn mapE(self) -> Result<T, E>;
+}
+
+impl <T, ET> MapErr<T, E2> for Result<T, ET>
+where
+    ET: Into<E2>,
+{
+    fn mapE(self) -> Result<T, E2> {
+        self.map_err(|e| e.into())
+    }
+}
+
+impl <T, ET> MapErr<T, E3> for Result<T, ET>
+where
+    ET: Into<E3>,
+{
+    fn mapE(self) -> Result<T, E3> {
+        self.map_err(|e| e.into())
+    }
+}
+        "#, expect![
+            r#"
+27..92 '{     ...()?; }': Result<i32, E3>
+37..38 'a': Result<i32, E1>
+59..62 'Err': Err<i32, E1>(E1) -> Result<i32, E1>
+59..66 'Err(E1)': Result<i32, E1>
+63..65 'E1': E1
+76..77 'b': Try::Output<Result<i32, E3>>
+80..81 'a': Result<i32, E1>
+80..88 'a.mapE()': Result<i32, E3>
+80..89 'a.mapE()?': Try::Output<Result<i32, E3>>
+162..167 'value': E1
+181..199 '{     ...     }': E2
+191..193 'E2': E2
+238..243 'value': E1
+257..275 '{     ...     }': E3
+267..269 'E3': E3
+311..315 'self': Self
+420..424 'self': Result<T, ET>
+443..485 '{     ...     }': Result<T, E2>
+453..457 'self': Result<T, ET>
+453..479 'self.m...nto())': Result<T, E2>
+466..478 '|e| e.into()': |{unknown}| -> {unknown}
+467..468 'e': {unknown}
+470..471 'e': {unknown}
+470..478 'e.into()': {unknown}
+572..576 'self': Result<T, ET>
+595..637 '{     ...     }': Result<T, E3>
+605..609 'self': Result<T, ET>
+605..631 'self.m...nto())': Result<T, E3>
+618..630 '|e| e.into()': |{unknown}| -> {unknown}
+619..620 'e': {unknown}
+622..623 'e': {unknown}
+622..630 'e.into()': {unknown}
+"#
+        ]
+    )
+}
+
+
 #[test]
 fn issue_8686() {
     check_infer(