Rollup merge of rust-lang#157601 - aerooneqq:delegation-glob-useless-target-expr-error, r=petrochenkov

Emit error for unused target expression in glob and list delegations

This PR emits error if unuse  target expression is specified for glob delegation. Second part of rust-lang#156798.

Part of rust-lang#118212.
r? @petrochenkov

Author: jhpratt

compiler/rustc_ast/src/ast.rs

@@ -31,7 +31,8 @@ use rustc_data_structures::tagged_ptr::Tag;
 use rustc_macros::{Decodable, Encodable, StableHash, Walkable};
 pub use rustc_span::AttrId;
 use rustc_span::{
-    ByteSymbol, DUMMY_SP, ErrorGuaranteed, Ident, Span, Spanned, Symbol, kw, respan, sym,
+    ByteSymbol, DUMMY_SP, ErrorGuaranteed, Ident, LocalExpnId, Span, Spanned, Symbol, kw, respan,
+    sym,
 };
 use thin_vec::{ThinVec, thin_vec};
 
@@ -3906,10 +3907,10 @@ pub struct EiiImpl {
     pub is_default: bool,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug, Walkable, PartialEq, Eq)]
+#[derive(Clone, Copy, Encodable, Decodable, Debug, PartialEq, Eq)]
 pub enum DelegationSource {
     Single,
-    List,
+    List(LocalExpnId),
     Glob,
 }
 
@@ -3923,6 +3924,7 @@ pub struct Delegation {
     pub rename: Option<Ident>,
     pub body: Option<Box<Block>>,
     /// The item was expanded from a glob delegation item.
+    #[visitable(ignore)]
     pub source: DelegationSource,
 }
 

compiler/rustc_ast/src/visit.rs

