[PoC] Track type-dependent defs in ItemCtxts (minimally)

Author: fmease

Diff for: compiler/rustc_hir_analysis/src/collect.rs

@@ -15,7 +15,7 @@
 //! crate as a kind of pass. This should eventually be factored away.
 
 use std::assert_matches::assert_matches;
-use std::cell::Cell;
+use std::cell::{Cell, RefCell};
 use std::iter;
 use std::ops::Bound;
 
@@ -34,6 +34,10 @@ use rustc_infer::infer::{InferCtxt, TyCtxtInferExt};
 use rustc_infer::traits::ObligationCause;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::query::Providers;
+use rustc_middle::ty::typeck_results::{
+    HasTypeDependentDefs, LocalTableInContext, LocalTableInContextMut, TypeDependentDef,
+    TypeDependentDefs,
+};
 use rustc_middle::ty::util::{Discr, IntTypeExt};
 use rustc_middle::ty::{self, AdtKind, Const, IsSuggestable, Ty, TyCtxt, TypingMode, fold_regions};
 use rustc_middle::{bug, span_bug};
@@ -125,6 +129,7 @@ pub(crate) fn provide(providers: &mut Providers) {
 pub(crate) struct ItemCtxt<'tcx> {
     tcx: TyCtxt<'tcx>,
     item_def_id: LocalDefId,
+    type_dependent_defs: RefCell<TypeDependentDefs>,
     tainted_by_errors: Cell<Option<ErrorGuaranteed>>,
 }
 
@@ -365,7 +370,12 @@ fn bad_placeholder<'cx, 'tcx>(
 
 impl<'tcx> ItemCtxt<'tcx> {
     pub(crate) fn new(tcx: TyCtxt<'tcx>, item_def_id: LocalDefId) -> ItemCtxt<'tcx> {
-        ItemCtxt { tcx, item_def_id, tainted_by_errors: Cell::new(None) }
+        ItemCtxt {
+            tcx,
+            item_def_id,
+            type_dependent_defs: Default::default(),
+            tainted_by_errors: Cell::new(None),
+        }
     }
 
     pub(crate) fn lower_ty(&self, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> {
@@ -539,6 +549,14 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
         // There's no place to record types from signatures?
     }
 
+    fn record_res(&self, hir_id: hir::HirId, result: TypeDependentDef) {
+        LocalTableInContextMut::new(
+            self.hir_id().owner,
+            &mut self.type_dependent_defs.borrow_mut(),
+        )
+        .insert(hir_id, result);
+    }
+
     fn infcx(&self) -> Option<&InferCtxt<'tcx>> {
         None
     }
@@ -628,6 +646,15 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
     }
 }
 
+impl HasTypeDependentDefs for ItemCtxt<'_> {
+    fn type_dependent_def(&self, id: hir::HirId) -> Option<(DefKind, DefId)> {
+        LocalTableInContext::new(self.hir_id().owner, &self.type_dependent_defs.borrow())
+            .get(id)
+            .copied()
+            .and_then(|result| result.ok())
+    }
+}
+
 /// Synthesize a new lifetime name that doesn't clash with any of the lifetimes already present.
 fn get_new_lifetime_name<'tcx>(
     tcx: TyCtxt<'tcx>,

Diff for: compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -37,6 +37,7 @@ use rustc_infer::traits::ObligationCause;
 use rustc_middle::middle::stability::AllowUnstable;
 use rustc_middle::mir::interpret::LitToConstInput;
 use rustc_middle::ty::print::PrintPolyTraitRefExt as _;
