Remove error reporting + move Result<...> in DelegationInfo

Author: aerooneqq

compiler/rustc_ast_lowering/src/delegation.rs

@@ -52,7 +52,6 @@ use rustc_middle::span_bug;
 use rustc_middle::ty::{Asyncness, TyCtxt};
 use rustc_span::symbol::kw;
 use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol};
-use smallvec::SmallVec;
 
 use crate::delegation::generics::{GenericsGenerationResult, GenericsGenerationResults};
 use crate::errors::CycleInDelegationSignatureResolution;
@@ -122,42 +121,36 @@ pub fn delegations_resolutions(
         let delegation = ast_index[def_id].delegation().expect("processing delegations");
         let span = delegation.last_segment_span();
 
-        if let Some(res_result) = resolver.delegation_info(def_id) {
-            let res = res_result.map(|info| check_for_cycles(tcx, info.resolution_id, span));
+        if let Some(info) = resolver.delegation_info(def_id) {
+            let res = info.resolution_id.map(|id| check_for_cycles(tcx, id, span).map(|_| id));
             result.insert(def_id, res.flatten());
         }
     }
 
     result
 }
 
-fn check_for_cycles(
-    tcx: TyCtxt<'_>,
-    mut def_id: DefId,
-    span: Span,
-) -> Result<DefId, ErrorGuaranteed> {
+fn check_for_cycles(tcx: TyCtxt<'_>, mut def_id: DefId, span: Span) -> Result<(), ErrorGuaranteed> {
     let mut visited: FxHashSet<DefId> = Default::default();
-    let mut path: SmallVec<[DefId; 1]> = Default::default();
 
     let (resolver, _) = &*tcx.hir_crate(()).delayed_resolver.borrow();
 
     loop {
         visited.insert(def_id);
 
-        path.push(def_id);
-
         // If def_id is in local crate and it corresponds to another delegation
         // 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(local_id) = def_id.as_local()
-            && let Some(Ok(delegation_info)) = resolver.delegation_info(local_id)
+            && let Some(info) = resolver.delegation_info(local_id)
+            && let Ok(id) = info.resolution_id
         {
-            def_id = delegation_info.resolution_id;
+            def_id = id;
             if visited.contains(&def_id) {
                 return Err(tcx.dcx().emit_err(CycleInDelegationSignatureResolution { span }));
             }
         } else {
-            return Ok(path[0]);
+            return Ok(());
         }
     }
 }

compiler/rustc_ast_lowering/src/lib.rs

@@ -64,7 +64,7 @@ use rustc_middle::span_bug;
 use rustc_middle::ty::{DelegationInfo, PerOwnerResolverData, ResolverAstLowering, TyCtxt};
 use rustc_session::errors::add_feature_diagnostics;
 use rustc_span::symbol::{Ident, Symbol, kw, sym};
-use rustc_span::{DUMMY_SP, DesugaringKind, ErrorGuaranteed, Span};
+use rustc_span::{DUMMY_SP, DesugaringKind, Span};
 use smallvec::SmallVec;
 use thin_vec::ThinVec;
 use tracing::{debug, instrument, trace};
@@ -304,7 +304,7 @@ impl<'tcx> ResolverAstLowering<'tcx> {
         self.extra_lifetime_params_map.get(&id).map_or(&[], |v| &v[..])
     }
 
-    fn delegation_info(&self, id: LocalDefId) -> Option<Result<DelegationInfo, ErrorGuaranteed>> {
+    fn delegation_info(&self, id: LocalDefId) -> Option<DelegationInfo> {
         self.delegation_infos.get(&id).copied()
     }
 

compiler/rustc_middle/src/ty/mod.rs

@@ -257,7 +257,7 @@ pub struct ResolverAstLowering<'tcx> {
     pub lint_buffer: Steal<LintBuffer>,
 
     // Information about delegations which is used when handling recursive delegations
-    pub delegation_infos: LocalDefIdMap<Result<DelegationInfo, ErrorGuaranteed>>,
+    pub delegation_infos: LocalDefIdMap<DelegationInfo>,
 
     pub disambiguators: LocalDefIdMap<Steal<PerParentDisambiguatorState>>,
 }
@@ -269,7 +269,7 @@ pub struct DelegationInfo {
     /// Refers to the next element in a delegation resolution chain.
     /// Usually points to the final resolution, as most "chains" are just
     /// one step to a trait or an impl.
-    pub resolution_id: DefId,
+    pub resolution_id: Result<DefId, ErrorGuaranteed>,
 }
 
 #[derive(Clone, Copy, Debug, StableHash)]

compiler/rustc_resolve/src/errors.rs

@@ -1776,10 +1776,3 @@ pub(crate) enum UnusedImportsSugg {
         num_to_remove: usize,
     },
 }