@@ -431,7 +431,6 @@ macro_rules! common_visitor_and_walkers {
             Delegation,
             DelegationMac,
             DelegationSuffixes,
-            DelegationSource,
             DelimArgs,
             DelimSpan,
             EnumDef,

compiler/rustc_ast_lowering/src/delegation.rs

@@ -62,7 +62,7 @@ use crate::diagnostics::{
 };
 use crate::{
     AllowReturnTypeNotation, ImplTraitContext, ImplTraitPosition, LoweringContext, ParamMode,
-    ResolverAstLoweringExt, index_crate,
+    index_crate,
 };
 
 mod generics;
@@ -126,7 +126,7 @@ pub(crate) fn delegations_resolutions(
         let delegation = ast_index[def_id].delegation().expect("processing delegations");
         let span = delegation.last_segment_span();
 
-        if let Some(info) = resolver.delegation_info(def_id) {
+        if let Some(info) = tcx.resolutions(()).delegation_infos.get(&def_id) {
             let res = info.resolution_id.map(|id| check_for_cycles(tcx, id, span).map(|_| id));
             result.insert(def_id, res.flatten());
         } else {
@@ -143,16 +143,14 @@ pub(crate) fn delegations_resolutions(
 fn check_for_cycles(tcx: TyCtxt<'_>, mut def_id: DefId, span: Span) -> Result<(), ErrorGuaranteed> {
     let mut visited: FxHashSet<DefId> = Default::default();
 
-    let (resolver, _) = &*tcx.hir_crate(()).delayed_resolver.borrow();
-
     loop {
         visited.insert(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(info) = resolver.delegation_info(local_id)
+            && let Some(info) = tcx.resolutions(()).delegation_infos.get(&local_id)
             && let Ok(id) = info.resolution_id
         {
             def_id = id;
@@ -209,17 +207,19 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         let mut generics = self.uplift_delegation_generics(delegation, sig_id, is_method);
 
-        let (body_id, call_expr_id) =
+        let (body_id, call_expr_id, unused_target_expr) =
             self.lower_delegation_body(delegation, sig_id, param_count, &mut generics, span);
 
         let decl = self.lower_delegation_decl(
+            delegation.source,
             sig_id,
             param_count,
             c_variadic,
             span,
             &generics,
             delegation.id,
             call_expr_id,
+            unused_target_expr,
         );
 
         let sig = self.lower_delegation_sig(sig_id, decl, span);
@@ -375,13 +375,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_delegation_decl(
         &mut self,
+        source: DelegationSource,
         sig_id: DefId,
         param_count: usize,
         c_variadic: bool,
         span: Span,
         generics: &GenericsGenerationResults<'hir>,
         call_path_node_id: NodeId,
         call_expr_id: HirId,
+        unused_target_expr: bool,
     ) -> &'hir hir::FnDecl<'hir> {
         // The last parameter in C variadic functions is skipped in the signature,
         // like during regular lowering.
@@ -406,6 +408,17 @@ 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,
+                    group_id: {
+                        let id = match source {
+                            DelegationSource::Single => None,
+                            DelegationSource::List(expn_id) => Some(expn_id),
+                            DelegationSource::Glob => {
+                                Some(self.tcx.expn_that_defined(self.owner.def_id).expect_local())
+                            }
+                        };
+
+                        id.map(|id| (id, unused_target_expr))
+                    },
                 })),
             )),
             span,
@@ -504,16 +517,23 @@ impl<'hir> LoweringContext<'_, 'hir> {
         param_count: usize,
         generics: &mut GenericsGenerationResults<'hir>,
         span: Span,
-    ) -> (BodyId, HirId) {
+    ) -> (BodyId, HirId, bool) {
         let block = delegation.body.as_deref();
         let mut call_expr_id = HirId::INVALID;
+        let mut unused_target_expr = false;
 
         let block_id = self.lower_body(|this| {
             let mut parameters: Vec<hir::Param<'_>> = Vec::with_capacity(param_count);
             let mut args: Vec<hir::Expr<'_>> = Vec::with_capacity(param_count);
             let mut stmts: &[hir::Stmt<'hir>] = &[];
 
             let is_method = this.is_method(sig_id, span);
+            let should_generate_block = this.should_generate_block(delegation, sig_id, is_method);
+
+            // Consider non-specified target expression as generated,
+            // as we do not want to emit error when target expression is
+            // not specified.
+            unused_target_expr = block.is_some() && (param_count == 0 || !should_generate_block);
 
             for idx in 0..param_count {
                 let (param, pat_node_id) = this.generate_param(is_method, idx, span);
@@ -524,7 +544,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
                 let arg = if let Some(block) = block
                     && idx == 0
-                    && this.should_generate_block(delegation, sig_id, is_method)
+                    && should_generate_block
                 {
                     let mut self_resolver = SelfResolver {
                         ctxt: this,
@@ -565,7 +585,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         debug_assert_ne!(call_expr_id, HirId::INVALID);
 
-        (block_id, call_expr_id)
+        (block_id, call_expr_id, unused_target_expr)
     }
 
     fn finalize_body_lowering(

compiler/rustc_ast_lowering/src/lib.rs

@@ -63,7 +63,7 @@ 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::ty::{PerOwnerResolverData, ResolverAstLowering, TyCtxt};
 use rustc_session::errors::add_feature_diagnostics;
 use rustc_span::symbol::{Ident, Symbol, kw, sym};
 use rustc_span::{DUMMY_SP, DesugaringKind, Span};
@@ -307,10 +307,6 @@ impl<'tcx> ResolverAstLowering<'tcx> {
         self.extra_lifetime_params_map.get(&id).map_or(&[], |v| &v[..])
     }
 
-    fn delegation_info(&self, id: LocalDefId) -> Option<&DelegationInfo> {
-        self.delegation_infos.get(&id)
-    }
-
     fn owner_def_id(&self, id: NodeId) -> LocalDefId {
         self.owners[&id].def_id
     }

compiler/rustc_expand/src/expand.rs

@@ -8,9 +8,9 @@ use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::visit::{self, AssocCtxt, Visitor, VisitorResult, try_visit, walk_list};
 use rustc_ast::{
     self as ast, AssocItemKind, AstNodeWrapper, AttrArgs, AttrItemKind, AttrStyle, AttrVec,
-    DUMMY_NODE_ID, DelegationSuffixes, EarlyParsedAttribute, ExprKind, ForeignItemKind, HasAttrs,
-    HasNodeId, Inline, ItemKind, MacStmtStyle, MetaItemInner, MetaItemKind, ModKind, NodeId,
-    PatKind, StmtKind, TyKind, token,
+    DUMMY_NODE_ID, DelegationSource, DelegationSuffixes, EarlyParsedAttribute, ExprKind,
+    ForeignItemKind, HasAttrs, HasNodeId, Inline, ItemKind, MacStmtStyle, MetaItemInner,
+    MetaItemKind, ModKind, NodeId, PatKind, StmtKind, TyKind, token,
 };
 use rustc_ast_pretty::pprust;
 use rustc_attr_parsing::parser::AllowExprMetavar;
@@ -992,7 +992,12 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
 
                 type Node = AstNodeWrapper<Box<ast::AssocItem>, ImplItemTag>;
                 let single_delegations = build_single_delegations::<Node>(
-                    self.cx, deleg, &item, &suffixes, item.span, true,
+                    self.cx,
+                    deleg,
+                    &item,
+                    &suffixes,
+                    item.span,
+                    DelegationSource::Glob,
                 );
                 // `-Zmacro-stats` ignores these because they don't seem important.
                 fragment_kind.expect_from_annotatables(single_delegations.map(|item| {
@@ -2041,8 +2046,12 @@ fn build_single_delegations<'a, Node: InvocationCollectorNode>(
     item: &'a ast::Item<Node::ItemKind>,
     suffixes: &'a [(Ident, Option<Ident>)],
     item_span: Span,
-    from_glob: bool,
+    source: DelegationSource,
 ) -> impl Iterator<Item = ast::Item<Node::ItemKind>> + 'a {
+    debug_assert_ne!(source, DelegationSource::Single);
+
+    let from_glob = source == DelegationSource::Glob;
+
     if suffixes.is_empty() {
         // Report an error for now, to avoid keeping stem for resolution and
         // stability checks.
@@ -2066,11 +2075,7 @@ fn build_single_delegations<'a, Node: InvocationCollectorNode>(
                 ident: rename.unwrap_or(ident),
                 rename,
                 body: deleg.body.clone(),
-                source: if from_glob {
-                    ast::DelegationSource::Glob
-                } else {
-                    ast::DelegationSource::List
-                },
+                source,
             })),
             tokens: None,
         }
@@ -2414,7 +2419,12 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
                     };
 
                     let single_delegations = build_single_delegations::<Node>(
-                        self.cx, deleg, item, suffixes, item.span, false,
+                        self.cx,
+                        deleg,
+                        item,
+                        suffixes,
+                        item.span,
+                        DelegationSource::List(LocalExpnId::fresh_empty()),
                     );
                     Node::flatten_outputs(single_delegations.map(|item| {
                         let mut item = Node::from_item(item);

compiler/rustc_hir/src/hir.rs

@@ -25,7 +25,8 @@ use rustc_index::IndexVec;
 use rustc_macros::{Decodable, Encodable, StableHash};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{
-    BytePos, DUMMY_SP, DesugaringKind, ErrorGuaranteed, Ident, Span, Spanned, Symbol, kw, sym,
+    BytePos, DUMMY_SP, DesugaringKind, ErrorGuaranteed, Ident, LocalExpnId, Span, Spanned, Symbol,
+    kw, sym,
 };
 use rustc_target::asm::InlineAsmRegOrRegClass;
 use smallvec::SmallVec;
@@ -3877,6 +3878,7 @@ pub struct DelegationInfo {
     pub child_args_segment_id: Option<HirId>,
     pub self_ty_id: Option<HirId>,
     pub propagate_self_ty: bool,
+    pub group_id: Option<(LocalExpnId, bool /* unused_target_expr */)>,
 }
 
 #[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

@@ -1083,6 +1083,8 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
     // to use `hir_crate_items`.
     tcx.ensure_done().hir_crate_items(());
 
+    rustc_passes::delegation::check_glob_and_list_delegations_target_expr(tcx);
+
     let sess = tcx.sess;
     sess.time("misc_checking_1", || {
         par_fns(&mut [