Emit error for unused target expression in glob delegations

Author: aerooneqq

compiler/rustc_ast_lowering/src/delegation.rs

@@ -46,19 +46,20 @@ use rustc_abi::ExternAbi;
 use rustc_ast as ast;
 use rustc_ast::node_id::NodeMap;
 use rustc_ast::*;
-use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
+use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_hir::attrs::{AttributeKind, InlineAttr};
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::{self as hir, FnDeclFlags};
 use rustc_middle::span_bug;
 use rustc_middle::ty::{Asyncness, PerOwnerResolverData, TyCtxt};
 use rustc_span::symbol::kw;
-use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol};
+use rustc_span::{ErrorGuaranteed, ExpnId, Ident, Span, Symbol};
 
 use crate::delegation::generics::{GenericsGenerationResult, GenericsGenerationResults};
 use crate::diagnostics::{
     CycleInDelegationSignatureResolution, DelegationAttemptedBlockWithDefsDeletion,
-    DelegationBlockSpecifiedWhenNoParams, UnresolvedDelegationCallee,
+    DelegationBlockSpecifiedWhenNoParams, DelegationTargetExprDeletedEverywhere,
+    UnresolvedDelegationCallee,
 };
 use crate::{
     AllowReturnTypeNotation, ImplTraitContext, ImplTraitPosition, LoweringContext, ParamMode,
@@ -168,6 +169,30 @@ fn check_for_cycles(tcx: TyCtxt<'_>, mut def_id: DefId, span: Span) -> Result<()
     }
 }
 
+pub(crate) fn check_unused_target_exprs_in_glob_delegations(
+    tcx: TyCtxt<'_>,
+    delegations_ids: &FxIndexSet<LocalDefId>,
+) {
+    let mut delegations_by_expansions = FxIndexMap::default();
+    for &id in delegations_ids {
+        let expn_id = tcx.expn_that_defined(id);
+        if expn_id == ExpnId::root() {
+            continue;
+        }
+
+        let entry = delegations_by_expansions.entry(expn_id);
+        let entry = entry.or_insert_with(|| (true, tcx.def_span(id)));
+
+        entry.0 &= tcx.hir_opt_delegation_info(id).is_some_and(|info| !info.generated_target_expr);
+    }
+
+    for (_, state) in delegations_by_expansions {
+        if state.0 {
+            tcx.dcx().emit_err(DelegationTargetExprDeletedEverywhere { span: state.1 });
+        }
+    }
+}
+
 impl<'hir> LoweringContext<'_, 'hir> {
     fn is_method(&self, def_id: DefId, span: Span) -> bool {
         match self.tcx.def_kind(def_id) {
@@ -213,6 +238,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             self.lower_delegation_body(delegation, sig_id, param_count, &mut generics, span);
 
         let decl = self.lower_delegation_decl(
+            delegation,
             sig_id,
             param_count,
             c_variadic,
@@ -375,6 +401,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_delegation_decl(
         &mut self,
+        delegation: &Delegation,
         sig_id: DefId,
         param_count: usize,
         c_variadic: bool,
@@ -395,6 +422,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
             span,
         }));
 
+        let is_method = self.is_method(sig_id, span);
+
+        // Consider target expression generated if it was not specified, as now
+        // it is used only for list/glob delegation's unused target expression diagnostic.
+        let generated_target_expr = delegation.body.is_none()
+            || (param_count > 0 && self.should_generate_block(delegation, sig_id, is_method));
+
         let output = self.arena.alloc(hir::Ty {
             hir_id: self.next_id(),
             kind: hir::TyKind::InferDelegation(hir::InferDelegation::Sig(
@@ -406,6 +440,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     parent_args_segment_id: generics.parent.args_segment_id,
                     self_ty_id: generics.self_ty_id,
                     propagate_self_ty: generics.propagate_self_ty,
+                    generated_target_expr,
                 })),
             )),
             span,

compiler/rustc_ast_lowering/src/diagnostics.rs

@@ -549,3 +549,11 @@ pub(crate) struct DelegationAttemptedBlockWithDefsDeletion {
     #[primary_span]
     pub span: Span,
 }
+
+// FIXME(fn_delegation): fix message when list delegations are supported
+#[derive(Diagnostic)]
+#[diag("unused target expression is specified for glob delegation")]
+pub(crate) struct DelegationTargetExprDeletedEverywhere {
+    #[primary_span]
+    pub span: Span,
+}

compiler/rustc_ast_lowering/src/lib.rs

