WIP on recursive delegations

aerooneqq · aerooneqq · commit a77bf4b5bfaf · 2025-12-15T14:20:13.000+03:00
diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -44,6 +44,7 @@ use hir::{BodyId, HirId};
 use rustc_abi::ExternAbi;
 use rustc_ast::*;
 use rustc_attr_parsing::{AttributeParser, ShouldEmit};
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::Target;
 use rustc_hir::attrs::{AttributeKind, InlineAttr};
@@ -119,10 +120,19 @@ impl<'hir> LoweringContext<'_, 'hir> {
         &mut self,
         delegation: &Delegation,
         item_id: NodeId,
-        is_in_trait_impl: bool,
+        _is_in_trait_impl: bool,
     ) -> DelegationResults<'hir> {
         let span = self.lower_span(delegation.path.segments.last().unwrap().ident.span);
-        let sig_id = self.get_delegation_sig_id(item_id, delegation.id, span, is_in_trait_impl);
+
+        let sig_id = self.get_resolution_id(
+            self.resolver
+                .delegation_resolution_info
+                .get(&self.local_def_id(item_id))
+                .unwrap()
+                .resolution_id,
+            span,
+        );
+
         match sig_id {
             Ok(sig_id) => {
                 self.add_attributes_if_needed(span, sig_id);
@@ -236,26 +246,42 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    fn get_delegation_sig_id(
-        &self,
-        item_id: NodeId,
-        path_id: NodeId,
-        span: Span,
-        is_in_trait_impl: bool,
-    ) -> Result<DefId, ErrorGuaranteed> {
-        let sig_id = if is_in_trait_impl { item_id } else { path_id };
-        self.get_resolution_id(sig_id, span)
-    }
-
-    fn get_resolution_id(&self, node_id: NodeId, span: Span) -> Result<DefId, ErrorGuaranteed> {
-        let def_id =
-            self.resolver.get_partial_res(node_id).and_then(|r| r.expect_full_res().opt_def_id());
-        def_id.ok_or_else(|| {
+    fn get_resolution_id(&self, mut node_id: NodeId, span: Span) -> Result<DefId, ErrorGuaranteed> {
+        let create_error = |node_id: NodeId| {
             self.tcx.dcx().span_delayed_bug(
                 span,
                 format!("LoweringContext: couldn't resolve node {:?} in delegation item", node_id),
             )
-        })
+        };
+
+        let mut processed: FxHashSet<NodeId> = Default::default();
+
+        loop {
+            processed.insert(node_id);
+
+            let def_id = self
+                .resolver
+                .get_partial_res(node_id)
+                .and_then(|r| r.expect_full_res().opt_def_id());
+
+            if let Some(def_id) = def_id
+                && let Some(local_id) = def_id.as_local()
+                && !self.resolver.delegation_fn_sigs.contains_key(&local_id)
+            {
+                if let Some(info) = self.resolver.delegation_resolution_info.get(&local_id) {
+                    node_id = info.resolution_id;
+                    if processed.contains(&node_id) {
+                        return Err(create_error(node_id));
+                    }
+
+                    continue;
+                } else {
+                    return Err(create_error(node_id));
+                }
+            }
+
+            return def_id.ok_or_else(|| create_error(node_id));
+        }
     }
 
     fn lower_delegation_generics(&mut self, span: Span) -> &'hir hir::Generics<'hir> {
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -220,6 +220,7 @@ pub struct ResolverAstLowering {
 
     /// Information about functions signatures for delegation items expansion
     pub delegation_fn_sigs: LocalDefIdMap<DelegationFnSig>,
+    pub delegation_resolution_info: LocalDefIdMap<DelegationResolutionInfo>,
 }
 
 bitflags::bitflags! {
@@ -242,6 +243,11 @@ pub struct DelegationFnSig {
     pub to_inherit_attrs: AttrVec,
 }
 
+#[derive(Debug)]
+pub struct DelegationResolutionInfo {
+    pub resolution_id: ast::NodeId,
+}
+
 #[derive(Clone, Copy, Debug, HashStable)]
 pub struct MainDefinition {
     pub res: Res<ast::NodeId>,
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
@@ -31,6 +31,7 @@ use rustc_middle::middle::resolve_bound_vars::Set1;
 use rustc_middle::ty::{
     AssocTag, DELEGATION_INHERIT_ATTRS_START, DelegationFnSig, DelegationFnSigAttrs, Visibility,
 };
+use rustc_middle::ty::{AssocTag, DelegationFnSig, DelegationResolutionInfo, Visibility};
 use rustc_middle::{bug, span_bug};
 use rustc_session::config::{CrateType, ResolveDocLinks};
 use rustc_session::lint;
@@ -2928,7 +2929,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                     item.id,
                     LifetimeBinderKind::Function,
                     span,
-                    |this| this.resolve_delegation(delegation),
+                    |this| this.resolve_delegation(delegation, item.id, false),
                 );
             }
 
@@ -3257,7 +3258,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                         item.id,
                         LifetimeBinderKind::Function,
                         delegation.path.segments.last().unwrap().ident.span,
-                        |this| this.resolve_delegation(delegation),
+                        |this| this.resolve_delegation(delegation, item.id, false),
                     );
                 }
                 AssocItemKind::Type(box TyAlias { generics, .. }) => self
@@ -3550,7 +3551,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                             |i, s, c| MethodNotMemberOfTrait(i, s, c),
                         );
 
-                        this.resolve_delegation(delegation)
+                        this.resolve_delegation(delegation, item.id, trait_id.is_some());
                     },
                 );
             }
