Merge pull request rust-lang#2 from mojave2/dev_stable

new_lint non_reentrant_functions

Author: surechen

CHANGELOG.md

@@ -4782,6 +4782,7 @@ Released 2018-09-13
 [`no_mangle_with_rust_abi`]: https://rust-lang.github.io/rust-clippy/master/index.html#no_mangle_with_rust_abi
 [`non_ascii_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_ascii_literal
 [`non_octal_unix_permissions`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_octal_unix_permissions
+[`non_reentrant_functions`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_reentrant_functions
 [`non_send_fields_in_send_ty`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_send_fields_in_send_ty
 [`nonminimal_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool
 [`nonsensical_open_options`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonsensical_open_options

clippy_lints/src/declared_lints.rs

@@ -471,6 +471,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::non_expressive_names::MANY_SINGLE_CHAR_NAMES_INFO,
     crate::non_expressive_names::SIMILAR_NAMES_INFO,
     crate::non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS_INFO,
+    crate::non_reentrant_functions::NON_REENTRANT_FUNCTIONS_INFO,
     crate::non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY_INFO,
     crate::nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES_INFO,
     crate::octal_escapes::OCTAL_ESCAPES_INFO,

clippy_lints/src/lib.rs

@@ -232,6 +232,7 @@ mod no_mangle_with_rust_abi;
 mod non_copy_const;
 mod non_expressive_names;
 mod non_octal_unix_permissions;
+mod non_reentrant_functions;
 mod non_send_fields_in_send_ty;
 mod nonstandard_macro_braces;
 mod octal_escapes;
@@ -966,6 +967,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move |_| Box::new(guidelines::GuidelineLints::new(mem_unsafe_functions.clone())));
     store.register_late_pass(|_| Box::new(unsafe_block_in_proc_macro::UnsafeBlockInProcMacro::new()));
     store.register_early_pass(|| Box::new(implicit_abi::ImplicitAbi));
+    store.register_early_pass(|| Box::new(non_reentrant_functions::NonReentrantFunctions));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 

clippy_lints/src/non_reentrant_functions.rs

@@ -0,0 +1,56 @@
+use clippy_utils::diagnostics::span_lint;
+use rustc_ast::ast::{Expr, ExprKind, Path};
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for non-reentrant functions.
+    ///
+    /// ### Why is this bad?
+    /// This makes code safer, especially in the context of concurrency.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let _tm = libc::localtime(&0i64 as *const libc::time_t);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let res = libc::malloc(std::mem::size_of::<libc::tm>());
+    ///
+    /// libc::locatime_r(&0i64 as *const libc::time_t, res);
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub NON_REENTRANT_FUNCTIONS,
+    nursery,
+    "this function is a non-reentrant-function"
+}
+declare_lint_pass!(NonReentrantFunctions => [NON_REENTRANT_FUNCTIONS]);
+
+impl EarlyLintPass for NonReentrantFunctions {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        let msg: &str = "consider using the reentrant version of the function";
+
+        if let ExprKind::Call(func, _) = &expr.kind {
+            if is_reentrant_fn(func) {
+                span_lint(cx, NON_REENTRANT_FUNCTIONS, expr.span, msg);
+            }
+        }
+    }
+}
+
+fn is_reentrant_fn(func: &Expr) -> bool {
+    match &func.kind {
+        ExprKind::Path(_, Path { segments, .. }) => {
+            if segments.len() != 2 || segments[0].ident.name != rustc_span::sym::libc {
+                return false;
+            }
+            matches!(segments[1].ident.as_str(), "strtok" | "localtime")
+        },
+        _ => false,
+    }
+}

tests/ui/non_reentrant_functions.rs

@@ -0,0 +1,38 @@
+#![warn(clippy::non_reentrant_functions)]
+#![allow(unused)]
+#![feature(rustc_private)]
+extern crate libc;
+
+use std::ffi::{CStr, CString};
+
+fn test_libc_localtime() {
+    // test code goes here
+    unsafe {
+        let _tm = libc::localtime(&0i64 as *const libc::time_t);
+    }
+}
+
+fn test_libc_strtok() {
+    let string = CString::new("welcome-to-rust").unwrap();
+    let string = string.as_ptr() as *mut libc::c_char;
+    let delim = CString::new(" - ").unwrap();
+    let delim = delim.as_ptr();
+
+    let mut token = unsafe { libc::strtok(string, delim) };
+    while !token.is_null() {
+        println!("{:?}", unsafe { CStr::from_ptr(token) });
+        token = unsafe { libc::strtok(std::ptr::null_mut(), delim) };
+    }
+}
+
+fn test_locatime() {
+    fn localtime() {}
+    localtime();
+}
+
+fn test_strtok() {
+    fn strtok() {}
+    strtok();
+}
+
+fn main() {}

tests/ui/non_reentrant_functions.stderr

@@ -0,0 +1,22 @@
+error: consider using the reentrant version of the function
+  --> $DIR/non_reentrant_functions.rs:11:19
+   |
+LL |         let _tm = libc::localtime(&0i64 as *const libc::time_t);
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::non-reentrant-functions` implied by `-D warnings`
+
+error: consider using the reentrant version of the function
+  --> $DIR/non_reentrant_functions.rs:21:30
+   |
+LL |     let mut token = unsafe { libc::strtok(string, delim) };
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: consider using the reentrant version of the function
+  --> $DIR/non_reentrant_functions.rs:24:26
+   |
+LL |         token = unsafe { libc::strtok(std::ptr::null_mut(), delim) };
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+