Some fixes + reformat

Author: aerooneqq

compiler/rustc_ast_lowering/messages.ftl

@@ -175,6 +175,7 @@ ast_lowering_underscore_expr_lhs_assign =
 
 ast_lowering_union_default_field_values = unions cannot have default field values
 
+ast_lowering_unresolved_delegation_callee = failed to resolve delegation callee
 ast_lowering_unstable_inline_assembly = inline assembly is not stable yet on this architecture
 ast_lowering_unstable_inline_assembly_label_operand_with_outputs =
     using both label and output operands for inline assembly is unstable
@@ -186,5 +187,3 @@ 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

@@ -48,9 +48,11 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::Target;
 use rustc_hir::attrs::{AttributeKind, InlineAttr};
-use rustc_hir::def_id::DefId;
+use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_middle::span_bug;
-use rustc_middle::ty::{Asyncness, DelegationFnSigAttrs, ResolverAstLowering};
+use rustc_middle::ty::{
+    Asyncness, DelegationFnSigAttrs, DelegationResolutionInfo, ResolverAstLowering,
+};
 use rustc_span::symbol::kw;
 use rustc_span::{DUMMY_SP, Ident, Span, Symbol};
 use {rustc_ast as ast, rustc_hir as hir};
@@ -124,14 +126,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ) -> DelegationResults<'hir> {
         let span = self.lower_span(delegation.path.segments.last().unwrap().ident.span);
 
-        let sig_id = self.resolve_callee_sig(
-            self.resolver
-                .delegation_resolution_info
-                .get(&self.local_def_id(item_id))
-                .unwrap()
-                .sig_resolution_id,
-            span,
-        );
+        let sig_id = self
+            .delegation_res_info_or_err(&self.local_def_id(item_id), span)
+            .map(|info| self.get_delegation_sig_id(info.sig_resolution_id, span))
+            .flatten();
 
         match sig_id {
             Ok(sig_id) => {
@@ -246,7 +244,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    fn resolve_callee_sig(
+    fn get_delegation_sig_id(
         &self,
         mut node_id: NodeId,
         span: Span,
@@ -265,31 +263,34 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 && 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.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 {
-                    // 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
-                    )));
+                node_id = self.delegation_res_info_or_err(&local_id, span)?.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;
             }
 
             // DefId 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 delegation_res_info_or_err(
+        &self,
+        local_id: &LocalDefId,
+        span: Span,
+    ) -> Result<&DelegationResolutionInfo, ErrorGuaranteed> {
+        self.resolver.delegation_resolution_info.get(local_id).ok_or_else(|| {
+            self.tcx.dcx().span_delayed_bug(span, format!(
+                "There is no information about delegation resolution node id for LocalDefId {:?}",
+                local_id
+            ))
+        })
+    }
+
     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())
     }
@@ -326,8 +327,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
     // Function parameter count, including C variadic `...` if present.
     fn param_count(&self, sig_id: DefId) -> (usize, bool /*c_variadic*/) {
         if let Some(local_sig_id) = sig_id.as_local() {
-            // Map may be filled incorrectly due to recursive delegation.
-            // Error will be emitted later during HIR ty lowering.
             match self.resolver.delegation_fn_sigs.get(&local_sig_id) {
                 Some(sig) => (sig.param_count, sig.c_variadic),
                 None => (0, false),

compiler/rustc_hir_analysis/src/delegation.rs

@@ -401,12 +401,6 @@ fn check_constraints<'tcx>(
         }));
     };
 
-    if let Some(local_sig_id) = sig_id.as_local()
-        && tcx.hir_opt_delegation_sig_id(local_sig_id).is_some()
-    {
-        emit("recursive delegation is not supported yet");
-    }
-
     if tcx.fn_sig(sig_id).skip_binder().skip_binder().c_variadic {
         // See issue #127443 for explanation.
         emit("delegation to C-variadic functions is not allowed");

compiler/rustc_resolve/src/lib.rs

@@ -70,7 +70,8 @@ use rustc_middle::middle::privacy::EffectiveVisibilities;
 use rustc_middle::query::Providers;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{
-    self, DelegationFnSig, DelegationResolutionInfo, 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;
@@ -1823,7 +1824,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
+            delegation_resolution_info: self.delegation_resolution_info,
         };
         ResolverOutputs { global_ctxt, ast_lowering }
     }