-
-#[derive(Diagnostic)]
-#[diag("failed to resolve delegation callee")]
-pub(crate) struct UnresolvedDelegationCallee {
-    #[primary_span]
-    pub span: Span,
-}

compiler/rustc_resolve/src/late.rs

@@ -39,7 +39,6 @@ use smallvec::{SmallVec, smallvec};
 use thin_vec::ThinVec;
 use tracing::{debug, instrument, trace};
 
-use crate::errors::UnresolvedDelegationCallee;
 use crate::{
     BindingError, BindingKey, Decl, DelegationFnSig, Finalize, IdentKey, LateDecl, LocalModule,
     Module, ModuleOrUniformRoot, ParentScope, PathResult, Res, ResolutionError, Resolver, Segment,
@@ -3907,25 +3906,23 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             .get(&resolution_node_id)
             .and_then(|r| r.expect_full_res().opt_def_id());
 
-        let resolution = if let Some(resolution_id) = def_id
+        let resolution_id = if let Some(resolution_id) = def_id
             // If there is a single unresolved `reuse foo` in a mod it resolves to itself,
             // in this case emit `UnresolvedDelegationCallee` error instead of cycle error.
             && resolution_id != self.r.current_owner.def_id.to_def_id()
         {
-            Ok(DelegationInfo { resolution_id })
+            Ok(resolution_id)
         } else {
-            self.r.tcx.dcx().span_delayed_bug(
+            Err(self.r.tcx.dcx().span_delayed_bug(
                 delegation.path.span,
                 format!(
                     "LateResolutionVisitor: couldn't resolve node {resolution_node_id:?} in delegation item",
                 ),
-            );
-
-            let err = UnresolvedDelegationCallee { span: delegation.last_segment_span() };
-            Err(self.r.tcx.dcx().emit_err(err))
+            ))
         };
 
-        self.r.delegation_infos.insert(self.r.current_owner.def_id, resolution);
+        let info = DelegationInfo { resolution_id };
+        self.r.delegation_infos.insert(self.r.current_owner.def_id, info);
 
         let Some(body) = &delegation.body else { return };
         self.with_rib(ValueNS, RibKind::FnOrCoroutine, |this| {

compiler/rustc_resolve/src/lib.rs

@@ -1509,7 +1509,7 @@ pub struct Resolver<'ra, 'tcx> {
     /// Generic args to suggest for required params (e.g. `<'_>`, `<_, _>`), if any.
     item_required_generic_args_suggestions: FxHashMap<LocalDefId, String> = default::fx_hash_map(),
     delegation_fn_sigs: LocalDefIdMap<DelegationFnSig> = Default::default(),
-    delegation_infos: LocalDefIdMap<Result<DelegationInfo, ErrorGuaranteed>> = Default::default(),
+    delegation_infos: LocalDefIdMap<DelegationInfo> = Default::default(),
 
     main_def: Option<MainDefinition> = None,
     trait_impls: FxIndexMap<DefId, Vec<LocalDefId>>,

tests/ui/delegation/bad-resolve.rs

@@ -23,34 +23,24 @@ impl Trait for S {
     reuse <F as Trait>::C;
     //~^ ERROR item `C` is an associated method, which doesn't match its trait `Trait`
     //~| ERROR expected function, found associated constant `Trait::C`
-    //~| ERROR: failed to resolve delegation callee
     reuse <F as Trait>::Type;
     //~^ ERROR item `Type` is an associated method, which doesn't match its trait `Trait`
     //~| ERROR expected method or associated constant, found associated type `Trait::Type`
-    //~| ERROR: failed to resolve delegation callee
     reuse <F as Trait>::baz;
     //~^ ERROR method `baz` is not a member of trait `Trait`
     //~| ERROR cannot find method or associated constant `baz` in trait `Trait`
-    //~| ERROR: failed to resolve delegation callee
     reuse <F as Trait>::bar;
 
     reuse foo { &self.0 }
     //~^ ERROR cannot find function `foo` in this scope
     reuse Trait::foo2 { self.0 }
     //~^ ERROR cannot find function `foo2` in trait `Trait`
     //~| ERROR method `foo2` is not a member of trait `Trait`
-    //~| ERROR: failed to resolve delegation callee
 }
 
 mod prefix {}
 reuse unresolved_prefix::{a, b, c}; //~ ERROR cannot find module or crate `unresolved_prefix`
-//~^ ERROR: failed to resolve delegation callee
-//~| ERROR: failed to resolve delegation callee
-//~| ERROR: failed to resolve delegation callee
 reuse prefix::{self, super, crate}; //~ ERROR `crate` in paths can only be used in start position
 //~^ ERROR expected function, found module `prefix::self`
-//~| ERROR: failed to resolve delegation callee
-//~| ERROR: failed to resolve delegation callee
-//~| ERROR: failed to resolve delegation callee
 
 fn main() {}

tests/ui/delegation/bad-resolve.stderr

@@ -7,107 +7,47 @@ LL |     const C: u32 = 0;
 LL |     reuse <F as Trait>::C;
    |     ^^^^^^^^^^^^^^^^^^^^^^ does not match trait
 
-error: failed to resolve delegation callee
-  --> $DIR/bad-resolve.rs:23:25
-   |
-LL |     reuse <F as Trait>::C;
-   |                         ^
-
 error[E0324]: item `Type` is an associated method, which doesn't match its trait `Trait`
-  --> $DIR/bad-resolve.rs:27:5
+  --> $DIR/bad-resolve.rs:26:5
    |
 LL |     type Type;
    |     ---------- item in trait
 ...
 LL |     reuse <F as Trait>::Type;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ does not match trait
 
-error: failed to resolve delegation callee
-  --> $DIR/bad-resolve.rs:27:25
-   |
-LL |     reuse <F as Trait>::Type;
-   |                         ^^^^
-
 error[E0407]: method `baz` is not a member of trait `Trait`
-  --> $DIR/bad-resolve.rs:31:5
+  --> $DIR/bad-resolve.rs:29:5
    |
 LL |     reuse <F as Trait>::baz;
    |     ^^^^^^^^^^^^^^^^^^^^---^
    |     |                   |
    |     |                   help: there is an associated function with a similar name: `bar`
    |     not a member of trait `Trait`
 
-error: failed to resolve delegation callee
-  --> $DIR/bad-resolve.rs:31:25
-   |
-LL |     reuse <F as Trait>::baz;
-   |                         ^^^
-
 error[E0407]: method `foo2` is not a member of trait `Trait`
-  --> $DIR/bad-resolve.rs:39:5
+  --> $DIR/bad-resolve.rs:36:5
    |
 LL |     reuse Trait::foo2 { self.0 }
    |     ^^^^^^^^^^^^^----^^^^^^^^^^^
    |     |            |
    |     |            help: there is an associated function with a similar name: `foo`
    |     not a member of trait `Trait`
 
-error: failed to resolve delegation callee
-  --> $DIR/bad-resolve.rs:39:18
-   |
-LL |     reuse Trait::foo2 { self.0 }
-   |                  ^^^^
-
-error: failed to resolve delegation callee
-  --> $DIR/bad-resolve.rs:46:27
-   |
-LL | reuse unresolved_prefix::{a, b, c};
-   |                           ^
-
-error: failed to resolve delegation callee
-  --> $DIR/bad-resolve.rs:46:30
-   |
-LL | reuse unresolved_prefix::{a, b, c};
-   |                              ^
-
-error: failed to resolve delegation callee
-  --> $DIR/bad-resolve.rs:46:33
-   |
-LL | reuse unresolved_prefix::{a, b, c};
-   |                                 ^
-
-error: failed to resolve delegation callee
-  --> $DIR/bad-resolve.rs:50:16
-   |
-LL | reuse prefix::{self, super, crate};
-   |                ^^^^
-
-error: failed to resolve delegation callee
-  --> $DIR/bad-resolve.rs:50:22
-   |
-LL | reuse prefix::{self, super, crate};
-   |                      ^^^^^
-
-error: failed to resolve delegation callee
-  --> $DIR/bad-resolve.rs:50:29
-   |
-LL | reuse prefix::{self, super, crate};
-   |                             ^^^^^
-
 error[E0423]: expected function, found associated constant `Trait::C`
   --> $DIR/bad-resolve.rs:23:11
    |
 LL |     reuse <F as Trait>::C;
    |           ^^^^^^^^^^^^^^^ not a function
 
 error[E0575]: expected method or associated constant, found associated type `Trait::Type`
-  --> $DIR/bad-resolve.rs:27:11
+  --> $DIR/bad-resolve.rs:26:11
    |
 LL |     reuse <F as Trait>::Type;
    |           ^^^^^^^^^^^^^^^^^^ not a method or associated constant
 
 error[E0576]: cannot find method or associated constant `baz` in trait `Trait`
-  --> $DIR/bad-resolve.rs:31:25
+  --> $DIR/bad-resolve.rs:29:25
    |
 LL |     fn bar() {}
    |     -------- similarly named associated function `bar` defined here
@@ -122,13 +62,13 @@ LL +     reuse <F as Trait>::bar;
    |
 
 error[E0425]: cannot find function `foo` in this scope
-  --> $DIR/bad-resolve.rs:37:11
+  --> $DIR/bad-resolve.rs:34:11
    |
 LL |     reuse foo { &self.0 }
    |           ^^^ not found in this scope
 
 error[E0425]: cannot find function `foo2` in trait `Trait`
-  --> $DIR/bad-resolve.rs:39:18
+  --> $DIR/bad-resolve.rs:36:18
    |
 LL |     fn foo(&self, x: i32) -> i32 { x }
    |     ---------------------------- similarly named associated function `foo` defined here
@@ -143,7 +83,7 @@ LL +     reuse Trait::foo { self.0 }
    |
 
 error[E0423]: expected function, found module `prefix::self`
-  --> $DIR/bad-resolve.rs:50:7
+  --> $DIR/bad-resolve.rs:43:7
    |
 LL | reuse prefix::{self, super, crate};
    |       ^^^^^^ not a function
@@ -158,20 +98,20 @@ LL | impl Trait for S {
    | ^^^^^^^^^^^^^^^^ missing `Type` in implementation
 
 error[E0433]: cannot find module or crate `unresolved_prefix` in this scope
-  --> $DIR/bad-resolve.rs:46:7
+  --> $DIR/bad-resolve.rs:42:7
    |
 LL | reuse unresolved_prefix::{a, b, c};
    |       ^^^^^^^^^^^^^^^^^ use of unresolved module or unlinked crate `unresolved_prefix`
    |
    = help: you might be missing a crate named `unresolved_prefix`
 
 error[E0433]: `crate` in paths can only be used in start position
-  --> $DIR/bad-resolve.rs:50:29
+  --> $DIR/bad-resolve.rs:43:29
    |
 LL | reuse prefix::{self, super, crate};
    |                             ^^^^^ can only be used in path start position
 
-error: aborting due to 23 previous errors
+error: aborting due to 13 previous errors
 
 Some errors have detailed explanations: E0046, E0324, E0407, E0423, E0425, E0433, E0575, E0576.
 For more information about an error, try `rustc --explain E0046`.

tests/ui/delegation/duplicate-definition-inside-trait-impl.rs

@@ -19,7 +19,6 @@ impl Trait for S {
     //~^ ERROR  duplicate definitions with name `foo`
     //~| ERROR: this function takes 1 argument but 0 arguments were supplied
     //~| ERROR: mismatched types
-    //~| ERROR: failed to resolve delegation callee
 }
 
 fn main() {}

tests/ui/delegation/duplicate-definition-inside-trait-impl.stderr

@@ -9,12 +9,6 @@ LL |     reuse to_reuse::foo { self }
 LL |     reuse Trait::foo;
    |     ^^^^^^^^^^^^^^^^^ duplicate definition
 
-error: failed to resolve delegation callee
-  --> $DIR/duplicate-definition-inside-trait-impl.rs:18:18
-   |
-LL |     reuse Trait::foo;
-   |                  ^^^
-
 error[E0061]: this function takes 1 argument but 0 arguments were supplied
   --> $DIR/duplicate-definition-inside-trait-impl.rs:18:18
    |
@@ -40,7 +34,7 @@ LL |     reuse Trait::foo;
    |                  expected `()`, found `u32`
    |                  expected `()` because of default return type
 
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0061, E0201, E0308.
 For more information about an error, try `rustc --explain E0061`.