@@ -60,9 +60,9 @@ use rustc_hir::{
 use rustc_index::{Idx, IndexSlice, IndexVec};
 use rustc_macros::extension;
 use rustc_middle::hir::{self as mid_hir};
-use rustc_middle::queries::Providers;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{DelegationInfo, PerOwnerResolverData, ResolverAstLowering, TyCtxt};
+use rustc_middle::util::Providers;
 use rustc_session::errors::add_feature_diagnostics;
 use rustc_span::symbol::{Ident, Symbol, kw, sym};
 use rustc_span::{DUMMY_SP, DesugaringKind, Span};
@@ -93,9 +93,11 @@ mod path;
 pub mod stability;
 
 pub fn provide(providers: &mut Providers) {
-    providers.hir_crate = lower_to_hir;
-    providers.lower_delayed_owner = lower_delayed_owner;
-    providers.delegations_resolutions = delegation::delegations_resolutions;
+    providers.queries.hir_crate = lower_to_hir;
+    providers.queries.lower_delayed_owner = lower_delayed_owner;
+    providers.queries.delegations_resolutions = delegation::delegations_resolutions;
+    providers.hooks.check_unused_target_exprs_in_glob_delegations =
+        delegation::check_unused_target_exprs_in_glob_delegations;
 }
 
 struct LoweringContext<'a, 'hir> {

compiler/rustc_hir/src/hir.rs

@@ -3875,6 +3875,7 @@ pub struct DelegationInfo {
     pub child_args_segment_id: Option<HirId>,
     pub self_ty_id: Option<HirId>,
     pub propagate_self_ty: bool,
+    pub generated_target_expr: bool,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, StableHash)]

compiler/rustc_hir_analysis/src/delegation.rs

@@ -5,9 +5,9 @@
 use std::debug_assert_matches;
 
 use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::PathSegment;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId};
-use rustc_hir::{DelegationInfo, PathSegment};
 use rustc_middle::ty::{
     self, EarlyBinder, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt,
 };
@@ -71,19 +71,6 @@ enum SelfPositionKind {
     None,
 }
 