@@ -3699,17 +3700,34 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
         })
     }
 
-    fn resolve_delegation(&mut self, delegation: &'ast Delegation) {
+    fn resolve_delegation(
+        &mut self,
+        delegation: &'ast Delegation,
+        item_id: NodeId,
+        is_in_trait_impl: bool,
+    ) {
         self.smart_resolve_path(
             delegation.id,
             &delegation.qself,
             &delegation.path,
             PathSource::Delegation,
         );
+
         if let Some(qself) = &delegation.qself {
             self.visit_ty(&qself.ty);
         }
+
         self.visit_path(&delegation.path);
+
+        if let Some(def_id) = self.r.opt_local_def_id(item_id) {
+            self.r.delegation_resolution_info.insert(
+                def_id,
+                DelegationResolutionInfo {
+                    resolution_id: if is_in_trait_impl { item_id } else { delegation.id },
+                },
+            );
+        }
+
         let Some(body) = &delegation.body else { return };
         self.with_rib(ValueNS, RibKind::FnOrCoroutine, |this| {
             let span = delegation.path.segments.last().unwrap().ident.span;
@@ -4294,7 +4312,6 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
         );
     }
 
-    #[instrument(level = "debug", skip(self))]
     fn smart_resolve_path_fragment(
         &mut self,
         qself: &Option<Box<QSelf>>,
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
@@ -70,8 +70,7 @@ use rustc_middle::middle::privacy::EffectiveVisibilities;
 use rustc_middle::query::Providers;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{
-    self, DelegationFnSig, Feed, MainDefinition, RegisteredTools, ResolverAstLowering,
-    ResolverGlobalCtxt, TyCtxt, TyCtxtFeed, Visibility,
+    self, DelegationFnSig, DelegationResolutionInfo, Feed, MainDefinition, RegisteredTools, ResolverAstLowering, ResolverGlobalCtxt, TyCtxt, TyCtxtFeed, Visibility
 };
 use rustc_query_system::ich::StableHashingContext;
 use rustc_session::config::CrateType;
@@ -1276,6 +1275,7 @@ pub struct Resolver<'ra, 'tcx> {
     /// Amount of lifetime parameters for each item in the crate.
     item_generics_num_lifetimes: FxHashMap<LocalDefId, usize>,
     delegation_fn_sigs: LocalDefIdMap<DelegationFnSig>,
+    delegation_resolution_info: LocalDefIdMap<DelegationResolutionInfo>,
 
     main_def: Option<MainDefinition> = None,
     trait_impls: FxIndexMap<DefId, Vec<LocalDefId>>,
@@ -1694,6 +1694,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             current_crate_outer_attr_insert_span,
             mods_with_parse_errors: Default::default(),
             impl_trait_names: Default::default(),
+            delegation_resolution_info: Default::default(),
             ..
         };
 
@@ -1822,6 +1823,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             lifetime_elision_allowed: self.lifetime_elision_allowed,
             lint_buffer: Steal::new(self.lint_buffer),
             delegation_fn_sigs: self.delegation_fn_sigs,
+            delegation_resolution_info: self.delegation_resolution_info
         };
         ResolverOutputs { global_ctxt, ast_lowering }
     }