tests/ui/delegation/auxiliary/recursive-delegation-aux.rs

@@ -6,4 +6,4 @@ fn foo() {
 }
 
 reuse foo as bar;
-pub reuse bar as goo;
+pub reuse bar as goo;

tests/ui/delegation/recursive_delegation_errors.rs

@@ -41,4 +41,17 @@ mod fourth_mod {
     }
 }
 
+mod fifth_mod {
+    reuse super::fifth_mod::{bar as foo, foo as bar};
+    //~^ ERROR failed to resolve delegation callee
+    //~| ERROR failed to resolve delegation callee
+
+    trait GlobReuse {
+        reuse GlobReuse::{foo as bar, bar as goo, goo as foo};
+        //~^ ERROR failed to resolve delegation callee
+        //~| ERROR failed to resolve delegation callee
+        //~| ERROR failed to resolve delegation callee
+    }
+}
+
 fn main() {}

tests/ui/delegation/recursive_delegation_errors.stderr

@@ -64,5 +64,35 @@ error: failed to resolve delegation callee
 LL |         reuse Trait::bar as foo;
    |                      ^^^
 
-error: aborting due to 11 previous errors
+error: failed to resolve delegation callee
+  --> $DIR/recursive_delegation_errors.rs:45:30
+   |
+LL |     reuse super::fifth_mod::{bar as foo, foo as bar};
+   |                              ^^^
+
+error: failed to resolve delegation callee
+  --> $DIR/recursive_delegation_errors.rs:45:42
+   |
+LL |     reuse super::fifth_mod::{bar as foo, foo as bar};
+   |                                          ^^^
+
+error: failed to resolve delegation callee
+  --> $DIR/recursive_delegation_errors.rs:50:27
+   |
+LL |         reuse GlobReuse::{foo as bar, bar as goo, goo as foo};
+   |                           ^^^
+
+error: failed to resolve delegation callee
+  --> $DIR/recursive_delegation_errors.rs:50:39
+   |
+LL |         reuse GlobReuse::{foo as bar, bar as goo, goo as foo};
+   |                                       ^^^
+
+error: failed to resolve delegation callee
+  --> $DIR/recursive_delegation_errors.rs:50:51
+   |
+LL |         reuse GlobReuse::{foo as bar, bar as goo, goo as foo};
+   |                                                   ^^^
+
+error: aborting due to 16 previous errors
 

tests/ui/delegation/recursive_delegation_pass.rs

@@ -16,12 +16,19 @@ mod first_mod {
         }
     }
 
-    reuse to_reuse::foo;
-    reuse foo as bar;
-    reuse foo as bar1;
-    reuse bar as goo;
-    reuse goo as koo;
-    reuse koo as too;
+    mod single_reuse {
+        reuse crate::first_mod::to_reuse::foo;
+        reuse foo as bar;
+        reuse foo as bar1;
+        reuse bar as goo;
+        reuse goo as koo;
+        reuse koo as too;
+    }
+
+    mod glob_reuse {
+        reuse super::to_reuse::{foo as bar, foo as bar1} { self }
+        reuse super::glob_reuse::{bar as goo, goo as koo, koo as too} { self }
+    }
 }
 
 mod second_mod {
@@ -31,6 +38,16 @@ mod second_mod {
         reuse T::bar as goo;
         reuse T::goo as poo;
     }
+
+    trait TGlob {
+        fn xd(&self) -> &Self;
+        fn foo1(&self);
+        fn foo2(&self);
+        fn foo3(&self);
+        fn foo4(&self);
+
+        reuse TGlob::{foo1 as bar1, foo3 as bar3, bar1 as bar11, bar11 as bar111} { self.xd() }
+    }
 }
 
 mod third_mod {