Rollup of 11 pull requests

compiler/rustc_ast_lowering/messages.ftl

@@ -56,6 +56,8 @@ ast_lowering_coroutine_too_many_parameters =
 ast_lowering_default_field_in_tuple = default fields are not supported in tuple structs
     .label = default fields are only supported on structs
 
+ast_lowering_delegation_cycle_in_signature_resolution = encountered a cycle during delegation signature resolution
+ast_lowering_delegation_unresolved_callee = failed to resolve delegation callee
 ast_lowering_does_not_support_modifiers =
     the `{$class_name}` register class does not support template modifiers
 

compiler/rustc_ast_lowering/src/delegation.rs

@@ -44,6 +44,7 @@ use hir::{BodyId, HirId};
 use rustc_abi::ExternAbi;
 use rustc_ast::*;
 use rustc_attr_parsing::{AttributeParser, ShouldEmit};
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::Target;
 use rustc_hir::attrs::{AttributeKind, InlineAttr};
@@ -55,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::{CycleInDelegationSignatureResolution, UnresolvedDelegationCallee};
 use crate::{AllowReturnTypeNotation, ImplTraitPosition, ResolverAstLoweringExt};
 
 pub(crate) struct DelegationResults<'hir> {
@@ -119,10 +121,14 @@ 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_delegation_sig_id(item_id, delegation.id, span, is_in_trait_impl);
+
+        let sig_id = self.get_delegation_sig_id(
+            self.resolver.delegation_sig_resolution_nodes[&self.local_def_id(item_id)],
+            span,
+        );
+
         match sig_id {
             Ok(sig_id) => {
                 self.add_attributes_if_needed(span, sig_id);
@@ -238,24 +244,48 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn get_delegation_sig_id(
         &self,
-        item_id: NodeId,
-        path_id: NodeId,
+        mut node_id: NodeId,
         span: Span,
-        is_in_trait_impl: bool,
     ) -> Result<DefId, ErrorGuaranteed> {
-        let sig_id = if is_in_trait_impl { item_id } else { path_id };
-        self.get_resolution_id(sig_id, span)
+        let mut visited: FxHashSet<NodeId> = Default::default();
+
+        loop {
+            visited.insert(node_id);
+
+            let Some(def_id) = self.get_resolution_id(node_id) else {
+                return Err(self.tcx.dcx().span_delayed_bug(
+                    span,
+                    format!(
+                        "LoweringContext: couldn't resolve node {:?} in delegation item",
+                        node_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(next_node_id) =
+                    self.resolver.delegation_sig_resolution_nodes.get(&local_id)
+            {
+                node_id = *next_node_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(match visited.len() {
+                        1 => self.dcx().emit_err(UnresolvedDelegationCallee { span }),
+                        _ => self.dcx().emit_err(CycleInDelegationSignatureResolution { span }),
+                    });
+                }
+            } else {
+                return Ok(def_id);
+            }
+        }
     }
 
-    fn get_resolution_id(&self, node_id: NodeId, span: Span) -> Result<DefId, ErrorGuaranteed> {
-        let def_id =
-            self.resolver.get_partial_res(node_id).and_then(|r| r.expect_full_res().opt_def_id());
-        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(&self, node_id: NodeId) -> Option<DefId> {
+        self.resolver.get_partial_res(node_id).and_then(|r| r.expect_full_res().opt_def_id())
     }
 
     fn lower_delegation_generics(&mut self, span: Span) -> &'hir hir::Generics<'hir> {
@@ -271,8 +301,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),
@@ -489,8 +517,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
             delegation.path.segments.iter().rev().skip(1).any(|segment| segment.args.is_some());
 
         let call = if self
-            .get_resolution_id(delegation.id, span)
-            .and_then(|def_id| Ok(self.is_method(def_id, span)))
+            .get_resolution_id(delegation.id)
+            .map(|def_id| self.is_method(def_id, span))
             .unwrap_or_default()
             && delegation.qself.is_none()
             && !has_generic_args

compiler/rustc_ast_lowering/src/errors.rs

@@ -475,3 +475,17 @@ pub(crate) struct UnionWithDefault {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(ast_lowering_delegation_unresolved_callee)]
+pub(crate) struct UnresolvedDelegationCallee {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(ast_lowering_delegation_cycle_in_signature_resolution)]
+pub(crate) struct CycleInDelegationSignatureResolution {
+    #[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_attr_parsing/src/attributes/cfg_select.rs

@@ -28,6 +28,33 @@ pub struct CfgSelectBranches {
     pub unreachable: Vec<(CfgSelectPredicate, TokenStream, Span)>,
 }
 
+impl CfgSelectBranches {
+    /// Removes the top-most branch for which `predicate` returns `true`,
+    /// or the wildcard if none of the reachable branches satisfied the predicate.
+    pub fn pop_first_match<F>(&mut self, predicate: F) -> Option<(TokenStream, Span)>
+    where
+        F: Fn(&CfgEntry) -> bool,
+    {
+        for (index, (cfg, _, _)) in self.reachable.iter().enumerate() {
+            if predicate(cfg) {
+                let matched = self.reachable.remove(index);
+                return Some((matched.1, matched.2));
+            }
+        }
+
+        self.wildcard.take().map(|(_, tts, span)| (tts, span))
+    }
+
+    /// Consume this value and iterate over all the `TokenStream`s that it stores.
+    pub fn into_iter_tts(self) -> impl Iterator<Item = (TokenStream, Span)> {
+        let it1 = self.reachable.into_iter().map(|(_, tts, span)| (tts, span));
+        let it2 = self.wildcard.into_iter().map(|(_, tts, span)| (tts, span));
+        let it3 = self.unreachable.into_iter().map(|(_, tts, span)| (tts, span));
+
+        it1.chain(it2).chain(it3)
+    }
+}
+
 pub fn parse_cfg_select(
     p: &mut Parser<'_>,
     sess: &Session,

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -117,11 +117,35 @@ impl<S: Stage> SingleAttributeParser<S> for RustcLegacyConstGenericsParser {
     }
 }
 
+pub(crate) struct RustcLintOptDenyFieldAccessParser;
+
+impl<S: Stage> SingleAttributeParser<S> for RustcLintOptDenyFieldAccessParser {
+    const PATH: &[Symbol] = &[sym::rustc_lint_opt_deny_field_access];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Field)]);
+    const TEMPLATE: AttributeTemplate = template!(Word);
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
+        let Some(arg) = args.list().and_then(MetaItemListParser::single) else {
+            cx.expected_single_argument(cx.attr_span);
+            return None;
+        };
+
+        let MetaItemOrLitParser::Lit(MetaItemLit { kind: LitKind::Str(lint_message, _), .. }) = arg
+        else {
+            cx.expected_string_literal(arg.span(), arg.lit());
+            return None;
+        };
+
+        Some(AttributeKind::RustcLintOptDenyFieldAccess { lint_message: *lint_message })
+    }
+}
+
 pub(crate) struct RustcLintOptTyParser;
 
 impl<S: Stage> NoArgsAttributeParser<S> for RustcLintOptTyParser {
     const PATH: &[Symbol] = &[sym::rustc_lint_opt_ty];
-    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Struct)]);
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcLintOptTy;
 }
