Add tests from #7273

Author: lnicola

crates/hir_ty/src/tests/method_resolution.rs

@@ -955,6 +955,97 @@ fn test() { foo.call(); }
     );
 }
 
+#[test]
+fn super_trait_assoc_type_impl_return() {
+    check_infer(
+        r#"
+        trait Base {
+            type Item;
+            fn foo(self) -> Self::Item;
+        }
+
+        trait Super : Base {}
+
+        fn base1() -> impl Base<Item = usize> { loop {} }
+        fn super1() -> impl Super<Item = usize> { loop {} }
+
+        fn test(base2: impl Base<Item = usize>, super2: impl Super<Item = usize>) {
+            base1().foo();
+            super1().foo();
+            base2.foo();
+            super2.foo();
+        }
+        "#,
+        expect![[r#"
+            39..43 'self': Self
+            124..135 '{ loop {} }': !
+            126..133 'loop {}': !
+            131..133 '{}': ()
+            176..187 '{ loop {} }': !
+            178..185 'loop {}': !
+            183..185 '{}': ()
+            197..202 'base2': impl Base<Item = usize>
+            229..235 'super2': impl Super<Item = usize>
+            263..340 '{     ...o(); }': ()
+            269..274 'base1': fn base1() -> impl Base<Item = usize>
+            269..276 'base1()': impl Base<Item = usize>
+            269..282 'base1().foo()': usize
+            288..294 'super1': fn super1() -> impl Super<Item = usize>
+            288..296 'super1()': impl Super<Item = usize>
+            288..302 'super1().foo()': usize
+            308..313 'base2': impl Base<Item = usize>
+            308..319 'base2.foo()': usize
+            325..331 'super2': impl Super<Item = usize>
+            325..337 'super2.foo()': usize
+        "#]],
+    );
+}
+
+#[test]
+fn super_trait_impl_return_trait_method_resolution() {
+    check_infer(
+        r#"
+        trait Base {
+            fn foo(self) -> usize;
+        }
+
+        trait Super : Base {}
+
+        fn base1() -> impl Base { loop {} }
+        fn super1() -> impl Super { loop {} }
+
+        fn test(base2: impl Base, super2: impl Super) {
+            base1().foo();
+            super1().foo();
+            base2.foo();
+            super2.foo();
+        }
+        "#,
+        expect![[r#"
+            24..28 'self': Self
+            90..101 '{ loop {} }': !
+            92..99 'loop {}': !
+            97..99 '{}': ()
+            128..139 '{ loop {} }': !
+            130..137 'loop {}': !
+            135..137 '{}': ()
+            149..154 'base2': impl Base
+            167..173 'super2': impl Super
+            187..264 '{     ...o(); }': ()
+            193..198 'base1': fn base1() -> impl Base
+            193..200 'base1()': impl Base
+            193..206 'base1().foo()': usize
+            212..218 'super1': fn super1() -> impl Super
+            212..220 'super1()': impl Super
+            212..226 'super1().foo()': usize
+            232..237 'base2': impl Base
+            232..243 'base2.foo()': usize
+            249..255 'super2': impl Super
+            249..261 'super2.foo()': usize
+        "#]],
+    );
+}
+
 #[test]
 fn method_resolution_non_parameter_type() {
     check_types(