Auto merge of #159344 - Urgau:canonical-symbols, r=mejrs

Replace weak only lang items with a custom attribute



When I added the `invalid_runtime_symbol_definitions` and `suspicious_runtime_symbol_definitions` lints in #155521 I added the concept of "weak only" lang item.

It's a `LangItem` that has no implementation, this is useful because the `core` symbols where not directly called, they were inserted by the compiler.

This mechanism work well, but T-lang [approved](#158522 (comment)) the extension to "all extern functions referenced by the standard library", which makes the lang item approach impractical as we needs to update 5 files just to declare them. I'm not sure we can ask library contributor to do the dance for each `extern "C"` functions.

But the most problematic thing is that many extern functions in `std` come from `libc` not `std`, and adding lang items there is just no feasible I think.

Instead this PR proposed that we introduce a proper mechanism for them by adding a attribute `#[rustc_canonical_symbol = "..."]`, which is encoded and decoded in `rmeta` like lang items and diagnostics items.

This simplifies the declaration as we only need to put the attribute to be effective `#[rustc_canonical_symbol = "open"]`. It also opens up many possibilities (none implemented here) like putting them on `use` statements (so we don't need to modify `libc`) or having the attribute be placed on a module. The table may also be useful on it's own if we want someday to do it for all crates, not just the standard library.

Follow up to #155521 and #158522

Author: bors

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -582,7 +582,7 @@ impl SingleAttributeParser for LangParser {
         // Only weak lang items may be applied to foreign items
         if [Target::ForeignFn, Target::ForeignStatic, Target::ForeignTy, Target::ForeignMod]
             .contains(&cx.target)
-            && !(lang_item.is_weak() || lang_item.is_weak_only())
+            && !lang_item.is_weak()
         {
             cx.emit_err(UnknownExternLangItem { span: cx.attr_span, lang_item: lang_item.name() });
             return None;
@@ -1145,3 +1145,18 @@ impl NoArgsAttributeParser for RustcExhaustiveParser {
     const STABILITY: AttributeStability = unstable!(rustc_attrs);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::RustcMustMatchExhaustively;
 }
+
+pub(crate) struct RustcCanonicalSymbolParser;
+
+impl NoArgsAttributeParser for RustcCanonicalSymbolParser {
+    const PATH: &[Symbol] = &[sym::rustc_canonical_symbol];
+    const ALLOWED_TARGETS: AllowedTargets<'_> =
+        AllowedTargets::AllowList(&[Allow(Target::ForeignFn)]);
+    const STABILITY: AttributeStability = unstable!(
+        rustc_attrs,
+        "the `#[rustc_canonical_symbol]` attribute registers a function's symbol to be linted against \
+        by the `invalid_runtime_symbol_definitions` and `suspicious_runtime_symbol_definitions` \
+        lints"
+    );
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcCanonicalSymbol;
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -275,6 +275,7 @@ attribute_parsers!(
         Single<WithoutArgs<RustcAllocatorZeroedParser>>,
         Single<WithoutArgs<RustcAllowIncoherentImplParser>>,
         Single<WithoutArgs<RustcAsPtrParser>>,
+        Single<WithoutArgs<RustcCanonicalSymbolParser>>,
         Single<WithoutArgs<RustcCaptureAnalysisParser>>,
         Single<WithoutArgs<RustcCoherenceIsCoreParser>>,
         Single<WithoutArgs<RustcCoinductiveParser>>,

compiler/rustc_feature/src/builtin_attrs.rs

@@ -354,6 +354,7 @@ pub static BUILTIN_ATTRIBUTES: &[Symbol] = &[
     sym::rustc_has_incoherent_inherent_impls,
     sym::rustc_non_const_trait_method,
 
+    sym::rustc_canonical_symbol,
     sym::rustc_diagnostic_item,
     sym::prelude_import,
     sym::rustc_paren_sugar,

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -1372,6 +1372,10 @@ pub enum AttributeKind {
         builtin_name: Option<Symbol>,
         helper_attrs: ThinVec<Symbol>,
     },
+
+    /// Represents `#[rustc_canonical_symbol]`
+    RustcCanonicalSymbol,
+
     /// Represents `#[rustc_capture_analysis]`
     RustcCaptureAnalysis,
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -110,6 +110,7 @@ impl AttributeKind {
             RustcAutodiff(..) => Yes,
             RustcBodyStability { .. } => No,
             RustcBuiltinMacro { .. } => Yes,
+            RustcCanonicalSymbol => No,
             RustcCaptureAnalysis => No,
             RustcCguTestAttr { .. } => No,
             RustcClean { .. } => No,

compiler/rustc_hir/src/canonical_symbols.rs

@@ -0,0 +1,41 @@
+use rustc_data_structures::fx::FxIndexMap;
+use rustc_macros::{Encodable, StableHash};
+use rustc_span::Symbol;
+use rustc_span::def_id::DefId;
+
+/// A representation of a canonical symbol
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Encodable, StableHash)]
+pub struct CanonicalSymbol {
+    pub def_id: DefId,
+    pub symbol: Symbol,
+}
+
+#[derive(StableHash, Debug)]
+pub struct CanonicalSymbols {
+    symbols: FxIndexMap<Symbol, CanonicalSymbol>,
+}
+
+impl CanonicalSymbols {
+    /// Construct an empty collection of canonical symbols
+    pub fn new() -> Self {
+        Self { symbols: FxIndexMap::default() }
+    }
+
+    pub fn get(&self, symbol: Symbol) -> Option<CanonicalSymbol> {
+        self.symbols.get(&symbol).copied()
+    }
+
+    pub fn set(&mut self, symbol: Symbol, def_id: DefId) -> Option<DefId> {
+        let preexisting = self.symbols.insert(symbol, CanonicalSymbol { def_id, symbol });
+
+        if let Some(preexisting) = preexisting {
+            (preexisting.def_id != def_id).then_some(preexisting.def_id)
+        } else {
+            None
+        }
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = CanonicalSymbol> {
+        self.symbols.values().copied()
+    }
+}

compiler/rustc_hir/src/lang_items.rs

@@ -453,22 +453,6 @@ language_item_table! {
 
     // Used to fallback `{float}` to `f32` when `f32: From<{float}>`
     From,                    sym::From,                from_trait,                 Target::Trait,          GenericRequirement::Exact(1);
-
-    // Runtime symbols
-    MemCpy,                  sym::memcpy_fn,           memcpy_fn,                  Target::ForeignFn,             GenericRequirement::None;
-    MemMove,                 sym::memmove_fn,          memmove_fn,                 Target::ForeignFn,             GenericRequirement::None;
-    MemSet,                  sym::memset_fn,           memset_fn,                  Target::ForeignFn,             GenericRequirement::None;
-    MemCmp,                  sym::memcmp_fn,           memcmp_fn,                  Target::ForeignFn,             GenericRequirement::None;
-    Bcmp,                    sym::bcmp_fn,             bcmp_fn,                    Target::ForeignFn,             GenericRequirement::None;
-    StrLen,                  sym::strlen_fn,           strlen_fn,                  Target::ForeignFn,             GenericRequirement::None;
-    Open,                    sym::open_fn,             open_fn,                    Target::ForeignFn,             GenericRequirement::None;
-    Read,                    sym::read_fn,             read_fn,                    Target::ForeignFn,             GenericRequirement::None;
-    Write,                   sym::write_fn,            write_fn,                   Target::ForeignFn,             GenericRequirement::None;
-    Close,                   sym::close_fn,            close_fn,                   Target::ForeignFn,             GenericRequirement::None;
-    Malloc,                  sym::malloc_fn,           malloc_fn,                  Target::ForeignFn,             GenericRequirement::None;
-    Realloc,                 sym::realloc_fn,          realloc_fn,                 Target::ForeignFn,             GenericRequirement::None;
-    Free,                    sym::free_fn,             free_fn,                    Target::ForeignFn,             GenericRequirement::None;
-    Exit,                    sym::exit_fn,             exit_fn,                    Target::ForeignFn,             GenericRequirement::None;
 }
 
 /// The requirement imposed on the generics of a lang item

compiler/rustc_hir/src/lib.rs

@@ -19,6 +19,7 @@ extern crate self as rustc_hir;
 
 mod arena;
 pub mod attrs;
+pub mod canonical_symbols;
 pub mod def;
 pub mod def_path_hash_map;
 pub mod definitions;
@@ -39,6 +40,7 @@ pub mod weak_lang_items;
 #[cfg(test)]
 mod tests;
 
+pub use canonical_symbols::{CanonicalSymbol, CanonicalSymbols};
 #[doc(no_inline)]
 pub use hir::*;
 pub use lang_items::{LangItem, LanguageItems};

compiler/rustc_hir/src/weak_lang_items.rs

@@ -23,34 +23,7 @@ macro_rules! weak_lang_items {
     }
 }
 
-macro_rules! weak_only_lang_items {
-    ($($item:ident,)*) => {
-        impl LangItem {
-            pub fn is_weak_only(self) -> bool {
-                matches!(self, $(LangItem::$item)|*)
-            }
-        }
-    }
-}
-
 weak_lang_items! {
     PanicImpl,          rust_begin_unwind;
     EhPersonality,      rust_eh_personality;
 }
-
-weak_only_lang_items! {
-    MemCpy,
-    MemMove,
-    MemSet,
-    MemCmp,
-    Bcmp,
-    StrLen,
-    Open,
-    Read,
-    Write,
-    Close,
-    Malloc,
-    Realloc,
-    Free,
-    Exit,
-}

compiler/rustc_interface/src/passes.rs

@@ -1244,6 +1244,11 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) {
         // diagnostic item. If the crate compiles without checking any diagnostic items,
         // we will fail to emit overlap diagnostics. Thus we invoke it here unconditionally.
         let _ = tcx.all_diagnostic_items(());
+
+        // This query is only invoked normally if a diagnostic is emitted that needs any
+        // canonical symbol. If the crate compiles without checking any runtime symbols,
+        // we will fail to emit overlap diagnostics. Thus we invoke it here unconditionally.
+        let _ = tcx.all_canonical_symbols(());
     });
 
     // If `-Zvalidate-mir` is set, we also want to compute the final MIR for each item