new lint null_pointer_optimization

Author: Centri3

CHANGELOG.md

@@ -5120,6 +5120,7 @@ Released 2018-09-13
 [`nonsensical_open_options`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonsensical_open_options
 [`nonstandard_macro_braces`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonstandard_macro_braces
 [`not_unsafe_ptr_arg_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#not_unsafe_ptr_arg_deref
+[`null_pointer_optimization`]: https://rust-lang.github.io/rust-clippy/master/index.html#null_pointer_optimization
 [`obfuscated_if_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#obfuscated_if_else
 [`octal_escapes`]: https://rust-lang.github.io/rust-clippy/master/index.html#octal_escapes
 [`ok_expect`]: https://rust-lang.github.io/rust-clippy/master/index.html#ok_expect

clippy_lints/src/declared_lints.rs

@@ -501,6 +501,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS_INFO,
     crate::non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY_INFO,
     crate::nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES_INFO,
+    crate::null_pointer_optimization::NULL_POINTER_OPTIMIZATION_INFO,
     crate::octal_escapes::OCTAL_ESCAPES_INFO,
     crate::only_used_in_recursion::ONLY_USED_IN_RECURSION_INFO,
     crate::operators::ABSURD_EXTREME_COMPARISONS_INFO,

clippy_lints/src/lib.rs

@@ -246,6 +246,7 @@ mod non_expressive_names;
 mod non_octal_unix_permissions;
 mod non_send_fields_in_send_ty;
 mod nonstandard_macro_braces;
+mod null_pointer_optimization;
 mod octal_escapes;
 mod only_used_in_recursion;
 mod operators;
@@ -1070,6 +1071,9 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         Box::new(single_call_fn::SingleCallFn {
             avoid_breaking_exported_api,
             def_id_to_usage: rustc_data_structures::fx::FxHashMap::default(),
+    store.register_late_pass(move |_| {
+        Box::new(null_pointer_optimization::NullPointerOptimization {
+            avoid_breaking_exported_api,
         })
     });
     let needless_raw_string_hashes_allow_one = conf.allow_one_hash_in_raw_strings;

clippy_lints/src/null_pointer_optimization.rs

@@ -0,0 +1,70 @@
+use clippy_utils::{diagnostics::span_lint_and_help, is_lang_item_or_ctor, last_path_segment, match_def_path, paths};
+use rustc_hir::{
+    def::{DefKind, Res},
+    GenericArg, LangItem, Ty, TyKind,
+};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `T<Option<U>>` where `T` is a type that has
+    /// [null pointer optimization](https://doc.rust-lang.org/core/option/#representation).
+    ///
+    /// ### Why is this bad?
+    /// It's slower, as `Option` can use `null` as `None`, instead of adding another layer of
+    /// indirection.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct MyWrapperType<T>(Box<Option<T>>);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct MyWrapperType<T>(Option<Box<T>>);
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub NULL_POINTER_OPTIMIZATION,
+    perf,
+    "checks for `U<Option<T>>` where `U` is a type that has null pointer optimization"
+}
+impl_lint_pass!(NullPointerOptimization => [NULL_POINTER_OPTIMIZATION]);
+
+#[derive(Clone, Copy)]
+pub struct NullPointerOptimization {
+    pub avoid_breaking_exported_api: bool,
+}
+
+impl LateLintPass<'_> for NullPointerOptimization {
+    fn check_ty(&mut self, cx: &LateContext<'_>, ty: &Ty<'_>) {
+        if let TyKind::Path(qpath) = ty.kind
+            && let res = cx.qpath_res(&qpath, ty.hir_id)
+            && let Res::Def(DefKind::Struct, def_id) = res
+        {
+            if !(is_lang_item_or_ctor(cx, def_id, LangItem::OwnedBox)
+                || match_def_path(cx, def_id, &paths::PTR_NON_NULL))
+            {
+                return;
+            }
+
+            if let Some(args) = last_path_segment(&qpath).args
+                && let GenericArg::Type(option_ty) = args.args[0]
+                && let TyKind::Path(option_qpath) = option_ty.kind
+                && let res = cx.qpath_res(&option_qpath, option_ty.hir_id)
+                && let Res::Def(.., def_id) = res
+                && is_lang_item_or_ctor(cx, def_id, LangItem::Option)
+            {
+                let outer_ty = last_path_segment(&qpath).ident.name;
+                span_lint_and_help(
+                    cx,
+                    NULL_POINTER_OPTIMIZATION,
+                    ty.span,
+                    &format!("usage of `{outer_ty}<Option<T>>`"),
+                    None,
+                    &format!("consider using `Option<{outer_ty}<T>>` instead, as it will grant better performance. For more information, see\n\
+                                https://doc.rust-lang.org/core/option/#representation"),
+                );
+            }
+        }
+    }
+}

tests/ui/null_pointer_optimization.rs

@@ -0,0 +1,34 @@
+#![allow(clippy::boxed_local, unused)]
+#![warn(clippy::null_pointer_optimization)]
+#![no_main]
+
+use std::ptr::NonNull;
+
+type A<T> = Box<Option<T>>;
+
+fn a<T>(a: Box<Option<T>>) {}
+
+// lint at `type A<T>`, but not here.
+fn a_ty_alias<T>(a: A<T>) {}
+
+fn b(b: String) {}
+
+fn c<T>(c: NonNull<Option<T>>) {}
+
+fn g<T>(e: Option<Box<Option<T>>>) {}
+
+struct H<T>(Box<Option<T>>);
+
+enum I<T> {
+    J(Box<Option<T>>),
+}
+
+// do not lint
+
+struct D<T>(Option<T>);
+
+fn d<T>(d: D<T>) {}
+
+fn e<T>(e: Option<NonNull<T>>) {}
+
+fn f<T>(e: Option<Box<T>>) {}

tests/ui/null_pointer_optimization.stderr

@@ -0,0 +1,57 @@
+error: usage of `Box<Option<T>>`
+  --> $DIR/null_pointer_optimization.rs:7:13
+   |
+LL | type A<T> = Box<Option<T>>;
+   |             ^^^^^^^^^^^^^^
+   |
+   = help: consider using `Option<Box<T>>` instead, as it will grant better performance. For more information, see
+           https://doc.rust-lang.org/core/option/#representation
+   = note: `-D clippy::null-pointer-optimization` implied by `-D warnings`
+
+error: usage of `Box<Option<T>>`
+  --> $DIR/null_pointer_optimization.rs:9:12
+   |
+LL | fn a<T>(a: Box<Option<T>>) {}
+   |            ^^^^^^^^^^^^^^
+   |
+   = help: consider using `Option<Box<T>>` instead, as it will grant better performance. For more information, see
+           https://doc.rust-lang.org/core/option/#representation
+
+error: usage of `NonNull<Option<T>>`
+  --> $DIR/null_pointer_optimization.rs:16:12
+   |
+LL | fn c<T>(c: NonNull<Option<T>>) {}
+   |            ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using `Option<NonNull<T>>` instead, as it will grant better performance. For more information, see
+           https://doc.rust-lang.org/core/option/#representation
+
+error: usage of `Box<Option<T>>`
+  --> $DIR/null_pointer_optimization.rs:18:19
+   |
+LL | fn g<T>(e: Option<Box<Option<T>>>) {}
+   |                   ^^^^^^^^^^^^^^
+   |
+   = help: consider using `Option<Box<T>>` instead, as it will grant better performance. For more information, see
+           https://doc.rust-lang.org/core/option/#representation
+
+error: usage of `Box<Option<T>>`
+  --> $DIR/null_pointer_optimization.rs:20:13
+   |
+LL | struct H<T>(Box<Option<T>>);
+   |             ^^^^^^^^^^^^^^
+   |
+   = help: consider using `Option<Box<T>>` instead, as it will grant better performance. For more information, see
+           https://doc.rust-lang.org/core/option/#representation
+
+error: usage of `Box<Option<T>>`
+  --> $DIR/null_pointer_optimization.rs:23:7
+   |
+LL |     J(Box<Option<T>>),
+   |       ^^^^^^^^^^^^^^
+   |
+   = help: consider using `Option<Box<T>>` instead, as it will grant better performance. For more information, see
+           https://doc.rust-lang.org/core/option/#representation
+
+error: aborting due to 6 previous errors
+