@@ -130,7 +154,7 @@ pub(crate) struct RustcLintQueryInstabilityParser;
 
 impl<S: Stage> NoArgsAttributeParser<S> for RustcLintQueryInstabilityParser {
     const PATH: &[Symbol] = &[sym::rustc_lint_query_instability];
-    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
         Allow(Target::Fn),
         Allow(Target::Method(MethodKind::Inherent)),

compiler/rustc_attr_parsing/src/context.rs

@@ -61,9 +61,9 @@ use crate::attributes::prototype::CustomMirParser;
 use crate::attributes::repr::{AlignParser, AlignStaticParser, ReprParser};
 use crate::attributes::rustc_internal::{
     RustcLayoutScalarValidRangeEndParser, RustcLayoutScalarValidRangeStartParser,
-    RustcLegacyConstGenericsParser, RustcLintOptTyParser, RustcLintQueryInstabilityParser,
-    RustcMainParser, RustcNeverReturnsNullPointerParser, RustcNoImplicitAutorefsParser,
-    RustcObjectLifetimeDefaultParser, RustcScalableVectorParser,
+    RustcLegacyConstGenericsParser, RustcLintOptDenyFieldAccessParser, RustcLintOptTyParser,
+    RustcLintQueryInstabilityParser, RustcMainParser, RustcNeverReturnsNullPointerParser,
+    RustcNoImplicitAutorefsParser, RustcObjectLifetimeDefaultParser, RustcScalableVectorParser,
     RustcSimdMonomorphizeLaneLimitParser,
 };
 use crate::attributes::semantics::MayDangleParser;
@@ -213,6 +213,7 @@ attribute_parsers!(
         Single<RustcLayoutScalarValidRangeEndParser>,
         Single<RustcLayoutScalarValidRangeStartParser>,
         Single<RustcLegacyConstGenericsParser>,
+        Single<RustcLintOptDenyFieldAccessParser>,
         Single<RustcObjectLifetimeDefaultParser>,
         Single<RustcScalableVectorParser>,
         Single<RustcSimdMonomorphizeLaneLimitParser>,

compiler/rustc_builtin_macros/src/cfg_select.rs

@@ -1,22 +1,65 @@
 use rustc_ast::tokenstream::TokenStream;
+use rustc_ast::{Expr, ast};
 use rustc_attr_parsing as attr;
 use rustc_attr_parsing::{
     CfgSelectBranches, CfgSelectPredicate, EvalConfigResult, parse_cfg_select,
 };
-use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacroExpanderResult};
+use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacResult, MacroExpanderResult};
 use rustc_span::{Ident, Span, sym};
