Sam's dev merge

Author: samueltardieu

.gitignore

@@ -46,6 +46,9 @@ helper.txt
 .vscode
 .idea
 
+# Emacs
+.dir-locals.el
+
 # mdbook generated output
 /book/book
 

CHANGELOG.md

@@ -6789,6 +6789,7 @@ Released 2018-09-13
 [`mut_mut`]: https://rust-lang.github.io/rust-clippy/master/index.html#mut_mut
 [`mut_mutex_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#mut_mutex_lock
 [`mut_range_bound`]: https://rust-lang.github.io/rust-clippy/master/index.html#mut_range_bound
+[`mutable_borrow_of_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#mutable_borrow_of_copy
 [`mutable_key_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#mutable_key_type
 [`mutex_atomic`]: https://rust-lang.github.io/rust-clippy/master/index.html#mutex_atomic
 [`mutex_integer`]: https://rust-lang.github.io/rust-clippy/master/index.html#mutex_integer
@@ -6881,6 +6882,7 @@ Released 2018-09-13
 [`panic_params`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic_params
 [`panicking_overflow_checks`]: https://rust-lang.github.io/rust-clippy/master/index.html#panicking_overflow_checks
 [`panicking_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#panicking_unwrap
+[`parsed_string_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#parsed_string_literals
 [`partial_pub_fields`]: https://rust-lang.github.io/rust-clippy/master/index.html#partial_pub_fields
 [`partialeq_ne_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#partialeq_ne_impl
 [`partialeq_to_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#partialeq_to_none
@@ -7103,6 +7105,7 @@ Released 2018-09-13
 [`uninit_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#uninit_vec
 [`uninlined_format_args`]: https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
 [`unit_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg
+[`unit_as_impl_trait`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_as_impl_trait
 [`unit_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_cmp
 [`unit_hash`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_hash
 [`unit_return_expecting_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_return_expecting_ord
@@ -7249,6 +7252,7 @@ Released 2018-09-13
 [`cargo-ignore-publish`]: https://doc.rust-lang.org/clippy/lint_configuration.html#cargo-ignore-publish
 [`check-incompatible-msrv-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-incompatible-msrv-in-tests
 [`check-inconsistent-struct-field-initializers`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-inconsistent-struct-field-initializers
+[`check-mutable-borrow-of-copy-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-mutable-borrow-of-copy-in-tests
 [`check-private-items`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-private-items
 [`cognitive-complexity-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#cognitive-complexity-threshold
 [`const-literal-digits-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#const-literal-digits-threshold

book/src/lint_configuration.md

@@ -472,6 +472,16 @@ fn main() {
 * [`inconsistent_struct_constructor`](https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_struct_constructor)
 
 
+## `check-mutable-borrow-of-copy-in-tests`
+Whether to search for mutable borrows of freshly copied data in tests.
+
+**Default Value:** `true`
+
+---
+**Affected lints:**
+* [`mutable_borrow_of_copy`](https://rust-lang.github.io/rust-clippy/master/index.html#mutable_borrow_of_copy)
+
+
 ## `check-private-items`
 Whether to also run the listed lints on private items.
 

clippy_config/src/conf.rs

@@ -567,6 +567,9 @@ define_Conf! {
     /// [from rust-clippy#11846]: https://github.com/rust-lang/rust-clippy/issues/11846#issuecomment-1820747924
     #[lints(inconsistent_struct_constructor)]
     check_inconsistent_struct_field_initializers: bool = false,
+    /// Whether to search for mutable borrows of freshly copied data in tests.
+    #[lints(mutable_borrow_of_copy)]
+    check_mutable_borrow_of_copy_in_tests: bool = true,
     /// Whether to also run the listed lints on private items.
     #[lints(missing_errors_doc, missing_panics_doc, missing_safety_doc, unnecessary_safety_doc)]
     check_private_items: bool = false,

clippy_dev/src/main.rs

@@ -39,6 +39,13 @@ fn main() {
             Err(e) => eprintln!("Unable to create lint: {e}"),
         },
         DevCommand::Setup(SetupCommand { subcommand }) => match subcommand {
+            SetupSubcommand::Emacs { remove, force_override } => {
+                if remove {
+                    setup::emacs::remove_dir_locals();
+                } else {
+                    setup::emacs::setup_dir_locals(force_override);
+                }
+            },
             SetupSubcommand::Intellij { remove, repo_path } => {
                 if remove {
                     setup::intellij::remove_rustc_src();
@@ -68,6 +75,7 @@ fn main() {
             },
         },
         DevCommand::Remove(RemoveCommand { subcommand }) => match subcommand {
+            RemoveSubcommand::Emacs => setup::emacs::remove_dir_locals(),
             RemoveSubcommand::Intellij => setup::intellij::remove_rustc_src(),
             RemoveSubcommand::GitHook => setup::git_hook::remove_hook(),
             RemoveSubcommand::VscodeTasks => setup::vscode::remove_tasks(),
@@ -272,6 +280,15 @@ struct SetupCommand {
 
 #[derive(Subcommand)]
 enum SetupSubcommand {
+    /// Add a `.dir-locals.el` so that Emacs can use `rustic-mode` and `eglot`
+    Emacs {
+        #[arg(long)]
+        /// Remove the `.dir-locals.el` file created by `cargo dev setup emacs`
+        remove: bool,
+        #[arg(long, short)]
+        /// Forces the override of an existing git pre-commit hook
+        force_override: bool,
+    },
     /// Alter dependencies so Intellij Rust can find rustc internals
     Intellij {
         #[arg(long)]
@@ -332,6 +349,8 @@ struct RemoveCommand {
 
 #[derive(Subcommand)]
 enum RemoveSubcommand {
+    /// Remove the `.dir-locals.el` file created by `cargo dev setup emacs`
+    Emacs,
     /// Remove the dependencies added with 'cargo dev setup intellij'
     Intellij,
     /// Remove the pre-commit git hook

clippy_dev/src/setup/emacs.rs

@@ -0,0 +1,30 @@
+const DIR_LOCALS_EL: &str = ".dir-locals.el";
+const DIR_LOCALS: &str = r#";; Emacs configuration
+((nil . ((eglot-workspace-configuration .
+           (:rust-analyzer
+            (:rustc
+             (:source "discover" :linkedProjects ["./Cargo.toml" "clippy_dev/Cargo.toml" "lintcheck/Cargo.toml"])
+             :cargo
+             (:features ["internal"]))))))
+ ("tests/ui" . ((auto-mode-alist ("\\.fixed\\'" . rustic-mode)))))
+"#;
+
+pub fn setup_dir_locals(force_override: bool) {
+    if !force_override && matches!(std::fs::exists(DIR_LOCALS_EL), Ok(true)) {
+        eprintln!("error: `{DIR_LOCALS_EL}` already exists");
+        return;
+    }
+    if std::fs::write(DIR_LOCALS_EL, DIR_LOCALS).is_err() {
+        eprintln!("error: unable to create file `{DIR_LOCALS_EL}`");
+        return;
+    }
+    println!("info: created `{DIR_LOCALS_EL}`");
+}
+
+pub fn remove_dir_locals() {
+    if std::fs::remove_file(DIR_LOCALS_EL).is_err() {
+        eprintln!("error: unable to remove `{DIR_LOCALS_EL}`");
+        return;
+    }
+    println!("info: removed `{DIR_LOCALS_EL}`");
+}

clippy_dev/src/setup/mod.rs

@@ -1,3 +1,4 @@
+pub mod emacs;
 pub mod git_hook;
 pub mod intellij;
 pub mod toolchain;

clippy_lints/src/casts/cast_nan_to_int.rs

@@ -21,9 +21,10 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
 
 fn is_known_nan(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
     match ConstEvalCtxt::new(cx).eval(e) {
-        // FIXME(f16_f128): add these types when nan checks are available on all platforms
+        Some(Constant::F128(n)) => n.is_nan(),
         Some(Constant::F64(n)) => n.is_nan(),
         Some(Constant::F32(n)) => n.is_nan(),
+        Some(Constant::F16(n)) => n.is_nan(),
         _ => false,
     }
 }

clippy_lints/src/casts/unnecessary_cast.rs

@@ -1,13 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::numeric_literal::NumericLiteral;
-use clippy_utils::res::MaybeResPath;
+use clippy_utils::res::MaybeResPath as _;
 use clippy_utils::source::{SpanRangeExt, snippet_opt};
 use clippy_utils::visitors::{Visitable, for_each_expr_without_closures};
 use clippy_utils::{get_parent_expr, is_hir_ty_cfg_dependant, is_ty_alias};
 use rustc_ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{Expr, ExprKind, Lit, Node, Path, QPath, TyKind, UnOp};
+use rustc_hir::{Expr, ExprKind, FnRetTy, Lit, Node, Path, QPath, TyKind, UnOp};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty::adjustment::Adjust;
 use rustc_middle::ty::{self, FloatTy, InferTy, Ty};
@@ -97,7 +97,7 @@ pub(super) fn check<'tcx>(
 
     // skip cast of fn call that returns type alias
     if let ExprKind::Cast(inner, ..) = expr.kind
-        && is_cast_from_ty_alias(cx, inner, cast_from)
+        && is_cast_from_ty_alias(cx, inner)
     {
         return false;
     }
@@ -270,42 +270,33 @@ fn fp_ty_mantissa_nbits(typ: Ty<'_>) -> u32 {
 
 /// Finds whether an `Expr` returns a type alias.
 ///
-/// TODO: Maybe we should move this to `clippy_utils` so others won't need to go down this dark,
-/// dark path reimplementing this (or something similar).
-fn is_cast_from_ty_alias<'tcx>(cx: &LateContext<'tcx>, expr: impl Visitable<'tcx>, cast_from: Ty<'tcx>) -> bool {
+/// When in doubt, for example because it calls a non-local function that we don't have the
+/// declaration for, assume if might be a type alias.
+fn is_cast_from_ty_alias<'tcx>(cx: &LateContext<'tcx>, expr: impl Visitable<'tcx>) -> bool {
     for_each_expr_without_closures(expr, |expr| {
         // Calls are a `Path`, and usage of locals are a `Path`. So, this checks
         // - call() as i32
         // - local as i32
         if let ExprKind::Path(qpath) = expr.kind {
             let res = cx.qpath_res(&qpath, expr.hir_id);
-            // Function call
             if let Res::Def(DefKind::Fn, def_id) = res {
-                let Some(snippet) = cx.tcx.def_span(def_id).get_source_text(cx) else {
-                    return ControlFlow::Continue(());
+                let Some(def_id) = def_id.as_local() else {
+                    // External function, we can't know, better be safe
+                    return ControlFlow::Break(());
                 };
-                // This is the worst part of this entire function. This is the only way I know of to
-                // check whether a function returns a type alias. Sure, you can get the return type
-                // from a function in the current crate as an hir ty, but how do you get it for
-                // external functions?? Simple: It's impossible. So, we check whether a part of the
-                // function's declaration snippet is exactly equal to the `Ty`. That way, we can
-                // see whether it's a type alias.
-                //
-                // FIXME: This won't work if the type is given an alias through `use`, should we
-                // consider this a type alias as well?
-                if !snippet
-                    .split("->")
-                    .skip(1)
-                    .any(|s| snippet_eq_ty(s, cast_from) || s.split("where").any(|ty| snippet_eq_ty(ty, cast_from)))
+                if let Some(FnRetTy::Return(ty)) = cx.tcx.hir_get_fn_output(def_id)
+                    && let TyKind::Path(qpath) = ty.kind
+                    && is_ty_alias(&qpath)
                 {
+                    // Function call to a local function returning a type alias
                     return ControlFlow::Break(());
                 }
             // Local usage
             } else if let Res::Local(hir_id) = res
                 && let Node::LetStmt(l) = cx.tcx.parent_hir_node(hir_id)
             {
                 if let Some(e) = l.init
-                    && is_cast_from_ty_alias(cx, e, cast_from)
+                    && is_cast_from_ty_alias(cx, e)
                 {
                     return ControlFlow::Break::<()>(());
                 }
@@ -323,7 +314,3 @@ fn is_cast_from_ty_alias<'tcx>(cx: &LateContext<'tcx>, expr: impl Visitable<'tcx
     })
     .is_some()
 }
-
-fn snippet_eq_ty(snippet: &str, ty: Ty<'_>) -> bool {
-    snippet.trim() == ty.to_string() || snippet.trim().contains(&format!("::{ty}"))
-}

clippy_lints/src/collapsible_if.rs

@@ -1,7 +1,7 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::msrvs::Msrv;
-use clippy_utils::source::{IntoSpan as _, SpanRangeExt, snippet, snippet_block_with_applicability};
+use clippy_utils::source::{IntoSpan as _, SpanRangeExt as _, snippet, snippet_block_with_applicability};
 use clippy_utils::{can_use_if_let_chains, span_contains_non_whitespace, sym, tokenize_with_text};
 use rustc_ast::{BinOpKind, MetaItemInner};
 use rustc_errors::Applicability;