+use rustc_middle::ty::typeck_results::{HasTypeDependentDefs, TypeDependentDef};
 use rustc_middle::ty::{
     self, AssocTag, Const, GenericArgKind, GenericArgsRef, GenericParamDefKind, ParamEnv, Ty,
     TyCtxt, TypeVisitableExt, TypingMode, Upcast, fold_regions,
@@ -105,7 +106,7 @@ pub enum RegionInferReason<'a> {
 /// the [`rustc_middle::ty`] representation.
 ///
 /// This trait used to be called `AstConv`.
-pub trait HirTyLowerer<'tcx> {
+pub trait HirTyLowerer<'tcx>: HasTypeDependentDefs {
     fn tcx(&self) -> TyCtxt<'tcx>;
 
     fn dcx(&self) -> DiagCtxtHandle<'_>;
@@ -190,6 +191,9 @@ pub trait HirTyLowerer<'tcx> {
     /// Record the lowered type of a HIR node in this context.
     fn record_ty(&self, hir_id: HirId, ty: Ty<'tcx>, span: Span);
 
+    /// Record the resolution of a HIR node corresponding to a type-dependent definition in this context.
+    fn record_res(&self, hir_id: hir::HirId, result: TypeDependentDef);
+
     /// The inference context of the lowering context if applicable.
     fn infcx(&self) -> Option<&InferCtxt<'tcx>>;
 
@@ -1153,6 +1157,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     /// [type-relative]: hir::QPath::TypeRelative
     /// [#22519]: https://github.com/rust-lang/rust/issues/22519
     /// [iat]: https://github.com/rust-lang/rust/issues/8995#issuecomment-1569208403
+    // FIXME(fmease): Update docs
     //
     // NOTE: When this function starts resolving `Trait::AssocTy` successfully
     // it should also start reporting the `BARE_TRAIT_OBJECTS` lint.
@@ -1233,8 +1238,28 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         mode: LowerAssocMode,
     ) -> Result<LoweredAssoc<'tcx>, ErrorGuaranteed> {
         debug!(%qself_ty, ?assoc_segment.ident);
-        let tcx = self.tcx();
+        let result =
+            self.lower_assoc_path_inner(hir_ref_id, span, qself_ty, qself, assoc_segment, mode);
+        self.record_res(
+            hir_ref_id,
+            result.map(|assoc| match assoc {
+                LoweredAssoc::Term(def_id, _) => (self.tcx().def_kind(def_id), def_id),
+                LoweredAssoc::Variant { .. } => todo!(), // FIXME: Properly handle
+            }),
+        );
+        result
+    }
 
+    fn lower_assoc_path_inner(
+        &self,
+        hir_ref_id: HirId,
+        span: Span,
+        qself_ty: Ty<'tcx>,
+        qself: &'tcx hir::Ty<'tcx>,
+        assoc_segment: &'tcx hir::PathSegment<'tcx>,
+        mode: LowerAssocMode,
+    ) -> Result<LoweredAssoc<'tcx>, ErrorGuaranteed> {
+        let tcx = self.tcx();
         let assoc_ident = assoc_segment.ident;
 
         // Check if we have an enum variant or an inherent associated type.
@@ -1275,10 +1300,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             }
         }
 
-        let qself_res = if let hir::TyKind::Path(hir::QPath::Resolved(_, path)) = &qself.kind {
-            path.res
-        } else {
-            Res::Err
+        let qself_res = match &qself.kind {
+            hir::TyKind::Path(qpath) => self.qpath_res(qpath, qself.hir_id),
+            _ => Res::Err,
         };
 
         // Find the type of the associated item, and the trait where the associated
@@ -1317,14 +1341,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 assoc_ident,
                 span,
             )?,
-            // FIXME(fmease):
-            // Require the pre-lowered projectee (the HIR QSelf) to have `DefKind::AssocTy`. Rephrased,
-            // `T::Assoc::Assoc` typeck'ing shouldn't imply `Identity<T::Assoc>::Assoc` typeck'ing where
-            // `Identity` is an eager (i.e., non-lazy) type alias. We should do this
-            // * for consistency with lazy type aliases (`ty::Weak`)
-            // * for consistency with the fact that `T::Assoc` typeck'ing doesn't imply `Identity<T>::Assoc`
-            //   typeck'ing
-            (ty::Alias(ty::Projection, alias_ty), _ /* Res::Def(DefKind::AssocTy, _) */) => {
+            (ty::Alias(ty::Projection, alias_ty), Res::Def(DefKind::AssocTy, _)) => {
                 // FIXME: Utilizing `item_bounds` for this is cycle-prone.
                 let predicates = tcx.item_bounds(alias_ty.def_id).instantiate(tcx, alias_ty.args);
 

Diff for: compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -176,9 +176,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     pub(crate) fn write_resolution(
         &self,
         hir_id: HirId,
-        r: Result<(DefKind, DefId), ErrorGuaranteed>,
+        result: Result<(DefKind, DefId), ErrorGuaranteed>,
     ) {
-        self.typeck_results.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
+        self.typeck_results.borrow_mut().type_dependent_defs_mut().insert(hir_id, result);
     }
 
     #[instrument(level = "debug", skip(self))]

Diff for: compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -2178,12 +2178,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     .map(|(ty, _, _)| ty)
                     .unwrap_or_else(|guar| Ty::new_error(self.tcx(), guar));
                 let ty = LoweredTy::from_raw(self, path_span, ty);
-                let result = result.map(|(_, kind, def_id)| (kind, def_id));
 
-                // Write back the new resolution.
-                self.write_resolution(hir_id, result);
-
-                (result.map_or(Res::Err, |(kind, def_id)| Res::Def(kind, def_id)), ty)
+                (result.map_or(Res::Err, |(_, kind, def_id)| Res::Def(kind, def_id)), ty)
             }
             QPath::LangItem(lang_item, span) => {
                 let (res, ty) = self.resolve_lang_item_path(lang_item, span, hir_id);

Diff for: compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -8,13 +8,14 @@ mod suggestions;
 use std::cell::{Cell, RefCell};
 use std::ops::Deref;
 
-use hir::def_id::CRATE_DEF_ID;
 use rustc_errors::DiagCtxtHandle;
-use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_hir::def::DefKind;
+use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
 use rustc_hir::{self as hir, HirId, ItemLocalMap};
 use rustc_hir_analysis::hir_ty_lowering::{HirTyLowerer, RegionInferReason};
 use rustc_infer::infer;
 use rustc_infer::traits::Obligation;
+use rustc_middle::ty::typeck_results::{HasTypeDependentDefs, TypeDependentDef};
 use rustc_middle::ty::{self, Const, Ty, TyCtxt, TypeVisitableExt};
 use rustc_session::Session;
 use rustc_span::{self, DUMMY_SP, ErrorGuaranteed, Ident, Span, sym};
@@ -350,7 +351,7 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
         }
     }
 
