fix: rust-lang#12247 fully qualified call required to determine trait method type

Author: bitgaoshu

crates/hir-expand/src/name.rs

@@ -266,11 +266,13 @@ pub mod known {
         IntoIter,
         Try,
         Ok,
+        Err,
         Future,
         IntoFuture,
         Result,
         Option,
         Output,
+        Residual,
         Target,
         Box,
         RangeFrom,

crates/hir-ty/src/infer.rs

@@ -928,6 +928,17 @@ impl<'a> InferenceContext<'a> {
             .or_else(|| trait_data.associated_type_by_name(&name![Output]))
     }
 
+    fn resolve_ops_try_err(&self) -> Option<TypeAliasId> {
+        // FIXME resolve via lang_item once try v2 is stable
+        let path = path![core::ops::Try];
+        let trait_ = self.resolver.resolve_known_trait(self.db.upcast(), &path)?;
+        let trait_data = self.db.trait_data(trait_);
+        trait_data
+            // FIXME remove once try v2 is stable
+            .associated_type_by_name(&name![Err])
+            .or_else(|| trait_data.associated_type_by_name(&name![Residual]))
+    }
+
     fn resolve_ops_neg_output(&self) -> Option<TypeAliasId> {
         let trait_ = self.resolve_lang_item(name![neg])?.as_trait()?;
         self.db.trait_data(trait_).associated_type_by_name(&name![Output])

crates/hir-ty/src/infer/expr.rs

@@ -567,6 +567,14 @@ impl<'a> InferenceContext<'a> {
             }
             Expr::Try { expr } => {
                 let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
+                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(_) => (),
+                }
                 self.resolve_associated_type(inner_ty, self.resolve_ops_try_ok())
             }
             Expr::Cast { expr, type_ref } => {

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(