-pub fn opt_get_delegation_info(
-    tcx: TyCtxt<'_>,
-    delegation_id: LocalDefId,
-) -> Option<&DelegationInfo> {
-    tcx.hir_node(tcx.local_def_id_to_hir_id(delegation_id))
-        .fn_sig()
-        .and_then(|sig| sig.decl.opt_delegation_info())
-}
-
-fn get_delegation_info(tcx: TyCtxt<'_>, delegation_id: LocalDefId) -> &DelegationInfo {
-    opt_get_delegation_info(tcx, delegation_id).expect("processing delegation")
-}
-
 fn create_self_position_kind(
     tcx: TyCtxt<'_>,
     delegation_id: LocalDefId,
@@ -96,7 +83,7 @@ fn create_self_position_kind(
         | (FnKind::AssocTrait, FnKind::Free) => SelfPositionKind::Zero,
 
         (FnKind::Free, FnKind::AssocTrait) => {
-            let propagate_self_ty = get_delegation_info(tcx, delegation_id).propagate_self_ty;
+            let propagate_self_ty = tcx.hir_delegation_info(delegation_id).propagate_self_ty;
             SelfPositionKind::AfterLifetimes(propagate_self_ty)
         }
 
@@ -282,7 +269,7 @@ fn get_parent_and_inheritance_kind<'tcx>(
 }
 
 fn get_delegation_self_ty_or_err(tcx: TyCtxt<'_>, delegation_id: LocalDefId) -> Ty<'_> {
-    get_delegation_info(tcx, delegation_id)
+    tcx.hir_delegation_info(delegation_id)
         .self_ty_id
         .map(|id| {
             let ctx = ItemCtxt::new(tcx, delegation_id);
@@ -644,7 +631,7 @@ pub(crate) fn delegation_user_specified_args<'tcx>(
     tcx: TyCtxt<'tcx>,
     delegation_id: LocalDefId,
 ) -> (&'tcx [ty::GenericArg<'tcx>], &'tcx [ty::GenericArg<'tcx>]) {
-    let info = get_delegation_info(tcx, delegation_id);
+    let info = tcx.hir_delegation_info(delegation_id);
 
     let get_segment = |hir_id| -> Option<(&'tcx PathSegment<'tcx>, DefId)> {
         let segment = tcx.hir_node(hir_id).expect_path_segment();

compiler/rustc_hir_typeck/src/callee.rs

@@ -7,7 +7,6 @@ use rustc_hir::def::{self, CtorKind, Namespace, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, HirId, LangItem, find_attr};
 use rustc_hir_analysis::autoderef::Autoderef;
-use rustc_hir_analysis::delegation::opt_get_delegation_info;
 use rustc_infer::infer::BoundRegionConversionTime;
 use rustc_infer::traits::{Obligation, ObligationCause, ObligationCauseCode};
 use rustc_middle::ty::adjustment::{
@@ -701,7 +700,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // by comparing their hir ids (otherwise we will encounter errors in nested delegations,
         // see tests\ui\delegation\impl-reuse-pass.rs:237).
         let parent_def = self.tcx.hir_get_parent_item(call_expr.hir_id).def_id;
-        let Some(info) = opt_get_delegation_info(self.tcx, parent_def) else { return None };
+        let Some(info) = self.tcx.hir_opt_delegation_info(parent_def) else {
+            return None;
+        };
 
         if call_expr.hir_id != info.call_expr_id {
             return None;

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -13,7 +13,6 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::Visitor;
 use rustc_hir::{Expr, ExprKind, FnRetTy, HirId, LangItem, Node, QPath, is_range_literal};
 use rustc_hir_analysis::check::potentially_plural_count;
-use rustc_hir_analysis::delegation::opt_get_delegation_info;
 use rustc_hir_analysis::hir_ty_lowering::{HirTyLowerer, ResolvedStructPath};
 use rustc_index::IndexVec;
 use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes, InferOk, TypeTrace};
@@ -341,7 +340,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
             // If we are processing first arg of delegation then we could have adjusted it
             // in `execute_delegation_aware_arguments_check`.
-            let checked_ty = opt_get_delegation_info(self.tcx, self.body_id)
+            let checked_ty = self
+                .tcx
+                .hir_opt_delegation_info(self.body_id)
                 .and_then(|_| self.typeck_results.borrow().node_type_opt(provided_arg.hir_id))
                 .unwrap_or_else(|| self.check_expr_with_expectation(provided_arg, expectation));
 

compiler/rustc_interface/src/passes.rs

@@ -885,7 +885,7 @@ pub static DEFAULT_QUERY_PROVIDERS: LazyLock<Providers> = LazyLock::new(|| {
     providers.queries.resolutions = |tcx, ()| tcx.resolver_for_lowering_raw(()).1;
     providers.queries.early_lint_checks = early_lint_checks;
     providers.queries.env_var_os = env_var_os;
-    rustc_ast_lowering::provide(&mut providers.queries);
+    rustc_ast_lowering::provide(providers);
     limits::provide(&mut providers.queries);
     proc_macro_decls::provide(&mut providers.queries);
     rustc_expand::provide(&mut providers.queries);

compiler/rustc_middle/src/hir/map.rs

@@ -865,6 +865,14 @@ impl<'tcx> TyCtxt<'tcx> {
         self.opt_hir_owner_node(def_id)?.fn_decl()?.opt_delegation_sig_id()
     }
 
+    pub fn hir_opt_delegation_info(self, def_id: LocalDefId) -> Option<&'tcx DelegationInfo> {
+        self.opt_hir_owner_node(def_id)?.fn_decl()?.opt_delegation_info()
+    }
+
+    pub fn hir_delegation_info(self, delegation_id: LocalDefId) -> &'tcx DelegationInfo {
+        self.hir_opt_delegation_info(delegation_id).expect("processing delegation")
+    }
+
     #[inline]
     fn hir_opt_ident(self, id: HirId) -> Option<Ident> {
         match self.hir_node(id) {
@@ -1282,6 +1290,8 @@ fn force_delayed_owners_lowering(tcx: TyCtxt<'_>) {
         tcx.ensure_done().lower_delayed_owner(id);
     }
 
+    tcx.check_unused_target_exprs_in_glob_delegations(&krate.delayed_ids);
+
     let (_, krate) = krate.delayed_resolver.steal();
     let prof = tcx.sess.prof.clone();
 

compiler/rustc_middle/src/hooks/mod.rs

@@ -3,6 +3,7 @@
 //! similar to queries, but queries come with a lot of machinery for caching and incremental
 //! compilation, whereas hooks are just plain function pointers without any of the query magic.
 
+use rustc_data_structures::fx::FxIndexSet;
 use rustc_hir::def_id::{DefId, DefPathHash};
 use rustc_session::StableCrateId;
 use rustc_span::def_id::{CrateNum, LocalDefId};
@@ -113,6 +114,8 @@ declare_hooks! {
 
     /// Serializes all eligible query return values into the on-disk cache.
     hook encode_query_values(encoder: &mut CacheEncoder<'_, 'tcx>) -> ();
+
+    hook check_unused_target_exprs_in_glob_delegations(ids: &FxIndexSet<LocalDefId>) -> ();
 }
 
 #[cold]