-    fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, span: Span) {
+    fn record_ty(&self, hir_id: HirId, ty: Ty<'tcx>, span: Span) {
         // FIXME: normalization and escaping regions
         let ty = if !ty.has_escaping_bound_vars() {
             // NOTE: These obligations are 100% redundant and are implied by
@@ -370,6 +371,10 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
         self.write_ty(hir_id, ty)
     }
 
+    fn record_res(&self, hir_id: HirId, result: TypeDependentDef) {
+        self.write_resolution(hir_id, result);
+    }
+
     fn infcx(&self) -> Option<&infer::InferCtxt<'tcx>> {
         Some(&self.infcx)
     }
@@ -378,7 +383,7 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
         &self,
         decl: &rustc_hir::FnDecl<'tcx>,
         _generics: Option<&rustc_hir::Generics<'_>>,
-        _hir_id: rustc_hir::HirId,
+        _hir_id: HirId,
         _hir_ty: Option<&hir::Ty<'_>>,
     ) -> (Vec<Ty<'tcx>>, Ty<'tcx>) {
         let input_tys = decl.inputs.iter().map(|a| self.lowerer().lower_arg_ty(a, None)).collect();
@@ -391,6 +396,12 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
     }
 }
 
+impl HasTypeDependentDefs for FnCtxt<'_, '_> {
+    fn type_dependent_def(&self, id: HirId) -> Option<(DefKind, DefId)> {
+        self.typeck_results.borrow().type_dependent_def(id)
+    }
+}
+
 /// The `ty` representation of a user-provided type. Depending on the use-site
 /// we want to either use the unnormalized or the normalized form of this type.
 ///

Diff for: compiler/rustc_middle/src/ty/mod.rs

@@ -125,6 +125,7 @@ pub mod print;
 pub mod relate;
 pub mod significant_drop_order;
 pub mod trait_def;
+pub mod typeck_results;
 pub mod util;
 pub mod vtable;
 
@@ -151,7 +152,6 @@ mod rvalue_scopes;
 mod structural_impls;
 #[allow(hidden_glob_reexports)]
 mod sty;
-mod typeck_results;
 mod visit;
 
 // Data types

Diff for: compiler/rustc_middle/src/ty/typeck_results.rs

@@ -32,9 +32,7 @@ pub struct TypeckResults<'tcx> {
     /// The `HirId::owner` all `ItemLocalId`s in this table are relative to.
     pub hir_owner: OwnerId,
 
-    /// Resolved definitions for `<T>::X` associated paths and
-    /// method calls, including those of overloaded operators.
-    type_dependent_defs: ItemLocalMap<Result<(DefKind, DefId), ErrorGuaranteed>>,
+    type_dependent_defs: TypeDependentDefs,
 
     /// Resolved field indices for field accesses in expressions (`S { field }`, `obj.field`)
     /// or patterns (`S { field }`). The index is often useful by itself, but to learn more
@@ -247,32 +245,22 @@ impl<'tcx> TypeckResults<'tcx> {
 
     /// Returns the final resolution of a `QPath` in an `Expr` or `Pat` node.
     pub fn qpath_res(&self, qpath: &hir::QPath<'_>, id: HirId) -> Res {
-        match *qpath {
-            hir::QPath::Resolved(_, path) => path.res,
-            hir::QPath::TypeRelative(..) | hir::QPath::LangItem(..) => self
-                .type_dependent_def(id)
-                .map_or(Res::Err, |(kind, def_id)| Res::Def(kind, def_id)),
-        }
+        HasTypeDependentDefs::qpath_res(self, qpath, id)
     }
 
-    pub fn type_dependent_defs(
-        &self,
-    ) -> LocalTableInContext<'_, Result<(DefKind, DefId), ErrorGuaranteed>> {
+    pub fn type_dependent_defs(&self) -> LocalTableInContext<'_, TypeDependentDef> {
         LocalTableInContext { hir_owner: self.hir_owner, data: &self.type_dependent_defs }
     }
 
     pub fn type_dependent_def(&self, id: HirId) -> Option<(DefKind, DefId)> {
-        validate_hir_id_for_typeck_results(self.hir_owner, id);
-        self.type_dependent_defs.get(&id.local_id).cloned().and_then(|r| r.ok())
+        self.type_dependent_defs().get(id).copied().and_then(|result| result.ok())
     }
 
     pub fn type_dependent_def_id(&self, id: HirId) -> Option<DefId> {
         self.type_dependent_def(id).map(|(_, def_id)| def_id)
     }
 
