Rename lint to redefining_runtime_symbols

Author: Urgau

compiler/rustc_lint/messages.ftl

@@ -195,10 +195,10 @@ lint_cfg_attr_no_attributes =
 
 lint_check_name_unknown_tool = unknown lint tool: `{$tool_name}`
 
-lint_clashing_function_names_with_fundamental_functions = this function symbol name `{$symbol_name}` clashes with the fundamental functions expected with `core` and `std`
-    .match_exactly = extra care must be taken when exposing a function with those symbol names, they must match exactly (ABI, function arguments, function return type, behavior, ...)
+lint_redefining_runtime_symbols = redefinition of the runtime `{$symbol_name}` symbol used by the standard library
+    .match_exactly = extra care must be taken when redefining those symbols, they must match exactly (ABI, function arguments, function return type, behavior, ...)
     .learn_more = see <https://doc.rust-lang.org/core/index.html#how-to-use-the-core-library> for the more details
-    .help = either allow this lint or remove any `#[unsafe(no_mangle)]` or `#[unsafe(export_name = "{$symbol_name}")]` if present
+    .help = either allow this lint or remove any `#[unsafe(no_mangle)]` or `#[unsafe(export_name = "{$symbol_name}")]`
 
 lint_closure_returning_async_block = closure returning async block can be made into an async closure
     .label = this async block can be removed, and the closure can be turned into an async closure

compiler/rustc_lint/src/fundamental_functions.rs

@@ -48,7 +48,6 @@ mod errors;
 mod expect;
 mod for_loops_over_fallibles;
 mod foreign_modules;
-mod fundamental_functions;
 mod if_let_rescope;
 mod impl_trait_overcaptures;
 mod internal;
@@ -71,6 +70,7 @@ mod pass_by_value;
 mod passes;
 mod precedence;
 mod ptr_nulls;
+mod redefining_runtime_symbols;
 mod redundant_semicolon;
 mod reference_casting;
 mod shadowed_into_iter;
@@ -93,7 +93,6 @@ use deref_into_dyn_supertrait::*;
 use drop_forget_useless::*;
 use enum_intrinsics_non_enums::EnumIntrinsicsNonEnums;
 use for_loops_over_fallibles::*;
-use fundamental_functions::*;
 use if_let_rescope::IfLetRescope;
 use impl_trait_overcaptures::ImplTraitOvercaptures;
 use internal::*;
@@ -112,6 +111,7 @@ use opaque_hidden_inferred_bound::*;
 use pass_by_value::*;
 use precedence::*;
 use ptr_nulls::*;
+use redefining_runtime_symbols::*;
 use redundant_semicolon::*;
 use reference_casting::*;
 use rustc_hir::def_id::LocalModDefId;
@@ -242,7 +242,7 @@ late_lint_methods!(
             AsyncClosureUsage: AsyncClosureUsage,
             AsyncFnInTrait: AsyncFnInTrait,
             NonLocalDefinitions: NonLocalDefinitions::default(),
-            FundamentalFunctions: FundamentalFunctions,
+            RedefiningRuntimeSymbols: RedefiningRuntimeSymbols,
             ImplTraitOvercaptures: ImplTraitOvercaptures,
             IfLetRescope: IfLetRescope::default(),
             StaticMutRefs: StaticMutRefs,

compiler/rustc_lint/src/lib.rs

@@ -705,13 +705,13 @@ pub(crate) enum UseLetUnderscoreIgnoreSuggestion {
     },
 }
 
-// fundamental_functions.rs
+// redefining_runtime_symbols.rs
 #[derive(LintDiagnostic)]
-#[diag(lint_clashing_function_names_with_fundamental_functions)]
+#[diag(lint_redefining_runtime_symbols)]
 #[note(lint_match_exactly)]
 #[note(lint_learn_more)]
 #[help]
