WIP on recursive delegation

Author: aerooneqq

compiler/rustc_ast_lowering/messages.ftl

@@ -186,3 +186,5 @@ ast_lowering_yield = yield syntax is experimental
 ast_lowering_yield_in_closure =
     `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
     .suggestion = use `#[coroutine]` to make this closure a coroutine
+
+ast_lowering_unresolved_delegation_callee = failed to resolve delegation callee

compiler/rustc_ast_lowering/src/delegation.rs

@@ -56,6 +56,7 @@ use rustc_span::{DUMMY_SP, Ident, Span, Symbol};
 use {rustc_ast as ast, rustc_hir as hir};
 
 use super::{GenericArgsMode, ImplTraitContext, LoweringContext, ParamMode};
+use crate::errors::UnresolvedDelegationCallee;
 use crate::{AllowReturnTypeNotation, ImplTraitPosition, ResolverAstLoweringExt};
 
 pub(crate) struct DelegationResults<'hir> {
@@ -120,16 +121,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
         &mut self,
         delegation: &Delegation,
         item_id: NodeId,
-        _is_in_trait_impl: bool,
     ) -> DelegationResults<'hir> {
         let span = self.lower_span(delegation.path.segments.last().unwrap().ident.span);
 
-        let sig_id = self.get_resolution_id(
+        let sig_id = self.resolve_callee_sig(
             self.resolver
                 .delegation_resolution_info
                 .get(&self.local_def_id(item_id))
                 .unwrap()
-                .resolution_id,
+                .sig_resolution_id,
             span,
         );
 
@@ -246,44 +246,73 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    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();
+    fn resolve_callee_sig(
+        &self,
+        mut node_id: NodeId,
+        span: Span,
+    ) -> Result<DefId, ErrorGuaranteed> {
+        let mut visited: FxHashSet<NodeId> = Default::default();
 
         loop {
-            processed.insert(node_id);
+            visited.insert(node_id);
 
-            let def_id = self
-                .resolver
-                .get_partial_res(node_id)
-                .and_then(|r| r.expect_full_res().opt_def_id());
+            let def_id = self.opt_get_partial_res_id(node_id);
 
+            // If def_id is in local crate and there is no signature in delegation_fn_sigs
+            // it means that we refer to another delegation as a callee, so in order to obtain
+            // a signature DefId we obtain NodeId of the callee delegation and try to get signature from it.
             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));
+                    node_id = info.sig_resolution_id;
+                    if visited.contains(&node_id) {
+                        // We encountered a cycle in the resolution, or delegation callee refers to non-existent
+                        // entity, in this case emit an error.
+                        return Err(self.dcx().emit_err(UnresolvedDelegationCallee { span }));
                     }
 
                     continue;
                 } else {
-                    return Err(create_error(node_id));
+                    // The LocalDefId for some reason refers not to another delegation, in this case
+                    // we will emit a bug (not an error), as we have to catch such cases on the resolve stage,
+                    // during smart_resolve_path in resolve_delegation.
+                    return Err(self.tcx.dcx().span_delayed_bug(span, format!(
+                        "There is no information about delegation resolution node id for LocalDefId {:?}",
+                        local_id
+                    )));
                 }
             }
 
-            return def_id.ok_or_else(|| create_error(node_id));
+            // Def id is either None or is from non-local crate, fallback to the original routine.
+            return self.def_id_or_guaranteed_err(def_id, node_id, span);
         }
     }
 