-    pub fn type_dependent_defs_mut(
-        &mut self,
-    ) -> LocalTableInContextMut<'_, Result<(DefKind, DefId), ErrorGuaranteed>> {
+    pub fn type_dependent_defs_mut(&mut self) -> LocalTableInContextMut<'_, TypeDependentDef> {
         LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.type_dependent_defs }
     }
 
@@ -540,6 +528,33 @@ impl<'tcx> TypeckResults<'tcx> {
     }
 }
 
+/// Resolved definitions for `<T>::X` associated paths and
+/// method calls, including those of overloaded operators.
+pub type TypeDependentDefs = ItemLocalMap<TypeDependentDef>;
+
+pub type TypeDependentDef = Result<(DefKind, DefId), ErrorGuaranteed>;
+
+// FIXME(fmease): Yuck!
+pub trait HasTypeDependentDefs {
+    fn type_dependent_def(&self, id: HirId) -> Option<(DefKind, DefId)>;
+
+    /// Returns the final resolution of a `QPath`.
+    fn qpath_res(&self, qpath: &hir::QPath<'_>, id: HirId) -> Res {
+        match qpath {
+            hir::QPath::Resolved(_, path) => path.res,
+            hir::QPath::TypeRelative(..) | hir::QPath::LangItem(..) => self
+                .type_dependent_def(id)
+                .map_or(Res::Err, |(kind, def_id)| Res::Def(kind, def_id)),
+        }
+    }
+}
+
+impl HasTypeDependentDefs for TypeckResults<'_> {
+    fn type_dependent_def(&self, id: HirId) -> Option<(DefKind, DefId)> {
+        self.type_dependent_def(id)
+    }
+}
+
 /// Validate that the given HirId (respectively its `local_id` part) can be
 /// safely used as a key in the maps of a TypeckResults. For that to be
 /// the case, the HirId must have the same `owner` as all the other IDs in
@@ -572,6 +587,10 @@ pub struct LocalTableInContext<'a, V> {
 }
 
 impl<'a, V> LocalTableInContext<'a, V> {
+    pub fn new(hir_owner: OwnerId, data: &'a ItemLocalMap<V>) -> Self {
+        Self { hir_owner, data }
+    }
+
     pub fn contains_key(&self, id: HirId) -> bool {
         validate_hir_id_for_typeck_results(self.hir_owner, id);
         self.data.contains_key(&id.local_id)
@@ -610,6 +629,10 @@ pub struct LocalTableInContextMut<'a, V> {
 }
 
 impl<'a, V> LocalTableInContextMut<'a, V> {
+    pub fn new(hir_owner: OwnerId, data: &'a mut ItemLocalMap<V>) -> Self {
+        Self { hir_owner, data }
+    }
+
     pub fn get_mut(&mut self, id: HirId) -> Option<&mut V> {
         validate_hir_id_for_typeck_results(self.hir_owner, id);
         self.data.get_mut(&id.local_id)

Diff for: src/tools/tidy/src/ui_tests.rs

@@ -17,7 +17,7 @@ use ignore::Walk;
 const ENTRY_LIMIT: u32 = 901;
 // FIXME: The following limits should be reduced eventually.
 
-const ISSUES_ENTRY_LIMIT: u32 = 1626;
+const ISSUES_ENTRY_LIMIT: u32 = 1624;
 
 const EXPECTED_TEST_FILE_EXTENSIONS: &[&str] = &[
     "rs",     // test source files

Diff for: tests/ui/associated-types/non-consecutive-shorthand-projections.eager.stderr

@@ -0,0 +1,14 @@
+error[E0223]: ambiguous associated type
+  --> $DIR/non-consecutive-shorthand-projections.rs:14:12
+   |
+LL |     let _: Identity<T::Project>::Project;
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: if there were a trait named `Example` with associated type `Project` implemented for `<T as Trait>::Project`, you could use the fully-qualified path
+   |
+LL |     let _: <<T as Trait>::Project as Example>::Project;
+   |            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0223`.