Reinstate early IAT candidate elimination

Author: fmease

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -1481,11 +1481,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             match assoc_tag {
                 // Don't attempt to look up inherent associated types when the feature is not
                 // enabled. Theoretically it'd be fine to do so since we feature-gate their
-                // definition site. However, due to current limitations of the implementation
-                // (caused by us performing selection during HIR ty lowering instead of in the
-                // trait solver), IATs can lead to cycle errors (#108491) which mask the
-                // feature-gate error, needlessly confusing users who use IATs by accident
-                // (#113265).
+                // definition site. However, the current implementation of inherent associated
+                // items is somewhat brittle, so let's not run it by default.
                 ty::AssocTag::Type => return Ok(None),
                 ty::AssocTag::Const => {
                     // We also gate the mgca codepath for type-level uses of inherent consts
@@ -1508,15 +1505,25 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             .inherent_impls(adt_did)
             .iter()
             .filter_map(|&impl_| {
+                // FIXME: Don't eagerly
                 let (item, scope) =
                     self.probe_assoc_item_unchecked(name, assoc_tag, block, impl_)?;
                 Some(InherentAssocCandidate { impl_, assoc_item: item.def_id, scope })
             })
             .collect();
 
+        // At the moment, we actually bail out with a hard error if the selection of an inherent
+        // associated item fails (see below). This means we never consider trait associated items
+        // as potential fallback candidates (#142006). To temporarily mask that issue, let's not
+        // select at all if there are no early inherent candidates.
+        if candidates.is_empty() {
+            return Ok(None);
+        }
+
         let (applicable_candidates, fulfillment_errors) =
             self.select_inherent_assoc_candidates(span, self_ty, candidates.clone());
 
+        // FIXME(#142006): Don't eagerly error here, there might be applicable trait candidates.
         let InherentAssocCandidate { impl_, assoc_item, scope: def_scope } =
             match &applicable_candidates[..] {
                 &[] => Err(self.report_unresolved_inherent_assoc_item(
@@ -1537,6 +1544,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 )),
             }?;
 
+        // FIXME(#142006): Don't eagerly validate here, there might be trait candidates that are
+        // accessible (visible and stable) contrary to the inherent candidate.
         self.check_assoc_item(assoc_item, name, def_scope, block, span);
 
         // FIXME(fmease): Currently creating throwaway `parent_args` to please

tests/ui/associated-inherent-types/fall-back-to-trait-candidate.rs

@@ -0,0 +1,25 @@
+// Ensure that IAT selection doesn't hard error on associated type paths that could refer to
+// an inherent associated type if we can't find an applicable inherent candidate since there
+// might still be valid trait associated type candidates.
+//
+// FIXME(#142006): This only covers the bare minimum, we also need to disqualify inherent
+// candidates if the impl headers doesn't match or if the item is inaccessible.
+//
+// issue: <https://github.com/rust-lang/rust/issues/142006#issuecomment-2938846613>
+//@ check-pass
+
+#![feature(inherent_associated_types)]
+#![expect(incomplete_features)]
+
+struct Type;
+trait Trait { type AssocTy; fn scope(); }
+
+impl Trait for Type {
+    type AssocTy = ();
+
+    fn scope() {
+        let (): Self::AssocTy;
+    }
+}
+
+fn main() { <Type as Trait>::scope(); }

tests/ui/associated-inherent-types/not-found-self-type-differs-shadowing-trait-item.rs

@@ -0,0 +1,28 @@
+#![feature(inherent_associated_types)]
+#![expect(incomplete_features)]
+
+// Ensure that prefer inherent associated types over trait associated types
+// (assuming the impl headers match and they're accessible).
+//@ check-pass
+
+struct Adt;
+
+impl Adt {
+    type Ty = ();
+}
+
+trait Trait {
+    type Ty;
+    fn scope();
+}
+
+impl Trait for Adt {
+    type Ty = i32;
+    fn scope() {
+        // We prefer the inherent assoc ty `Adt::Ty` (`()`) over the
+        // trait assoc ty `<Adt as Trait>::Ty` (`i32`).
+        let (): Self::Ty;
+    }
+}
+
+fn main() {}