Some fixes + WIP on tests

Author: aerooneqq

compiler/rustc_ast_lowering/src/delegation.rs

@@ -49,7 +49,7 @@ use rustc_hir::def_id::DefId;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{Asyncness, DelegationFnSigAttrs, ResolverAstLowering};
 use rustc_span::symbol::kw;
-use rustc_span::{Ident, Span, Symbol, sym};
+use rustc_span::{Ident, Span, Symbol};
 use {rustc_ast as ast, rustc_hir as hir};
 
 use super::{GenericArgsMode, ImplTraitContext, LoweringContext, ParamMode};
@@ -75,7 +75,7 @@ struct AttributeAdditionStatus {
 
 enum AttributeAdditionKind {
     Default,
-    Inherit { symbol: Symbol, flag: DelegationFnSigAttrs },
+    Inherit { flag: DelegationFnSigAttrs },
 }
 
 const PARENT_ID: hir::ItemLocalId = hir::ItemLocalId::ZERO;
@@ -84,10 +84,7 @@ static ATTRS_ADDITIONS: &'static [AttributeAdditionInfo; 2] = &[
     AttributeAdditionInfo {
         factory: |span| hir::Attribute::Parsed(AttributeKind::MustUse { span, reason: None }),
         equals: |a| matches!(a, hir::Attribute::Parsed(AttributeKind::MustUse { .. })),
-        kind: AttributeAdditionKind::Inherit {
-            symbol: sym::must_use,
-            flag: DelegationFnSigAttrs::MUST_USE,
-        },
+        kind: AttributeAdditionKind::Inherit { flag: DelegationFnSigAttrs::MUST_USE },
     },
     AttributeAdditionInfo {
         factory: |span| hir::Attribute::Parsed(AttributeKind::Inline(InlineAttr::Hint, span)),
@@ -191,11 +188,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 true => None,
                 false => match a.info.kind {
                     AttributeAdditionKind::Default => Some((a.info.factory)(span)),
-                    AttributeAdditionKind::Inherit { symbol, flag } => {
-                        // Check if an anttribute present on the target of delegation,
+                    AttributeAdditionKind::Inherit { flag } => {
+                        // Check if an attribute present on the target of delegation,
                         // either in this crate or others
                         let should_inherit = match sig_id.as_local() {
-                            None => self.tcx.get_attr(sig_id, symbol).is_some(),
+                            None => self
+                                .tcx
+                                .get_all_attrs(sig_id)
+                                .iter()
+                                .any(|base_attr| (a.info.equals)(base_attr)),
                             Some(local_id) => self
                                 .resolver
                                 .delegation_fn_sigs

tests/pretty/auxiliary/to-reuse-functions.rs

@@ -0,0 +1,12 @@
+//@ edition:2021
+
+#[must_use]
+pub unsafe fn unsafe_fn_extern() -> usize { 1 }
+
+#[must_use]
+pub extern "C" fn extern_fn_extern() -> usize { 1 }
+
+pub const fn const_fn_extern() -> usize { 1 }
+
+#[must_use]
+pub async fn async_fn_extern() { }

tests/pretty/delegation-inherit-attributes.pp

@@ -0,0 +1,39 @@
+//@ edition:2021
+//@ aux-crate:to_reuse_functions=to-reuse-functions.rs
+//@ pretty-mode:hir
+//@ pretty-compare-only
+//@ pp-exact:delegation-inherit-attributes.pp
+
+#![allow(incomplete_features)]
+#![feature(fn_delegation)]
+#[attr = MacroUse {arguments: UseAll}]
+extern crate std;
+#[prelude_import]
+use std::prelude::rust_2021::*;
+
+extern crate to_reuse_functions;
+
+mod to_reuse {
+    #[attr = MustUse]
+    fn foo(x: usize) -> usize { x }
+}
+
+#[attr = MustUse]
+#[attr = Inline(Hint)]
+fn bar(arg0: _) -> _ { to_reuse::foo(self + 1) }
+
+#[attr = MustUse]
+#[attr = Inline(Hint)]
+unsafe fn unsafe_fn_extern() -> _ { to_reuse_functions::unsafe_fn_extern() }
+#[attr = MustUse]
+#[attr = Inline(Hint)]
+extern "C" fn extern_fn_extern()
+    -> _ { to_reuse_functions::extern_fn_extern() }
+#[attr = Inline(Hint)]
+const fn const_fn_extern() -> _ { to_reuse_functions::const_fn_extern() }
+#[attr = MustUse]
+#[attr = Inline(Hint)]
+async fn async_fn_extern() -> _ { to_reuse_functions::async_fn_extern() }
+
+
+fn main() { }

tests/pretty/delegation-inherit-attributes.rs

@@ -0,0 +1,29 @@
+//@ edition:2021
+//@ aux-crate:to_reuse_functions=to-reuse-functions.rs
+//@ pretty-mode:hir
+//@ pretty-compare-only
+//@ pp-exact:delegation-inherit-attributes.pp
+
+#![allow(incomplete_features)]
+#![feature(fn_delegation)]
+
+extern crate to_reuse_functions;
+
+mod to_reuse {
+    #[must_use]
+    pub fn foo(x: usize) -> usize {
+        x
+    }
+}
+
+reuse to_reuse::foo as bar {
+    self + 1
+}
+
+reuse to_reuse_functions::unsafe_fn_extern;
+reuse to_reuse_functions::extern_fn_extern;
+reuse to_reuse_functions::const_fn_extern;
+reuse to_reuse_functions::async_fn_extern;
+
+
+fn main() {}