+    fn opt_get_partial_res_id(&self, node_id: NodeId) -> Option<DefId> {
+        self.resolver.get_partial_res(node_id).and_then(|r| r.expect_full_res().opt_def_id())
+    }
+
+    fn def_id_or_guaranteed_err(
+        &self,
+        def_id: Option<DefId>,
+        node_id: NodeId,
+        span: Span,
+    ) -> Result<DefId, ErrorGuaranteed> {
+        def_id.ok_or_else(|| {
+            self.tcx.dcx().span_delayed_bug(
+                span,
+                format!("LoweringContext: couldn't resolve node {:?} in delegation item", node_id),
+            )
+        })
+    }
+
+    fn get_resolution_id(&mut self, node_id: NodeId, span: Span) -> Result<DefId, ErrorGuaranteed> {
+        let def_id = self.opt_get_partial_res_id(node_id);
+        self.def_id_or_guaranteed_err(def_id, node_id, span)
+    }
+
     fn lower_delegation_generics(&mut self, span: Span) -> &'hir hir::Generics<'hir> {
         self.arena.alloc(hir::Generics {
             params: &[],

compiler/rustc_ast_lowering/src/errors.rs

@@ -475,3 +475,10 @@ pub(crate) struct UnionWithDefault {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(ast_lowering_unresolved_delegation_callee)]
+pub(crate) struct UnresolvedDelegationCallee {
+    #[primary_span]
+    pub span: Span,
+}

compiler/rustc_ast_lowering/src/item.rs

@@ -541,7 +541,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 hir::ItemKind::Macro(ident, macro_def, macro_kinds)
             }
             ItemKind::Delegation(box delegation) => {
-                let delegation_results = self.lower_delegation(delegation, id, false);
+                let delegation_results = self.lower_delegation(delegation, id);
                 hir::ItemKind::Fn {
                     sig: delegation_results.sig,
                     ident: delegation_results.ident,
@@ -1026,7 +1026,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 (*ident, generics, kind, ty.is_some())
             }
             AssocItemKind::Delegation(box delegation) => {
-                let delegation_results = self.lower_delegation(delegation, i.id, false);
+                let delegation_results = self.lower_delegation(delegation, i.id);
                 let item_kind = hir::TraitItemKind::Fn(
                     delegation_results.sig,
                     hir::TraitFn::Provided(delegation_results.body_id),
@@ -1196,7 +1196,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 )
             }
             AssocItemKind::Delegation(box delegation) => {
-                let delegation_results = self.lower_delegation(delegation, i.id, is_in_trait_impl);
+                let delegation_results = self.lower_delegation(delegation, i.id);
                 (
                     delegation.ident,
                     (

compiler/rustc_middle/src/ty/mod.rs

@@ -245,7 +245,7 @@ pub struct DelegationFnSig {
 
 #[derive(Debug)]
 pub struct DelegationResolutionInfo {
-    pub resolution_id: ast::NodeId,
+    pub sig_resolution_id: ast::NodeId,
 }
 
 #[derive(Clone, Copy, Debug, HashStable)]

compiler/rustc_resolve/src/late.rs

@@ -29,7 +29,8 @@ use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LOCAL_CRATE, LocalDefId};
 use rustc_hir::{MissingLifetimeKind, PrimTy, TraitCandidate};
 use rustc_middle::middle::resolve_bound_vars::Set1;
 use rustc_middle::ty::{
-    AssocTag, DELEGATION_INHERIT_ATTRS_START, DelegationFnSig, DelegationFnSigAttrs, Visibility,
+    AssocTag, DELEGATION_INHERIT_ATTRS_START, DelegationFnSig, DelegationFnSigAttrs,
+    DelegationResolutionInfo, Visibility,
 };
 use rustc_middle::ty::{AssocTag, DelegationFnSig, DelegationResolutionInfo, Visibility};
 use rustc_middle::{bug, span_bug};
@@ -3723,7 +3724,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             self.r.delegation_resolution_info.insert(
                 def_id,
                 DelegationResolutionInfo {
-                    resolution_id: if is_in_trait_impl { item_id } else { delegation.id },
+                    sig_resolution_id: if is_in_trait_impl { item_id } else { delegation.id },
                 },
             );
         }

tests/ui/delegation/ice-issue-124347.rs

@@ -1,12 +1,12 @@
 #![feature(fn_delegation)]
 #![allow(incomplete_features)]
 
-// FIXME(fn_delegation): `recursive delegation` error should be emitted here
 trait Trait {
     reuse Trait::foo { &self.0 }
+    //~^ ERROR failed to resolve delegation callee
 }
 
 reuse foo;
-//~^ ERROR cycle detected when computing generics of `foo`
+//~^ ERROR failed to resolve delegation callee
 
 fn main() {}

tests/ui/delegation/ice-issue-124347.stderr

@@ -1,17 +1,14 @@
-error[E0391]: cycle detected when computing generics of `foo`
-  --> $DIR/ice-issue-124347.rs:9:7
+error: failed to resolve delegation callee
+  --> $DIR/ice-issue-124347.rs:5:18
    |
-LL | reuse foo;
-   |       ^^^
-   |
-   = note: ...which immediately requires computing generics of `foo` again
-note: cycle used when checking that `foo` is well-formed
+LL |     reuse Trait::foo { &self.0 }
+   |                  ^^^
+
+error: failed to resolve delegation callee
   --> $DIR/ice-issue-124347.rs:9:7
    |
 LL | reuse foo;
    |       ^^^
-   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0391`.

tests/ui/delegation/unsupported.current.stderr

@@ -36,24 +36,15 @@ LL |         reuse ToReuse::opaque_ret;
    |                        ^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: recursive delegation is not supported yet
-  --> $DIR/unsupported.rs:46:22
-   |
-LL |         pub reuse to_reuse2::foo;
-   |                              --- callee defined here
-...
-LL |     reuse to_reuse1::foo;
-   |                      ^^^
-
 error[E0283]: type annotations needed
-  --> $DIR/unsupported.rs:55:18
+  --> $DIR/unsupported.rs:54:18
    |
 LL |     reuse Trait::foo;
    |                  ^^^ cannot infer type
    |
    = note: cannot satisfy `_: effects::Trait`
 
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0283, E0391.
 For more information about an error, try `rustc --explain E0283`.

tests/ui/delegation/unsupported.next.stderr

@@ -28,24 +28,15 @@ LL |         reuse ToReuse::opaque_ret;
    = note: cycle used when computing implied outlives bounds for `<u16 as opaque::ToReuse>::opaque_ret::{anon_assoc#0}` (hack disabled = false)
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: recursive delegation is not supported yet
-  --> $DIR/unsupported.rs:46:22
-   |
-LL |         pub reuse to_reuse2::foo;
-   |                              --- callee defined here
-...
-LL |     reuse to_reuse1::foo;
-   |                      ^^^
-
 error[E0283]: type annotations needed
-  --> $DIR/unsupported.rs:55:18
+  --> $DIR/unsupported.rs:54:18
    |
 LL |     reuse Trait::foo;
    |                  ^^^ cannot infer type
    |
    = note: cannot satisfy `_: effects::Trait`
 
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0283, E0391.
 For more information about an error, try `rustc --explain E0283`.