Rollup of 9 pull requests #91602

Windows Server 2022 is a different version from Win11, breaking precent

…, r=flip1995 Reference `clippy_utils` docs on nightly-rustc and some other documentation updates The `clippy_utils` crate is now part of the nightly-rustc documentation. See [**very beautiful documentation**](https://doc.rust-lang.org/nightly/nightly-rustc/clippy_utils/). This PR references them in our documentation and updates some other documentation. changelog: none

Fix false negative in [`match_overlapping_arms`] changelog: Fix false negative in [`match_overlapping_arms`]

Replace `in_macro` usage with `from_expansion` changelog: none Generally replace `in_macro(span)` with `span.from_expansion()`. If we're just trying to avoid expanded code, this seems more appropriate because any kind of expanded code is prone to false positives. One place I did not touch is `macro_use.rs`. I think this lint could use a rewrite so I moved `in_macro` there, the only place it is still used.

…shearth Remove rustfmt::skip attribute from register_plugins function r? `@Manishearth` since you added this in rust-lang#540 😄 changelog: none

I found the manual run command really useful, this makes it a bit easier to type

…effen Extend author lint changelog: none * Print float and int suffixes * Print labels * Struct field checks * Repeat length expression check * Destructure method calls * Destructure closures

Add `cargo dev lint` to manually run clippy on a file I found the manual run command really useful, this makes it a bit easier to type Not sure if this belongs in the changelog or not changelog: Add `cargo dev lint` to manually run clippy on a file

TraitKind -> Trait TyAliasKind -> TyAlias ImplKind -> Impl FnKind -> Fn All `*Kind`s in AST are supposed to be enums. Tuple structs are converted to braced structs for the types above, and fields are reordered in syntactic order. Also, mutable AST visitor now correctly visit spans in defaultness, unsafety, impl polarity and constness.

The only reason to use `abort_if_errors` is when the program is so broken that either: 1. later passes get confused and ICE 2. any diagnostics from later passes would be noise This is never the case for lints, because the compiler has to be able to deal with `allow`-ed lints. So it can continue to lint and compile even if there are lint errors.

Fix ICE in undocumented_unsafe_blocks changelog: Fix ICE in [`undocumented_unsafe_blocks`] closes: rust-lang#7934

Introduce `expr_visitor` and `expr_visitor_no_bodies` changelog: none A couple utils that satisfy a *lot* of visitor use cases. Factoring in every possible usage would be really big so I just focused on cleaning clippy_utils.

…=giraffate Add MSRV to deprecated_cfg_attr changelog: Add MSRV to [`deprecated_cfg_attr`] closes: rust-lang#7922

This unbounded case never actually happens because `all_ranges(..)` uses the scrutinee type bounds for open ranges. Switch to our own `Bound` enum so that we don't have this case.

Only the end bounds of ranges can actually be included or excluded. This commit changes the SpannedRange type to reflect that. Update `Kind::value` to and `Kind::cmp` for this change. `Kind::cmp` gets flipped to check value first and then the bound details and is much shorter.

Reword the `Kind` type so that the `cmp` function is simpler.

There is no reason for these to be `pub`. They aren't used anywhere else.

Don't destructure args tuple in format_args! This allows Clippy to parse the HIR more simply since `arg0` is changed to `_args.0`. (cc rust-lang/rust-clippy#7843). From rustc's perspective, I think this is something between a lateral move and a tiny improvement since there are fewer bindings. r? `@m-ou-se`

Don't abort compilation after giving a lint error The only reason to use `abort_if_errors` is when the program is so broken that either: 1. later passes get confused and ICE 2. any diagnostics from later passes would be noise This is never the case for lints, because the compiler has to be able to deal with `allow`-ed lints. So it can continue to lint and compile even if there are lint errors. Closes rust-lang#82761. This is a WIP because I have a feeling it will exit with 0 even if there were lint errors; I don't have a computer that can build rustc locally at the moment.

…twco Make `select_*` methods return `Vec` for `TraitEngine` This reduces some complexity as an empty vec means no errors and non-empty vec means errors occurred.

Fix suggestion for deref expressions in redundant_pattern_matching changelog: Fix suggestion for deref expressions in [`redundant_pattern_matching`] closes: rust-lang#7921

Type inference for inline consts Fixes rust-lang#78132 Fixes rust-lang#78174 Fixes rust-lang#81857 Fixes rust-lang#89964 Perform type checking/inference of inline consts in the same context as the outer def, similar to what is currently done to closure. Doing so would require `closure_base_def_id` of the inline const to return the outer def, and since `closure_base_def_id` can be called on non-local crate (and thus have no HIR available), a new `DefKind` is created for inline consts. The type of the generated anon const can capture lifetime of outer def, so we couldn't just use the typeck result as the type of the inline const's def. Closure has a similar issue, and it uses extra type params `CK, CS, U` to capture closure kind, input/output signature and upvars. I use a similar approach for inline consts, letting it have an extra type param `R`, and then `typeof(InlineConst<[paremt generics], R>)` would just be `R`. In borrowck region requirements are also propagated to the outer MIR body just like it's currently done for closure. With this PR, inline consts in expression position are quitely usable now; however the usage in pattern position is still incomplete -- since those does not remain in the MIR borrowck couldn't verify the lifetime there. I have left an ignored test as a FIXME. Some disucssions can be found on [this Zulip thread](https://rust-lang.zulipchat.com/#narrow/stream/260443-project-const-generics/topic/inline.20consts.20typeck). cc `````@spastorino````` `````@lcnr````` r? `````@nikomatsakis````` `````@rustbot````` label A-inference F-inline_const T-compiler

Fix `explicit_counter_loop` suggestion for non-usize types changelog: Add a new suggestion for non-usize types in [`explicit_counter_loop`] closes: rust-lang#7920

`match_overlapping_arm` refactoring The main purpose of this pull request is to remove the unneeded and scary `unimplented!()` in the `match_arm_overlapping` code. The rest is gratuitous refactoring. changelog: none

…colon

Fix `semicolon_if_nothing_returned` FP on `let-else` stmts closes rust-lang#7912 `semicolon_if_nothing_returned` now additionally checks if the statements ends in `;` , this will also prevent `let-else` statements to be linted. changelog: fix [`semicolon_if_nothing_returned`] FP firing on `let-else`

So, some context for this, well, more a story. I'm not used to scripting, I've never really scripted anything, even if it's a valuable skill. I just never really needed it. Now, `@flip1995` correctly suggested using a script for this in `rust-clippy#7813`... And I decided to write a script using nushell because why not? This was a mistake... I spend way more time on this than I would like to admit. It has definitely been more than 4 hours. It shouldn't take that long, but me being new to scripting and nushell just wasn't a good mixture... Anyway, here is the script that creates another script which adds the versions. Fun... Just execute this on the `gh-pages` branch and the resulting `replacer.sh` in `clippy_lints` and it should all work. ```nu mv v0.0.212 rust-1.00.0; mv beta rust-1.57.0; mv master rust-1.58.0; let paths = (open ./rust-1.58.0/lints.json | select id id_span | flatten | select id path); let versions = ( ls | where name =~ "rust-" | select name | format {name}/lints.json | each { open $it | select id | insert version $it | str substring "5,11" version} | group-by id | rotate counter-clockwise id version | update version {get version | first 1} | flatten | select id version); $paths | each { |row| let version = ($versions | where id == ($row.id) | format {version}) let idu = ($row.id | str upcase) $"sed -i '0,/($idu),/{s/pub ($idu),/#[clippy::version = "($version)"]\n pub ($idu),/}' ($row.path)" } | str collect ";" | str find-replace --all '1.00.0' 'pre 1.29.0' | save "replacer.sh"; ``` And this still has some problems, but at this point I just want to be done -.-

Moved out reusable pieces from `is_automatically_derived` and `any_parent_is_automatically_derived`.

This commit adds a `no_std` and `no_core` check on `swap` lint and additionally suggest `core::mem::swap` whenever possible. Remove warning if both `std` and `core` is not present.

Adds additional test to check for `swap` suggestion when `no_std` is present

[`swap`] lints now check if there is `no_std` or `no_core` attribute Closes rust-lang#7858 changelog: [`swap`] lints now check if there is `no_std` or `no_core` attribute

Add Clippy version to Clippy's lint list Hey, hey, the semester is finally over, and I wanted to get back into hacking on Clippy. It has also been some time since our metadata collection monster has been feed. So, this PR adds a new attribute `clippy::version` to document which version a lint was stabilized. I considered using `git blame` but that would be very hacky and probably not accurate. I'm also thinking that this attribute can be used to have a `clippy::nightly` lint group which is allow-by-default that delays setting the actual lint group until the defined version is reached. Just something to consider regarding rust-lang#6623 🙃 This PR only adds the version to 4 lints to keep it reviewable. I'll do a followup PR to add the version to other lints if the implementation is accepted 🙃 ![image](https://user-images.githubusercontent.com/17087237/137118859-0aafdfdf-7595-4289-8ba4-33d58eb6991d.png) Also, mobile approved xD ![image](https://user-images.githubusercontent.com/17087237/137118944-833cf7fb-a4a1-45d6-9af8-32c951822360.png) --- r? `@flip1995` cc: rust-lang#7172 closes: rust-lang#6492 changelog: [Clippy's lint list](https://rust-lang.github.io/rust-clippy/master/index.html) now displays the version a lint was added. 🎉 --- Example lint declaration after this update: ```rs declare_clippy_lint! { /// [...] /// /// ### Example /// ```rust /// // Bad /// let x = 3.14; /// // Good /// let x = std::f32::consts::PI; /// ``` #[clippy::version = "pre 1.29.0"] pub APPROX_CONSTANT, correctness, "the approximate of a known float constant (in `std::fXX::consts`)" } ```

* Finding pattern slices for `avoidable_slice_indexing` * `avoidable_slice_indexing` analysing slice usage * Add configuration to `avoidable_slice_indexing` * Emitting `avoidable_slice_indexing` with suggestions * Dogfooding and fixing bugs * Add ui-toml test for `avoidable_slice_indexing` * Correctly suggest `ref` keywords for `avoidable_slice_indexing` * Test and document `mut` for `avoid_slice_indexing` * Handle macros with `avoidable_slice_indexing` lint * Ignore slices with sub patterns in `avoidable_slice_indexing` * Update lint description for `avoidable_slice_indexing` * Move `avoidable_slice_indexing` to nursery * Added more tests for `avoidable_slice_indexing` * Update documentation and message for `avoidable_slice_indexing` * Teach `avoidable_slice_indexing` about `HirId`s and `Visitors` * Rename lint to `index_refutable_slice` and connected config

…steffen New lint `index_refutable_slice` to avoid slice indexing A new lint to check for slices that could be deconstructed to avoid indexing. This lint should hopefully prevent some panics in other projects and ICEs for us. See rust-lang#7569 for an example The implementation specifically checks for immutable bindings in `if let` statements to slices and arrays. Then it checks if these bindings are only used for value access using indices and that these indices are lower than the configured limit. I did my best to keep the implementation small, however the check was sadly quite complex. Now it's around 300 lines for the implementation and the rest are test. --- Optional future improvements: * Check for these instances also in `match` statements * Check for mutable slice bindings that could also be destructed --- changelog: New lint [`index_refutable_slice`] I've already fixed a bunch of lint triggers in rust-lang#7638 to make this PR smaller Closes: rust-lang#7569

Author improvements changelog: none Various aspects of the author implementation are re-imagined to be much less repetitive. Also fixes some bugs. I hope this makes author more fun to work on for future contributors. The last commit is pretty heavy but I tried to at least separate some changes so that the test file diffs per commit are simple.

Use rustfmt version from `rust-toolchain` changelog: None

Lint for bool to integer casts in `cast_lossless` The lint description says > Checks for casts between *numerical* types that may be replaced by safe conversion functions. Which is strictly speaking being violated here, but it seems within the spirit of the lint. I think it is still a useful lint to have, and having a different lint for just this feels excessive. Thoughts? Fixes rust-lang#7947 changelog: Lint for bool to integer casts in [`cast_lossless`]

Run rustfmt on batches of multiple files changelog: none This gives `cargo dev fmt` a nice speed boost, down from 90s (because old) on my laptop and 120s (because windows) on my desktop to ~5s on both 250 at a time was to give windows a good amount of headroom (failed at ~800, rust-lang#40384) Also adds rustfmt to the toolchain file and has the clippy_dev workflow test using the pinned version as a follow up to rust-lang#7963

…e blocks.

fix typo just fixed typo changelog: none

Fixes rust-lang#7973 changelog: don't expand macros in suggestion of clippy::option_if_let_else

Still needs to generalize to other mixes of let bindings, `map` method calls, etc.

I think the detection of parking_lot's mutex and rwlock is valuable, so submit this pr, please help judge and review, thank you. Make let_underscore_lock support parking_lot. changelog: Make let_underscore_lock support parking_lot

Support suggestion for rust-lang#7854 I think the detection of parking_lot's mutex and rwlock is valuable, so submit this pr, please help judge and review, thank you. Make let_underscore_lock support parking_lot.(Fixes rust-lang#7854) changelog: Make let_underscore_lock support parking_lot

…_expand_sugg_macro, r=flip1995 option_if_let_else: don't expand macros in suggestion Fixes rust-lang#7973 changelog: don't expand macros in suggestion of clippy::option_if_let_else

* Lint when a borrow is auto dereferenced more than once * Lint when the expression is used as the expression of a block for a match arm Moves `needless_borrow` and `ref_binding_to_reference` to `dereference` lint pass in preperation for `explicit_auto_deref` lint.

…s preferred

…msteffen Improve heuristic for eagerness suggestion Still to be done: * a more complete list of cheap functions * a way to limit the complexity of cheap expressions changelog: Improve heuristics for `or_fun_call` and `unnecessary_lazy_evaluations`

…table borrows. Also add some more tests to check that it's working.

1. Make the lifetime contained in LateContext `'tcx`. 2. Fix `'txc` to `'tcx` because it was a typo. 3. Refactor `IterFunctionVisitor`'s `visit_block` method to be more readable. 4. Replace uses of `rustc_middle::ty::TyKind` with `rustc::middle::ty`, and remove the `#[allow(...)]`. (Thank you llogiq for all these suggestions!)

Fix `needless_collect`'s tendency to suggest code requiring multiple mutable borrows of the same value. Fixes error specified in rust-lang#7975. changelog: [`needless_collect`] no longer suggests removal of `collect` when removal would create code requiring mutably borrowing a value multiple times.

1. Fix the problem of manual_split_once changing the original behavior. 2. Add a new lint needless_splitn. changelog: Fix the problem of manual_split_once changing the original behavior and add a new lint needless_splitn.

…teffen Fix for rust-lang#7889 and add new lint needless_splitn fixes: rust-lang#7889 1. Fix the problem of manual_split_once changing the original behavior. 2. Add a new lint needless_splitn. changelog: Fix the problem of manual_split_once changing the original behavior and add a new lint needless_splitn.

Don't show no_effect warning on unit structs implementing fn_once Fixes rust-lang#7792 changelog: Don't show [`no_effect`] or [`unecessary_operation`] warning for unit struct implementing FnOnce

…fe_blocks, r=flip1995 Fix ICE on `undocumented_unsafe_blocks` fix rust-lang/rust-clippy#7979 changelog: Fix ICE on `undocumented_unsafe_blocks`

…logiq fix suggestion in option_map_or_none fix: rust-lang#7960 changelog: change suggestion in the lint rule `option_map_or_none`

Fix `manual_map` with unsafe functions fixes: rust-lang#7820 changelog: Fix `manual_map` suggestion when used with unsafe functions and unsafe blocks

This function parameter attribute was introduced in rust-lang#44866 as an intermediate step in implementing `impl Trait`, it's not necessary or used anywhere by itself.

fix typo just fixed typo changelog: none

Rustup r? `@ghost` changelog: none

This was brought up in [Zulip] and is also mentioned in the lint naming conventions. Since this is still a nursery lint, I think there shouldn't be any problem in renaming it. [Zulip]: https://rust-lang.zulipchat.com/#narrow/stream/257328-clippy/topic/disallow_type.20vs.20disallowed-types

This way they match up with the pluralized lint name as well.

To stay consistent with the sister lint disallowed_type, also rename the disallowed_method lint to disallowed_methods.

Improve `needless_borrow` lint fixes: rust-lang#5327 fixes: rust-lang#1726 fixes: rust-lang#1212 This is merging `needless_borrow` into the `dereference` pass in preparation for `explicit_auto_deref`. `explicit_auto_deref` needs to implement most of what `needless_borrow` implements in order to work. There is a minor regression here where `let x: &str = &x.deref()` will trigger `needless_borrow` without triggering `explicit_deref_methods`. Removing the redundant borrow will cause `explicit_deref_methods` to trigger. This will be fixed when `explicit_auto_deref` is implemented. changelog: Lint `needless_borrow` when a borrow is auto-derefed more than once changelog: Lint `needless_borrow` in the trailing expression of a block for a match arm

…arth Add test case for RESULT_MAP_OR_INTO_OPTION just added test case for RESULT_MAP_OR_INTO_OPTION. changelog: none

…dnet Pluralize `disallowed_type` lint This was brought up in [Zulip] and is also mentioned in the lint naming conventions. Since this is still a nursery lint, I think there shouldn't be any problem in renaming it. [Zulip]: rust-lang.zulipchat.com/#narrow/stream/257328-clippy/topic/disallow_type.20vs.20disallowed-types changelog: Rename nursery lint [`disallowed_type`] to [`disallowed_types`].

…replacement

This checks for sequences in strings that would be octal character escapes in C, but are not supported in Rust. It suggests either to use the `\x00` escape, or an equivalent hex escape if the octal was intended.

Don't check for a nightly toolchain in fmt test changelog: None

Avoid inline hints with double backticks for `doc-markdown` The easiest route here was to ensure that the suggestion is always shown on its own line, where no additional backticks are added by the diagnostic formatter. Fixes rust-lang#8002 --- *Please write a short comment explaining your change (or "none" for internal only changes)* changelog: Avoid inline hints with double backticks for `doc-markdown`

Fix shadow_same's positive false for async function's params: Example Code: ```rust #![deny(clippy::shadow_same)] pub async fn foo(_a: i32) { } ``` Output: ``` error: `_a` is shadowed by itself in `_a ``` Hir: ```rust pub async fn foo(_a: i32) -> /*impl Trait*/ #[lang = "from_generator"](move |mut _task_context| { let _a = _a; { let _t = { }; _t } }) ``` Skip checking async function's params. changelog: Fix shadow_same's positive false for async function's params

Fixes shadow_same's false positive for rust-lang#7915 Fix shadow_same's false positive for async function's params(Fixes rust-lang#7915): Example Code: ```rust #![deny(clippy::shadow_same)] pub async fn foo(_a: i32) { } ``` Output: ``` error: `_a` is shadowed by itself in `_a ``` Hir: ```rust pub async fn foo(_a: i32) -> /*impl Trait*/ #[lang = "from_generator"](move |mut _task_context| { let _a = _a; { let _t = { }; _t } }) ``` Skip checking async function's params. changelog: Fix shadow_same's false positive for async function's params

…t, r=giraffate Allow `suboptimal_flops` in const functions This PR allows `clippy::suboptimal_flops` in constant functions. The check also effects the `clippy::imprecise_flops` lint logic. However, this doesn't have any effects as all functions checked for are not const and can therefore not be found in such functions. --- changelog: [`suboptimal_flops`]: No longer triggers in constant functions Closes: rust-lang/rust-clippy#8004

…ponents, r=flip1995 Add missing components to rust-toolchain file Somehow these basic components are missing from the toolchain file... changelog: none

Add new lint `octal_escapes` This checks for sequences in strings that would be octal character escapes in C, but are not supported in Rust. It suggests either to use the `\x00` escape, or an equivalent hex escape if the octal was intended. Fixes rust-lang#7981 --- *Please write a short comment explaining your change (or "none" for internal only changes)* changelog: Add new lint [`octal_escapes`], which checks for literals like `"\033[0m"`.

Fix FP on `if_then_some_else_none` when there is early return closes rust-lang#7870 changelog: [`if_then_some_else_none`] now does not fire when there is early return

Rustup Re-sync, because I didn't get to syncing things back to rustc. r? `@ghost` changelog: none

Add more descriptive help info for `needless_question_mark` closes rust-lang#8016 changelog: [`needless_question_mark`] help suggestion now explains what should be changed

This oversight appears to have gone unnoticed for a long time without causing issues, but it should still be fixed.

Visit `param_env` field in Obligation's `TypeFoldable` impl This oversight appears to have gone unnoticed for a long time without causing issues, but it should still be fixed.

… r=llogiq Non ascii in sigle literal fix: rust-lang#8013 changelog: `non_ascii_literal` warn against non-ASCII within `char`, not just `strings`

+nits

…nstant functions

Add `needless_late_init` lint examples: ```rust let a; a = 1; // to let a = 1; ``` ```rust let b; match 3 { 0 => b = "zero", 1 => b = "one", _ => b = "many", } // to let b = match 3 { 0 => "zero", 1 => "one", _ => "many", }; ``` ```rust let c; if true { c = 1; } else { c = -1; } // to let c = if true { 1 } else { -1 }; ``` changelog: Add [`needless_late_init`]

Prior to PR rust-lang#91205, checking for errors in the overall obligation would check checking the `ParamEnv`, due to an incorrect `super_visit_with` impl. With this bug fixed, we will now bail out of impl candidate assembly if the `ParamEnv` contains any error types. In practice, this appears to be overly conservative - when an error occurs early in compilation, we end up giving up early for some predicates that we could have successfully evaluated without overflow. By only checking for errors in the predicate itself, we avoid causing additional spurious 'type annotations needed' errors after a 'real' error has already occurred. With this PR, the diagnostic changes caused by PR rust-lang#91205 are reverted.

…remove unneeded statements

…ffen apply iter_cloned_collect to collect() using copied() fix: rust-lang#6703 changelog: apply `iter_cloned_collect` to `collect()` using`copied()`

Improve `strlen_on_c_string` fixes: rust-lang#7436 changelog: lint `strlen_on_c_string` when used without a fully-qualified path changelog: suggest removing the surrounding unsafe block for `strlen_on_c_string` when possible

GitHub has a new way to define issue templates. This gives an even more consistent formatting of our issues.

Use new template forms for issue templates GitHub has a new way to define issue templates. This gives an even more consistent formatting of our issues. You can find (read-only) rendered versions [here](https://github.com/flip1995/rust-clippy/tree/new_templates/.github/ISSUE_TEMPLATE). If you want to try to fill out this kind of issue, you can do this in the [`cargo` Repo](https://github.com/rust-lang/cargo/issues/new/choose). changelog: Better issue templates

This issue has been fixed by [commit](rust-lang/rust-clippy@8c1c763) This PR is used for close rust-lang#7946(Fixes rust-lang#7946). changelog: Add test for pattern_type_mismatch.

`no_std_swap`: Fix typo in TODO changelog: none

Add test for pattern_type_mismatch. This issue has been fixed by [commit](rust-lang/rust-clippy@8c1c763) This PR is used for close rust-lang#7946(Fixes rust-lang#7946). changelog: Add test for pattern_type_mismatch.

Rustup r? `@ghost` changelog: none

Fix `any()` not taking reference in `search_is_some` lint `find` gives reference to the item, but `any` does not, so suggestion is broken in some specific cases. Fixes: rust-lang#7392 changelog: [`search_is_some`] Fix suggestion for `any()` not taking item by reference

…le_char_pattern, r=giraffate Escape backslash in single_char_pattern.rs Escape backslash in single_char_pattern. Previously, the proposed clippy fix for a single backslash in raw strings ```r"\"``` or ```r#"\"#``` was also only an unescaped, *single* ```'\'```: ```shell warning: single-character string constant used as pattern 2 | let s = r#"abc\xyz/"#.find(r"\"); | ^^^^ help: try using a `char` instead: `'\'` | = note: `#[warn(clippy::single_char_pattern)]` on by default ``` This PR corrects this to a properly escaped *double* backslash ```'\\'```. I haven't come up with any other problematic cases, a single quote was already handled. Closes: rust-lang#8060 changelog: Escape backslash in ``[`single_char_pattern`]``

…=flip1995 Fixed same_name_method description Noticed some odd phrasing, while checking out the new release. changelog: none

…n it existed. Also, no tests fail when turning that arm into an ICE

…or-pre-expansion, r=camsteffen Updated known problems section for pre-expansion lints about level attributes Our last three pre-macro expansion lints aren't affected by lint level attributes. This adds a comment to the know problems section of them. I've also updated some CSS to add some spacing after lists on Clippy's lint list: Before: ![image](https://user-images.githubusercontent.com/17087237/143783579-064326d4-4e58-4d7d-bbe4-fad8b115fcd4.png) After: ![image](https://user-images.githubusercontent.com/17087237/143783650-9803fa03-c332-4e0e-886f-523d4217c6e6.png) --- changelog: [`print_stdout`], [`print_stderr`], [`dbg_macro`]: Document how the lint level can be changed and reference rust-lang/rust-clippy#6610 cc: rust-lang/rust-clippy#6610

@lqd

Adds the minimial repro test case from rust-lang#85360. The fix for rust-lang#85360 was supposed to be rust-lang#85868 however the repro was resolved in the 2021-07-05 nightly while rust-lang#85360 didn't land until 2021-09-03. The reason for that is d34a3a4 **also** resolves that issue. To test if rust-lang#85868 actually fixes rust-lang#85360, I reverted d34a3a4 and found that rust-lang#85868 does indeed resolve rust-lang#85360. With that question resolved, add a test case to our incremental test suite for the original Ok(EvaluatedToOkModuloRegions) ICE. Thanks to @lqd for helping track this down!

As suggested via reviewer feedback.

Upgrade map_flatten to complexity changelog: upgrade [`map_flatten`] to complexity Resolves rust-lang#7999

Consider NonNull as a pointer type PR 1/2 for issue rust-lang#8045. Add `NonNull` as a pointer class to suppress false positives like `UnsafeCell<NonNull<()>>`. However, this change is not sufficient to handle the cases shared in gtk-rs and Rug in the issue. changelog: none r? `@xFrednet`

Signed-off-by: TennyZhuang <zty0826@gmail.com>

…r=llogiq Enable rustbot shortcuts for rust-clippy This enables shortcuts for ``@rustbot`.` Just a quality of life feature for contributors. |Shortcut| Full comment | |---|---| | ``@rustbot` ready` | ``@rustbot` label -S-waiting-on-author +S-waiting-on-review` | | ``@rustbot` author` | ``@rustbot` label +S-waiting-on-author -S-waiting-on-review` | See: https://github.com/rust-lang/triagebot/wiki/Shortcuts The documentation also states that the author/assignee will be pinged. However, this doesn't seem to be the case, it at least hasn't done so for me and in this [PR](rust-lang#90642 (comment)) --- changelog: none

…negatives, r=camsteffen Fix some false negatives for [`single_char_pattern`] *Please write a short comment explaining your change (or "none" for internal only changes)* changelog: Fix some false negatives for [`single_char_pattern`] I noticed that clippy wasn't complaining about my usage of `split_once("x")` in a personal project so I updated the list of functions. I had to update the test case for an unrelated issue because replace is now included in the list of functions to be linted.

Add test Apply suggestions Switch to match Apply cargofmt

Update std::env::temp_dir to use GetTempPath2 on Windows when available. As a security measure, Windows 11 introduces a new temporary directory API, GetTempPath2. When the calling process is running as SYSTEM, a separate temporary directory will be returned inaccessible to non-SYSTEM processes. For non-SYSTEM processes the behavior will be the same as before. This can help mitigate against attacks such as this one: https://medium.com/csis-techblog/cve-2020-1088-yet-another-arbitrary-delete-eop-a00b97d8c3e2 Compatibility risk: Software which relies on temporary files to communicate between SYSTEM and non-SYSTEM processes may be affected by this change. In many cases, such patterns may be vulnerable to the very attacks the new API was introduced to harden against. I'm unclear on the Rust project's tolerance for such change-of-behavior in the standard library. If anything, this PR is meant to raise awareness of the issue and hopefully start the conversation. How tested: Taking the example code from the documentation and running it through psexec (from SysInternals) on Win10 and Win11. On Win10: C:\test>psexec -s C:\test\main.exe <...> Temporary directory: C:\WINDOWS\TEMP\ On Win11: C:\test>psexec -s C:\test\main.exe <...> Temporary directory: C:\Windows\SystemTemp\

Add test for evaluate_obligation: Ok(EvaluatedToOkModuloRegions) ICE Adds the minimial repro test case from rust-lang#85360. The fix for rust-lang#85360 was supposed to be rust-lang#85868 however the repro was resolved in the 2021-07-05 nightly while rust-lang#85868 didn't land until 2021-09-03. The reason for that is d34a3a4 **also** resolves that issue. To test if rust-lang#85868 actually fixes rust-lang#85360, I reverted d34a3a4 and found that rust-lang#85868 does indeed resolve rust-lang#85360. With that question resolved, add a test case to our incremental test suite for the original Ok(EvaluatedToOkModuloRegions) ICE. Thanks to ``@lqd`` for helping track this down!

…, r=wesleywiser Print a suggestion when comparing references to primitive types in `const fn` Fixes rust-lang#90870.

…kh726 Fix AnonConst ICE I am not sure if this is even the correct place to fix this issue, but i went down the path where the generic args came from and i wasn't able to find a clear cause for this down there. But if anybody has a suggestion what i should do, just tell me. This fixes: rust-lang#91267

Remove a dead code path. It is neither documented nor can I see any way it could ever be reached. Also, no tests fail when turning that arm into an ICE

…rister Tweak "call this function" suggestion to have smaller span

…scottmcm Suggest try_reserve in try_reserve_exact During developing rust-lang#91529 , I found that `try_reserve_exact` suggests `reserve` for further insertions. I think it's a mistake by copy&paste, `try_reserve` is better here.

Update Clippy Since RLS is now already broken rust-lang#91543 , we shouldn't be blocked by it anymore. I plan to do the RLS update once new rustc-ap packages are released. r? `@Manishearth`

update Miri Fixes rust-lang#91542 r? `@ghost`

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Rollup of 9 pull requests #91602

Rollup of 9 pull requests #91602

Commits on Oct 27, 2021

Commits on Nov 1, 2021

Commits on Nov 4, 2021

Commits on Nov 5, 2021

Commits on Nov 6, 2021

Commits on Nov 7, 2021

Commits on Nov 8, 2021

Commits on Nov 9, 2021

Commits on Nov 10, 2021

Commits on Nov 11, 2021

Commits on Nov 12, 2021

Commits on Nov 13, 2021

Commits on Nov 14, 2021

Commits on Nov 15, 2021

Commits on Nov 16, 2021

Commits on Nov 17, 2021

Commits on Nov 18, 2021

Commits on Nov 19, 2021

Commits on Nov 20, 2021

Commits on Nov 21, 2021

Commits on Nov 22, 2021

Commits on Nov 23, 2021

Commits on Nov 25, 2021

Commits on Nov 26, 2021

Commits on Nov 27, 2021

Commits on Nov 28, 2021

Commits on Nov 29, 2021

Commits on Nov 30, 2021

Commits on Dec 1, 2021

Commits on Dec 2, 2021

Commits on Dec 3, 2021

Commits on Dec 4, 2021

Commits on Dec 5, 2021

Commits on Dec 6, 2021