+use smallvec::SmallVec;
 
 use crate::errors::{CfgSelectNoMatches, CfgSelectUnreachable};
 
-/// Selects the first arm whose predicate evaluates to true.
-fn select_arm(ecx: &ExtCtxt<'_>, branches: CfgSelectBranches) -> Option<(TokenStream, Span)> {
-    for (cfg, tt, arm_span) in branches.reachable {
-        if let EvalConfigResult::True = attr::eval_config_entry(&ecx.sess, &cfg) {
-            return Some((tt, arm_span));
-        }
+/// This intermediate structure is used to emit parse errors for the branches that are not chosen.
+/// The `MacResult` instance below parses all branches, emitting any errors it encounters, but only
+/// keeps the parse result for the selected branch.
+struct CfgSelectResult<'cx, 'sess> {
+    ecx: &'cx mut ExtCtxt<'sess>,
+    site_span: Span,
+    selected_tts: TokenStream,
+    selected_span: Span,
+    other_branches: CfgSelectBranches,
+}
+
+fn tts_to_mac_result<'cx, 'sess>(
+    ecx: &'cx mut ExtCtxt<'sess>,
+    site_span: Span,
+    tts: TokenStream,
+    span: Span,
+) -> Box<dyn MacResult + 'cx> {
+    match ExpandResult::from_tts(ecx, tts, site_span, span, Ident::with_dummy_span(sym::cfg_select))
+    {
+        ExpandResult::Ready(x) => x,
+        _ => unreachable!("from_tts always returns Ready"),
     }
+}
+
+macro_rules! forward_to_parser_any_macro {
+    ($method_name:ident, $ret_ty:ty) => {
+        fn $method_name(self: Box<Self>) -> Option<$ret_ty> {
+            let CfgSelectResult { ecx, site_span, selected_tts, selected_span, .. } = *self;
+
+            for (tts, span) in self.other_branches.into_iter_tts() {
+                let _ = tts_to_mac_result(ecx, site_span, tts, span).$method_name();
+            }
+
+            tts_to_mac_result(ecx, site_span, selected_tts, selected_span).$method_name()
+        }
+    };
+}
+
+impl<'cx, 'sess> MacResult for CfgSelectResult<'cx, 'sess> {
+    forward_to_parser_any_macro!(make_expr, Box<Expr>);
+    forward_to_parser_any_macro!(make_stmts, SmallVec<[ast::Stmt; 1]>);
+    forward_to_parser_any_macro!(make_items, SmallVec<[Box<ast::Item>; 1]>);
+
+    forward_to_parser_any_macro!(make_impl_items, SmallVec<[Box<ast::AssocItem>; 1]>);
+    forward_to_parser_any_macro!(make_trait_impl_items, SmallVec<[Box<ast::AssocItem>; 1]>);
+    forward_to_parser_any_macro!(make_trait_items, SmallVec<[Box<ast::AssocItem>; 1]>);
+    forward_to_parser_any_macro!(make_foreign_items, SmallVec<[Box<ast::ForeignItem>; 1]>);
 
-    branches.wildcard.map(|(_, tt, span)| (tt, span))
+    forward_to_parser_any_macro!(make_ty, Box<ast::Ty>);
+    forward_to_parser_any_macro!(make_pat, Box<ast::Pat>);
 }
 
 pub(super) fn expand_cfg_select<'cx>(
@@ -31,7 +74,7 @@ pub(super) fn expand_cfg_select<'cx>(
             Some(ecx.ecfg.features),
             ecx.current_expansion.lint_node_id,
         ) {
-            Ok(branches) => {
+            Ok(mut branches) => {
                 if let Some((underscore, _, _)) = branches.wildcard {
                     // Warn for every unreachable predicate. We store the fully parsed branch for rustfmt.
                     for (predicate, _, _) in &branches.unreachable {
@@ -44,14 +87,17 @@ pub(super) fn expand_cfg_select<'cx>(
                     }
                 }
 
-                if let Some((tts, arm_span)) = select_arm(ecx, branches) {
-                    return ExpandResult::from_tts(
+                if let Some((selected_tts, selected_span)) = branches.pop_first_match(|cfg| {
+                    matches!(attr::eval_config_entry(&ecx.sess, cfg), EvalConfigResult::True)
+                }) {
+                    let mac = CfgSelectResult {
                         ecx,
-                        tts,
-                        sp,
-                        arm_span,
-                        Ident::with_dummy_span(sym::cfg_select),
-                    );
+                        selected_tts,
+                        selected_span,
+                        other_branches: branches,
+                        site_span: sp,
+                    };
+                    return ExpandResult::Ready(Box::new(mac));
                 } else {
                     // Emit a compiler error when none of the predicates matched.
                     let guar = ecx.dcx().emit_err(CfgSelectNoMatches { span: sp });