-pub(crate) struct ClashingFunctionNamesWithFundamentalFunctions {
+pub(crate) struct RedefiningRuntimeSymbolsDiag {
     pub symbol_name: String,
 }
 

compiler/rustc_lint/src/lints.rs

@@ -0,0 +1,72 @@
+use rustc_hir as hir;
+use rustc_session::{declare_lint, declare_lint_pass};
+
+use crate::lints::RedefiningRuntimeSymbolsDiag;
+use crate::{LateContext, LateLintPass, LintContext};
+
+declare_lint! {
+    /// The `redefining_runtime_symbols` lint checks for items whose symbol name redefines
+    /// a runtime symbols expected by `core` and/or `std`.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,compile_fail
+    /// #![deny(redefining_runtime_symbols)]
+    ///
+    /// #[unsafe(no_mangle)]
+    /// pub fn strlen() {} // redefines the libc `strlen` function
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// Up-most care is required when redefining runtime symbols assumed and
+    /// used by the standard library. They must follow the C specification, not use any
+    /// standard-library facility or undefined behavior may occur.
+    ///
+    /// The symbols currently checked are respectively:
+    ///  - from `core`[^1]: `memcpy`, `memmove`, `memset`, `memcmp`, `bcmp`, `strlen`
+    ///  - from `std`: `read`, `write`, `open`, `close`
+    ///
+    /// [^1]: https://doc.rust-lang.org/core/index.html#how-to-use-the-core-library
+    pub REDEFINING_RUNTIME_SYMBOLS,
+    Warn,
+    "redefining a symbol used by the standard library"
+}
+
+declare_lint_pass!(RedefiningRuntimeSymbols => [REDEFINING_RUNTIME_SYMBOLS]);
+
+static CORE_RUNTIME_SYMBOLS: &[&str] = &["memcpy", "memmove", "memset", "memcmp", "bcmp", "strlen"];
+
+static STD_RUNTIME_SYMBOLS: &[&str] = &["open", "read", "write", "close"];
+
+impl<'tcx> LateLintPass<'tcx> for RedefiningRuntimeSymbols {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
+        // Bail-out if the item is not a function/method or static.
+        match item.kind {
+            hir::ItemKind::Fn { sig: _, ident: _, generics: _, body: _, has_body: true }
+            | hir::ItemKind::Static(..) => {}
+            _ => return,
+        }
+
+        // Compute the symbol name of our item (without mangling, as our mangling cannot ever
+        // conflict with runtime symbols).
+        let Some(symbol_name) = rustc_symbol_mangling::symbol_name_without_mangling(
+            cx.tcx,
+            rustc_middle::ty::InstanceKind::Item(item.owner_id.to_def_id()),
+        ) else {
+            return;
+        };
+
+        if CORE_RUNTIME_SYMBOLS.contains(&&*symbol_name)
+            || STD_RUNTIME_SYMBOLS.contains(&&*symbol_name)
+        {
+            cx.emit_span_lint(
+                REDEFINING_RUNTIME_SYMBOLS,
+                item.span,
+                RedefiningRuntimeSymbolsDiag { symbol_name },
+            );
+        }
+    }
+}

compiler/rustc_lint/src/redefining_runtime_symbols.rs

@@ -11,45 +11,45 @@ pub extern "C" fn memcpy(
     src: *const c_void,
     n: i64,
 ) -> *mut c_void { std::ptr::null_mut() }
-//~^^^^^ WARN `memcpy` clashes
+//~^^^^^ WARN redefinition of the runtime `memcpy` symbol
 
 #[no_mangle]
 pub fn memmove() {}
-//~^ WARN `memmove` clashes
+//~^ WARN redefinition of the runtime `memmove` symbol
 
 #[no_mangle]
 pub fn memset() {}
-//~^ WARN `memset` clashes
+//~^ WARN redefinition of the runtime `memset` symbol
 
 #[no_mangle]
 pub fn memcmp() {}
-//~^ WARN `memcmp` clashes
+//~^ WARN redefinition of the runtime `memcmp` symbol
 
 #[export_name = "bcmp"]
 pub fn bcmp_() {}
-//~^ WARN `bcmp` clashes
+//~^ WARN redefinition of the runtime `bcmp` symbol
 
 #[no_mangle]
-pub fn strlen() {}
-//~^ WARN `strlen` clashes
+pub static strlen: () = ();
+//~^ WARN redefinition of the runtime `strlen` symbol
 
 // From std
 
 #[no_mangle]
 pub fn open() {}
-//~^ WARN `open` clashes
+//~^ WARN redefinition of the runtime `open` symbol
 
 #[export_name = "read"]
 pub async fn read1() {}
-//~^ WARN `read` clashes
+//~^ WARN redefinition of the runtime `read` symbol
 
 #[export_name = "write"]
 pub fn write1() {}
-//~^ WARN `write` clashes
+//~^ WARN redefinition of the runtime `write` symbol
 
 #[export_name = "close"]
 pub fn close_() {}
-//~^ WARN `close` clashes
+//~^ WARN redefinition of the runtime `close` symbol
 
 extern "C" {
     // No warning, not a body.