Fix a bug in orphan rules calculation

Where a fundamental type applied twice wasn't considered local.

crates/hir-ty/src/method_resolution.rs

@@ -874,21 +874,26 @@ pub fn check_orphan_rules(db: &dyn HirDatabase, impl_: ImplId) -> bool {
         return true;
     }
 
-    let unwrap_fundamental = |ty: Ty| match ty.kind(Interner) {
+    let unwrap_fundamental = |mut ty: Ty| {
-        TyKind::Ref(_, _, referenced) => referenced.clone(),
+        // Unwrap all layers of fundamental types with a loop.
+        loop {
+            match ty.kind(Interner) {
+                TyKind::Ref(_, _, referenced) => ty = referenced.clone(),
                 &TyKind::Adt(AdtId(hir_def::AdtId::StructId(s)), ref subs) => {
                     let struct_data = db.struct_data(s);
                     if struct_data.flags.contains(StructFlags::IS_FUNDAMENTAL) {
                         let next = subs.type_parameters(Interner).next();
                         match next {
-                    Some(ty) => ty,
+                            Some(it) => ty = it,
-                    None => ty,
+                            None => break ty,
                         }
                     } else {
-                ty
+                        break ty;
+                    }
+                }
+                _ => break ty,
             }
         }
-        _ => ty,
     };
     //   - At least one of the types `T0..=Tn`` must be a local type. Let `Ti`` be the first such type.
     let is_not_orphan = trait_ref.substitution.type_parameters(Interner).any(|ty| {

crates/ide-diagnostics/src/handlers/trait_impl_orphan.rs

@@ -104,4 +104,17 @@ impl<T> foo::Foo<dyn LocalTrait> for Bar {}
 "#,
         );
     }
+
+    #[test]
+    fn twice_fundamental() {
+        check_diagnostics(
+            r#"
+//- /foo.rs crate:foo
+pub trait Trait {}
+//- /bar.rs crate:bar deps:foo
+struct Foo;
+impl foo::Trait for &&Foo {}
+        "#,
+        );
+    }
 }