[INFO] crate clippy_lints 0.0.212 is already in cache [INFO] extracting crate clippy_lints 0.0.212 into work/ex/pr-63376/sources/master#60960a260f7b5c695fd0717311d72ce62dd4eb43/reg/clippy_lints/0.0.212 [INFO] extracting crate clippy_lints 0.0.212 into work/ex/pr-63376/sources/try#266783e4e09e4e9d5307c1c8e695659c58bbcac7/reg/clippy_lints/0.0.212 [INFO] validating manifest of clippy_lints-0.0.212 on toolchain master#60960a260f7b5c695fd0717311d72ce62dd4eb43 [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+60960a260f7b5c695fd0717311d72ce62dd4eb43-alt" "read-manifest" "--manifest-path" "Cargo.toml"` [INFO] validating manifest of clippy_lints-0.0.212 on toolchain try#266783e4e09e4e9d5307c1c8e695659c58bbcac7 [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+266783e4e09e4e9d5307c1c8e695659c58bbcac7-alt" "read-manifest" "--manifest-path" "Cargo.toml"` [INFO] started frobbing clippy_lints-0.0.212 [INFO] finished frobbing clippy_lints-0.0.212 [INFO] frobbed toml for clippy_lints-0.0.212 written to work/ex/pr-63376/sources/master#60960a260f7b5c695fd0717311d72ce62dd4eb43/reg/clippy_lints/0.0.212/Cargo.toml [INFO] started frobbing clippy_lints-0.0.212 [INFO] finished frobbing clippy_lints-0.0.212 [INFO] frobbed toml for clippy_lints-0.0.212 written to work/ex/pr-63376/sources/try#266783e4e09e4e9d5307c1c8e695659c58bbcac7/reg/clippy_lints/0.0.212/Cargo.toml [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+60960a260f7b5c695fd0717311d72ce62dd4eb43-alt" "generate-lockfile" "--manifest-path" "Cargo.toml" "-Zno-index-update"` [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+266783e4e09e4e9d5307c1c8e695659c58bbcac7-alt" "generate-lockfile" "--manifest-path" "Cargo.toml" "-Zno-index-update"` [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+60960a260f7b5c695fd0717311d72ce62dd4eb43-alt" "fetch" "--locked" "--manifest-path" "Cargo.toml"` [INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+266783e4e09e4e9d5307c1c8e695659c58bbcac7-alt" "fetch" "--locked" "--manifest-path" "Cargo.toml"` [INFO] checking clippy_lints-0.0.212 against try#266783e4e09e4e9d5307c1c8e695659c58bbcac7 for pr-63376 [INFO] running `"docker" "create" "-v" "/mnt/big/crater/work/local/target-dirs/pr-63376/worker-5/try#266783e4e09e4e9d5307c1c8e695659c58bbcac7:/opt/crater/target:rw,Z" "-v" "/mnt/big/crater/work/ex/pr-63376/sources/try#266783e4e09e4e9d5307c1c8e695659c58bbcac7/reg/clippy_lints/0.0.212:/opt/crater/workdir:ro,Z" "-v" "/mnt/big/crater/work/local/cargo-home:/opt/crater/cargo-home:ro,Z" "-v" "/mnt/big/crater/work/local/rustup-home:/opt/crater/rustup-home:ro,Z" "-e" "USER_ID=1000" "-e" "SOURCE_DIR=/opt/crater/workdir" "-e" "MAP_USER_ID=1000" "-e" "CARGO_TARGET_DIR=/opt/crater/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/crater/cargo-home" "-e" "RUSTUP_HOME=/opt/crater/rustup-home" "-w" "/opt/crater/workdir" "-m" "1536M" "--network" "none" "rustops/crates-build-env" "/opt/crater/cargo-home/bin/cargo" "+266783e4e09e4e9d5307c1c8e695659c58bbcac7-alt" "check" "--frozen" "--all" "--all-targets"` [INFO] [stdout] 66f56dbeb284c407cd6498f4e0276e74f3e1aaac1a32e0ab9850137a7419d750 [INFO] running `"docker" "start" "-a" "66f56dbeb284c407cd6498f4e0276e74f3e1aaac1a32e0ab9850137a7419d750"` [INFO] [stderr] warning: the cargo feature `edition` is now stable and is no longer necessary to be listed in the manifest [INFO] [stderr] Checking quine-mc_cluskey v0.2.4 [INFO] [stderr] Checking error-chain v0.11.0 [INFO] [stderr] Checking cargo_metadata v0.5.8 [INFO] [stderr] Checking clippy_lints v0.0.212 (/opt/crater/workdir) [INFO] [stderr] warning[E0705]: the feature `rust_2018_preview` is included in the Rust 2018 edition [INFO] [stderr] --> src/lib.rs:14:12 [INFO] [stderr] | [INFO] [stderr] 14 | #![feature(rust_2018_preview)] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/utils/inspector.rs:11:1 [INFO] [stderr] | [INFO] [stderr] 11 | / /// **What it does:** Dumps every ast/hir node which has the `#[clippy_dump]` [INFO] [stderr] 12 | | /// attribute [INFO] [stderr] 13 | | /// [INFO] [stderr] 14 | | /// **Example:** [INFO] [stderr] ... | [INFO] [stderr] 25 | | /// extern crate dylib source: "/path/to/foo.so" [INFO] [stderr] 26 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 27 | / declare_clippy_lint! { [INFO] [stderr] 28 | | pub DEEP_CODE_INSPECTION, [INFO] [stderr] 29 | | internal_warn, [INFO] [stderr] 30 | | "helper to dump info about code" [INFO] [stderr] 31 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = note: `#[warn(unused_doc_comments)]` on by default [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/utils/internal_lints.rs:11:1 [INFO] [stderr] | [INFO] [stderr] 11 | / /// **What it does:** Checks for various things we like to keep tidy in clippy. [INFO] [stderr] 12 | | /// [INFO] [stderr] 13 | | /// **Why is this bad?** We like to pretend we're an example of tidy code. [INFO] [stderr] 14 | | /// [INFO] [stderr] 15 | | /// **Known problems:** None. [INFO] [stderr] 16 | | /// [INFO] [stderr] 17 | | /// **Example:** Wrong ordering of the util::paths constants. [INFO] [stderr] | |_____________________________________________________________^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub CLIPPY_LINTS_INTERNAL, [INFO] [stderr] 20 | | internal, [INFO] [stderr] 21 | | "various things that will negatively affect your clippy experience" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/utils/internal_lints.rs:25:1 [INFO] [stderr] | [INFO] [stderr] 25 | / /// **What it does:** Ensures every lint is associated to a `LintPass`. [INFO] [stderr] 26 | | /// [INFO] [stderr] 27 | | /// **Why is this bad?** The compiler only knows lints via a `LintPass`. Without [INFO] [stderr] 28 | | /// putting a lint to a `LintPass::get_lints()`'s return, the compiler will not [INFO] [stderr] ... | [INFO] [stderr] 46 | | /// } [INFO] [stderr] 47 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 48 | / declare_clippy_lint! { [INFO] [stderr] 49 | | pub LINT_WITHOUT_LINT_PASS, [INFO] [stderr] 50 | | internal, [INFO] [stderr] 51 | | "declaring a lint without associating it in a LintPass" [INFO] [stderr] 52 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/utils/author.rs:14:1 [INFO] [stderr] | [INFO] [stderr] 14 | / /// **What it does:** Generates clippy code that detects the offending pattern [INFO] [stderr] 15 | | /// [INFO] [stderr] 16 | | /// **Example:** [INFO] [stderr] 17 | | /// ```rust [INFO] [stderr] ... | [INFO] [stderr] 43 | | /// } [INFO] [stderr] 44 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 45 | / declare_clippy_lint! { [INFO] [stderr] 46 | | pub LINT_AUTHOR, [INFO] [stderr] 47 | | internal_warn, [INFO] [stderr] 48 | | "helper for writing lints" [INFO] [stderr] 49 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/approx_const.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for floating point literals that approximate [INFO] [stderr] 9 | | /// constants which are defined in [INFO] [stderr] 10 | | /// [`std::f32::consts`](https://doc.rust-lang.org/stable/std/f32/consts/#constants) [INFO] [stderr] 11 | | /// or [INFO] [stderr] ... | [INFO] [stderr] 27 | | /// let x = 3.14; [INFO] [stderr] 28 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 29 | / declare_clippy_lint! { [INFO] [stderr] 30 | | pub APPROX_CONSTANT, [INFO] [stderr] 31 | | correctness, [INFO] [stderr] 32 | | "the approximate of a known float constant (in `std::fXX::consts`)" [INFO] [stderr] 33 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/arithmetic.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for plain integer arithmetic. [INFO] [stderr] 7 | | /// [INFO] [stderr] 8 | | /// **Why is this bad?** This is only checked against overflow in debug builds. [INFO] [stderr] 9 | | /// In some applications one wants explicitly checked, wrapping or saturating [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// a + 1 [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub INTEGER_ARITHMETIC, [INFO] [stderr] 20 | | restriction, [INFO] [stderr] 21 | | "any integer arithmetic statement" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/arithmetic.rs:24:1 [INFO] [stderr] | [INFO] [stderr] 24 | / /// **What it does:** Checks for float arithmetic. [INFO] [stderr] 25 | | /// [INFO] [stderr] 26 | | /// **Why is this bad?** For some embedded systems or kernel development, it [INFO] [stderr] 27 | | /// can be useful to rule out floating-point numbers. [INFO] [stderr] ... | [INFO] [stderr] 33 | | /// a + 1.0 [INFO] [stderr] 34 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 35 | / declare_clippy_lint! { [INFO] [stderr] 36 | | pub FLOAT_ARITHMETIC, [INFO] [stderr] 37 | | restriction, [INFO] [stderr] 38 | | "any floating-point arithmetic statement" [INFO] [stderr] 39 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/assign_ops.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for compound assignment operations (`+=` and [INFO] [stderr] 9 | | /// similar). [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** Projects with many developers from languages without [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// a += 1; [INFO] [stderr] 20 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub ASSIGN_OPS, [INFO] [stderr] 23 | | restriction, [INFO] [stderr] 24 | | "any compound assignment operation" [INFO] [stderr] 25 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/assign_ops.rs:27:1 [INFO] [stderr] | [INFO] [stderr] 27 | / /// **What it does:** Checks for `a = a op b` or `a = b commutative_op a` [INFO] [stderr] 28 | | /// patterns. [INFO] [stderr] 29 | | /// [INFO] [stderr] 30 | | /// **Why is this bad?** These can be written as the shorter `a op= b`. [INFO] [stderr] ... | [INFO] [stderr] 39 | | /// a = a + b; [INFO] [stderr] 40 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 41 | / declare_clippy_lint! { [INFO] [stderr] 42 | | pub ASSIGN_OP_PATTERN, [INFO] [stderr] 43 | | style, [INFO] [stderr] 44 | | "assigning the result of an operation on a variable to that same variable" [INFO] [stderr] 45 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/assign_ops.rs:47:1 [INFO] [stderr] | [INFO] [stderr] 47 | / /// **What it does:** Checks for `a op= a op b` or `a op= b op a` patterns. [INFO] [stderr] 48 | | /// [INFO] [stderr] 49 | | /// **Why is this bad?** Most likely these are bugs where one meant to write `a [INFO] [stderr] 50 | | /// op= b`. [INFO] [stderr] ... | [INFO] [stderr] 59 | | /// a += a + b; [INFO] [stderr] 60 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 61 | / declare_clippy_lint! { [INFO] [stderr] 62 | | pub MISREFACTORED_ASSIGN_OP, [INFO] [stderr] 63 | | complexity, [INFO] [stderr] 64 | | "having a variable on both sides of an assign op" [INFO] [stderr] 65 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/attrs.rs:15:1 [INFO] [stderr] | [INFO] [stderr] 15 | / /// **What it does:** Checks for items annotated with `#[inline(always)]`, [INFO] [stderr] 16 | | /// unless the annotated function is empty or simply panics. [INFO] [stderr] 17 | | /// [INFO] [stderr] 18 | | /// **Why is this bad?** While there are valid uses of this annotation (and once [INFO] [stderr] ... | [INFO] [stderr] 33 | | /// fn not_quite_hot_code(..) { ... } [INFO] [stderr] 34 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 35 | / declare_clippy_lint! { [INFO] [stderr] 36 | | pub INLINE_ALWAYS, [INFO] [stderr] 37 | | pedantic, [INFO] [stderr] 38 | | "use of `#[inline(always)]`" [INFO] [stderr] 39 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/attrs.rs:41:1 [INFO] [stderr] | [INFO] [stderr] 41 | / /// **What it does:** Checks for `extern crate` and `use` items annotated with [INFO] [stderr] 42 | | /// lint attributes [INFO] [stderr] 43 | | /// [INFO] [stderr] 44 | | /// **Why is this bad?** Lint attributes have no effect on crate imports. Most [INFO] [stderr] ... | [INFO] [stderr] 57 | | /// use foo::bar; [INFO] [stderr] 58 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 59 | / declare_clippy_lint! { [INFO] [stderr] 60 | | pub USELESS_ATTRIBUTE, [INFO] [stderr] 61 | | correctness, [INFO] [stderr] 62 | | "use of lint attributes on `extern crate` items" [INFO] [stderr] 63 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/attrs.rs:65:1 [INFO] [stderr] | [INFO] [stderr] 65 | / /// **What it does:** Checks for `#[deprecated]` annotations with a `since` [INFO] [stderr] 66 | | /// field that is not a valid semantic version. [INFO] [stderr] 67 | | /// [INFO] [stderr] 68 | | /// **Why is this bad?** For checking the version of the deprecation, it must be [INFO] [stderr] ... | [INFO] [stderr] 76 | | /// fn something_else(..) { ... } [INFO] [stderr] 77 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 78 | / declare_clippy_lint! { [INFO] [stderr] 79 | | pub DEPRECATED_SEMVER, [INFO] [stderr] 80 | | correctness, [INFO] [stderr] 81 | | "use of `#[deprecated(since = \"x\")]` where x is not semver" [INFO] [stderr] 82 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/attrs.rs:84:1 [INFO] [stderr] | [INFO] [stderr] 84 | / /// **What it does:** Checks for empty lines after outer attributes [INFO] [stderr] 85 | | /// [INFO] [stderr] 86 | | /// **Why is this bad?** [INFO] [stderr] 87 | | /// Most likely the attribute was meant to be an inner attribute using a '!'. [INFO] [stderr] ... | [INFO] [stderr] 111 | | /// fn this_is_fine_too(..) { ... } [INFO] [stderr] 112 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 113 | / declare_clippy_lint! { [INFO] [stderr] 114 | | pub EMPTY_LINE_AFTER_OUTER_ATTR, [INFO] [stderr] 115 | | nursery, [INFO] [stderr] 116 | | "empty line after outer attribute" [INFO] [stderr] 117 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/bit_mask.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for incompatible bit masks in comparisons. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// The formula for detecting if an expression of the type `_ m [INFO] [stderr] 12 | | /// c` (where `` is one of {`&`, `|`} and `` is one of [INFO] [stderr] ... | [INFO] [stderr] 37 | | /// if (x & 1 == 2) { … } [INFO] [stderr] 38 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 39 | / declare_clippy_lint! { [INFO] [stderr] 40 | | pub BAD_BIT_MASK, [INFO] [stderr] 41 | | correctness, [INFO] [stderr] 42 | | "expressions of the form `_ & mask == select` that will only ever return `true` or `false`" [INFO] [stderr] 43 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/bit_mask.rs:45:1 [INFO] [stderr] | [INFO] [stderr] 45 | / /// **What it does:** Checks for bit masks in comparisons which can be removed [INFO] [stderr] 46 | | /// without changing the outcome. The basic structure can be seen in the [INFO] [stderr] 47 | | /// following table: [INFO] [stderr] 48 | | /// [INFO] [stderr] ... | [INFO] [stderr] 65 | | /// if (x | 1 > 3) { … } [INFO] [stderr] 66 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 67 | / declare_clippy_lint! { [INFO] [stderr] 68 | | pub INEFFECTIVE_BIT_MASK, [INFO] [stderr] 69 | | correctness, [INFO] [stderr] 70 | | "expressions where a bit mask will be rendered useless by a comparison, e.g. `(x | 1) > 2`" [INFO] [stderr] 71 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/bit_mask.rs:73:1 [INFO] [stderr] | [INFO] [stderr] 73 | / /// **What it does:** Checks for bit masks that can be replaced by a call [INFO] [stderr] 74 | | /// to `trailing_zeros` [INFO] [stderr] 75 | | /// [INFO] [stderr] 76 | | /// **Why is this bad?** `x.trailing_zeros() > 4` is much clearer than `x & 15 [INFO] [stderr] ... | [INFO] [stderr] 83 | | /// x & 0x1111 == 0 [INFO] [stderr] 84 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 85 | / declare_clippy_lint! { [INFO] [stderr] 86 | | pub VERBOSE_BIT_MASK, [INFO] [stderr] 87 | | style, [INFO] [stderr] 88 | | "expressions where a bit mask is less readable than the corresponding method call" [INFO] [stderr] 89 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/blacklisted_name.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for usage of blacklisted names for variables, such [INFO] [stderr] 6 | | /// as `foo`. [INFO] [stderr] 7 | | /// [INFO] [stderr] 8 | | /// **Why is this bad?** These names are usually placeholder names and should be [INFO] [stderr] ... | [INFO] [stderr] 15 | | /// let foo = 3.14; [INFO] [stderr] 16 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 17 | / declare_clippy_lint! { [INFO] [stderr] 18 | | pub BLACKLISTED_NAME, [INFO] [stderr] 19 | | style, [INFO] [stderr] 20 | | "usage of a blacklisted/placeholder name" [INFO] [stderr] 21 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/block_in_if_condition.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for `if` conditions that use blocks to contain an [INFO] [stderr] 7 | | /// expression. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** It isn't really Rust style, same as using parentheses [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// if { true } .. [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub BLOCK_IN_IF_CONDITION_EXPR, [INFO] [stderr] 20 | | style, [INFO] [stderr] 21 | | "braces that can be eliminated in conditions, e.g. `if { true } ...`" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/block_in_if_condition.rs:24:1 [INFO] [stderr] | [INFO] [stderr] 24 | / /// **What it does:** Checks for `if` conditions that use blocks containing [INFO] [stderr] 25 | | /// statements, or conditions that use closures with blocks. [INFO] [stderr] 26 | | /// [INFO] [stderr] 27 | | /// **Why is this bad?** Using blocks in the condition makes it hard to read. [INFO] [stderr] ... | [INFO] [stderr] 35 | | /// if somefunc(|x| { x == 47 }) .. [INFO] [stderr] 36 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 37 | / declare_clippy_lint! { [INFO] [stderr] 38 | | pub BLOCK_IN_IF_CONDITION_STMT, [INFO] [stderr] 39 | | style, [INFO] [stderr] 40 | | "complex blocks in conditions, e.g. `if { let x = true; x } ...`" [INFO] [stderr] 41 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/booleans.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for boolean expressions that can be written more [INFO] [stderr] 10 | | /// concisely. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** Readability of boolean expressions suffers from [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// if !(a == b) // should be: if a != b [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub NONMINIMAL_BOOL, [INFO] [stderr] 25 | | complexity, [INFO] [stderr] 26 | | "boolean expressions that can be written more concisely" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/booleans.rs:29:1 [INFO] [stderr] | [INFO] [stderr] 29 | / /// **What it does:** Checks for boolean expressions that contain terminals that [INFO] [stderr] 30 | | /// can be eliminated. [INFO] [stderr] 31 | | /// [INFO] [stderr] 32 | | /// **Why is this bad?** This is most likely a logic bug. [INFO] [stderr] ... | [INFO] [stderr] 39 | | /// ``` [INFO] [stderr] 40 | | /// The `b` is unnecessary, the expression is equivalent to `if a`. [INFO] [stderr] | |___________________________________________________________________^ [INFO] [stderr] 41 | / declare_clippy_lint! { [INFO] [stderr] 42 | | pub LOGIC_BUG, [INFO] [stderr] 43 | | correctness, [INFO] [stderr] 44 | | "boolean expressions that contain terminals which can be eliminated" [INFO] [stderr] 45 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/bytecount.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for naive byte counts [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** The [`bytecount`](https://crates.io/crates/bytecount) [INFO] [stderr] 11 | | /// crate has methods to count your bytes faster, especially for large slices. [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// &my_data.filter(|&x| x == 0u8).count() // use bytecount::count instead [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub NAIVE_BYTECOUNT, [INFO] [stderr] 25 | | perf, [INFO] [stderr] 26 | | "use of naive `.filter(|&x| x == y).count()` to count byte values" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/collapsible_if.rs:21:1 [INFO] [stderr] | [INFO] [stderr] 21 | / /// **What it does:** Checks for nested `if` statements which can be collapsed [INFO] [stderr] 22 | | /// by `&&`-combining their conditions and for `else { if ... }` expressions [INFO] [stderr] 23 | | /// that [INFO] [stderr] 24 | | /// can be collapsed to `else if ...`. [INFO] [stderr] ... | [INFO] [stderr] 63 | | /// } [INFO] [stderr] 64 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 65 | / declare_clippy_lint! { [INFO] [stderr] 66 | | pub COLLAPSIBLE_IF, [INFO] [stderr] 67 | | style, [INFO] [stderr] 68 | | "`if`s that can be collapsed (e.g. `if x { if y { ... } }` and `else { if x { ... } }`)" [INFO] [stderr] 69 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/const_static_lifetime.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for constants with an explicit `'static` lifetime. [INFO] [stderr] 6 | | /// [INFO] [stderr] 7 | | /// **Why is this bad?** Adding `'static` to every reference can create very [INFO] [stderr] 8 | | /// complicated types. [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// const FOO: &[(&str, &str, fn(&Bar) -> bool)] = &[...] [INFO] [stderr] 20 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub CONST_STATIC_LIFETIME, [INFO] [stderr] 23 | | style, [INFO] [stderr] 24 | | "Using explicit `'static` lifetime for constants when elision rules would allow omitting them." [INFO] [stderr] 25 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/copies.rs:11:1 [INFO] [stderr] | [INFO] [stderr] 11 | / /// **What it does:** Checks for consecutive `if`s with the same condition. [INFO] [stderr] 12 | | /// [INFO] [stderr] 13 | | /// **Why is this bad?** This is probably a copy & paste error. [INFO] [stderr] 14 | | /// [INFO] [stderr] ... | [INFO] [stderr] 34 | | /// } [INFO] [stderr] 35 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 36 | / declare_clippy_lint! { [INFO] [stderr] 37 | | pub IFS_SAME_COND, [INFO] [stderr] 38 | | correctness, [INFO] [stderr] 39 | | "consecutive `ifs` with the same condition" [INFO] [stderr] 40 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/copies.rs:42:1 [INFO] [stderr] | [INFO] [stderr] 42 | / /// **What it does:** Checks for `if/else` with the same body as the *then* part [INFO] [stderr] 43 | | /// and the *else* part. [INFO] [stderr] 44 | | /// [INFO] [stderr] 45 | | /// **Why is this bad?** This is probably a copy & paste error. [INFO] [stderr] ... | [INFO] [stderr] 55 | | /// }; [INFO] [stderr] 56 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 57 | / declare_clippy_lint! { [INFO] [stderr] 58 | | pub IF_SAME_THEN_ELSE, [INFO] [stderr] 59 | | correctness, [INFO] [stderr] 60 | | "if with the same *then* and *else* blocks" [INFO] [stderr] 61 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/copies.rs:63:1 [INFO] [stderr] | [INFO] [stderr] 63 | / /// **What it does:** Checks for `match` with identical arm bodies. [INFO] [stderr] 64 | | /// [INFO] [stderr] 65 | | /// **Why is this bad?** This is probably a copy & paste error. If arm bodies [INFO] [stderr] 66 | | /// are the same on purpose, you can factor them [INFO] [stderr] ... | [INFO] [stderr] 96 | | /// } [INFO] [stderr] 97 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 98 | / declare_clippy_lint! { [INFO] [stderr] 99 | | pub MATCH_SAME_ARMS, [INFO] [stderr] 100 | | pedantic, [INFO] [stderr] 101 | | "`match` with identical arm bodies" [INFO] [stderr] 102 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/cyclomatic_complexity.rs:13:1 [INFO] [stderr] | [INFO] [stderr] 13 | / /// **What it does:** Checks for methods with high cyclomatic complexity. [INFO] [stderr] 14 | | /// [INFO] [stderr] 15 | | /// **Why is this bad?** Methods of high cyclomatic complexity tend to be badly [INFO] [stderr] 16 | | /// readable. Also LLVM will usually optimize small methods better. [INFO] [stderr] ... | [INFO] [stderr] 20 | | /// [INFO] [stderr] 21 | | /// **Example:** No. You'll see it when you get the warning. [INFO] [stderr] | |____________________________________________________________^ [INFO] [stderr] 22 | / declare_clippy_lint! { [INFO] [stderr] 23 | | pub CYCLOMATIC_COMPLEXITY, [INFO] [stderr] 24 | | complexity, [INFO] [stderr] 25 | | "functions that should be split up into multiple functions" [INFO] [stderr] 26 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/default_trait_access.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for literal calls to `Default::default()`. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** It's more clear to the reader to use the name of the type whose default is [INFO] [stderr] 11 | | /// being gotten than the generic `Default`. [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// let s = String::default(); [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub DEFAULT_TRAIT_ACCESS, [INFO] [stderr] 25 | | pedantic, [INFO] [stderr] 26 | | "checks for literal calls to Default::default()" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/derive.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for deriving `Hash` but implementing `PartialEq` [INFO] [stderr] 9 | | /// explicitly or vice versa. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** The implementation of these traits must agree (for [INFO] [stderr] ... | [INFO] [stderr] 29 | | /// } [INFO] [stderr] 30 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 31 | / declare_clippy_lint! { [INFO] [stderr] 32 | | pub DERIVE_HASH_XOR_EQ, [INFO] [stderr] 33 | | correctness, [INFO] [stderr] 34 | | "deriving `Hash` but implementing `PartialEq` explicitly" [INFO] [stderr] 35 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/derive.rs:37:1 [INFO] [stderr] | [INFO] [stderr] 37 | / /// **What it does:** Checks for explicit `Clone` implementations for `Copy` [INFO] [stderr] 38 | | /// types. [INFO] [stderr] 39 | | /// [INFO] [stderr] 40 | | /// **Why is this bad?** To avoid surprising behaviour, these traits should [INFO] [stderr] ... | [INFO] [stderr] 55 | | /// } [INFO] [stderr] 56 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 57 | / declare_clippy_lint! { [INFO] [stderr] 58 | | pub EXPL_IMPL_CLONE_ON_COPY, [INFO] [stderr] 59 | | pedantic, [INFO] [stderr] 60 | | "implementing `Clone` explicitly on `Copy` types" [INFO] [stderr] 61 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/doc.rs:10:1 [INFO] [stderr] | [INFO] [stderr] 10 | / /// **What it does:** Checks for the presence of `_`, `::` or camel-case words [INFO] [stderr] 11 | | /// outside ticks in documentation. [INFO] [stderr] 12 | | /// [INFO] [stderr] 13 | | /// **Why is this bad?** *Rustdoc* supports markdown formatting, `_`, `::` and [INFO] [stderr] ... | [INFO] [stderr] 26 | | /// fn doit(foo_bar) { .. } [INFO] [stderr] 27 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 28 | / declare_clippy_lint! { [INFO] [stderr] 29 | | pub DOC_MARKDOWN, [INFO] [stderr] 30 | | pedantic, [INFO] [stderr] 31 | | "presence of `_`, `::` or camel-case outside backticks in documentation" [INFO] [stderr] 32 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/double_comparison.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for double comparions that could be simpified to a single expression. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** Readability. [INFO] [stderr] ... | [INFO] [stderr] 24 | | /// x <= y [INFO] [stderr] 25 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 26 | / declare_clippy_lint! { [INFO] [stderr] 27 | | pub DOUBLE_COMPARISONS, [INFO] [stderr] 28 | | complexity, [INFO] [stderr] 29 | | "unnecessary double comparisons that can be simplified" [INFO] [stderr] 30 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/double_parens.rs:4:1 [INFO] [stderr] | [INFO] [stderr] 4 | / /// **What it does:** Checks for unnecessary double parentheses. [INFO] [stderr] 5 | | /// [INFO] [stderr] 6 | | /// **Why is this bad?** This makes code harder to read and might indicate a [INFO] [stderr] 7 | | /// mistake. [INFO] [stderr] ... | [INFO] [stderr] 15 | | /// ((1, 2)) [INFO] [stderr] 16 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 17 | / declare_clippy_lint! { [INFO] [stderr] 18 | | pub DOUBLE_PARENS, [INFO] [stderr] 19 | | complexity, [INFO] [stderr] 20 | | "Warn on unnecessary double parentheses" [INFO] [stderr] 21 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/drop_forget_ref.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for calls to `std::mem::drop` with a reference [INFO] [stderr] 7 | | /// instead of an owned value. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** Calling `drop` on a reference will only drop the [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// operation_that_requires_mutex_to_be_unlocked(); [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub DROP_REF, [INFO] [stderr] 25 | | correctness, [INFO] [stderr] 26 | | "calls to `std::mem::drop` with a reference instead of an owned value" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/drop_forget_ref.rs:29:1 [INFO] [stderr] | [INFO] [stderr] 29 | / /// **What it does:** Checks for calls to `std::mem::forget` with a reference [INFO] [stderr] 30 | | /// instead of an owned value. [INFO] [stderr] 31 | | /// [INFO] [stderr] 32 | | /// **Why is this bad?** Calling `forget` on a reference will only forget the [INFO] [stderr] ... | [INFO] [stderr] 42 | | /// std::mem::forget(&x) // Should have been forget(x), x will still be dropped [INFO] [stderr] 43 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 44 | / declare_clippy_lint! { [INFO] [stderr] 45 | | pub FORGET_REF, [INFO] [stderr] 46 | | correctness, [INFO] [stderr] 47 | | "calls to `std::mem::forget` with a reference instead of an owned value" [INFO] [stderr] 48 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/drop_forget_ref.rs:50:1 [INFO] [stderr] | [INFO] [stderr] 50 | / /// **What it does:** Checks for calls to `std::mem::drop` with a value [INFO] [stderr] 51 | | /// that derives the Copy trait [INFO] [stderr] 52 | | /// [INFO] [stderr] 53 | | /// **Why is this bad?** Calling `std::mem::drop` [does nothing for types that [INFO] [stderr] ... | [INFO] [stderr] 63 | | /// // original unaffected [INFO] [stderr] 64 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 65 | / declare_clippy_lint! { [INFO] [stderr] 66 | | pub DROP_COPY, [INFO] [stderr] 67 | | correctness, [INFO] [stderr] 68 | | "calls to `std::mem::drop` with a value that implements Copy" [INFO] [stderr] 69 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/drop_forget_ref.rs:71:1 [INFO] [stderr] | [INFO] [stderr] 71 | / /// **What it does:** Checks for calls to `std::mem::forget` with a value that [INFO] [stderr] 72 | | /// derives the Copy trait [INFO] [stderr] 73 | | /// [INFO] [stderr] 74 | | /// **Why is this bad?** Calling `std::mem::forget` [does nothing for types that [INFO] [stderr] ... | [INFO] [stderr] 90 | | /// // original unaffected [INFO] [stderr] 91 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 92 | / declare_clippy_lint! { [INFO] [stderr] 93 | | pub FORGET_COPY, [INFO] [stderr] 94 | | correctness, [INFO] [stderr] 95 | | "calls to `std::mem::forget` with a value that implements Copy" [INFO] [stderr] 96 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/duration_subsec.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for calculation of subsecond microseconds or milliseconds [INFO] [stderr] 10 | | /// from other `Duration` methods. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** It's more concise to call `Duration::subsec_micros()` or [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// let _millis = dur.subsec_nanos() / 1_000_000; [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub DURATION_SUBSEC, [INFO] [stderr] 25 | | complexity, [INFO] [stderr] 26 | | "checks for calculation of subsecond microseconds or milliseconds" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/else_if_without_else.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for usage of if expressions with an `else if` branch, [INFO] [stderr] 9 | | /// but without a final `else` branch. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** Some coding guidelines require this (e.g. MISRA-C:2004 Rule 14.10). [INFO] [stderr] ... | [INFO] [stderr] 33 | | /// } [INFO] [stderr] 34 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 35 | / declare_clippy_lint! { [INFO] [stderr] 36 | | pub ELSE_IF_WITHOUT_ELSE, [INFO] [stderr] 37 | | restriction, [INFO] [stderr] 38 | | "if expression with an `else if`, but without a final `else` branch" [INFO] [stderr] 39 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/empty_enum.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for `enum`s with no variants. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** Enum's with no variants should be replaced with `!`, [INFO] [stderr] 10 | | /// the uninhabited type, [INFO] [stderr] ... | [INFO] [stderr] 17 | | /// enum Test {} [INFO] [stderr] 18 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 19 | / declare_clippy_lint! { [INFO] [stderr] 20 | | pub EMPTY_ENUM, [INFO] [stderr] 21 | | pedantic, [INFO] [stderr] 22 | | "enum with no variants" [INFO] [stderr] 23 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/entry.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for uses of `contains_key` + `insert` on `HashMap` [INFO] [stderr] 9 | | /// or `BTreeMap`. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** Using `entry` is more efficient. [INFO] [stderr] ... | [INFO] [stderr] 25 | | /// m.entry(k).or_insert(v); [INFO] [stderr] 26 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 27 | / declare_clippy_lint! { [INFO] [stderr] 28 | | pub MAP_ENTRY, [INFO] [stderr] 29 | | perf, [INFO] [stderr] 30 | | "use of `contains_key` followed by `insert` on a `HashMap` or `BTreeMap`" [INFO] [stderr] 31 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/enum_clike.rs:14:1 [INFO] [stderr] | [INFO] [stderr] 14 | / /// **What it does:** Checks for C-like enumerations that are [INFO] [stderr] 15 | | /// `repr(isize/usize)` and have values that don't fit into an `i32`. [INFO] [stderr] 16 | | /// [INFO] [stderr] 17 | | /// **Why is this bad?** This will truncate the variant value on 32 bit [INFO] [stderr] ... | [INFO] [stderr] 28 | | /// } [INFO] [stderr] 29 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 30 | / declare_clippy_lint! { [INFO] [stderr] 31 | | pub ENUM_CLIKE_UNPORTABLE_VARIANT, [INFO] [stderr] 32 | | correctness, [INFO] [stderr] 33 | | "C-like enums that are `repr(isize/usize)` and have values that don't fit into an `i32`" [INFO] [stderr] 34 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/enum_glob_use.rs:10:1 [INFO] [stderr] | [INFO] [stderr] 10 | / /// **What it does:** Checks for `use Enum::*`. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** It is usually better style to use the prefixed name of [INFO] [stderr] 13 | | /// an enumeration variant, rather than importing variants. [INFO] [stderr] ... | [INFO] [stderr] 20 | | /// use std::cmp::Ordering::*; [INFO] [stderr] 21 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 22 | / declare_clippy_lint! { [INFO] [stderr] 23 | | pub ENUM_GLOB_USE, [INFO] [stderr] 24 | | pedantic, [INFO] [stderr] 25 | | "use items that import all variants of an enum" [INFO] [stderr] 26 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/enum_variants.rs:10:1 [INFO] [stderr] | [INFO] [stderr] 10 | / /// **What it does:** Detects enumeration variants that are prefixed or suffixed [INFO] [stderr] 11 | | /// by the same characters. [INFO] [stderr] 12 | | /// [INFO] [stderr] 13 | | /// **Why is this bad?** Enumeration variant names should specify their variant, [INFO] [stderr] ... | [INFO] [stderr] 24 | | /// } [INFO] [stderr] 25 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 26 | / declare_clippy_lint! { [INFO] [stderr] 27 | | pub ENUM_VARIANT_NAMES, [INFO] [stderr] 28 | | style, [INFO] [stderr] 29 | | "enums where all variants share a prefix/postfix" [INFO] [stderr] 30 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/enum_variants.rs:32:1 [INFO] [stderr] | [INFO] [stderr] 32 | / /// **What it does:** Detects enumeration variants that are prefixed or suffixed [INFO] [stderr] 33 | | /// by the same characters. [INFO] [stderr] 34 | | /// [INFO] [stderr] 35 | | /// **Why is this bad?** Enumeration variant names should specify their variant, [INFO] [stderr] ... | [INFO] [stderr] 46 | | /// } [INFO] [stderr] 47 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 48 | / declare_clippy_lint! { [INFO] [stderr] 49 | | pub PUB_ENUM_VARIANT_NAMES, [INFO] [stderr] 50 | | pedantic, [INFO] [stderr] 51 | | "enums where all variants share a prefix/postfix" [INFO] [stderr] 52 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/enum_variants.rs:54:1 [INFO] [stderr] | [INFO] [stderr] 54 | / /// **What it does:** Detects type names that are prefixed or suffixed by the [INFO] [stderr] 55 | | /// containing module's name. [INFO] [stderr] 56 | | /// [INFO] [stderr] 57 | | /// **Why is this bad?** It requires the user to type the module name twice. [INFO] [stderr] ... | [INFO] [stderr] 65 | | /// } [INFO] [stderr] 66 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 67 | / declare_clippy_lint! { [INFO] [stderr] 68 | | pub STUTTER, [INFO] [stderr] 69 | | pedantic, [INFO] [stderr] 70 | | "type names prefixed/postfixed with their containing module's name" [INFO] [stderr] 71 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/enum_variants.rs:73:1 [INFO] [stderr] | [INFO] [stderr] 73 | / /// **What it does:** Checks for modules that have the same name as their [INFO] [stderr] 74 | | /// parent module [INFO] [stderr] 75 | | /// [INFO] [stderr] 76 | | /// **Why is this bad?** A typical beginner mistake is to have `mod foo;` and [INFO] [stderr] ... | [INFO] [stderr] 95 | | /// } [INFO] [stderr] 96 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 97 | / declare_clippy_lint! { [INFO] [stderr] 98 | | pub MODULE_INCEPTION, [INFO] [stderr] 99 | | style, [INFO] [stderr] 100 | | "modules that have the same name as their parent module" [INFO] [stderr] 101 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/eq_op.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for equal operands to comparison, logical and [INFO] [stderr] 6 | | /// bitwise, difference and division binary operators (`==`, `>`, etc., `&&`, [INFO] [stderr] 7 | | /// `||`, `&`, `|`, `^`, `-` and `/`). [INFO] [stderr] 8 | | /// [INFO] [stderr] ... | [INFO] [stderr] 18 | | /// x + 1 == x + 1 [INFO] [stderr] 19 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 20 | / declare_clippy_lint! { [INFO] [stderr] 21 | | pub EQ_OP, [INFO] [stderr] 22 | | correctness, [INFO] [stderr] 23 | | "equal operands on both sides of a comparison or bitwise combination (e.g. `x == x`)" [INFO] [stderr] 24 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/eq_op.rs:26:1 [INFO] [stderr] | [INFO] [stderr] 26 | / /// **What it does:** Checks for arguments to `==` which have their address [INFO] [stderr] 27 | | /// taken to satisfy a bound [INFO] [stderr] 28 | | /// and suggests to dereference the other argument instead [INFO] [stderr] 29 | | /// [INFO] [stderr] ... | [INFO] [stderr] 36 | | /// &x == y [INFO] [stderr] 37 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 38 | / declare_clippy_lint! { [INFO] [stderr] 39 | | pub OP_REF, [INFO] [stderr] 40 | | style, [INFO] [stderr] 41 | | "taking a reference to satisfy the type constraints on `==`" [INFO] [stderr] 42 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/erasing_op.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for erasing operations, e.g. `x * 0`. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** The whole expression can be replaced by zero. [INFO] [stderr] 10 | | /// This is most likely not the intended outcome and should probably be [INFO] [stderr] ... | [INFO] [stderr] 17 | | /// 0 / x; 0 * x; x & 0 [INFO] [stderr] 18 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 19 | / declare_clippy_lint! { [INFO] [stderr] 20 | | pub ERASING_OP, [INFO] [stderr] 21 | | correctness, [INFO] [stderr] 22 | | "using erasing operations, e.g. `x * 0` or `y & 0`" [INFO] [stderr] 23 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/escape.rs:18:1 [INFO] [stderr] | [INFO] [stderr] 18 | / /// **What it does:** Checks for usage of `Box` where an unboxed `T` would [INFO] [stderr] 19 | | /// work fine. [INFO] [stderr] 20 | | /// [INFO] [stderr] 21 | | /// **Why is this bad?** This is an unnecessary allocation, and bad for [INFO] [stderr] ... | [INFO] [stderr] 33 | | /// } [INFO] [stderr] 34 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 35 | / declare_clippy_lint! { [INFO] [stderr] 36 | | pub BOXED_LOCAL, [INFO] [stderr] 37 | | perf, [INFO] [stderr] 38 | | "using `Box` where unnecessary" [INFO] [stderr] 39 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/eta_reduction.rs:10:1 [INFO] [stderr] | [INFO] [stderr] 10 | / /// **What it does:** Checks for closures which just call another function where [INFO] [stderr] 11 | | /// the function can be called directly. `unsafe` functions or calls where types [INFO] [stderr] 12 | | /// get adjusted are ignored. [INFO] [stderr] 13 | | /// [INFO] [stderr] ... | [INFO] [stderr] 23 | | /// where `foo(_)` is a plain function that takes the exact argument type of [INFO] [stderr] 24 | | /// `x`. [INFO] [stderr] | |________^ [INFO] [stderr] 25 | / declare_clippy_lint! { [INFO] [stderr] 26 | | pub REDUNDANT_CLOSURE, [INFO] [stderr] 27 | | style, [INFO] [stderr] 28 | | "redundant closures, i.e. `|a| foo(a)` (which can be written as just `foo`)" [INFO] [stderr] 29 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/eval_order_dependence.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for a read and a write to the same variable where [INFO] [stderr] 9 | | /// whether the read occurs before or after the write depends on the evaluation [INFO] [stderr] 10 | | /// order of sub-expressions. [INFO] [stderr] 11 | | /// [INFO] [stderr] ... | [INFO] [stderr] 22 | | /// // Unclear whether a is 1 or 2. [INFO] [stderr] 23 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 24 | / declare_clippy_lint! { [INFO] [stderr] 25 | | pub EVAL_ORDER_DEPENDENCE, [INFO] [stderr] 26 | | complexity, [INFO] [stderr] 27 | | "whether a variable read occurs before a write depends on sub-expression evaluation order" [INFO] [stderr] 28 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/eval_order_dependence.rs:30:1 [INFO] [stderr] | [INFO] [stderr] 30 | / /// **What it does:** Checks for diverging calls that are not match arms or [INFO] [stderr] 31 | | /// statements. [INFO] [stderr] 32 | | /// [INFO] [stderr] 33 | | /// **Why is this bad?** It is often confusing to read. In addition, the [INFO] [stderr] ... | [INFO] [stderr] 44 | | /// // can simply be replaced by `panic!()` [INFO] [stderr] 45 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 46 | / declare_clippy_lint! { [INFO] [stderr] 47 | | pub DIVERGING_SUB_EXPRESSION, [INFO] [stderr] 48 | | complexity, [INFO] [stderr] 49 | | "whether an expression contains a diverging sub expression" [INFO] [stderr] 50 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/excessive_precision.rs:11:1 [INFO] [stderr] | [INFO] [stderr] 11 | / /// **What it does:** Checks for float literals with a precision greater [INFO] [stderr] 12 | | /// than that supported by the underlying type [INFO] [stderr] 13 | | /// [INFO] [stderr] 14 | | /// **Why is this bad?** Rust will truncate the literal silently. [INFO] [stderr] ... | [INFO] [stderr] 27 | | /// println!("{}", v); // 0.123_456_789_9 [INFO] [stderr] 28 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 29 | / declare_clippy_lint! { [INFO] [stderr] 30 | | pub EXCESSIVE_PRECISION, [INFO] [stderr] 31 | | style, [INFO] [stderr] 32 | | "excessive precision for float literal" [INFO] [stderr] 33 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/explicit_write.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for usage of `write!()` / `writeln()!` which can be [INFO] [stderr] 7 | | /// replaced with `(e)print!()` / `(e)println!()` [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** Using `(e)println! is clearer and more concise [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// writeln!(&mut io::stderr(), "foo: {:?}", bar).unwrap(); [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub EXPLICIT_WRITE, [INFO] [stderr] 20 | | complexity, [INFO] [stderr] 21 | | "using the `write!()` family of functions instead of the `print!()` family \ [INFO] [stderr] 22 | | of functions, when using the latter would work" [INFO] [stderr] 23 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/fallible_impl_from.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for impls of `From<..>` that contain `panic!()` or `unwrap()` [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** `TryFrom` should be used if there's a possibility of failure. [INFO] [stderr] 11 | | /// [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// } [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub FALLIBLE_IMPL_FROM, [INFO] [stderr] 25 | | nursery, [INFO] [stderr] 26 | | "Warn on impls of `From<..>` that contain `panic!()` or `unwrap()`" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/format.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for the use of `format!("string literal with no [INFO] [stderr] 10 | | /// argument")` and `format!("{}", foo)` where `foo` is a string. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** There is no point of doing that. `format!("too")` can [INFO] [stderr] ... | [INFO] [stderr] 23 | | /// format!("{}", foo) [INFO] [stderr] 24 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 25 | / declare_clippy_lint! { [INFO] [stderr] 26 | | pub USELESS_FORMAT, [INFO] [stderr] 27 | | complexity, [INFO] [stderr] 28 | | "useless use of `format!`" [INFO] [stderr] 29 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/formatting.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for use of the non-existent `=*`, `=!` and `=-` [INFO] [stderr] 7 | | /// operators. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** This is either a typo of `*=`, `!=` or `-=` or [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// a =- 42; // confusing, should it be `a -= 42` or `a = -42`? [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub SUSPICIOUS_ASSIGNMENT_FORMATTING, [INFO] [stderr] 20 | | style, [INFO] [stderr] 21 | | "suspicious formatting of `*=`, `-=` or `!=`" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/formatting.rs:24:1 [INFO] [stderr] | [INFO] [stderr] 24 | / /// **What it does:** Checks for formatting of `else if`. It lints if the `else` [INFO] [stderr] 25 | | /// and `if` are not on the same line or the `else` seems to be missing. [INFO] [stderr] 26 | | /// [INFO] [stderr] 27 | | /// **Why is this bad?** This is probably some refactoring remnant, even if the [INFO] [stderr] ... | [INFO] [stderr] 42 | | /// } [INFO] [stderr] 43 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 44 | / declare_clippy_lint! { [INFO] [stderr] 45 | | pub SUSPICIOUS_ELSE_FORMATTING, [INFO] [stderr] 46 | | style, [INFO] [stderr] 47 | | "suspicious formatting of `else if`" [INFO] [stderr] 48 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/formatting.rs:50:1 [INFO] [stderr] | [INFO] [stderr] 50 | / /// **What it does:** Checks for possible missing comma in an array. It lints if [INFO] [stderr] 51 | | /// an array element is a binary operator expression and it lies on two lines. [INFO] [stderr] 52 | | /// [INFO] [stderr] 53 | | /// **Why is this bad?** This could lead to unexpected results. [INFO] [stderr] ... | [INFO] [stderr] 62 | | /// ]; [INFO] [stderr] 63 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 64 | / declare_clippy_lint! { [INFO] [stderr] 65 | | pub POSSIBLE_MISSING_COMMA, [INFO] [stderr] 66 | | correctness, [INFO] [stderr] 67 | | "possible missing comma in array" [INFO] [stderr] 68 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/functions.rs:12:1 [INFO] [stderr] | [INFO] [stderr] 12 | / /// **What it does:** Checks for functions with too many parameters. [INFO] [stderr] 13 | | /// [INFO] [stderr] 14 | | /// **Why is this bad?** Functions with lots of parameters are considered bad [INFO] [stderr] 15 | | /// style and reduce readability (“what does the 5th parameter mean?”). Consider [INFO] [stderr] ... | [INFO] [stderr] 23 | | /// f32) { .. } [INFO] [stderr] 24 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 25 | / declare_clippy_lint! { [INFO] [stderr] 26 | | pub TOO_MANY_ARGUMENTS, [INFO] [stderr] 27 | | complexity, [INFO] [stderr] 28 | | "functions with too many arguments" [INFO] [stderr] 29 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/functions.rs:31:1 [INFO] [stderr] | [INFO] [stderr] 31 | / /// **What it does:** Checks for public functions that dereferences raw pointer [INFO] [stderr] 32 | | /// arguments but are not marked unsafe. [INFO] [stderr] 33 | | /// [INFO] [stderr] 34 | | /// **Why is this bad?** The function should probably be marked `unsafe`, since [INFO] [stderr] ... | [INFO] [stderr] 49 | | /// pub fn foo(x: *const u8) { println!("{}", unsafe { *x }); } [INFO] [stderr] 50 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 51 | / declare_clippy_lint! { [INFO] [stderr] 52 | | pub NOT_UNSAFE_PTR_ARG_DEREF, [INFO] [stderr] 53 | | correctness, [INFO] [stderr] 54 | | "public functions dereferencing raw pointer arguments but not marked `unsafe`" [INFO] [stderr] 55 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/identity_conversion.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for always-identical `Into`/`From` conversions. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** Redundant code. [INFO] [stderr] 10 | | /// [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// let s: String = format!("hello").into(); [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub IDENTITY_CONVERSION, [INFO] [stderr] 20 | | complexity, [INFO] [stderr] 21 | | "using always-identical `Into`/`From` conversions" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/identity_op.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for identity operations, e.g. `x + 0`. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** This code can be removed without changing the [INFO] [stderr] 11 | | /// meaning. So it just obscures what's going on. Delete it mercilessly. [INFO] [stderr] ... | [INFO] [stderr] 17 | | /// x / 1 + 0 * 1 - 0 | 0 [INFO] [stderr] 18 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 19 | / declare_clippy_lint! { [INFO] [stderr] 20 | | pub IDENTITY_OP, [INFO] [stderr] 21 | | complexity, [INFO] [stderr] 22 | | "using identity operations, e.g. `x + 0` or `y / 1`" [INFO] [stderr] 23 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/if_let_redundant_pattern_matching.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Lint for redundant pattern matching over `Result` or [INFO] [stderr] 6 | | /// `Option` [INFO] [stderr] 7 | | /// [INFO] [stderr] 8 | | /// **Why is this bad?** It's more concise and clear to just use the proper [INFO] [stderr] ... | [INFO] [stderr] 29 | | /// ``` [INFO] [stderr] 30 | | /// [INFO] [stderr] | |___^ [INFO] [stderr] 31 | / declare_clippy_lint! { [INFO] [stderr] 32 | | pub IF_LET_REDUNDANT_PATTERN_MATCHING, [INFO] [stderr] 33 | | style, [INFO] [stderr] 34 | | "use the proper utility function avoiding an `if let`" [INFO] [stderr] 35 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/if_not_else.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for usage of `!` or `!=` in an if condition with an [INFO] [stderr] 10 | | /// else branch. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** Negations reduce the readability of statements. [INFO] [stderr] ... | [INFO] [stderr] 32 | | /// } [INFO] [stderr] 33 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 34 | / declare_clippy_lint! { [INFO] [stderr] 35 | | pub IF_NOT_ELSE, [INFO] [stderr] 36 | | pedantic, [INFO] [stderr] 37 | | "`if` branches that could be swapped so no negation operation is necessary on the condition" [INFO] [stderr] 38 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/indexing_slicing.rs:12:1 [INFO] [stderr] | [INFO] [stderr] 12 | / /// **What it does:** Checks for out of bounds array indexing with a constant [INFO] [stderr] 13 | | /// index. [INFO] [stderr] 14 | | /// [INFO] [stderr] 15 | | /// **Why is this bad?** This will always panic at runtime. [INFO] [stderr] ... | [INFO] [stderr] 29 | | /// x[3]; [INFO] [stderr] 30 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 31 | / declare_clippy_lint! { [INFO] [stderr] 32 | | pub OUT_OF_BOUNDS_INDEXING, [INFO] [stderr] 33 | | correctness, [INFO] [stderr] 34 | | "out of bounds constant indexing" [INFO] [stderr] 35 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/indexing_slicing.rs:37:1 [INFO] [stderr] | [INFO] [stderr] 37 | / /// **What it does:** Checks for usage of indexing or slicing. Arrays are special cased, this lint [INFO] [stderr] 38 | | /// does report on arrays if we can tell that slicing operations are in bounds and does not [INFO] [stderr] 39 | | /// lint on constant `usize` indexing on arrays because that is handled by rustc's `const_err` lint. [INFO] [stderr] 40 | | /// [INFO] [stderr] ... | [INFO] [stderr] 78 | | /// y.get(..100); [INFO] [stderr] 79 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 80 | / declare_clippy_lint! { [INFO] [stderr] 81 | | pub INDEXING_SLICING, [INFO] [stderr] 82 | | pedantic, [INFO] [stderr] 83 | | "indexing/slicing usage" [INFO] [stderr] 84 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/infallible_destructuring_match.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for matches being used to destructure a single-variant enum [INFO] [stderr] 6 | | /// or tuple struct where a `let` will suffice. [INFO] [stderr] 7 | | /// [INFO] [stderr] 8 | | /// **Why is this bad?** Just readability – `let` doesn't nest, whereas a `match` does. [INFO] [stderr] ... | [INFO] [stderr] 32 | | /// let Wrapper::Data(data) = wrapper; [INFO] [stderr] 33 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 34 | / declare_clippy_lint! { [INFO] [stderr] 35 | | pub INFALLIBLE_DESTRUCTURING_MATCH, [INFO] [stderr] 36 | | style, [INFO] [stderr] 37 | | "a match statement with a single infallible arm instead of a `let`" [INFO] [stderr] 38 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/infinite_iter.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for iteration that is guaranteed to be infinite. [INFO] [stderr] 6 | | /// [INFO] [stderr] 7 | | /// **Why is this bad?** While there may be places where this is acceptable [INFO] [stderr] 8 | | /// (e.g. in event streams), in most cases this is simply an error. [INFO] [stderr] ... | [INFO] [stderr] 14 | | /// repeat(1_u8).iter().collect::>() [INFO] [stderr] 15 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 16 | / declare_clippy_lint! { [INFO] [stderr] 17 | | pub INFINITE_ITER, [INFO] [stderr] 18 | | correctness, [INFO] [stderr] 19 | | "infinite iteration" [INFO] [stderr] 20 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/infinite_iter.rs:22:1 [INFO] [stderr] | [INFO] [stderr] 22 | / /// **What it does:** Checks for iteration that may be infinite. [INFO] [stderr] 23 | | /// [INFO] [stderr] 24 | | /// **Why is this bad?** While there may be places where this is acceptable [INFO] [stderr] 25 | | /// (e.g. in event streams), in most cases this is simply an error. [INFO] [stderr] ... | [INFO] [stderr] 32 | | /// [0..].iter().zip(infinite_iter.take_while(|x| x > 5)) [INFO] [stderr] 33 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 34 | / declare_clippy_lint! { [INFO] [stderr] 35 | | pub MAYBE_INFINITE_ITER, [INFO] [stderr] 36 | | pedantic, [INFO] [stderr] 37 | | "possible infinite iteration" [INFO] [stderr] 38 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/inherent_impl.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for multiple inherent implementations of a struct [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** Splitting the implementation of a type makes the code harder to navigate. [INFO] [stderr] 12 | | /// [INFO] [stderr] ... | [INFO] [stderr] 33 | | /// } [INFO] [stderr] 34 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 35 | / declare_clippy_lint! { [INFO] [stderr] 36 | | pub MULTIPLE_INHERENT_IMPL, [INFO] [stderr] 37 | | restriction, [INFO] [stderr] 38 | | "Multiple inherent impl that could be grouped" [INFO] [stderr] 39 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/inline_fn_without_body.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for `#[inline]` on trait methods without bodies [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** Only implementations of trait methods may be inlined. [INFO] [stderr] 12 | | /// The inline attribute is ignored for trait methods without bodies. [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// } [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub INLINE_FN_WITHOUT_BODY, [INFO] [stderr] 25 | | correctness, [INFO] [stderr] 26 | | "use of `#[inline]` on trait methods without bodies" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/int_plus_one.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for usage of `x >= y + 1` or `x - 1 >= y` (and `<=`) in a block [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** Readability -- better to use `> y` instead of `>= y + 1`. [INFO] [stderr] ... | [INFO] [stderr] 23 | | /// x > y [INFO] [stderr] 24 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 25 | / declare_clippy_lint! { [INFO] [stderr] 26 | | pub INT_PLUS_ONE, [INFO] [stderr] 27 | | complexity, [INFO] [stderr] 28 | | "instead of using x >= y + 1, use x > y" [INFO] [stderr] 29 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/invalid_ref.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for creation of references to zeroed or uninitialized memory. [INFO] [stderr] 7 | | /// [INFO] [stderr] 8 | | /// **Why is this bad?** Creation of null references is undefined behavior. [INFO] [stderr] 9 | | /// [INFO] [stderr] ... | [INFO] [stderr] 14 | | /// let bad_ref: &usize = std::mem::zeroed(); [INFO] [stderr] 15 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 16 | / declare_clippy_lint! { [INFO] [stderr] 17 | | pub INVALID_REF, [INFO] [stderr] 18 | | correctness, [INFO] [stderr] 19 | | "creation of invalid reference" [INFO] [stderr] 20 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/items_after_statements.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for items declared after some statement in a block. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** Items live for the entire scope they are declared [INFO] [stderr] 10 | | /// in. But statements are processed in order. This might cause confusion as [INFO] [stderr] ... | [INFO] [stderr] 27 | | /// } [INFO] [stderr] 28 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 29 | / declare_clippy_lint! { [INFO] [stderr] 30 | | pub ITEMS_AFTER_STATEMENTS, [INFO] [stderr] 31 | | pedantic, [INFO] [stderr] 32 | | "blocks where an item comes after a statement" [INFO] [stderr] 33 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/large_enum_variant.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for large size differences between variants on [INFO] [stderr] 9 | | /// `enum`s. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** Enum size is bounded by the largest variant. Having a [INFO] [stderr] ... | [INFO] [stderr] 22 | | /// } [INFO] [stderr] 23 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 24 | / declare_clippy_lint! { [INFO] [stderr] 25 | | pub LARGE_ENUM_VARIANT, [INFO] [stderr] 26 | | perf, [INFO] [stderr] 27 | | "large size difference between variants on an enum" [INFO] [stderr] 28 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/len_zero.rs:10:1 [INFO] [stderr] | [INFO] [stderr] 10 | / /// **What it does:** Checks for getting the length of something via `.len()` [INFO] [stderr] 11 | | /// just to compare to zero, and suggests using `.is_empty()` where applicable. [INFO] [stderr] 12 | | /// [INFO] [stderr] 13 | | /// **Why is this bad?** Some structures can answer `.is_empty()` much faster [INFO] [stderr] ... | [INFO] [stderr] 23 | | /// if x.len() == 0 { .. } [INFO] [stderr] 24 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 25 | / declare_clippy_lint! { [INFO] [stderr] 26 | | pub LEN_ZERO, [INFO] [stderr] 27 | | style, [INFO] [stderr] 28 | | "checking `.len() == 0` or `.len() > 0` (or similar) when `.is_empty()` \ [INFO] [stderr] 29 | | could be used instead" [INFO] [stderr] 30 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/len_zero.rs:32:1 [INFO] [stderr] | [INFO] [stderr] 32 | / /// **What it does:** Checks for items that implement `.len()` but not [INFO] [stderr] 33 | | /// `.is_empty()`. [INFO] [stderr] 34 | | /// [INFO] [stderr] 35 | | /// **Why is this bad?** It is good custom to have both methods, because for [INFO] [stderr] ... | [INFO] [stderr] 47 | | /// } [INFO] [stderr] 48 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 49 | / declare_clippy_lint! { [INFO] [stderr] 50 | | pub LEN_WITHOUT_IS_EMPTY, [INFO] [stderr] 51 | | style, [INFO] [stderr] 52 | | "traits or impls with a public `len` method but no corresponding `is_empty` method" [INFO] [stderr] 53 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/let_if_seq.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for variable declarations immediately followed by a [INFO] [stderr] 9 | | /// conditional affectation. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** This is not idiomatic Rust. [INFO] [stderr] ... | [INFO] [stderr] 45 | | /// }; [INFO] [stderr] 46 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 47 | / declare_clippy_lint! { [INFO] [stderr] 48 | | pub USELESS_LET_IF_SEQ, [INFO] [stderr] 49 | | style, [INFO] [stderr] 50 | | "unidiomatic `let mut` declaration followed by initialization in `if`" [INFO] [stderr] 51 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/lifetimes.rs:11:1 [INFO] [stderr] | [INFO] [stderr] 11 | / /// **What it does:** Checks for lifetime annotations which can be removed by [INFO] [stderr] 12 | | /// relying on lifetime elision. [INFO] [stderr] 13 | | /// [INFO] [stderr] 14 | | /// **Why is this bad?** The additional lifetimes make the code look more [INFO] [stderr] ... | [INFO] [stderr] 23 | | /// fn in_and_out<'a>(x: &'a u8, y: u8) -> &'a u8 { x } [INFO] [stderr] 24 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 25 | / declare_clippy_lint! { [INFO] [stderr] 26 | | pub NEEDLESS_LIFETIMES, [INFO] [stderr] 27 | | complexity, [INFO] [stderr] 28 | | "using explicit lifetimes for references in function arguments when elision rules \ [INFO] [stderr] 29 | | would allow omitting them" [INFO] [stderr] 30 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/lifetimes.rs:32:1 [INFO] [stderr] | [INFO] [stderr] 32 | / /// **What it does:** Checks for lifetimes in generics that are never used [INFO] [stderr] 33 | | /// anywhere else. [INFO] [stderr] 34 | | /// [INFO] [stderr] 35 | | /// **Why is this bad?** The additional lifetimes make the code look more [INFO] [stderr] ... | [INFO] [stderr] 43 | | /// fn unused_lifetime<'a>(x: u8) { .. } [INFO] [stderr] 44 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 45 | / declare_clippy_lint! { [INFO] [stderr] 46 | | pub EXTRA_UNUSED_LIFETIMES, [INFO] [stderr] 47 | | complexity, [INFO] [stderr] 48 | | "unused lifetimes in function definitions" [INFO] [stderr] 49 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/literal_representation.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Warns if a long integral or floating-point constant does [INFO] [stderr] 10 | | /// not contain underscores. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** Reading long numbers is difficult without separators. [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// 61864918973511 [INFO] [stderr] 20 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub UNREADABLE_LITERAL, [INFO] [stderr] 23 | | style, [INFO] [stderr] 24 | | "long integer literal without underscores" [INFO] [stderr] 25 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/literal_representation.rs:27:1 [INFO] [stderr] | [INFO] [stderr] 27 | / /// **What it does:** Warns if an integral or floating-point constant is [INFO] [stderr] 28 | | /// grouped inconsistently with underscores. [INFO] [stderr] 29 | | /// [INFO] [stderr] 30 | | /// **Why is this bad?** Readers may incorrectly interpret inconsistently [INFO] [stderr] ... | [INFO] [stderr] 38 | | /// 618_64_9189_73_511 [INFO] [stderr] 39 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 40 | / declare_clippy_lint! { [INFO] [stderr] 41 | | pub INCONSISTENT_DIGIT_GROUPING, [INFO] [stderr] 42 | | style, [INFO] [stderr] 43 | | "integer literals with digits grouped inconsistently" [INFO] [stderr] 44 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/literal_representation.rs:46:1 [INFO] [stderr] | [INFO] [stderr] 46 | / /// **What it does:** Warns if the digits of an integral or floating-point [INFO] [stderr] 47 | | /// constant are grouped into groups that [INFO] [stderr] 48 | | /// are too large. [INFO] [stderr] 49 | | /// [INFO] [stderr] ... | [INFO] [stderr] 57 | | /// 6186491_8973511 [INFO] [stderr] 58 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 59 | / declare_clippy_lint! { [INFO] [stderr] 60 | | pub LARGE_DIGIT_GROUPS, [INFO] [stderr] 61 | | style, [INFO] [stderr] 62 | | "grouping digits into groups that are too large" [INFO] [stderr] 63 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/literal_representation.rs:65:1 [INFO] [stderr] | [INFO] [stderr] 65 | / /// **What it does:** Warns if there is a better representation for a numeric literal. [INFO] [stderr] 66 | | /// [INFO] [stderr] 67 | | /// **Why is this bad?** Especially for big powers of 2 a hexadecimal representation is more [INFO] [stderr] 68 | | /// readable than a decimal representation. [INFO] [stderr] ... | [INFO] [stderr] 75 | | /// `65_535` => `0xFFFF` [INFO] [stderr] 76 | | /// `4_042_322_160` => `0xF0F0_F0F0` [INFO] [stderr] | |____________________________________^ [INFO] [stderr] 77 | / declare_clippy_lint! { [INFO] [stderr] 78 | | pub DECIMAL_LITERAL_REPRESENTATION, [INFO] [stderr] 79 | | restriction, [INFO] [stderr] 80 | | "using decimal representation when hexadecimal would be better" [INFO] [stderr] 81 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:29:1 [INFO] [stderr] | [INFO] [stderr] 29 | / /// **What it does:** Checks for for-loops that manually copy items between [INFO] [stderr] 30 | | /// slices that could be optimized by having a memcpy. [INFO] [stderr] 31 | | /// [INFO] [stderr] 32 | | /// **Why is this bad?** It is not as fast as a memcpy. [INFO] [stderr] ... | [INFO] [stderr] 40 | | /// } [INFO] [stderr] 41 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 42 | / declare_clippy_lint! { [INFO] [stderr] 43 | | pub MANUAL_MEMCPY, [INFO] [stderr] 44 | | perf, [INFO] [stderr] 45 | | "manually copying items between slices" [INFO] [stderr] 46 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:48:1 [INFO] [stderr] | [INFO] [stderr] 48 | / /// **What it does:** Checks for looping over the range of `0..len` of some [INFO] [stderr] 49 | | /// collection just to get the values by index. [INFO] [stderr] 50 | | /// [INFO] [stderr] 51 | | /// **Why is this bad?** Just iterating the collection itself makes the intent [INFO] [stderr] ... | [INFO] [stderr] 60 | | /// } [INFO] [stderr] 61 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 62 | / declare_clippy_lint! { [INFO] [stderr] 63 | | pub NEEDLESS_RANGE_LOOP, [INFO] [stderr] 64 | | style, [INFO] [stderr] 65 | | "for-looping over a range of indices where an iterator over items would do" [INFO] [stderr] 66 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:68:1 [INFO] [stderr] | [INFO] [stderr] 68 | / /// **What it does:** Checks for loops on `x.iter()` where `&x` will do, and [INFO] [stderr] 69 | | /// suggests the latter. [INFO] [stderr] 70 | | /// [INFO] [stderr] 71 | | /// **Why is this bad?** Readability. [INFO] [stderr] ... | [INFO] [stderr] 79 | | /// for x in y.iter() { .. } [INFO] [stderr] 80 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 81 | / declare_clippy_lint! { [INFO] [stderr] 82 | | pub EXPLICIT_ITER_LOOP, [INFO] [stderr] 83 | | style, [INFO] [stderr] 84 | | "for-looping over `_.iter()` or `_.iter_mut()` when `&_` or `&mut _` would do" [INFO] [stderr] 85 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:87:1 [INFO] [stderr] | [INFO] [stderr] 87 | / /// **What it does:** Checks for loops on `y.into_iter()` where `y` will do, and [INFO] [stderr] 88 | | /// suggests the latter. [INFO] [stderr] 89 | | /// [INFO] [stderr] 90 | | /// **Why is this bad?** Readability. [INFO] [stderr] ... | [INFO] [stderr] 97 | | /// for x in y.into_iter() { .. } [INFO] [stderr] 98 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 99 | / declare_clippy_lint! { [INFO] [stderr] 100 | | pub EXPLICIT_INTO_ITER_LOOP, [INFO] [stderr] 101 | | style, [INFO] [stderr] 102 | | "for-looping over `_.into_iter()` when `_` would do" [INFO] [stderr] 103 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:105:1 [INFO] [stderr] | [INFO] [stderr] 105 | / /// **What it does:** Checks for loops on `x.next()`. [INFO] [stderr] 106 | | /// [INFO] [stderr] 107 | | /// **Why is this bad?** `next()` returns either `Some(value)` if there was a [INFO] [stderr] 108 | | /// value, or `None` otherwise. The insidious thing is that `Option<_>` [INFO] [stderr] ... | [INFO] [stderr] 118 | | /// for x in y.next() { .. } [INFO] [stderr] 119 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 120 | / declare_clippy_lint! { [INFO] [stderr] 121 | | pub ITER_NEXT_LOOP, [INFO] [stderr] 122 | | correctness, [INFO] [stderr] 123 | | "for-looping over `_.next()` which is probably not intended" [INFO] [stderr] 124 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:126:1 [INFO] [stderr] | [INFO] [stderr] 126 | / /// **What it does:** Checks for `for` loops over `Option` values. [INFO] [stderr] 127 | | /// [INFO] [stderr] 128 | | /// **Why is this bad?** Readability. This is more clearly expressed as an `if [INFO] [stderr] 129 | | /// let`. [INFO] [stderr] ... | [INFO] [stderr] 140 | | /// if let Some(x) = option { .. } [INFO] [stderr] 141 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 142 | / declare_clippy_lint! { [INFO] [stderr] 143 | | pub FOR_LOOP_OVER_OPTION, [INFO] [stderr] 144 | | correctness, [INFO] [stderr] 145 | | "for-looping over an `Option`, which is more clearly expressed as an `if let`" [INFO] [stderr] 146 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:148:1 [INFO] [stderr] | [INFO] [stderr] 148 | / /// **What it does:** Checks for `for` loops over `Result` values. [INFO] [stderr] 149 | | /// [INFO] [stderr] 150 | | /// **Why is this bad?** Readability. This is more clearly expressed as an `if [INFO] [stderr] 151 | | /// let`. [INFO] [stderr] ... | [INFO] [stderr] 162 | | /// if let Ok(x) = result { .. } [INFO] [stderr] 163 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 164 | / declare_clippy_lint! { [INFO] [stderr] 165 | | pub FOR_LOOP_OVER_RESULT, [INFO] [stderr] 166 | | correctness, [INFO] [stderr] 167 | | "for-looping over a `Result`, which is more clearly expressed as an `if let`" [INFO] [stderr] 168 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:170:1 [INFO] [stderr] | [INFO] [stderr] 170 | / /// **What it does:** Detects `loop + match` combinations that are easier [INFO] [stderr] 171 | | /// written as a `while let` loop. [INFO] [stderr] 172 | | /// [INFO] [stderr] 173 | | /// **Why is this bad?** The `while let` loop is usually shorter and more [INFO] [stderr] ... | [INFO] [stderr] 190 | | /// } [INFO] [stderr] 191 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 192 | / declare_clippy_lint! { [INFO] [stderr] 193 | | pub WHILE_LET_LOOP, [INFO] [stderr] 194 | | complexity, [INFO] [stderr] 195 | | "`loop { if let { ... } else break }`, which can be written as a `while let` loop" [INFO] [stderr] 196 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:198:1 [INFO] [stderr] | [INFO] [stderr] 198 | / /// **What it does:** Checks for using `collect()` on an iterator without using [INFO] [stderr] 199 | | /// the result. [INFO] [stderr] 200 | | /// [INFO] [stderr] 201 | | /// **Why is this bad?** It is more idiomatic to use a `for` loop over the [INFO] [stderr] ... | [INFO] [stderr] 208 | | /// vec.iter().map(|x| /* some operation returning () */).collect::>(); [INFO] [stderr] 209 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 210 | / declare_clippy_lint! { [INFO] [stderr] 211 | | pub UNUSED_COLLECT, [INFO] [stderr] 212 | | perf, [INFO] [stderr] 213 | | "`collect()`ing an iterator without using the result; this is usually better \ [INFO] [stderr] 214 | | written as a for loop" [INFO] [stderr] 215 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:217:1 [INFO] [stderr] | [INFO] [stderr] 217 | / /// **What it does:** Checks for loops over ranges `x..y` where both `x` and `y` [INFO] [stderr] 218 | | /// are constant and `x` is greater or equal to `y`, unless the range is [INFO] [stderr] 219 | | /// reversed or has a negative `.step_by(_)`. [INFO] [stderr] 220 | | /// [INFO] [stderr] ... | [INFO] [stderr] 231 | | /// for x in 5..10-5 { .. } // oops, stray `-` [INFO] [stderr] 232 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 233 | / declare_clippy_lint! { [INFO] [stderr] 234 | | pub REVERSE_RANGE_LOOP, [INFO] [stderr] 235 | | correctness, [INFO] [stderr] 236 | | "iteration over an empty range, such as `10..0` or `5..5`" [INFO] [stderr] 237 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:239:1 [INFO] [stderr] | [INFO] [stderr] 239 | / /// **What it does:** Checks `for` loops over slices with an explicit counter [INFO] [stderr] 240 | | /// and suggests the use of `.enumerate()`. [INFO] [stderr] 241 | | /// [INFO] [stderr] 242 | | /// **Why is it bad?** Not only is the version using `.enumerate()` more [INFO] [stderr] ... | [INFO] [stderr] 251 | | /// for i in 0..v.len() { bar(i, v[i]); } [INFO] [stderr] 252 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 253 | / declare_clippy_lint! { [INFO] [stderr] 254 | | pub EXPLICIT_COUNTER_LOOP, [INFO] [stderr] 255 | | complexity, [INFO] [stderr] 256 | | "for-looping with an explicit counter when `_.enumerate()` would do" [INFO] [stderr] 257 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:259:1 [INFO] [stderr] | [INFO] [stderr] 259 | / /// **What it does:** Checks for empty `loop` expressions. [INFO] [stderr] 260 | | /// [INFO] [stderr] 261 | | /// **Why is this bad?** Those busy loops burn CPU cycles without doing [INFO] [stderr] 262 | | /// anything. Think of the environment and either block on something or at least [INFO] [stderr] ... | [INFO] [stderr] 269 | | /// loop {} [INFO] [stderr] 270 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 271 | / declare_clippy_lint! { [INFO] [stderr] 272 | | pub EMPTY_LOOP, [INFO] [stderr] 273 | | style, [INFO] [stderr] 274 | | "empty `loop {}`, which should block or sleep" [INFO] [stderr] 275 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:277:1 [INFO] [stderr] | [INFO] [stderr] 277 | / /// **What it does:** Checks for `while let` expressions on iterators. [INFO] [stderr] 278 | | /// [INFO] [stderr] 279 | | /// **Why is this bad?** Readability. A simple `for` loop is shorter and conveys [INFO] [stderr] 280 | | /// the intent better. [INFO] [stderr] ... | [INFO] [stderr] 286 | | /// while let Some(val) = iter() { .. } [INFO] [stderr] 287 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 288 | / declare_clippy_lint! { [INFO] [stderr] 289 | | pub WHILE_LET_ON_ITERATOR, [INFO] [stderr] 290 | | style, [INFO] [stderr] 291 | | "using a while-let loop instead of a for loop on an iterator" [INFO] [stderr] 292 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:294:1 [INFO] [stderr] | [INFO] [stderr] 294 | / /// **What it does:** Checks for iterating a map (`HashMap` or `BTreeMap`) and [INFO] [stderr] 295 | | /// ignoring either the keys or values. [INFO] [stderr] 296 | | /// [INFO] [stderr] 297 | | /// **Why is this bad?** Readability. There are `keys` and `values` methods that [INFO] [stderr] ... | [INFO] [stderr] 310 | | /// for k in map.keys() { .. } [INFO] [stderr] 311 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 312 | / declare_clippy_lint! { [INFO] [stderr] 313 | | pub FOR_KV_MAP, [INFO] [stderr] 314 | | style, [INFO] [stderr] 315 | | "looping on a map using `iter` when `keys` or `values` would do" [INFO] [stderr] 316 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:318:1 [INFO] [stderr] | [INFO] [stderr] 318 | / /// **What it does:** Checks for loops that will always `break`, `return` or [INFO] [stderr] 319 | | /// `continue` an outer loop. [INFO] [stderr] 320 | | /// [INFO] [stderr] 321 | | /// **Why is this bad?** This loop never loops, all it does is obfuscating the [INFO] [stderr] ... | [INFO] [stderr] 328 | | /// loop { ..; break; } [INFO] [stderr] 329 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 330 | / declare_clippy_lint! { [INFO] [stderr] 331 | | pub NEVER_LOOP, [INFO] [stderr] 332 | | correctness, [INFO] [stderr] 333 | | "any loop that will always `break` or `return`" [INFO] [stderr] 334 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:336:1 [INFO] [stderr] | [INFO] [stderr] 336 | / /// **What it does:** Checks for loops which have a range bound that is a mutable variable [INFO] [stderr] 337 | | /// [INFO] [stderr] 338 | | /// **Why is this bad?** One might think that modifying the mutable variable changes the loop bounds [INFO] [stderr] 339 | | /// [INFO] [stderr] ... | [INFO] [stderr] 348 | | /// } [INFO] [stderr] 349 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 350 | / declare_clippy_lint! { [INFO] [stderr] 351 | | pub MUT_RANGE_BOUND, [INFO] [stderr] 352 | | complexity, [INFO] [stderr] 353 | | "for loop over a range where one of the bounds is a mutable variable" [INFO] [stderr] 354 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:356:1 [INFO] [stderr] | [INFO] [stderr] 356 | / /// **What it does:** Checks whether variables used within while loop condition [INFO] [stderr] 357 | | /// can be (and are) mutated in the body. [INFO] [stderr] 358 | | /// [INFO] [stderr] 359 | | /// **Why is this bad?** If the condition is unchanged, entering the body of the loop [INFO] [stderr] ... | [INFO] [stderr] 371 | | /// } [INFO] [stderr] 372 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 373 | / declare_clippy_lint! { [INFO] [stderr] 374 | | pub WHILE_IMMUTABLE_CONDITION, [INFO] [stderr] 375 | | correctness, [INFO] [stderr] 376 | | "variables used within while expression are not mutated in the body" [INFO] [stderr] 377 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/map_clone.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for mapping `clone()` over an iterator. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** It makes the code less readable than using the [INFO] [stderr] 11 | | /// `.cloned()` adapter. [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// x.map(|e| e.clone()); [INFO] [stderr] 20 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub MAP_CLONE, [INFO] [stderr] 23 | | style, [INFO] [stderr] 24 | | "using `.map(|x| x.clone())` to clone an iterator or option's contents" [INFO] [stderr] 25 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/map_unit_fn.rs:12:1 [INFO] [stderr] | [INFO] [stderr] 12 | / /// **What it does:** Checks for usage of `option.map(f)` where f is a function [INFO] [stderr] 13 | | /// or closure that returns the unit type. [INFO] [stderr] 14 | | /// [INFO] [stderr] 15 | | /// **Why is this bad?** Readability, this can be written more clearly with [INFO] [stderr] ... | [INFO] [stderr] 37 | | /// } [INFO] [stderr] 38 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 39 | / declare_clippy_lint! { [INFO] [stderr] 40 | | pub OPTION_MAP_UNIT_FN, [INFO] [stderr] 41 | | complexity, [INFO] [stderr] 42 | | "using `option.map(f)`, where f is a function or closure that returns ()" [INFO] [stderr] 43 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/map_unit_fn.rs:45:1 [INFO] [stderr] | [INFO] [stderr] 45 | / /// **What it does:** Checks for usage of `result.map(f)` where f is a function [INFO] [stderr] 46 | | /// or closure that returns the unit type. [INFO] [stderr] 47 | | /// [INFO] [stderr] 48 | | /// **Why is this bad?** Readability, this can be written more clearly with [INFO] [stderr] ... | [INFO] [stderr] 70 | | /// } [INFO] [stderr] 71 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 72 | / declare_clippy_lint! { [INFO] [stderr] 73 | | pub RESULT_MAP_UNIT_FN, [INFO] [stderr] 74 | | complexity, [INFO] [stderr] 75 | | "using `result.map(f)`, where f is a function or closure that returns ()" [INFO] [stderr] 76 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/matches.rs:14:1 [INFO] [stderr] | [INFO] [stderr] 14 | / /// **What it does:** Checks for matches with a single arm where an `if let` [INFO] [stderr] 15 | | /// will usually suffice. [INFO] [stderr] 16 | | /// [INFO] [stderr] 17 | | /// **Why is this bad?** Just readability – `if let` nests less than a `match`. [INFO] [stderr] ... | [INFO] [stderr] 26 | | /// } [INFO] [stderr] 27 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 28 | / declare_clippy_lint! { [INFO] [stderr] 29 | | pub SINGLE_MATCH, [INFO] [stderr] 30 | | style, [INFO] [stderr] 31 | | "a match statement with a single nontrivial arm (i.e. where the other arm \ [INFO] [stderr] 32 | | is `_ => {}`) instead of `if let`" [INFO] [stderr] 33 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/matches.rs:35:1 [INFO] [stderr] | [INFO] [stderr] 35 | / /// **What it does:** Checks for matches with a two arms where an `if let` will [INFO] [stderr] 36 | | /// usually suffice. [INFO] [stderr] 37 | | /// [INFO] [stderr] 38 | | /// **Why is this bad?** Just readability – `if let` nests less than a `match`. [INFO] [stderr] ... | [INFO] [stderr] 47 | | /// } [INFO] [stderr] 48 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 49 | / declare_clippy_lint! { [INFO] [stderr] 50 | | pub SINGLE_MATCH_ELSE, [INFO] [stderr] 51 | | pedantic, [INFO] [stderr] 52 | | "a match statement with a two arms where the second arm's pattern is a wildcard \ [INFO] [stderr] 53 | | instead of `if let`" [INFO] [stderr] 54 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/matches.rs:56:1 [INFO] [stderr] | [INFO] [stderr] 56 | / /// **What it does:** Checks for matches where all arms match a reference, [INFO] [stderr] 57 | | /// suggesting to remove the reference and deref the matched expression [INFO] [stderr] 58 | | /// instead. It also checks for `if let &foo = bar` blocks. [INFO] [stderr] 59 | | /// [INFO] [stderr] ... | [INFO] [stderr] 71 | | /// } [INFO] [stderr] 72 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 73 | / declare_clippy_lint! { [INFO] [stderr] 74 | | pub MATCH_REF_PATS, [INFO] [stderr] 75 | | style, [INFO] [stderr] 76 | | "a match or `if let` with all arms prefixed with `&` instead of deref-ing the match expression" [INFO] [stderr] 77 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/matches.rs:79:1 [INFO] [stderr] | [INFO] [stderr] 79 | / /// **What it does:** Checks for matches where match expression is a `bool`. It [INFO] [stderr] 80 | | /// suggests to replace the expression with an `if...else` block. [INFO] [stderr] 81 | | /// [INFO] [stderr] 82 | | /// **Why is this bad?** It makes the code less readable. [INFO] [stderr] ... | [INFO] [stderr] 92 | | /// } [INFO] [stderr] 93 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 94 | / declare_clippy_lint! { [INFO] [stderr] 95 | | pub MATCH_BOOL, [INFO] [stderr] 96 | | style, [INFO] [stderr] 97 | | "a match on a boolean expression instead of an `if..else` block" [INFO] [stderr] 98 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/matches.rs:100:1 [INFO] [stderr] | [INFO] [stderr] 100 | / /// **What it does:** Checks for overlapping match arms. [INFO] [stderr] 101 | | /// [INFO] [stderr] 102 | | /// **Why is this bad?** It is likely to be an error and if not, makes the code [INFO] [stderr] 103 | | /// less obvious. [INFO] [stderr] ... | [INFO] [stderr] 114 | | /// } [INFO] [stderr] 115 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 116 | / declare_clippy_lint! { [INFO] [stderr] 117 | | pub MATCH_OVERLAPPING_ARM, [INFO] [stderr] 118 | | style, [INFO] [stderr] 119 | | "a match with overlapping arms" [INFO] [stderr] 120 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] warning[E0705]: the feature `rust_2018_preview` is included in the Rust 2018 edition [INFO] [stderr] --> src/lib.rs:14:12 [INFO] [stderr] | [INFO] [stderr] 14 | #![feature(rust_2018_preview)] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^ [INFO] [stderr] [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/matches.rs:122:1 [INFO] [stderr] | [INFO] [stderr] 122 | / /// **What it does:** Checks for arm which matches all errors with `Err(_)` [INFO] [stderr] 123 | | /// and take drastic actions like `panic!`. [INFO] [stderr] 124 | | /// [INFO] [stderr] 125 | | /// **Why is this bad?** It is generally a bad practice, just like [INFO] [stderr] ... | [INFO] [stderr] 136 | | /// } [INFO] [stderr] 137 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 138 | / declare_clippy_lint! { [INFO] [stderr] 139 | | pub MATCH_WILD_ERR_ARM, [INFO] [stderr] 140 | | style, [INFO] [stderr] 141 | | "a match with `Err(_)` arm and take drastic actions" [INFO] [stderr] 142 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/matches.rs:144:1 [INFO] [stderr] | [INFO] [stderr] 144 | / /// **What it does:** Checks for match which is used to add a reference to an [INFO] [stderr] 145 | | /// `Option` value. [INFO] [stderr] 146 | | /// [INFO] [stderr] 147 | | /// **Why is this bad?** Using `as_ref()` or `as_mut()` instead is shorter. [INFO] [stderr] ... | [INFO] [stderr] 157 | | /// }; [INFO] [stderr] 158 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 159 | / declare_clippy_lint! { [INFO] [stderr] 160 | | pub MATCH_AS_REF, [INFO] [stderr] 161 | | complexity, [INFO] [stderr] 162 | | "a match on an Option value instead of using `as_ref()` or `as_mut`" [INFO] [stderr] 163 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/mem_forget.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for usage of `std::mem::forget(t)` where `t` is [INFO] [stderr] 6 | | /// `Drop`. [INFO] [stderr] 7 | | /// [INFO] [stderr] 8 | | /// **Why is this bad?** `std::mem::forget(t)` prevents `t` from running its [INFO] [stderr] ... | [INFO] [stderr] 15 | | /// mem::forget(Rc::new(55))) [INFO] [stderr] 16 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 17 | / declare_clippy_lint! { [INFO] [stderr] 18 | | pub MEM_FORGET, [INFO] [stderr] 19 | | restriction, [INFO] [stderr] 20 | | "`mem::forget` usage on `Drop` types, likely to cause memory leaks" [INFO] [stderr] 21 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:21:1 [INFO] [stderr] | [INFO] [stderr] 21 | / /// **What it does:** Checks for `.unwrap()` calls on `Option`s. [INFO] [stderr] 22 | | /// [INFO] [stderr] 23 | | /// **Why is this bad?** Usually it is better to handle the `None` case, or to [INFO] [stderr] 24 | | /// at least call `.expect(_)` with a more helpful message. Still, for a lot of [INFO] [stderr] ... | [INFO] [stderr] 32 | | /// x.unwrap() [INFO] [stderr] 33 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 34 | / declare_clippy_lint! { [INFO] [stderr] 35 | | pub OPTION_UNWRAP_USED, [INFO] [stderr] 36 | | restriction, [INFO] [stderr] 37 | | "using `Option.unwrap()`, which should at least get a better message using `expect()`" [INFO] [stderr] 38 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:40:1 [INFO] [stderr] | [INFO] [stderr] 40 | / /// **What it does:** Checks for `.unwrap()` calls on `Result`s. [INFO] [stderr] 41 | | /// [INFO] [stderr] 42 | | /// **Why is this bad?** `result.unwrap()` will let the thread panic on `Err` [INFO] [stderr] 43 | | /// values. Normally, you want to implement more sophisticated error handling, [INFO] [stderr] ... | [INFO] [stderr] 54 | | /// x.unwrap() [INFO] [stderr] 55 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 56 | / declare_clippy_lint! { [INFO] [stderr] 57 | | pub RESULT_UNWRAP_USED, [INFO] [stderr] 58 | | restriction, [INFO] [stderr] 59 | | "using `Result.unwrap()`, which might be better handled" [INFO] [stderr] 60 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:62:1 [INFO] [stderr] | [INFO] [stderr] 62 | / /// **What it does:** Checks for methods that should live in a trait [INFO] [stderr] 63 | | /// implementation of a `std` trait (see [llogiq's blog [INFO] [stderr] 64 | | /// post](http://llogiq.github.io/2015/07/30/traits.html) for further [INFO] [stderr] 65 | | /// information) instead of an inherent implementation. [INFO] [stderr] ... | [INFO] [stderr] 80 | | /// } [INFO] [stderr] 81 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 82 | / declare_clippy_lint! { [INFO] [stderr] 83 | | pub SHOULD_IMPLEMENT_TRAIT, [INFO] [stderr] 84 | | style, [INFO] [stderr] 85 | | "defining a method that should be implementing a std trait" [INFO] [stderr] 86 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:88:1 [INFO] [stderr] | [INFO] [stderr] 88 | / /// **What it does:** Checks for methods with certain name prefixes and which [INFO] [stderr] 89 | | /// doesn't match how self is taken. The actual rules are: [INFO] [stderr] 90 | | /// [INFO] [stderr] 91 | | /// |Prefix |`self` taken | [INFO] [stderr] ... | [INFO] [stderr] 109 | | /// } [INFO] [stderr] 110 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 111 | / declare_clippy_lint! { [INFO] [stderr] 112 | | pub WRONG_SELF_CONVENTION, [INFO] [stderr] 113 | | style, [INFO] [stderr] 114 | | "defining a method named with an established prefix (like \"into_\") that takes \ [INFO] [stderr] 115 | | `self` with the wrong convention" [INFO] [stderr] 116 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:118:1 [INFO] [stderr] | [INFO] [stderr] 118 | / /// **What it does:** This is the same as [INFO] [stderr] 119 | | /// [`wrong_self_convention`](#wrong_self_convention), but for public items. [INFO] [stderr] 120 | | /// [INFO] [stderr] 121 | | /// **Why is this bad?** See [`wrong_self_convention`](#wrong_self_convention). [INFO] [stderr] ... | [INFO] [stderr] 131 | | /// } [INFO] [stderr] 132 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 133 | / declare_clippy_lint! { [INFO] [stderr] 134 | | pub WRONG_PUB_SELF_CONVENTION, [INFO] [stderr] 135 | | restriction, [INFO] [stderr] 136 | | "defining a public method named with an established prefix (like \"into_\") that takes \ [INFO] [stderr] 137 | | `self` with the wrong convention" [INFO] [stderr] 138 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:140:1 [INFO] [stderr] | [INFO] [stderr] 140 | / /// **What it does:** Checks for usage of `ok().expect(..)`. [INFO] [stderr] 141 | | /// [INFO] [stderr] 142 | | /// **Why is this bad?** Because you usually call `expect()` on the `Result` [INFO] [stderr] 143 | | /// directly to get a better error message. [INFO] [stderr] ... | [INFO] [stderr] 149 | | /// x.ok().expect("why did I do this again?") [INFO] [stderr] 150 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 151 | / declare_clippy_lint! { [INFO] [stderr] 152 | | pub OK_EXPECT, [INFO] [stderr] 153 | | style, [INFO] [stderr] 154 | | "using `ok().expect()`, which gives worse error messages than \ [INFO] [stderr] 155 | | calling `expect` directly on the Result" [INFO] [stderr] 156 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:158:1 [INFO] [stderr] | [INFO] [stderr] 158 | / /// **What it does:** Checks for usage of `_.map(_).unwrap_or(_)`. [INFO] [stderr] 159 | | /// [INFO] [stderr] 160 | | /// **Why is this bad?** Readability, this can be written more concisely as [INFO] [stderr] 161 | | /// `_.map_or(_, _)`. [INFO] [stderr] ... | [INFO] [stderr] 167 | | /// x.map(|a| a + 1).unwrap_or(0) [INFO] [stderr] 168 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 169 | / declare_clippy_lint! { [INFO] [stderr] 170 | | pub OPTION_MAP_UNWRAP_OR, [INFO] [stderr] 171 | | pedantic, [INFO] [stderr] 172 | | "using `Option.map(f).unwrap_or(a)`, which is more succinctly expressed as \ [INFO] [stderr] 173 | | `map_or(a, f)`" [INFO] [stderr] 174 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/utils/inspector.rs:11:1 [INFO] [stderr] | [INFO] [stderr] 11 | / /// **What it does:** Dumps every ast/hir node which has the `#[clippy_dump]` [INFO] [stderr] 12 | | /// attribute [INFO] [stderr] 13 | | /// [INFO] [stderr] 14 | | /// **Example:** [INFO] [stderr] ... | [INFO] [stderr] 25 | | /// extern crate dylib source: "/path/to/foo.so" [INFO] [stderr] 26 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 27 | / declare_clippy_lint! { [INFO] [stderr] 28 | | pub DEEP_CODE_INSPECTION, [INFO] [stderr] 29 | | internal_warn, [INFO] [stderr] 30 | | "helper to dump info about code" [INFO] [stderr] 31 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = note: `#[warn(unused_doc_comments)]` on by default [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/utils/internal_lints.rs:11:1 [INFO] [stderr] | [INFO] [stderr] 11 | / /// **What it does:** Checks for various things we like to keep tidy in clippy. [INFO] [stderr] 12 | | /// [INFO] [stderr] 13 | | /// **Why is this bad?** We like to pretend we're an example of tidy code. [INFO] [stderr] 14 | | /// [INFO] [stderr] 15 | | /// **Known problems:** None. [INFO] [stderr] 16 | | /// [INFO] [stderr] 17 | | /// **Example:** Wrong ordering of the util::paths constants. [INFO] [stderr] | |_____________________________________________________________^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub CLIPPY_LINTS_INTERNAL, [INFO] [stderr] 20 | | internal, [INFO] [stderr] 21 | | "various things that will negatively affect your clippy experience" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/utils/internal_lints.rs:25:1 [INFO] [stderr] | [INFO] [stderr] 25 | / /// **What it does:** Ensures every lint is associated to a `LintPass`. [INFO] [stderr] 26 | | /// [INFO] [stderr] 27 | | /// **Why is this bad?** The compiler only knows lints via a `LintPass`. Without [INFO] [stderr] 28 | | /// putting a lint to a `LintPass::get_lints()`'s return, the compiler will not [INFO] [stderr] ... | [INFO] [stderr] 46 | | /// } [INFO] [stderr] 47 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 48 | / declare_clippy_lint! { [INFO] [stderr] 49 | | pub LINT_WITHOUT_LINT_PASS, [INFO] [stderr] 50 | | internal, [INFO] [stderr] 51 | | "declaring a lint without associating it in a LintPass" [INFO] [stderr] 52 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/utils/author.rs:14:1 [INFO] [stderr] | [INFO] [stderr] 14 | / /// **What it does:** Generates clippy code that detects the offending pattern [INFO] [stderr] 15 | | /// [INFO] [stderr] 16 | | /// **Example:** [INFO] [stderr] 17 | | /// ```rust [INFO] [stderr] ... | [INFO] [stderr] 43 | | /// } [INFO] [stderr] 44 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 45 | / declare_clippy_lint! { [INFO] [stderr] 46 | | pub LINT_AUTHOR, [INFO] [stderr] 47 | | internal_warn, [INFO] [stderr] 48 | | "helper for writing lints" [INFO] [stderr] 49 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/approx_const.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for floating point literals that approximate [INFO] [stderr] 9 | | /// constants which are defined in [INFO] [stderr] 10 | | /// [`std::f32::consts`](https://doc.rust-lang.org/stable/std/f32/consts/#constants) [INFO] [stderr] 11 | | /// or [INFO] [stderr] ... | [INFO] [stderr] 27 | | /// let x = 3.14; [INFO] [stderr] 28 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 29 | / declare_clippy_lint! { [INFO] [stderr] 30 | | pub APPROX_CONSTANT, [INFO] [stderr] 31 | | correctness, [INFO] [stderr] 32 | | "the approximate of a known float constant (in `std::fXX::consts`)" [INFO] [stderr] 33 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/arithmetic.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for plain integer arithmetic. [INFO] [stderr] 7 | | /// [INFO] [stderr] 8 | | /// **Why is this bad?** This is only checked against overflow in debug builds. [INFO] [stderr] 9 | | /// In some applications one wants explicitly checked, wrapping or saturating [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// a + 1 [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub INTEGER_ARITHMETIC, [INFO] [stderr] 20 | | restriction, [INFO] [stderr] 21 | | "any integer arithmetic statement" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/arithmetic.rs:24:1 [INFO] [stderr] | [INFO] [stderr] 24 | / /// **What it does:** Checks for float arithmetic. [INFO] [stderr] 25 | | /// [INFO] [stderr] 26 | | /// **Why is this bad?** For some embedded systems or kernel development, it [INFO] [stderr] 27 | | /// can be useful to rule out floating-point numbers. [INFO] [stderr] ... | [INFO] [stderr] 33 | | /// a + 1.0 [INFO] [stderr] 34 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 35 | / declare_clippy_lint! { [INFO] [stderr] 36 | | pub FLOAT_ARITHMETIC, [INFO] [stderr] 37 | | restriction, [INFO] [stderr] 38 | | "any floating-point arithmetic statement" [INFO] [stderr] 39 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/assign_ops.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for compound assignment operations (`+=` and [INFO] [stderr] 9 | | /// similar). [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** Projects with many developers from languages without [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// a += 1; [INFO] [stderr] 20 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub ASSIGN_OPS, [INFO] [stderr] 23 | | restriction, [INFO] [stderr] 24 | | "any compound assignment operation" [INFO] [stderr] 25 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/assign_ops.rs:27:1 [INFO] [stderr] | [INFO] [stderr] 27 | / /// **What it does:** Checks for `a = a op b` or `a = b commutative_op a` [INFO] [stderr] 28 | | /// patterns. [INFO] [stderr] 29 | | /// [INFO] [stderr] 30 | | /// **Why is this bad?** These can be written as the shorter `a op= b`. [INFO] [stderr] ... | [INFO] [stderr] 39 | | /// a = a + b; [INFO] [stderr] 40 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 41 | / declare_clippy_lint! { [INFO] [stderr] 42 | | pub ASSIGN_OP_PATTERN, [INFO] [stderr] 43 | | style, [INFO] [stderr] 44 | | "assigning the result of an operation on a variable to that same variable" [INFO] [stderr] 45 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/assign_ops.rs:47:1 [INFO] [stderr] | [INFO] [stderr] 47 | / /// **What it does:** Checks for `a op= a op b` or `a op= b op a` patterns. [INFO] [stderr] 48 | | /// [INFO] [stderr] 49 | | /// **Why is this bad?** Most likely these are bugs where one meant to write `a [INFO] [stderr] 50 | | /// op= b`. [INFO] [stderr] ... | [INFO] [stderr] 59 | | /// a += a + b; [INFO] [stderr] 60 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 61 | / declare_clippy_lint! { [INFO] [stderr] 62 | | pub MISREFACTORED_ASSIGN_OP, [INFO] [stderr] 63 | | complexity, [INFO] [stderr] 64 | | "having a variable on both sides of an assign op" [INFO] [stderr] 65 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/attrs.rs:15:1 [INFO] [stderr] | [INFO] [stderr] 15 | / /// **What it does:** Checks for items annotated with `#[inline(always)]`, [INFO] [stderr] 16 | | /// unless the annotated function is empty or simply panics. [INFO] [stderr] 17 | | /// [INFO] [stderr] 18 | | /// **Why is this bad?** While there are valid uses of this annotation (and once [INFO] [stderr] ... | [INFO] [stderr] 33 | | /// fn not_quite_hot_code(..) { ... } [INFO] [stderr] 34 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 35 | / declare_clippy_lint! { [INFO] [stderr] 36 | | pub INLINE_ALWAYS, [INFO] [stderr] 37 | | pedantic, [INFO] [stderr] 38 | | "use of `#[inline(always)]`" [INFO] [stderr] 39 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/attrs.rs:41:1 [INFO] [stderr] | [INFO] [stderr] 41 | / /// **What it does:** Checks for `extern crate` and `use` items annotated with [INFO] [stderr] 42 | | /// lint attributes [INFO] [stderr] 43 | | /// [INFO] [stderr] 44 | | /// **Why is this bad?** Lint attributes have no effect on crate imports. Most [INFO] [stderr] ... | [INFO] [stderr] 57 | | /// use foo::bar; [INFO] [stderr] 58 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 59 | / declare_clippy_lint! { [INFO] [stderr] 60 | | pub USELESS_ATTRIBUTE, [INFO] [stderr] 61 | | correctness, [INFO] [stderr] 62 | | "use of lint attributes on `extern crate` items" [INFO] [stderr] 63 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/attrs.rs:65:1 [INFO] [stderr] | [INFO] [stderr] 65 | / /// **What it does:** Checks for `#[deprecated]` annotations with a `since` [INFO] [stderr] 66 | | /// field that is not a valid semantic version. [INFO] [stderr] 67 | | /// [INFO] [stderr] 68 | | /// **Why is this bad?** For checking the version of the deprecation, it must be [INFO] [stderr] ... | [INFO] [stderr] 76 | | /// fn something_else(..) { ... } [INFO] [stderr] 77 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 78 | / declare_clippy_lint! { [INFO] [stderr] 79 | | pub DEPRECATED_SEMVER, [INFO] [stderr] 80 | | correctness, [INFO] [stderr] 81 | | "use of `#[deprecated(since = \"x\")]` where x is not semver" [INFO] [stderr] 82 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/attrs.rs:84:1 [INFO] [stderr] | [INFO] [stderr] 84 | / /// **What it does:** Checks for empty lines after outer attributes [INFO] [stderr] 85 | | /// [INFO] [stderr] 86 | | /// **Why is this bad?** [INFO] [stderr] 87 | | /// Most likely the attribute was meant to be an inner attribute using a '!'. [INFO] [stderr] ... | [INFO] [stderr] 111 | | /// fn this_is_fine_too(..) { ... } [INFO] [stderr] 112 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 113 | / declare_clippy_lint! { [INFO] [stderr] 114 | | pub EMPTY_LINE_AFTER_OUTER_ATTR, [INFO] [stderr] 115 | | nursery, [INFO] [stderr] 116 | | "empty line after outer attribute" [INFO] [stderr] 117 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/bit_mask.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for incompatible bit masks in comparisons. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// The formula for detecting if an expression of the type `_ m [INFO] [stderr] 12 | | /// c` (where `` is one of {`&`, `|`} and `` is one of [INFO] [stderr] ... | [INFO] [stderr] 37 | | /// if (x & 1 == 2) { … } [INFO] [stderr] 38 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 39 | / declare_clippy_lint! { [INFO] [stderr] 40 | | pub BAD_BIT_MASK, [INFO] [stderr] 41 | | correctness, [INFO] [stderr] 42 | | "expressions of the form `_ & mask == select` that will only ever return `true` or `false`" [INFO] [stderr] 43 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/bit_mask.rs:45:1 [INFO] [stderr] | [INFO] [stderr] 45 | / /// **What it does:** Checks for bit masks in comparisons which can be removed [INFO] [stderr] 46 | | /// without changing the outcome. The basic structure can be seen in the [INFO] [stderr] 47 | | /// following table: [INFO] [stderr] 48 | | /// [INFO] [stderr] ... | [INFO] [stderr] 65 | | /// if (x | 1 > 3) { … } [INFO] [stderr] 66 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 67 | / declare_clippy_lint! { [INFO] [stderr] 68 | | pub INEFFECTIVE_BIT_MASK, [INFO] [stderr] 69 | | correctness, [INFO] [stderr] 70 | | "expressions where a bit mask will be rendered useless by a comparison, e.g. `(x | 1) > 2`" [INFO] [stderr] 71 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/bit_mask.rs:73:1 [INFO] [stderr] | [INFO] [stderr] 73 | / /// **What it does:** Checks for bit masks that can be replaced by a call [INFO] [stderr] 74 | | /// to `trailing_zeros` [INFO] [stderr] 75 | | /// [INFO] [stderr] 76 | | /// **Why is this bad?** `x.trailing_zeros() > 4` is much clearer than `x & 15 [INFO] [stderr] ... | [INFO] [stderr] 83 | | /// x & 0x1111 == 0 [INFO] [stderr] 84 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 85 | / declare_clippy_lint! { [INFO] [stderr] 86 | | pub VERBOSE_BIT_MASK, [INFO] [stderr] 87 | | style, [INFO] [stderr] 88 | | "expressions where a bit mask is less readable than the corresponding method call" [INFO] [stderr] 89 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/blacklisted_name.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for usage of blacklisted names for variables, such [INFO] [stderr] 6 | | /// as `foo`. [INFO] [stderr] 7 | | /// [INFO] [stderr] 8 | | /// **Why is this bad?** These names are usually placeholder names and should be [INFO] [stderr] ... | [INFO] [stderr] 15 | | /// let foo = 3.14; [INFO] [stderr] 16 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 17 | / declare_clippy_lint! { [INFO] [stderr] 18 | | pub BLACKLISTED_NAME, [INFO] [stderr] 19 | | style, [INFO] [stderr] 20 | | "usage of a blacklisted/placeholder name" [INFO] [stderr] 21 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/block_in_if_condition.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for `if` conditions that use blocks to contain an [INFO] [stderr] 7 | | /// expression. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** It isn't really Rust style, same as using parentheses [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// if { true } .. [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub BLOCK_IN_IF_CONDITION_EXPR, [INFO] [stderr] 20 | | style, [INFO] [stderr] 21 | | "braces that can be eliminated in conditions, e.g. `if { true } ...`" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/block_in_if_condition.rs:24:1 [INFO] [stderr] | [INFO] [stderr] 24 | / /// **What it does:** Checks for `if` conditions that use blocks containing [INFO] [stderr] 25 | | /// statements, or conditions that use closures with blocks. [INFO] [stderr] 26 | | /// [INFO] [stderr] 27 | | /// **Why is this bad?** Using blocks in the condition makes it hard to read. [INFO] [stderr] ... | [INFO] [stderr] 35 | | /// if somefunc(|x| { x == 47 }) .. [INFO] [stderr] 36 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 37 | / declare_clippy_lint! { [INFO] [stderr] 38 | | pub BLOCK_IN_IF_CONDITION_STMT, [INFO] [stderr] 39 | | style, [INFO] [stderr] 40 | | "complex blocks in conditions, e.g. `if { let x = true; x } ...`" [INFO] [stderr] 41 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/booleans.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for boolean expressions that can be written more [INFO] [stderr] 10 | | /// concisely. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** Readability of boolean expressions suffers from [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// if !(a == b) // should be: if a != b [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub NONMINIMAL_BOOL, [INFO] [stderr] 25 | | complexity, [INFO] [stderr] 26 | | "boolean expressions that can be written more concisely" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/booleans.rs:29:1 [INFO] [stderr] | [INFO] [stderr] 29 | / /// **What it does:** Checks for boolean expressions that contain terminals that [INFO] [stderr] 30 | | /// can be eliminated. [INFO] [stderr] 31 | | /// [INFO] [stderr] 32 | | /// **Why is this bad?** This is most likely a logic bug. [INFO] [stderr] ... | [INFO] [stderr] 39 | | /// ``` [INFO] [stderr] 40 | | /// The `b` is unnecessary, the expression is equivalent to `if a`. [INFO] [stderr] | |___________________________________________________________________^ [INFO] [stderr] 41 | / declare_clippy_lint! { [INFO] [stderr] 42 | | pub LOGIC_BUG, [INFO] [stderr] 43 | | correctness, [INFO] [stderr] 44 | | "boolean expressions that contain terminals which can be eliminated" [INFO] [stderr] 45 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/bytecount.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for naive byte counts [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** The [`bytecount`](https://crates.io/crates/bytecount) [INFO] [stderr] 11 | | /// crate has methods to count your bytes faster, especially for large slices. [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// &my_data.filter(|&x| x == 0u8).count() // use bytecount::count instead [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub NAIVE_BYTECOUNT, [INFO] [stderr] 25 | | perf, [INFO] [stderr] 26 | | "use of naive `.filter(|&x| x == y).count()` to count byte values" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/collapsible_if.rs:21:1 [INFO] [stderr] | [INFO] [stderr] 21 | / /// **What it does:** Checks for nested `if` statements which can be collapsed [INFO] [stderr] 22 | | /// by `&&`-combining their conditions and for `else { if ... }` expressions [INFO] [stderr] 23 | | /// that [INFO] [stderr] 24 | | /// can be collapsed to `else if ...`. [INFO] [stderr] ... | [INFO] [stderr] 63 | | /// } [INFO] [stderr] 64 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 65 | / declare_clippy_lint! { [INFO] [stderr] 66 | | pub COLLAPSIBLE_IF, [INFO] [stderr] 67 | | style, [INFO] [stderr] 68 | | "`if`s that can be collapsed (e.g. `if x { if y { ... } }` and `else { if x { ... } }`)" [INFO] [stderr] 69 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/const_static_lifetime.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for constants with an explicit `'static` lifetime. [INFO] [stderr] 6 | | /// [INFO] [stderr] 7 | | /// **Why is this bad?** Adding `'static` to every reference can create very [INFO] [stderr] 8 | | /// complicated types. [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// const FOO: &[(&str, &str, fn(&Bar) -> bool)] = &[...] [INFO] [stderr] 20 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub CONST_STATIC_LIFETIME, [INFO] [stderr] 23 | | style, [INFO] [stderr] 24 | | "Using explicit `'static` lifetime for constants when elision rules would allow omitting them." [INFO] [stderr] 25 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/copies.rs:11:1 [INFO] [stderr] | [INFO] [stderr] 11 | / /// **What it does:** Checks for consecutive `if`s with the same condition. [INFO] [stderr] 12 | | /// [INFO] [stderr] 13 | | /// **Why is this bad?** This is probably a copy & paste error. [INFO] [stderr] 14 | | /// [INFO] [stderr] ... | [INFO] [stderr] 34 | | /// } [INFO] [stderr] 35 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 36 | / declare_clippy_lint! { [INFO] [stderr] 37 | | pub IFS_SAME_COND, [INFO] [stderr] 38 | | correctness, [INFO] [stderr] 39 | | "consecutive `ifs` with the same condition" [INFO] [stderr] 40 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/copies.rs:42:1 [INFO] [stderr] | [INFO] [stderr] 42 | / /// **What it does:** Checks for `if/else` with the same body as the *then* part [INFO] [stderr] 43 | | /// and the *else* part. [INFO] [stderr] 44 | | /// [INFO] [stderr] 45 | | /// **Why is this bad?** This is probably a copy & paste error. [INFO] [stderr] ... | [INFO] [stderr] 55 | | /// }; [INFO] [stderr] 56 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 57 | / declare_clippy_lint! { [INFO] [stderr] 58 | | pub IF_SAME_THEN_ELSE, [INFO] [stderr] 59 | | correctness, [INFO] [stderr] 60 | | "if with the same *then* and *else* blocks" [INFO] [stderr] 61 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/copies.rs:63:1 [INFO] [stderr] | [INFO] [stderr] 63 | / /// **What it does:** Checks for `match` with identical arm bodies. [INFO] [stderr] 64 | | /// [INFO] [stderr] 65 | | /// **Why is this bad?** This is probably a copy & paste error. If arm bodies [INFO] [stderr] 66 | | /// are the same on purpose, you can factor them [INFO] [stderr] ... | [INFO] [stderr] 96 | | /// } [INFO] [stderr] 97 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 98 | / declare_clippy_lint! { [INFO] [stderr] 99 | | pub MATCH_SAME_ARMS, [INFO] [stderr] 100 | | pedantic, [INFO] [stderr] 101 | | "`match` with identical arm bodies" [INFO] [stderr] 102 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/cyclomatic_complexity.rs:13:1 [INFO] [stderr] | [INFO] [stderr] 13 | / /// **What it does:** Checks for methods with high cyclomatic complexity. [INFO] [stderr] 14 | | /// [INFO] [stderr] 15 | | /// **Why is this bad?** Methods of high cyclomatic complexity tend to be badly [INFO] [stderr] 16 | | /// readable. Also LLVM will usually optimize small methods better. [INFO] [stderr] ... | [INFO] [stderr] 20 | | /// [INFO] [stderr] 21 | | /// **Example:** No. You'll see it when you get the warning. [INFO] [stderr] | |____________________________________________________________^ [INFO] [stderr] 22 | / declare_clippy_lint! { [INFO] [stderr] 23 | | pub CYCLOMATIC_COMPLEXITY, [INFO] [stderr] 24 | | complexity, [INFO] [stderr] 25 | | "functions that should be split up into multiple functions" [INFO] [stderr] 26 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/default_trait_access.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for literal calls to `Default::default()`. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** It's more clear to the reader to use the name of the type whose default is [INFO] [stderr] 11 | | /// being gotten than the generic `Default`. [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// let s = String::default(); [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub DEFAULT_TRAIT_ACCESS, [INFO] [stderr] 25 | | pedantic, [INFO] [stderr] 26 | | "checks for literal calls to Default::default()" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/derive.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for deriving `Hash` but implementing `PartialEq` [INFO] [stderr] 9 | | /// explicitly or vice versa. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** The implementation of these traits must agree (for [INFO] [stderr] ... | [INFO] [stderr] 29 | | /// } [INFO] [stderr] 30 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 31 | / declare_clippy_lint! { [INFO] [stderr] 32 | | pub DERIVE_HASH_XOR_EQ, [INFO] [stderr] 33 | | correctness, [INFO] [stderr] 34 | | "deriving `Hash` but implementing `PartialEq` explicitly" [INFO] [stderr] 35 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/derive.rs:37:1 [INFO] [stderr] | [INFO] [stderr] 37 | / /// **What it does:** Checks for explicit `Clone` implementations for `Copy` [INFO] [stderr] 38 | | /// types. [INFO] [stderr] 39 | | /// [INFO] [stderr] 40 | | /// **Why is this bad?** To avoid surprising behaviour, these traits should [INFO] [stderr] ... | [INFO] [stderr] 55 | | /// } [INFO] [stderr] 56 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 57 | / declare_clippy_lint! { [INFO] [stderr] 58 | | pub EXPL_IMPL_CLONE_ON_COPY, [INFO] [stderr] 59 | | pedantic, [INFO] [stderr] 60 | | "implementing `Clone` explicitly on `Copy` types" [INFO] [stderr] 61 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/doc.rs:10:1 [INFO] [stderr] | [INFO] [stderr] 10 | / /// **What it does:** Checks for the presence of `_`, `::` or camel-case words [INFO] [stderr] 11 | | /// outside ticks in documentation. [INFO] [stderr] 12 | | /// [INFO] [stderr] 13 | | /// **Why is this bad?** *Rustdoc* supports markdown formatting, `_`, `::` and [INFO] [stderr] ... | [INFO] [stderr] 26 | | /// fn doit(foo_bar) { .. } [INFO] [stderr] 27 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 28 | / declare_clippy_lint! { [INFO] [stderr] 29 | | pub DOC_MARKDOWN, [INFO] [stderr] 30 | | pedantic, [INFO] [stderr] 31 | | "presence of `_`, `::` or camel-case outside backticks in documentation" [INFO] [stderr] 32 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/double_comparison.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for double comparions that could be simpified to a single expression. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** Readability. [INFO] [stderr] ... | [INFO] [stderr] 24 | | /// x <= y [INFO] [stderr] 25 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 26 | / declare_clippy_lint! { [INFO] [stderr] 27 | | pub DOUBLE_COMPARISONS, [INFO] [stderr] 28 | | complexity, [INFO] [stderr] 29 | | "unnecessary double comparisons that can be simplified" [INFO] [stderr] 30 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/double_parens.rs:4:1 [INFO] [stderr] | [INFO] [stderr] 4 | / /// **What it does:** Checks for unnecessary double parentheses. [INFO] [stderr] 5 | | /// [INFO] [stderr] 6 | | /// **Why is this bad?** This makes code harder to read and might indicate a [INFO] [stderr] 7 | | /// mistake. [INFO] [stderr] ... | [INFO] [stderr] 15 | | /// ((1, 2)) [INFO] [stderr] 16 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 17 | / declare_clippy_lint! { [INFO] [stderr] 18 | | pub DOUBLE_PARENS, [INFO] [stderr] 19 | | complexity, [INFO] [stderr] 20 | | "Warn on unnecessary double parentheses" [INFO] [stderr] 21 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/drop_forget_ref.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for calls to `std::mem::drop` with a reference [INFO] [stderr] 7 | | /// instead of an owned value. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** Calling `drop` on a reference will only drop the [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// operation_that_requires_mutex_to_be_unlocked(); [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub DROP_REF, [INFO] [stderr] 25 | | correctness, [INFO] [stderr] 26 | | "calls to `std::mem::drop` with a reference instead of an owned value" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/drop_forget_ref.rs:29:1 [INFO] [stderr] | [INFO] [stderr] 29 | / /// **What it does:** Checks for calls to `std::mem::forget` with a reference [INFO] [stderr] 30 | | /// instead of an owned value. [INFO] [stderr] 31 | | /// [INFO] [stderr] 32 | | /// **Why is this bad?** Calling `forget` on a reference will only forget the [INFO] [stderr] ... | [INFO] [stderr] 42 | | /// std::mem::forget(&x) // Should have been forget(x), x will still be dropped [INFO] [stderr] 43 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 44 | / declare_clippy_lint! { [INFO] [stderr] 45 | | pub FORGET_REF, [INFO] [stderr] 46 | | correctness, [INFO] [stderr] 47 | | "calls to `std::mem::forget` with a reference instead of an owned value" [INFO] [stderr] 48 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/drop_forget_ref.rs:50:1 [INFO] [stderr] | [INFO] [stderr] 50 | / /// **What it does:** Checks for calls to `std::mem::drop` with a value [INFO] [stderr] 51 | | /// that derives the Copy trait [INFO] [stderr] 52 | | /// [INFO] [stderr] 53 | | /// **Why is this bad?** Calling `std::mem::drop` [does nothing for types that [INFO] [stderr] ... | [INFO] [stderr] 63 | | /// // original unaffected [INFO] [stderr] 64 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 65 | / declare_clippy_lint! { [INFO] [stderr] 66 | | pub DROP_COPY, [INFO] [stderr] 67 | | correctness, [INFO] [stderr] 68 | | "calls to `std::mem::drop` with a value that implements Copy" [INFO] [stderr] 69 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/drop_forget_ref.rs:71:1 [INFO] [stderr] | [INFO] [stderr] 71 | / /// **What it does:** Checks for calls to `std::mem::forget` with a value that [INFO] [stderr] 72 | | /// derives the Copy trait [INFO] [stderr] 73 | | /// [INFO] [stderr] 74 | | /// **Why is this bad?** Calling `std::mem::forget` [does nothing for types that [INFO] [stderr] ... | [INFO] [stderr] 90 | | /// // original unaffected [INFO] [stderr] 91 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 92 | / declare_clippy_lint! { [INFO] [stderr] 93 | | pub FORGET_COPY, [INFO] [stderr] 94 | | correctness, [INFO] [stderr] 95 | | "calls to `std::mem::forget` with a value that implements Copy" [INFO] [stderr] 96 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/duration_subsec.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for calculation of subsecond microseconds or milliseconds [INFO] [stderr] 10 | | /// from other `Duration` methods. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** It's more concise to call `Duration::subsec_micros()` or [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// let _millis = dur.subsec_nanos() / 1_000_000; [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub DURATION_SUBSEC, [INFO] [stderr] 25 | | complexity, [INFO] [stderr] 26 | | "checks for calculation of subsecond microseconds or milliseconds" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/else_if_without_else.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for usage of if expressions with an `else if` branch, [INFO] [stderr] 9 | | /// but without a final `else` branch. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** Some coding guidelines require this (e.g. MISRA-C:2004 Rule 14.10). [INFO] [stderr] ... | [INFO] [stderr] 33 | | /// } [INFO] [stderr] 34 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 35 | / declare_clippy_lint! { [INFO] [stderr] 36 | | pub ELSE_IF_WITHOUT_ELSE, [INFO] [stderr] 37 | | restriction, [INFO] [stderr] 38 | | "if expression with an `else if`, but without a final `else` branch" [INFO] [stderr] 39 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/empty_enum.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for `enum`s with no variants. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** Enum's with no variants should be replaced with `!`, [INFO] [stderr] 10 | | /// the uninhabited type, [INFO] [stderr] ... | [INFO] [stderr] 17 | | /// enum Test {} [INFO] [stderr] 18 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 19 | / declare_clippy_lint! { [INFO] [stderr] 20 | | pub EMPTY_ENUM, [INFO] [stderr] 21 | | pedantic, [INFO] [stderr] 22 | | "enum with no variants" [INFO] [stderr] 23 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/entry.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for uses of `contains_key` + `insert` on `HashMap` [INFO] [stderr] 9 | | /// or `BTreeMap`. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** Using `entry` is more efficient. [INFO] [stderr] ... | [INFO] [stderr] 25 | | /// m.entry(k).or_insert(v); [INFO] [stderr] 26 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 27 | / declare_clippy_lint! { [INFO] [stderr] 28 | | pub MAP_ENTRY, [INFO] [stderr] 29 | | perf, [INFO] [stderr] 30 | | "use of `contains_key` followed by `insert` on a `HashMap` or `BTreeMap`" [INFO] [stderr] 31 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/enum_clike.rs:14:1 [INFO] [stderr] | [INFO] [stderr] 14 | / /// **What it does:** Checks for C-like enumerations that are [INFO] [stderr] 15 | | /// `repr(isize/usize)` and have values that don't fit into an `i32`. [INFO] [stderr] 16 | | /// [INFO] [stderr] 17 | | /// **Why is this bad?** This will truncate the variant value on 32 bit [INFO] [stderr] ... | [INFO] [stderr] 28 | | /// } [INFO] [stderr] 29 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 30 | / declare_clippy_lint! { [INFO] [stderr] 31 | | pub ENUM_CLIKE_UNPORTABLE_VARIANT, [INFO] [stderr] 32 | | correctness, [INFO] [stderr] 33 | | "C-like enums that are `repr(isize/usize)` and have values that don't fit into an `i32`" [INFO] [stderr] 34 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/enum_glob_use.rs:10:1 [INFO] [stderr] | [INFO] [stderr] 10 | / /// **What it does:** Checks for `use Enum::*`. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** It is usually better style to use the prefixed name of [INFO] [stderr] 13 | | /// an enumeration variant, rather than importing variants. [INFO] [stderr] ... | [INFO] [stderr] 20 | | /// use std::cmp::Ordering::*; [INFO] [stderr] 21 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 22 | / declare_clippy_lint! { [INFO] [stderr] 23 | | pub ENUM_GLOB_USE, [INFO] [stderr] 24 | | pedantic, [INFO] [stderr] 25 | | "use items that import all variants of an enum" [INFO] [stderr] 26 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/enum_variants.rs:10:1 [INFO] [stderr] | [INFO] [stderr] 10 | / /// **What it does:** Detects enumeration variants that are prefixed or suffixed [INFO] [stderr] 11 | | /// by the same characters. [INFO] [stderr] 12 | | /// [INFO] [stderr] 13 | | /// **Why is this bad?** Enumeration variant names should specify their variant, [INFO] [stderr] ... | [INFO] [stderr] 24 | | /// } [INFO] [stderr] 25 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 26 | / declare_clippy_lint! { [INFO] [stderr] 27 | | pub ENUM_VARIANT_NAMES, [INFO] [stderr] 28 | | style, [INFO] [stderr] 29 | | "enums where all variants share a prefix/postfix" [INFO] [stderr] 30 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/enum_variants.rs:32:1 [INFO] [stderr] | [INFO] [stderr] 32 | / /// **What it does:** Detects enumeration variants that are prefixed or suffixed [INFO] [stderr] 33 | | /// by the same characters. [INFO] [stderr] 34 | | /// [INFO] [stderr] 35 | | /// **Why is this bad?** Enumeration variant names should specify their variant, [INFO] [stderr] ... | [INFO] [stderr] 46 | | /// } [INFO] [stderr] 47 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 48 | / declare_clippy_lint! { [INFO] [stderr] 49 | | pub PUB_ENUM_VARIANT_NAMES, [INFO] [stderr] 50 | | pedantic, [INFO] [stderr] 51 | | "enums where all variants share a prefix/postfix" [INFO] [stderr] 52 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/enum_variants.rs:54:1 [INFO] [stderr] | [INFO] [stderr] 54 | / /// **What it does:** Detects type names that are prefixed or suffixed by the [INFO] [stderr] 55 | | /// containing module's name. [INFO] [stderr] 56 | | /// [INFO] [stderr] 57 | | /// **Why is this bad?** It requires the user to type the module name twice. [INFO] [stderr] ... | [INFO] [stderr] 65 | | /// } [INFO] [stderr] 66 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 67 | / declare_clippy_lint! { [INFO] [stderr] 68 | | pub STUTTER, [INFO] [stderr] 69 | | pedantic, [INFO] [stderr] 70 | | "type names prefixed/postfixed with their containing module's name" [INFO] [stderr] 71 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/enum_variants.rs:73:1 [INFO] [stderr] | [INFO] [stderr] 73 | / /// **What it does:** Checks for modules that have the same name as their [INFO] [stderr] 74 | | /// parent module [INFO] [stderr] 75 | | /// [INFO] [stderr] 76 | | /// **Why is this bad?** A typical beginner mistake is to have `mod foo;` and [INFO] [stderr] ... | [INFO] [stderr] 95 | | /// } [INFO] [stderr] 96 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 97 | / declare_clippy_lint! { [INFO] [stderr] 98 | | pub MODULE_INCEPTION, [INFO] [stderr] 99 | | style, [INFO] [stderr] 100 | | "modules that have the same name as their parent module" [INFO] [stderr] 101 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/eq_op.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for equal operands to comparison, logical and [INFO] [stderr] 6 | | /// bitwise, difference and division binary operators (`==`, `>`, etc., `&&`, [INFO] [stderr] 7 | | /// `||`, `&`, `|`, `^`, `-` and `/`). [INFO] [stderr] 8 | | /// [INFO] [stderr] ... | [INFO] [stderr] 18 | | /// x + 1 == x + 1 [INFO] [stderr] 19 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 20 | / declare_clippy_lint! { [INFO] [stderr] 21 | | pub EQ_OP, [INFO] [stderr] 22 | | correctness, [INFO] [stderr] 23 | | "equal operands on both sides of a comparison or bitwise combination (e.g. `x == x`)" [INFO] [stderr] 24 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/eq_op.rs:26:1 [INFO] [stderr] | [INFO] [stderr] 26 | / /// **What it does:** Checks for arguments to `==` which have their address [INFO] [stderr] 27 | | /// taken to satisfy a bound [INFO] [stderr] 28 | | /// and suggests to dereference the other argument instead [INFO] [stderr] 29 | | /// [INFO] [stderr] ... | [INFO] [stderr] 36 | | /// &x == y [INFO] [stderr] 37 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 38 | / declare_clippy_lint! { [INFO] [stderr] 39 | | pub OP_REF, [INFO] [stderr] 40 | | style, [INFO] [stderr] 41 | | "taking a reference to satisfy the type constraints on `==`" [INFO] [stderr] 42 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/erasing_op.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for erasing operations, e.g. `x * 0`. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** The whole expression can be replaced by zero. [INFO] [stderr] 10 | | /// This is most likely not the intended outcome and should probably be [INFO] [stderr] ... | [INFO] [stderr] 17 | | /// 0 / x; 0 * x; x & 0 [INFO] [stderr] 18 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 19 | / declare_clippy_lint! { [INFO] [stderr] 20 | | pub ERASING_OP, [INFO] [stderr] 21 | | correctness, [INFO] [stderr] 22 | | "using erasing operations, e.g. `x * 0` or `y & 0`" [INFO] [stderr] 23 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/escape.rs:18:1 [INFO] [stderr] | [INFO] [stderr] 18 | / /// **What it does:** Checks for usage of `Box` where an unboxed `T` would [INFO] [stderr] 19 | | /// work fine. [INFO] [stderr] 20 | | /// [INFO] [stderr] 21 | | /// **Why is this bad?** This is an unnecessary allocation, and bad for [INFO] [stderr] ... | [INFO] [stderr] 33 | | /// } [INFO] [stderr] 34 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 35 | / declare_clippy_lint! { [INFO] [stderr] 36 | | pub BOXED_LOCAL, [INFO] [stderr] 37 | | perf, [INFO] [stderr] 38 | | "using `Box` where unnecessary" [INFO] [stderr] 39 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/eta_reduction.rs:10:1 [INFO] [stderr] | [INFO] [stderr] 10 | / /// **What it does:** Checks for closures which just call another function where [INFO] [stderr] 11 | | /// the function can be called directly. `unsafe` functions or calls where types [INFO] [stderr] 12 | | /// get adjusted are ignored. [INFO] [stderr] 13 | | /// [INFO] [stderr] ... | [INFO] [stderr] 23 | | /// where `foo(_)` is a plain function that takes the exact argument type of [INFO] [stderr] 24 | | /// `x`. [INFO] [stderr] | |________^ [INFO] [stderr] 25 | / declare_clippy_lint! { [INFO] [stderr] 26 | | pub REDUNDANT_CLOSURE, [INFO] [stderr] 27 | | style, [INFO] [stderr] 28 | | "redundant closures, i.e. `|a| foo(a)` (which can be written as just `foo`)" [INFO] [stderr] 29 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/eval_order_dependence.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for a read and a write to the same variable where [INFO] [stderr] 9 | | /// whether the read occurs before or after the write depends on the evaluation [INFO] [stderr] 10 | | /// order of sub-expressions. [INFO] [stderr] 11 | | /// [INFO] [stderr] ... | [INFO] [stderr] 22 | | /// // Unclear whether a is 1 or 2. [INFO] [stderr] 23 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 24 | / declare_clippy_lint! { [INFO] [stderr] 25 | | pub EVAL_ORDER_DEPENDENCE, [INFO] [stderr] 26 | | complexity, [INFO] [stderr] 27 | | "whether a variable read occurs before a write depends on sub-expression evaluation order" [INFO] [stderr] 28 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/eval_order_dependence.rs:30:1 [INFO] [stderr] | [INFO] [stderr] 30 | / /// **What it does:** Checks for diverging calls that are not match arms or [INFO] [stderr] 31 | | /// statements. [INFO] [stderr] 32 | | /// [INFO] [stderr] 33 | | /// **Why is this bad?** It is often confusing to read. In addition, the [INFO] [stderr] ... | [INFO] [stderr] 44 | | /// // can simply be replaced by `panic!()` [INFO] [stderr] 45 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 46 | / declare_clippy_lint! { [INFO] [stderr] 47 | | pub DIVERGING_SUB_EXPRESSION, [INFO] [stderr] 48 | | complexity, [INFO] [stderr] 49 | | "whether an expression contains a diverging sub expression" [INFO] [stderr] 50 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/excessive_precision.rs:11:1 [INFO] [stderr] | [INFO] [stderr] 11 | / /// **What it does:** Checks for float literals with a precision greater [INFO] [stderr] 12 | | /// than that supported by the underlying type [INFO] [stderr] 13 | | /// [INFO] [stderr] 14 | | /// **Why is this bad?** Rust will truncate the literal silently. [INFO] [stderr] ... | [INFO] [stderr] 27 | | /// println!("{}", v); // 0.123_456_789_9 [INFO] [stderr] 28 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 29 | / declare_clippy_lint! { [INFO] [stderr] 30 | | pub EXCESSIVE_PRECISION, [INFO] [stderr] 31 | | style, [INFO] [stderr] 32 | | "excessive precision for float literal" [INFO] [stderr] 33 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/explicit_write.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for usage of `write!()` / `writeln()!` which can be [INFO] [stderr] 7 | | /// replaced with `(e)print!()` / `(e)println!()` [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** Using `(e)println! is clearer and more concise [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// writeln!(&mut io::stderr(), "foo: {:?}", bar).unwrap(); [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub EXPLICIT_WRITE, [INFO] [stderr] 20 | | complexity, [INFO] [stderr] 21 | | "using the `write!()` family of functions instead of the `print!()` family \ [INFO] [stderr] 22 | | of functions, when using the latter would work" [INFO] [stderr] 23 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/fallible_impl_from.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for impls of `From<..>` that contain `panic!()` or `unwrap()` [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** `TryFrom` should be used if there's a possibility of failure. [INFO] [stderr] 11 | | /// [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// } [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub FALLIBLE_IMPL_FROM, [INFO] [stderr] 25 | | nursery, [INFO] [stderr] 26 | | "Warn on impls of `From<..>` that contain `panic!()` or `unwrap()`" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/format.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for the use of `format!("string literal with no [INFO] [stderr] 10 | | /// argument")` and `format!("{}", foo)` where `foo` is a string. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** There is no point of doing that. `format!("too")` can [INFO] [stderr] ... | [INFO] [stderr] 23 | | /// format!("{}", foo) [INFO] [stderr] 24 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 25 | / declare_clippy_lint! { [INFO] [stderr] 26 | | pub USELESS_FORMAT, [INFO] [stderr] 27 | | complexity, [INFO] [stderr] 28 | | "useless use of `format!`" [INFO] [stderr] 29 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/formatting.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for use of the non-existent `=*`, `=!` and `=-` [INFO] [stderr] 7 | | /// operators. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** This is either a typo of `*=`, `!=` or `-=` or [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// a =- 42; // confusing, should it be `a -= 42` or `a = -42`? [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub SUSPICIOUS_ASSIGNMENT_FORMATTING, [INFO] [stderr] 20 | | style, [INFO] [stderr] 21 | | "suspicious formatting of `*=`, `-=` or `!=`" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/formatting.rs:24:1 [INFO] [stderr] | [INFO] [stderr] 24 | / /// **What it does:** Checks for formatting of `else if`. It lints if the `else` [INFO] [stderr] 25 | | /// and `if` are not on the same line or the `else` seems to be missing. [INFO] [stderr] 26 | | /// [INFO] [stderr] 27 | | /// **Why is this bad?** This is probably some refactoring remnant, even if the [INFO] [stderr] ... | [INFO] [stderr] 42 | | /// } [INFO] [stderr] 43 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 44 | / declare_clippy_lint! { [INFO] [stderr] 45 | | pub SUSPICIOUS_ELSE_FORMATTING, [INFO] [stderr] 46 | | style, [INFO] [stderr] 47 | | "suspicious formatting of `else if`" [INFO] [stderr] 48 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/formatting.rs:50:1 [INFO] [stderr] | [INFO] [stderr] 50 | / /// **What it does:** Checks for possible missing comma in an array. It lints if [INFO] [stderr] 51 | | /// an array element is a binary operator expression and it lies on two lines. [INFO] [stderr] 52 | | /// [INFO] [stderr] 53 | | /// **Why is this bad?** This could lead to unexpected results. [INFO] [stderr] ... | [INFO] [stderr] 62 | | /// ]; [INFO] [stderr] 63 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 64 | / declare_clippy_lint! { [INFO] [stderr] 65 | | pub POSSIBLE_MISSING_COMMA, [INFO] [stderr] 66 | | correctness, [INFO] [stderr] 67 | | "possible missing comma in array" [INFO] [stderr] 68 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/functions.rs:12:1 [INFO] [stderr] | [INFO] [stderr] 12 | / /// **What it does:** Checks for functions with too many parameters. [INFO] [stderr] 13 | | /// [INFO] [stderr] 14 | | /// **Why is this bad?** Functions with lots of parameters are considered bad [INFO] [stderr] 15 | | /// style and reduce readability (“what does the 5th parameter mean?”). Consider [INFO] [stderr] ... | [INFO] [stderr] 23 | | /// f32) { .. } [INFO] [stderr] 24 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 25 | / declare_clippy_lint! { [INFO] [stderr] 26 | | pub TOO_MANY_ARGUMENTS, [INFO] [stderr] 27 | | complexity, [INFO] [stderr] 28 | | "functions with too many arguments" [INFO] [stderr] 29 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/functions.rs:31:1 [INFO] [stderr] | [INFO] [stderr] 31 | / /// **What it does:** Checks for public functions that dereferences raw pointer [INFO] [stderr] 32 | | /// arguments but are not marked unsafe. [INFO] [stderr] 33 | | /// [INFO] [stderr] 34 | | /// **Why is this bad?** The function should probably be marked `unsafe`, since [INFO] [stderr] ... | [INFO] [stderr] 49 | | /// pub fn foo(x: *const u8) { println!("{}", unsafe { *x }); } [INFO] [stderr] 50 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 51 | / declare_clippy_lint! { [INFO] [stderr] 52 | | pub NOT_UNSAFE_PTR_ARG_DEREF, [INFO] [stderr] 53 | | correctness, [INFO] [stderr] 54 | | "public functions dereferencing raw pointer arguments but not marked `unsafe`" [INFO] [stderr] 55 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/identity_conversion.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for always-identical `Into`/`From` conversions. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** Redundant code. [INFO] [stderr] 10 | | /// [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// let s: String = format!("hello").into(); [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub IDENTITY_CONVERSION, [INFO] [stderr] 20 | | complexity, [INFO] [stderr] 21 | | "using always-identical `Into`/`From` conversions" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/identity_op.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for identity operations, e.g. `x + 0`. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** This code can be removed without changing the [INFO] [stderr] 11 | | /// meaning. So it just obscures what's going on. Delete it mercilessly. [INFO] [stderr] ... | [INFO] [stderr] 17 | | /// x / 1 + 0 * 1 - 0 | 0 [INFO] [stderr] 18 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 19 | / declare_clippy_lint! { [INFO] [stderr] 20 | | pub IDENTITY_OP, [INFO] [stderr] 21 | | complexity, [INFO] [stderr] 22 | | "using identity operations, e.g. `x + 0` or `y / 1`" [INFO] [stderr] 23 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/if_let_redundant_pattern_matching.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Lint for redundant pattern matching over `Result` or [INFO] [stderr] 6 | | /// `Option` [INFO] [stderr] 7 | | /// [INFO] [stderr] 8 | | /// **Why is this bad?** It's more concise and clear to just use the proper [INFO] [stderr] ... | [INFO] [stderr] 29 | | /// ``` [INFO] [stderr] 30 | | /// [INFO] [stderr] | |___^ [INFO] [stderr] 31 | / declare_clippy_lint! { [INFO] [stderr] 32 | | pub IF_LET_REDUNDANT_PATTERN_MATCHING, [INFO] [stderr] 33 | | style, [INFO] [stderr] 34 | | "use the proper utility function avoiding an `if let`" [INFO] [stderr] 35 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/if_not_else.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for usage of `!` or `!=` in an if condition with an [INFO] [stderr] 10 | | /// else branch. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** Negations reduce the readability of statements. [INFO] [stderr] ... | [INFO] [stderr] 32 | | /// } [INFO] [stderr] 33 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 34 | / declare_clippy_lint! { [INFO] [stderr] 35 | | pub IF_NOT_ELSE, [INFO] [stderr] 36 | | pedantic, [INFO] [stderr] 37 | | "`if` branches that could be swapped so no negation operation is necessary on the condition" [INFO] [stderr] 38 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/indexing_slicing.rs:12:1 [INFO] [stderr] | [INFO] [stderr] 12 | / /// **What it does:** Checks for out of bounds array indexing with a constant [INFO] [stderr] 13 | | /// index. [INFO] [stderr] 14 | | /// [INFO] [stderr] 15 | | /// **Why is this bad?** This will always panic at runtime. [INFO] [stderr] ... | [INFO] [stderr] 29 | | /// x[3]; [INFO] [stderr] 30 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 31 | / declare_clippy_lint! { [INFO] [stderr] 32 | | pub OUT_OF_BOUNDS_INDEXING, [INFO] [stderr] 33 | | correctness, [INFO] [stderr] 34 | | "out of bounds constant indexing" [INFO] [stderr] 35 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/indexing_slicing.rs:37:1 [INFO] [stderr] | [INFO] [stderr] 37 | / /// **What it does:** Checks for usage of indexing or slicing. Arrays are special cased, this lint [INFO] [stderr] 38 | | /// does report on arrays if we can tell that slicing operations are in bounds and does not [INFO] [stderr] 39 | | /// lint on constant `usize` indexing on arrays because that is handled by rustc's `const_err` lint. [INFO] [stderr] 40 | | /// [INFO] [stderr] ... | [INFO] [stderr] 78 | | /// y.get(..100); [INFO] [stderr] 79 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 80 | / declare_clippy_lint! { [INFO] [stderr] 81 | | pub INDEXING_SLICING, [INFO] [stderr] 82 | | pedantic, [INFO] [stderr] 83 | | "indexing/slicing usage" [INFO] [stderr] 84 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/infallible_destructuring_match.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for matches being used to destructure a single-variant enum [INFO] [stderr] 6 | | /// or tuple struct where a `let` will suffice. [INFO] [stderr] 7 | | /// [INFO] [stderr] 8 | | /// **Why is this bad?** Just readability – `let` doesn't nest, whereas a `match` does. [INFO] [stderr] ... | [INFO] [stderr] 32 | | /// let Wrapper::Data(data) = wrapper; [INFO] [stderr] 33 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 34 | / declare_clippy_lint! { [INFO] [stderr] 35 | | pub INFALLIBLE_DESTRUCTURING_MATCH, [INFO] [stderr] 36 | | style, [INFO] [stderr] 37 | | "a match statement with a single infallible arm instead of a `let`" [INFO] [stderr] 38 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/infinite_iter.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for iteration that is guaranteed to be infinite. [INFO] [stderr] 6 | | /// [INFO] [stderr] 7 | | /// **Why is this bad?** While there may be places where this is acceptable [INFO] [stderr] 8 | | /// (e.g. in event streams), in most cases this is simply an error. [INFO] [stderr] ... | [INFO] [stderr] 14 | | /// repeat(1_u8).iter().collect::>() [INFO] [stderr] 15 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 16 | / declare_clippy_lint! { [INFO] [stderr] 17 | | pub INFINITE_ITER, [INFO] [stderr] 18 | | correctness, [INFO] [stderr] 19 | | "infinite iteration" [INFO] [stderr] 20 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/infinite_iter.rs:22:1 [INFO] [stderr] | [INFO] [stderr] 22 | / /// **What it does:** Checks for iteration that may be infinite. [INFO] [stderr] 23 | | /// [INFO] [stderr] 24 | | /// **Why is this bad?** While there may be places where this is acceptable [INFO] [stderr] 25 | | /// (e.g. in event streams), in most cases this is simply an error. [INFO] [stderr] ... | [INFO] [stderr] 32 | | /// [0..].iter().zip(infinite_iter.take_while(|x| x > 5)) [INFO] [stderr] 33 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 34 | / declare_clippy_lint! { [INFO] [stderr] 35 | | pub MAYBE_INFINITE_ITER, [INFO] [stderr] 36 | | pedantic, [INFO] [stderr] 37 | | "possible infinite iteration" [INFO] [stderr] 38 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/inherent_impl.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for multiple inherent implementations of a struct [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** Splitting the implementation of a type makes the code harder to navigate. [INFO] [stderr] 12 | | /// [INFO] [stderr] ... | [INFO] [stderr] 33 | | /// } [INFO] [stderr] 34 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 35 | / declare_clippy_lint! { [INFO] [stderr] 36 | | pub MULTIPLE_INHERENT_IMPL, [INFO] [stderr] 37 | | restriction, [INFO] [stderr] 38 | | "Multiple inherent impl that could be grouped" [INFO] [stderr] 39 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/inline_fn_without_body.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for `#[inline]` on trait methods without bodies [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** Only implementations of trait methods may be inlined. [INFO] [stderr] 12 | | /// The inline attribute is ignored for trait methods without bodies. [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// } [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub INLINE_FN_WITHOUT_BODY, [INFO] [stderr] 25 | | correctness, [INFO] [stderr] 26 | | "use of `#[inline]` on trait methods without bodies" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/int_plus_one.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for usage of `x >= y + 1` or `x - 1 >= y` (and `<=`) in a block [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** Readability -- better to use `> y` instead of `>= y + 1`. [INFO] [stderr] ... | [INFO] [stderr] 23 | | /// x > y [INFO] [stderr] 24 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 25 | / declare_clippy_lint! { [INFO] [stderr] 26 | | pub INT_PLUS_ONE, [INFO] [stderr] 27 | | complexity, [INFO] [stderr] 28 | | "instead of using x >= y + 1, use x > y" [INFO] [stderr] 29 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/invalid_ref.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for creation of references to zeroed or uninitialized memory. [INFO] [stderr] 7 | | /// [INFO] [stderr] 8 | | /// **Why is this bad?** Creation of null references is undefined behavior. [INFO] [stderr] 9 | | /// [INFO] [stderr] ... | [INFO] [stderr] 14 | | /// let bad_ref: &usize = std::mem::zeroed(); [INFO] [stderr] 15 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 16 | / declare_clippy_lint! { [INFO] [stderr] 17 | | pub INVALID_REF, [INFO] [stderr] 18 | | correctness, [INFO] [stderr] 19 | | "creation of invalid reference" [INFO] [stderr] 20 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/items_after_statements.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for items declared after some statement in a block. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** Items live for the entire scope they are declared [INFO] [stderr] 10 | | /// in. But statements are processed in order. This might cause confusion as [INFO] [stderr] ... | [INFO] [stderr] 27 | | /// } [INFO] [stderr] 28 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 29 | / declare_clippy_lint! { [INFO] [stderr] 30 | | pub ITEMS_AFTER_STATEMENTS, [INFO] [stderr] 31 | | pedantic, [INFO] [stderr] 32 | | "blocks where an item comes after a statement" [INFO] [stderr] 33 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/large_enum_variant.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for large size differences between variants on [INFO] [stderr] 9 | | /// `enum`s. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** Enum size is bounded by the largest variant. Having a [INFO] [stderr] ... | [INFO] [stderr] 22 | | /// } [INFO] [stderr] 23 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 24 | / declare_clippy_lint! { [INFO] [stderr] 25 | | pub LARGE_ENUM_VARIANT, [INFO] [stderr] 26 | | perf, [INFO] [stderr] 27 | | "large size difference between variants on an enum" [INFO] [stderr] 28 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/len_zero.rs:10:1 [INFO] [stderr] | [INFO] [stderr] 10 | / /// **What it does:** Checks for getting the length of something via `.len()` [INFO] [stderr] 11 | | /// just to compare to zero, and suggests using `.is_empty()` where applicable. [INFO] [stderr] 12 | | /// [INFO] [stderr] 13 | | /// **Why is this bad?** Some structures can answer `.is_empty()` much faster [INFO] [stderr] ... | [INFO] [stderr] 23 | | /// if x.len() == 0 { .. } [INFO] [stderr] 24 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 25 | / declare_clippy_lint! { [INFO] [stderr] 26 | | pub LEN_ZERO, [INFO] [stderr] 27 | | style, [INFO] [stderr] 28 | | "checking `.len() == 0` or `.len() > 0` (or similar) when `.is_empty()` \ [INFO] [stderr] 29 | | could be used instead" [INFO] [stderr] 30 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/len_zero.rs:32:1 [INFO] [stderr] | [INFO] [stderr] 32 | / /// **What it does:** Checks for items that implement `.len()` but not [INFO] [stderr] 33 | | /// `.is_empty()`. [INFO] [stderr] 34 | | /// [INFO] [stderr] 35 | | /// **Why is this bad?** It is good custom to have both methods, because for [INFO] [stderr] ... | [INFO] [stderr] 47 | | /// } [INFO] [stderr] 48 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 49 | / declare_clippy_lint! { [INFO] [stderr] 50 | | pub LEN_WITHOUT_IS_EMPTY, [INFO] [stderr] 51 | | style, [INFO] [stderr] 52 | | "traits or impls with a public `len` method but no corresponding `is_empty` method" [INFO] [stderr] 53 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/let_if_seq.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for variable declarations immediately followed by a [INFO] [stderr] 9 | | /// conditional affectation. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** This is not idiomatic Rust. [INFO] [stderr] ... | [INFO] [stderr] 45 | | /// }; [INFO] [stderr] 46 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 47 | / declare_clippy_lint! { [INFO] [stderr] 48 | | pub USELESS_LET_IF_SEQ, [INFO] [stderr] 49 | | style, [INFO] [stderr] 50 | | "unidiomatic `let mut` declaration followed by initialization in `if`" [INFO] [stderr] 51 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/lifetimes.rs:11:1 [INFO] [stderr] | [INFO] [stderr] 11 | / /// **What it does:** Checks for lifetime annotations which can be removed by [INFO] [stderr] 12 | | /// relying on lifetime elision. [INFO] [stderr] 13 | | /// [INFO] [stderr] 14 | | /// **Why is this bad?** The additional lifetimes make the code look more [INFO] [stderr] ... | [INFO] [stderr] 23 | | /// fn in_and_out<'a>(x: &'a u8, y: u8) -> &'a u8 { x } [INFO] [stderr] 24 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 25 | / declare_clippy_lint! { [INFO] [stderr] 26 | | pub NEEDLESS_LIFETIMES, [INFO] [stderr] 27 | | complexity, [INFO] [stderr] 28 | | "using explicit lifetimes for references in function arguments when elision rules \ [INFO] [stderr] 29 | | would allow omitting them" [INFO] [stderr] 30 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/lifetimes.rs:32:1 [INFO] [stderr] | [INFO] [stderr] 32 | / /// **What it does:** Checks for lifetimes in generics that are never used [INFO] [stderr] 33 | | /// anywhere else. [INFO] [stderr] 34 | | /// [INFO] [stderr] 35 | | /// **Why is this bad?** The additional lifetimes make the code look more [INFO] [stderr] ... | [INFO] [stderr] 43 | | /// fn unused_lifetime<'a>(x: u8) { .. } [INFO] [stderr] 44 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 45 | / declare_clippy_lint! { [INFO] [stderr] 46 | | pub EXTRA_UNUSED_LIFETIMES, [INFO] [stderr] 47 | | complexity, [INFO] [stderr] 48 | | "unused lifetimes in function definitions" [INFO] [stderr] 49 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/literal_representation.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Warns if a long integral or floating-point constant does [INFO] [stderr] 10 | | /// not contain underscores. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** Reading long numbers is difficult without separators. [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// 61864918973511 [INFO] [stderr] 20 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub UNREADABLE_LITERAL, [INFO] [stderr] 23 | | style, [INFO] [stderr] 24 | | "long integer literal without underscores" [INFO] [stderr] 25 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/literal_representation.rs:27:1 [INFO] [stderr] | [INFO] [stderr] 27 | / /// **What it does:** Warns if an integral or floating-point constant is [INFO] [stderr] 28 | | /// grouped inconsistently with underscores. [INFO] [stderr] 29 | | /// [INFO] [stderr] 30 | | /// **Why is this bad?** Readers may incorrectly interpret inconsistently [INFO] [stderr] ... | [INFO] [stderr] 38 | | /// 618_64_9189_73_511 [INFO] [stderr] 39 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 40 | / declare_clippy_lint! { [INFO] [stderr] 41 | | pub INCONSISTENT_DIGIT_GROUPING, [INFO] [stderr] 42 | | style, [INFO] [stderr] 43 | | "integer literals with digits grouped inconsistently" [INFO] [stderr] 44 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/literal_representation.rs:46:1 [INFO] [stderr] | [INFO] [stderr] 46 | / /// **What it does:** Warns if the digits of an integral or floating-point [INFO] [stderr] 47 | | /// constant are grouped into groups that [INFO] [stderr] 48 | | /// are too large. [INFO] [stderr] 49 | | /// [INFO] [stderr] ... | [INFO] [stderr] 57 | | /// 6186491_8973511 [INFO] [stderr] 58 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 59 | / declare_clippy_lint! { [INFO] [stderr] 60 | | pub LARGE_DIGIT_GROUPS, [INFO] [stderr] 61 | | style, [INFO] [stderr] 62 | | "grouping digits into groups that are too large" [INFO] [stderr] 63 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/literal_representation.rs:65:1 [INFO] [stderr] | [INFO] [stderr] 65 | / /// **What it does:** Warns if there is a better representation for a numeric literal. [INFO] [stderr] 66 | | /// [INFO] [stderr] 67 | | /// **Why is this bad?** Especially for big powers of 2 a hexadecimal representation is more [INFO] [stderr] 68 | | /// readable than a decimal representation. [INFO] [stderr] ... | [INFO] [stderr] 75 | | /// `65_535` => `0xFFFF` [INFO] [stderr] 76 | | /// `4_042_322_160` => `0xF0F0_F0F0` [INFO] [stderr] | |____________________________________^ [INFO] [stderr] 77 | / declare_clippy_lint! { [INFO] [stderr] 78 | | pub DECIMAL_LITERAL_REPRESENTATION, [INFO] [stderr] 79 | | restriction, [INFO] [stderr] 80 | | "using decimal representation when hexadecimal would be better" [INFO] [stderr] 81 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:29:1 [INFO] [stderr] | [INFO] [stderr] 29 | / /// **What it does:** Checks for for-loops that manually copy items between [INFO] [stderr] 30 | | /// slices that could be optimized by having a memcpy. [INFO] [stderr] 31 | | /// [INFO] [stderr] 32 | | /// **Why is this bad?** It is not as fast as a memcpy. [INFO] [stderr] ... | [INFO] [stderr] 40 | | /// } [INFO] [stderr] 41 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 42 | / declare_clippy_lint! { [INFO] [stderr] 43 | | pub MANUAL_MEMCPY, [INFO] [stderr] 44 | | perf, [INFO] [stderr] 45 | | "manually copying items between slices" [INFO] [stderr] 46 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:48:1 [INFO] [stderr] | [INFO] [stderr] 48 | / /// **What it does:** Checks for looping over the range of `0..len` of some [INFO] [stderr] 49 | | /// collection just to get the values by index. [INFO] [stderr] 50 | | /// [INFO] [stderr] 51 | | /// **Why is this bad?** Just iterating the collection itself makes the intent [INFO] [stderr] ... | [INFO] [stderr] 60 | | /// } [INFO] [stderr] 61 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 62 | / declare_clippy_lint! { [INFO] [stderr] 63 | | pub NEEDLESS_RANGE_LOOP, [INFO] [stderr] 64 | | style, [INFO] [stderr] 65 | | "for-looping over a range of indices where an iterator over items would do" [INFO] [stderr] 66 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:68:1 [INFO] [stderr] | [INFO] [stderr] 68 | / /// **What it does:** Checks for loops on `x.iter()` where `&x` will do, and [INFO] [stderr] 69 | | /// suggests the latter. [INFO] [stderr] 70 | | /// [INFO] [stderr] 71 | | /// **Why is this bad?** Readability. [INFO] [stderr] ... | [INFO] [stderr] 79 | | /// for x in y.iter() { .. } [INFO] [stderr] 80 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 81 | / declare_clippy_lint! { [INFO] [stderr] 82 | | pub EXPLICIT_ITER_LOOP, [INFO] [stderr] 83 | | style, [INFO] [stderr] 84 | | "for-looping over `_.iter()` or `_.iter_mut()` when `&_` or `&mut _` would do" [INFO] [stderr] 85 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:87:1 [INFO] [stderr] | [INFO] [stderr] 87 | / /// **What it does:** Checks for loops on `y.into_iter()` where `y` will do, and [INFO] [stderr] 88 | | /// suggests the latter. [INFO] [stderr] 89 | | /// [INFO] [stderr] 90 | | /// **Why is this bad?** Readability. [INFO] [stderr] ... | [INFO] [stderr] 97 | | /// for x in y.into_iter() { .. } [INFO] [stderr] 98 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 99 | / declare_clippy_lint! { [INFO] [stderr] 100 | | pub EXPLICIT_INTO_ITER_LOOP, [INFO] [stderr] 101 | | style, [INFO] [stderr] 102 | | "for-looping over `_.into_iter()` when `_` would do" [INFO] [stderr] 103 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:105:1 [INFO] [stderr] | [INFO] [stderr] 105 | / /// **What it does:** Checks for loops on `x.next()`. [INFO] [stderr] 106 | | /// [INFO] [stderr] 107 | | /// **Why is this bad?** `next()` returns either `Some(value)` if there was a [INFO] [stderr] 108 | | /// value, or `None` otherwise. The insidious thing is that `Option<_>` [INFO] [stderr] ... | [INFO] [stderr] 118 | | /// for x in y.next() { .. } [INFO] [stderr] 119 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 120 | / declare_clippy_lint! { [INFO] [stderr] 121 | | pub ITER_NEXT_LOOP, [INFO] [stderr] 122 | | correctness, [INFO] [stderr] 123 | | "for-looping over `_.next()` which is probably not intended" [INFO] [stderr] 124 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:126:1 [INFO] [stderr] | [INFO] [stderr] 126 | / /// **What it does:** Checks for `for` loops over `Option` values. [INFO] [stderr] 127 | | /// [INFO] [stderr] 128 | | /// **Why is this bad?** Readability. This is more clearly expressed as an `if [INFO] [stderr] 129 | | /// let`. [INFO] [stderr] ... | [INFO] [stderr] 140 | | /// if let Some(x) = option { .. } [INFO] [stderr] 141 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 142 | / declare_clippy_lint! { [INFO] [stderr] 143 | | pub FOR_LOOP_OVER_OPTION, [INFO] [stderr] 144 | | correctness, [INFO] [stderr] 145 | | "for-looping over an `Option`, which is more clearly expressed as an `if let`" [INFO] [stderr] 146 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:148:1 [INFO] [stderr] | [INFO] [stderr] 148 | / /// **What it does:** Checks for `for` loops over `Result` values. [INFO] [stderr] 149 | | /// [INFO] [stderr] 150 | | /// **Why is this bad?** Readability. This is more clearly expressed as an `if [INFO] [stderr] 151 | | /// let`. [INFO] [stderr] ... | [INFO] [stderr] 162 | | /// if let Ok(x) = result { .. } [INFO] [stderr] 163 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 164 | / declare_clippy_lint! { [INFO] [stderr] 165 | | pub FOR_LOOP_OVER_RESULT, [INFO] [stderr] 166 | | correctness, [INFO] [stderr] 167 | | "for-looping over a `Result`, which is more clearly expressed as an `if let`" [INFO] [stderr] 168 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:176:1 [INFO] [stderr] | [INFO] [stderr] 176 | / /// **What it does:** Checks for usage of `_.map(_).unwrap_or_else(_)`. [INFO] [stderr] 177 | | /// [INFO] [stderr] 178 | | /// **Why is this bad?** Readability, this can be written more concisely as [INFO] [stderr] 179 | | /// `_.map_or_else(_, _)`. [INFO] [stderr] ... | [INFO] [stderr] 185 | | /// x.map(|a| a + 1).unwrap_or_else(some_function) [INFO] [stderr] 186 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 187 | / declare_clippy_lint! { [INFO] [stderr] 188 | | pub OPTION_MAP_UNWRAP_OR_ELSE, [INFO] [stderr] 189 | | pedantic, [INFO] [stderr] 190 | | "using `Option.map(f).unwrap_or_else(g)`, which is more succinctly expressed as \ [INFO] [stderr] 191 | | `map_or_else(g, f)`" [INFO] [stderr] 192 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:170:1 [INFO] [stderr] | [INFO] [stderr] 170 | / /// **What it does:** Detects `loop + match` combinations that are easier [INFO] [stderr] 171 | | /// written as a `while let` loop. [INFO] [stderr] 172 | | /// [INFO] [stderr] 173 | | /// **Why is this bad?** The `while let` loop is usually shorter and more [INFO] [stderr] ... | [INFO] [stderr] 190 | | /// } [INFO] [stderr] 191 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 192 | / declare_clippy_lint! { [INFO] [stderr] 193 | | pub WHILE_LET_LOOP, [INFO] [stderr] 194 | | complexity, [INFO] [stderr] 195 | | "`loop { if let { ... } else break }`, which can be written as a `while let` loop" [INFO] [stderr] 196 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:194:1 [INFO] [stderr] | [INFO] [stderr] 194 | / /// **What it does:** Checks for usage of `result.map(_).unwrap_or_else(_)`. [INFO] [stderr] 195 | | /// [INFO] [stderr] 196 | | /// **Why is this bad?** Readability, this can be written more concisely as [INFO] [stderr] 197 | | /// `result.ok().map_or_else(_, _)`. [INFO] [stderr] ... | [INFO] [stderr] 203 | | /// x.map(|a| a + 1).unwrap_or_else(some_function) [INFO] [stderr] 204 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 205 | / declare_clippy_lint! { [INFO] [stderr] 206 | | pub RESULT_MAP_UNWRAP_OR_ELSE, [INFO] [stderr] 207 | | pedantic, [INFO] [stderr] 208 | | "using `Result.map(f).unwrap_or_else(g)`, which is more succinctly expressed as \ [INFO] [stderr] 209 | | `.ok().map_or_else(g, f)`" [INFO] [stderr] 210 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:198:1 [INFO] [stderr] | [INFO] [stderr] 198 | / /// **What it does:** Checks for using `collect()` on an iterator without using [INFO] [stderr] 199 | | /// the result. [INFO] [stderr] 200 | | /// [INFO] [stderr] 201 | | /// **Why is this bad?** It is more idiomatic to use a `for` loop over the [INFO] [stderr] ... | [INFO] [stderr] 208 | | /// vec.iter().map(|x| /* some operation returning () */).collect::>(); [INFO] [stderr] 209 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 210 | / declare_clippy_lint! { [INFO] [stderr] 211 | | pub UNUSED_COLLECT, [INFO] [stderr] | [INFO] [stderr] 212 | | perf, [INFO] [stderr] 213 | | "`collect()`ing an iterator without using the result; this is usually better \ [INFO] [stderr] 214 | | written as a for loop" [INFO] [stderr] 215 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:212:1 [INFO] [stderr] | [INFO] [stderr] 212 | / /// **What it does:** Checks for usage of `_.map_or(None, _)`. [INFO] [stderr] 213 | | /// [INFO] [stderr] 214 | | /// **Why is this bad?** Readability, this can be written more concisely as [INFO] [stderr] 215 | | /// `_.and_then(_)`. [INFO] [stderr] ... | [INFO] [stderr] 221 | | /// opt.map_or(None, |a| a + 1) [INFO] [stderr] 222 | | /// ``` [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:217:1 [INFO] [stderr] | |_______^ [INFO] [stderr] | [INFO] [stderr] 223 | / declare_clippy_lint! { [INFO] [stderr] 217 | / /// **What it does:** Checks for loops over ranges `x..y` where both `x` and `y` [INFO] [stderr] 224 | | pub OPTION_MAP_OR_NONE, [INFO] [stderr] 225 | | style, [INFO] [stderr] 218 | | /// are constant and `x` is greater or equal to `y`, unless the range is [INFO] [stderr] 226 | | "using `Option.map_or(None, f)`, which is more succinctly expressed as \ [INFO] [stderr] 227 | | `and_then(f)`" [INFO] [stderr] 228 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] 219 | | /// reversed or has a negative `.step_by(_)`. [INFO] [stderr] 220 | | /// [INFO] [stderr] ... | [INFO] [stderr] 231 | | /// for x in 5..10-5 { .. } // oops, stray `-` [INFO] [stderr] 232 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 233 | / declare_clippy_lint! { [INFO] [stderr] 234 | | pub REVERSE_RANGE_LOOP, [INFO] [stderr] 235 | | correctness, [INFO] [stderr] 236 | | "iteration over an empty range, such as `10..0` or `5..5`" [INFO] [stderr] 237 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:230:1 [INFO] [stderr] | [INFO] [stderr] 230 | / /// **What it does:** Checks for usage of `_.filter(_).next()`. [INFO] [stderr] 231 | | /// [INFO] [stderr] 232 | | /// **Why is this bad?** Readability, this can be written more concisely as [INFO] [stderr] 233 | | /// `_.find(_)`. [INFO] [stderr] ... | [INFO] [stderr] 239 | | /// iter.filter(|x| x == 0).next() [INFO] [stderr] 240 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 241 | / declare_clippy_lint! { [INFO] [stderr] 242 | | pub FILTER_NEXT, [INFO] [stderr] 243 | | complexity, [INFO] [stderr] 244 | | "using `filter(p).next()`, which is more succinctly expressed as `.find(p)`" [INFO] [stderr] 245 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:239:1 [INFO] [stderr] | [INFO] [stderr] 239 | / /// **What it does:** Checks `for` loops over slices with an explicit counter [INFO] [stderr] 240 | | /// and suggests the use of `.enumerate()`. [INFO] [stderr] 241 | | /// [INFO] [stderr] 242 | | /// **Why is it bad?** Not only is the version using `.enumerate()` more [INFO] [stderr] ... | [INFO] [stderr] 251 | | /// for i in 0..v.len() { bar(i, v[i]); } [INFO] [stderr] 252 | | /// ``` [INFO] [stderr] | [INFO] [stderr] | |_______^ [INFO] [stderr] 253 | / declare_clippy_lint! { [INFO] [stderr] 254 | | pub EXPLICIT_COUNTER_LOOP, [INFO] [stderr] 255 | | complexity, [INFO] [stderr] 256 | | "for-looping with an explicit counter when `_.enumerate()` would do" [INFO] [stderr] 257 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:247:1 [INFO] [stderr] | [INFO] [stderr] 247 | / /// **What it does:** Checks for usage of `_.filter(_).map(_)`, [INFO] [stderr] 248 | | /// `_.filter(_).flat_map(_)`, `_.filter_map(_).flat_map(_)` and similar. [INFO] [stderr] 249 | | /// [INFO] [stderr] 250 | | /// **Why is this bad?** Readability, this can be written more concisely as a [INFO] [stderr] ... | [INFO] [stderr] 258 | | /// iter.filter(|x| x == 0).map(|x| x * 2) [INFO] [stderr] 259 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 260 | / declare_clippy_lint! { [INFO] [stderr] 261 | | pub FILTER_MAP, [INFO] [stderr] 262 | | pedantic, [INFO] [stderr] 263 | | "using combinations of `filter`, `map`, `filter_map` and `flat_map` which can \ [INFO] [stderr] 264 | | usually be written as a single method call" [INFO] [stderr] 265 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:259:1 [INFO] [stderr] | [INFO] [stderr] 259 | / /// **What it does:** Checks for empty `loop` expressions. [INFO] [stderr] 260 | | /// [INFO] [stderr] 261 | | /// **Why is this bad?** Those busy loops burn CPU cycles without doing [INFO] [stderr] 262 | | /// anything. Think of the environment and either block on something or at least [INFO] [stderr] ... | [INFO] [stderr] 269 | | /// loop {} [INFO] [stderr] 270 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 271 | / declare_clippy_lint! { [INFO] [stderr] 272 | | pub EMPTY_LOOP, [INFO] [stderr] 273 | | style, [INFO] [stderr] 274 | | "empty `loop {}`, which should block or sleep" [INFO] [stderr] 275 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:267:1 [INFO] [stderr] | [INFO] [stderr] 267 | / /// **What it does:** Checks for an iterator search (such as `find()`, [INFO] [stderr] 268 | | /// `position()`, or `rposition()`) followed by a call to `is_some()`. [INFO] [stderr] 269 | | /// [INFO] [stderr] 270 | | /// **Why is this bad?** Readability, this can be written more concisely as [INFO] [stderr] ... | [INFO] [stderr] 277 | | /// iter.find(|x| x == 0).is_some() [INFO] [stderr] 278 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 279 | / declare_clippy_lint! { [INFO] [stderr] 280 | | pub SEARCH_IS_SOME, [INFO] [stderr] 281 | | complexity, [INFO] [stderr] 282 | | "using an iterator search followed by `is_some()`, which is more succinctly \ [INFO] [stderr] 283 | | expressed as a call to `any()`" [INFO] [stderr] 284 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:277:1 [INFO] [stderr] | [INFO] [stderr] 277 | / /// **What it does:** Checks for `while let` expressions on iterators. [INFO] [stderr] 278 | | /// [INFO] [stderr] 279 | | /// **Why is this bad?** Readability. A simple `for` loop is shorter and conveys [INFO] [stderr] 280 | | /// the intent better. [INFO] [stderr] ... | [INFO] [stderr] 286 | | /// while let Some(val) = iter() { .. } [INFO] [stderr] 287 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 288 | / declare_clippy_lint! { [INFO] [stderr] 289 | | pub WHILE_LET_ON_ITERATOR, [INFO] [stderr] | [INFO] [stderr] 290 | | style, [INFO] [stderr] 291 | | "using a while-let loop instead of a for loop on an iterator" [INFO] [stderr] 292 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:286:1 [INFO] [stderr] | [INFO] [stderr] 286 | / /// **What it does:** Checks for usage of `.chars().next()` on a `str` to check [INFO] [stderr] 287 | | /// if it starts with a given char. [INFO] [stderr] 288 | | /// [INFO] [stderr] 289 | | /// **Why is this bad?** Readability, this can be written more concisely as [INFO] [stderr] ... | [INFO] [stderr] 296 | | /// name.chars().next() == Some('_') [INFO] [stderr] 297 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 298 | / declare_clippy_lint! { [INFO] [stderr] 299 | | pub CHARS_NEXT_CMP, [INFO] [stderr] 300 | | complexity, [INFO] [stderr] 301 | | "using `.chars().next()` to check if a string starts with a char" [INFO] [stderr] 302 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:294:1 [INFO] [stderr] | [INFO] [stderr] 294 | / /// **What it does:** Checks for iterating a map (`HashMap` or `BTreeMap`) and [INFO] [stderr] 295 | | /// ignoring either the keys or values. [INFO] [stderr] 296 | | /// [INFO] [stderr] 297 | | /// **Why is this bad?** Readability. There are `keys` and `values` methods that [INFO] [stderr] ... | [INFO] [stderr] 310 | | /// for k in map.keys() { .. } [INFO] [stderr] 311 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 312 | / declare_clippy_lint! { [INFO] [stderr] 313 | | pub FOR_KV_MAP, [INFO] [stderr] 314 | | style, [INFO] [stderr] 315 | | "looping on a map using `iter` when `keys` or `values` would do" [INFO] [stderr] 316 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:304:1 [INFO] [stderr] | [INFO] [stderr] 304 | / /// **What it does:** Checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`, [INFO] [stderr] 305 | | /// etc., and suggests to use `or_else`, `unwrap_or_else`, etc., or [INFO] [stderr] 306 | | /// `unwrap_or_default` instead. [INFO] [stderr] 307 | | /// [INFO] [stderr] ... | [INFO] [stderr] 324 | | /// foo.unwrap_or_default() [INFO] [stderr] 325 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 326 | / declare_clippy_lint! { [INFO] [stderr] 327 | | pub OR_FUN_CALL, [INFO] [stderr] 328 | | perf, [INFO] [stderr] 329 | | "using any `*or` method with a function call, which suggests `*or_else`" [INFO] [stderr] 330 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:318:1 [INFO] [stderr] | [INFO] [stderr] 318 | / /// **What it does:** Checks for loops that will always `break`, `return` or [INFO] [stderr] 319 | | /// `continue` an outer loop. [INFO] [stderr] 320 | | /// [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] 321 | | /// **Why is this bad?** This loop never loops, all it does is obfuscating the [INFO] [stderr] ... | [INFO] [stderr] 328 | | /// loop { ..; break; } [INFO] [stderr] 329 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 330 | / declare_clippy_lint! { [INFO] [stderr] 331 | | pub NEVER_LOOP, [INFO] [stderr] 332 | | correctness, [INFO] [stderr] 333 | | "any loop that will always `break` or `return`" [INFO] [stderr] 334 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:332:1 [INFO] [stderr] | [INFO] [stderr] 332 | / /// **What it does:** Checks for calls to `.expect(&format!(...))`, `.expect(foo(..))`, [INFO] [stderr] 333 | | /// etc., and suggests to use `unwrap_or_else` instead [INFO] [stderr] 334 | | /// [INFO] [stderr] 335 | | /// **Why is this bad?** The function will always be called. [INFO] [stderr] ... | [INFO] [stderr] 354 | | /// foo.unwrap_or_else(|_| panic!(format("Err {}: {}", err_code, err_msg).as_str())) [INFO] [stderr] 355 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 356 | / declare_clippy_lint! { [INFO] [stderr] 357 | | pub EXPECT_FUN_CALL, [INFO] [stderr] 358 | | perf, [INFO] [stderr] 359 | | "using any `expect` method with a function call" [INFO] [stderr] 360 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:336:1 [INFO] [stderr] | [INFO] [stderr] 336 | / /// **What it does:** Checks for loops which have a range bound that is a mutable variable [INFO] [stderr] 337 | | /// [INFO] [stderr] 338 | | /// **Why is this bad?** One might think that modifying the mutable variable changes the loop bounds [INFO] [stderr] 339 | | /// [INFO] [stderr] ... | [INFO] [stderr] 348 | | /// } [INFO] [stderr] 349 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 350 | / declare_clippy_lint! { [INFO] [stderr] 351 | | pub MUT_RANGE_BOUND, [INFO] [stderr] 352 | | complexity, [INFO] [stderr] 353 | | "for loop over a range where one of the bounds is a mutable variable" [INFO] [stderr] 354 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:362:1 [INFO] [stderr] | [INFO] [stderr] 362 | / /// **What it does:** Checks for usage of `.clone()` on a `Copy` type. [INFO] [stderr] 363 | | /// [INFO] [stderr] 364 | | /// **Why is this bad?** The only reason `Copy` types implement `Clone` is for [INFO] [stderr] 365 | | /// generics, not for using the `clone` method on a concrete type. [INFO] [stderr] ... | [INFO] [stderr] 371 | | /// 42u64.clone() [INFO] [stderr] 372 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 373 | / declare_clippy_lint! { [INFO] [stderr] 374 | | pub CLONE_ON_COPY, [INFO] [stderr] 375 | | complexity, [INFO] [stderr] 376 | | "using `clone` on a `Copy` type" [INFO] [stderr] 377 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/loops.rs:356:1 [INFO] [stderr] | [INFO] [stderr] 356 | / /// **What it does:** Checks whether variables used within while loop condition [INFO] [stderr] 357 | | /// can be (and are) mutated in the body. [INFO] [stderr] 358 | | /// [INFO] [stderr] 359 | | /// **Why is this bad?** If the condition is unchanged, entering the body of the loop [INFO] [stderr] ... | [INFO] [stderr] 371 | | /// } [INFO] [stderr] 372 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 373 | / declare_clippy_lint! { [INFO] [stderr] 374 | | pub WHILE_IMMUTABLE_CONDITION, [INFO] [stderr] 375 | | correctness, [INFO] [stderr] 376 | | "variables used within while expression are not mutated in the body" [INFO] [stderr] 377 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:379:1 [INFO] [stderr] | [INFO] [stderr] 379 | / /// **What it does:** Checks for usage of `.clone()` on a ref-counted pointer, [INFO] [stderr] 380 | | /// (`Rc`, `Arc`, `rc::Weak`, or `sync::Weak`), and suggests calling Clone via unified [INFO] [stderr] 381 | | /// function syntax instead (e.g. `Rc::clone(foo)`). [INFO] [stderr] 382 | | /// [INFO] [stderr] ... | [INFO] [stderr] 389 | | /// x.clone() [INFO] [stderr] 390 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 391 | / declare_clippy_lint! { [INFO] [stderr] 392 | | pub CLONE_ON_REF_PTR, [INFO] [stderr] 393 | | restriction, [INFO] [stderr] 394 | | "using 'clone' on a ref-counted pointer" [INFO] [stderr] 395 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:397:1 [INFO] [stderr] | [INFO] [stderr] 397 | / /// **What it does:** Checks for usage of `.clone()` on an `&&T`. [INFO] [stderr] 398 | | /// [INFO] [stderr] 399 | | /// **Why is this bad?** Cloning an `&&T` copies the inner `&T`, instead of [INFO] [stderr] 400 | | /// cloning the underlying `T`. [INFO] [stderr] ... | [INFO] [stderr] 411 | | /// } [INFO] [stderr] 412 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 413 | / declare_clippy_lint! { [INFO] [stderr] 414 | | pub CLONE_DOUBLE_REF, [INFO] [stderr] 415 | | correctness, [INFO] [stderr] 416 | | "using `clone` on `&&T`" [INFO] [stderr] 417 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:419:1 [INFO] [stderr] | [INFO] [stderr] 419 | / /// **What it does:** Checks for `new` not returning `Self`. [INFO] [stderr] 420 | | /// [INFO] [stderr] 421 | | /// **Why is this bad?** As a convention, `new` methods are used to make a new [INFO] [stderr] 422 | | /// instance of a type. [INFO] [stderr] ... | [INFO] [stderr] 431 | | /// } [INFO] [stderr] 432 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 433 | / declare_clippy_lint! { [INFO] [stderr] 434 | | pub NEW_RET_NO_SELF, [INFO] [stderr] 435 | | style, [INFO] [stderr] 436 | | "not returning `Self` in a `new` method" [INFO] [stderr] 437 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:439:1 [INFO] [stderr] | [INFO] [stderr] 439 | / /// **What it does:** Checks for string methods that receive a single-character [INFO] [stderr] 440 | | /// `str` as an argument, e.g. `_.split("x")`. [INFO] [stderr] 441 | | /// [INFO] [stderr] 442 | | /// **Why is this bad?** Performing these methods using a `char` is faster than [INFO] [stderr] ... | [INFO] [stderr] 447 | | /// **Example:** [INFO] [stderr] 448 | | /// `_.split("x")` could be `_.split('x') [INFO] [stderr] | |_________________________________________^ [INFO] [stderr] 449 | / declare_clippy_lint! { [INFO] [stderr] 450 | | pub SINGLE_CHAR_PATTERN, [INFO] [stderr] 451 | | perf, [INFO] [stderr] 452 | | "using a single-character str where a char could be used, e.g. \ [INFO] [stderr] 453 | | `_.split(\"x\")`" [INFO] [stderr] 454 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:456:1 [INFO] [stderr] | [INFO] [stderr] 456 | / /// **What it does:** Checks for getting the inner pointer of a temporary [INFO] [stderr] 457 | | /// `CString`. [INFO] [stderr] 458 | | /// [INFO] [stderr] 459 | | /// **Why is this bad?** The inner pointer of a `CString` is only valid as long [INFO] [stderr] ... | [INFO] [stderr] 476 | | /// } [INFO] [stderr] 477 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 478 | / declare_clippy_lint! { [INFO] [stderr] 479 | | pub TEMPORARY_CSTRING_AS_PTR, [INFO] [stderr] 480 | | correctness, [INFO] [stderr] 481 | | "getting the inner pointer of a temporary `CString`" [INFO] [stderr] 482 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:484:1 [INFO] [stderr] | [INFO] [stderr] 484 | / /// **What it does:** Checks for use of `.iter().nth()` (and the related [INFO] [stderr] 485 | | /// `.iter_mut().nth()`) on standard library types with O(1) element access. [INFO] [stderr] 486 | | /// [INFO] [stderr] 487 | | /// **Why is this bad?** `.get()` and `.get_mut()` are more efficient and more [INFO] [stderr] ... | [INFO] [stderr] 502 | | /// let bad_slice = &some_vec[..].get(3); [INFO] [stderr] 503 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 504 | / declare_clippy_lint! { [INFO] [stderr] 505 | | pub ITER_NTH, [INFO] [stderr] 506 | | perf, [INFO] [stderr] 507 | | "using `.iter().nth()` on a standard library type with O(1) element access" [INFO] [stderr] 508 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:510:1 [INFO] [stderr] | [INFO] [stderr] 510 | / /// **What it does:** Checks for use of `.skip(x).next()` on iterators. [INFO] [stderr] 511 | | /// [INFO] [stderr] 512 | | /// **Why is this bad?** `.nth(x)` is cleaner [INFO] [stderr] 513 | | /// [INFO] [stderr] ... | [INFO] [stderr] 526 | | /// let bad_slice = &some_vec[..].iter().nth(3); [INFO] [stderr] 527 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 528 | / declare_clippy_lint! { [INFO] [stderr] 529 | | pub ITER_SKIP_NEXT, [INFO] [stderr] 530 | | style, [INFO] [stderr] 531 | | "using `.skip(x).next()` on an iterator" [INFO] [stderr] 532 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:534:1 [INFO] [stderr] | [INFO] [stderr] 534 | / /// **What it does:** Checks for use of `.get().unwrap()` (or [INFO] [stderr] 535 | | /// `.get_mut().unwrap`) on a standard library type which implements `Index` [INFO] [stderr] 536 | | /// [INFO] [stderr] 537 | | /// **Why is this bad?** Using the Index trait (`[]`) is more clear and more [INFO] [stderr] ... | [INFO] [stderr] 552 | | /// some_vec[0] = 1; [INFO] [stderr] 553 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 554 | / declare_clippy_lint! { [INFO] [stderr] 555 | | pub GET_UNWRAP, [INFO] [stderr] 556 | | style, [INFO] [stderr] 557 | | "using `.get().unwrap()` or `.get_mut().unwrap()` when using `[]` would work instead" [INFO] [stderr] 558 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/map_clone.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for mapping `clone()` over an iterator. [INFO] [stderr] 9 | | /// [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] 10 | | /// **Why is this bad?** It makes the code less readable than using the [INFO] [stderr] 11 | | /// `.cloned()` adapter. [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// x.map(|e| e.clone()); [INFO] [stderr] 20 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub MAP_CLONE, [INFO] [stderr] 23 | | style, [INFO] [stderr] 24 | | "using `.map(|x| x.clone())` to clone an iterator or option's contents" [INFO] [stderr] 25 | | } [INFO] [stderr] [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:560:1 [INFO] [stderr] | [INFO] [stderr] 560 | / /// **What it does:** Checks for the use of `.extend(s.chars())` where s is a [INFO] [stderr] 561 | | /// `&str` or `String`. [INFO] [stderr] 562 | | /// [INFO] [stderr] 563 | | /// **Why is this bad?** `.push_str(s)` is clearer [INFO] [stderr] ... | [INFO] [stderr] 581 | | /// s.push_str(&def)); [INFO] [stderr] 582 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 583 | / declare_clippy_lint! { [INFO] [stderr] 584 | | pub STRING_EXTEND_CHARS, [INFO] [stderr] 585 | | style, [INFO] [stderr] 586 | | "using `x.extend(s.chars())` where s is a `&str` or `String`" [INFO] [stderr] 587 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/map_unit_fn.rs:12:1 [INFO] [stderr] | [INFO] [stderr] 12 | / /// **What it does:** Checks for usage of `option.map(f)` where f is a function [INFO] [stderr] 13 | | /// or closure that returns the unit type. [INFO] [stderr] 14 | | /// [INFO] [stderr] 15 | | /// **Why is this bad?** Readability, this can be written more clearly with [INFO] [stderr] ... | [INFO] [stderr] 37 | | /// } [INFO] [stderr] 38 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 39 | / declare_clippy_lint! { [INFO] [stderr] 40 | | pub OPTION_MAP_UNIT_FN, [INFO] [stderr] 41 | | complexity, [INFO] [stderr] 42 | | "using `option.map(f)`, where f is a function or closure that returns ()" [INFO] [stderr] 43 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/map_unit_fn.rs:45:1 [INFO] [stderr] | [INFO] [stderr] 45 | / /// **What it does:** Checks for usage of `result.map(f)` where f is a function [INFO] [stderr] 46 | | /// or closure that returns the unit type. [INFO] [stderr] 47 | | /// [INFO] [stderr] 48 | | /// **Why is this bad?** Readability, this can be written more clearly with [INFO] [stderr] ... | [INFO] [stderr] 70 | | /// } [INFO] [stderr] 71 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 72 | / declare_clippy_lint! { [INFO] [stderr] 73 | | pub RESULT_MAP_UNIT_FN, [INFO] [stderr] 74 | | complexity, [INFO] [stderr] 75 | | "using `result.map(f)`, where f is a function or closure that returns ()" [INFO] [stderr] 76 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/matches.rs:14:1 [INFO] [stderr] | [INFO] [stderr] 14 | / /// **What it does:** Checks for matches with a single arm where an `if let` [INFO] [stderr] 15 | | /// will usually suffice. [INFO] [stderr] 16 | | /// [INFO] [stderr] 17 | | /// **Why is this bad?** Just readability – `if let` nests less than a `match`. [INFO] [stderr] ... | [INFO] [stderr] 26 | | /// } [INFO] [stderr] 27 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 28 | / declare_clippy_lint! { [INFO] [stderr] 29 | | pub SINGLE_MATCH, [INFO] [stderr] 30 | | style, [INFO] [stderr] 31 | | "a match statement with a single nontrivial arm (i.e. where the other arm \ [INFO] [stderr] 32 | | is `_ => {}`) instead of `if let`" [INFO] [stderr] 33 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/matches.rs:35:1 [INFO] [stderr] | [INFO] [stderr] 35 | / /// **What it does:** Checks for matches with a two arms where an `if let` will [INFO] [stderr] 36 | | /// usually suffice. [INFO] [stderr] 37 | | /// [INFO] [stderr] 38 | | /// **Why is this bad?** Just readability – `if let` nests less than a `match`. [INFO] [stderr] ... | [INFO] [stderr] 47 | | /// } [INFO] [stderr] 48 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 49 | / declare_clippy_lint! { [INFO] [stderr] 50 | | pub SINGLE_MATCH_ELSE, [INFO] [stderr] 51 | | pedantic, [INFO] [stderr] 52 | | "a match statement with a two arms where the second arm's pattern is a wildcard \ [INFO] [stderr] 53 | | instead of `if let`" [INFO] [stderr] 54 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/matches.rs:56:1 [INFO] [stderr] | [INFO] [stderr] 56 | / /// **What it does:** Checks for matches where all arms match a reference, [INFO] [stderr] 57 | | /// suggesting to remove the reference and deref the matched expression [INFO] [stderr] 58 | | /// instead. It also checks for `if let &foo = bar` blocks. [INFO] [stderr] 59 | | /// [INFO] [stderr] ... | [INFO] [stderr] 71 | | /// } [INFO] [stderr] 72 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 73 | / declare_clippy_lint! { [INFO] [stderr] 74 | | pub MATCH_REF_PATS, [INFO] [stderr] 75 | | style, [INFO] [stderr] 76 | | "a match or `if let` with all arms prefixed with `&` instead of deref-ing the match expression" [INFO] [stderr] 77 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/matches.rs:79:1 [INFO] [stderr] | [INFO] [stderr] 79 | / /// **What it does:** Checks for matches where match expression is a `bool`. It [INFO] [stderr] 80 | | /// suggests to replace the expression with an `if...else` block. [INFO] [stderr] 81 | | /// [INFO] [stderr] 82 | | /// **Why is this bad?** It makes the code less readable. [INFO] [stderr] ... | [INFO] [stderr] 92 | | /// } [INFO] [stderr] 93 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 94 | / declare_clippy_lint! { [INFO] [stderr] 95 | | pub MATCH_BOOL, [INFO] [stderr] 96 | | style, [INFO] [stderr] 97 | | "a match on a boolean expression instead of an `if..else` block" [INFO] [stderr] 98 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/matches.rs:100:1 [INFO] [stderr] | [INFO] [stderr] 100 | / /// **What it does:** Checks for overlapping match arms. [INFO] [stderr] 101 | | /// [INFO] [stderr] 102 | | /// **Why is this bad?** It is likely to be an error and if not, makes the code [INFO] [stderr] 103 | | /// less obvious. [INFO] [stderr] ... | [INFO] [stderr] 114 | | /// } [INFO] [stderr] 115 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 116 | / declare_clippy_lint! { [INFO] [stderr] 117 | | pub MATCH_OVERLAPPING_ARM, [INFO] [stderr] 118 | | style, [INFO] [stderr] 119 | | "a match with overlapping arms" [INFO] [stderr] 120 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/matches.rs:122:1 [INFO] [stderr] | [INFO] [stderr] 122 | / /// **What it does:** Checks for arm which matches all errors with `Err(_)` [INFO] [stderr] 123 | | /// and take drastic actions like `panic!`. [INFO] [stderr] 124 | | /// [INFO] [stderr] 125 | | /// **Why is this bad?** It is generally a bad practice, just like [INFO] [stderr] ... | [INFO] [stderr] 136 | | /// } [INFO] [stderr] 137 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 138 | / declare_clippy_lint! { [INFO] [stderr] 139 | | pub MATCH_WILD_ERR_ARM, [INFO] [stderr] 140 | | style, [INFO] [stderr] 141 | | "a match with `Err(_)` arm and take drastic actions" [INFO] [stderr] 142 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/matches.rs:144:1 [INFO] [stderr] | [INFO] [stderr] 144 | / /// **What it does:** Checks for match which is used to add a reference to an [INFO] [stderr] 145 | | /// `Option` value. [INFO] [stderr] 146 | | /// [INFO] [stderr] 147 | | /// **Why is this bad?** Using `as_ref()` or `as_mut()` instead is shorter. [INFO] [stderr] ... | [INFO] [stderr] 157 | | /// }; [INFO] [stderr] 158 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 159 | / declare_clippy_lint! { [INFO] [stderr] 160 | | pub MATCH_AS_REF, [INFO] [stderr] 161 | | complexity, [INFO] [stderr] 162 | | "a match on an Option value instead of using `as_ref()` or `as_mut`" [INFO] [stderr] 163 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/mem_forget.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for usage of `std::mem::forget(t)` where `t` is [INFO] [stderr] 6 | | /// `Drop`. [INFO] [stderr] 7 | | /// [INFO] [stderr] 8 | | /// **Why is this bad?** `std::mem::forget(t)` prevents `t` from running its [INFO] [stderr] ... | [INFO] [stderr] 15 | | /// mem::forget(Rc::new(55))) [INFO] [stderr] 16 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 17 | / declare_clippy_lint! { [INFO] [stderr] 18 | | pub MEM_FORGET, [INFO] [stderr] 19 | | restriction, [INFO] [stderr] 20 | | "`mem::forget` usage on `Drop` types, likely to cause memory leaks" [INFO] [stderr] 21 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:21:1 [INFO] [stderr] | [INFO] [stderr] 21 | / /// **What it does:** Checks for `.unwrap()` calls on `Option`s. [INFO] [stderr] 22 | | /// [INFO] [stderr] 23 | | /// **Why is this bad?** Usually it is better to handle the `None` case, or to [INFO] [stderr] 24 | | /// at least call `.expect(_)` with a more helpful message. Still, for a lot of [INFO] [stderr] ... | [INFO] [stderr] 32 | | /// x.unwrap() [INFO] [stderr] 33 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 34 | / declare_clippy_lint! { [INFO] [stderr] 35 | | pub OPTION_UNWRAP_USED, [INFO] [stderr] 36 | | restriction, [INFO] [stderr] 37 | | "using `Option.unwrap()`, which should at least get a better message using `expect()`" [INFO] [stderr] 38 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:40:1 [INFO] [stderr] | [INFO] [stderr] 40 | / /// **What it does:** Checks for `.unwrap()` calls on `Result`s. [INFO] [stderr] 41 | | /// [INFO] [stderr] 42 | | /// **Why is this bad?** `result.unwrap()` will let the thread panic on `Err` [INFO] [stderr] 43 | | /// values. Normally, you want to implement more sophisticated error handling, [INFO] [stderr] ... | [INFO] [stderr] 54 | | /// x.unwrap() [INFO] [stderr] 55 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 56 | / declare_clippy_lint! { [INFO] [stderr] 57 | | pub RESULT_UNWRAP_USED, [INFO] [stderr] 58 | | restriction, [INFO] [stderr] 59 | | "using `Result.unwrap()`, which might be better handled" [INFO] [stderr] 60 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:62:1 [INFO] [stderr] | [INFO] [stderr] 62 | / /// **What it does:** Checks for methods that should live in a trait [INFO] [stderr] 63 | | /// implementation of a `std` trait (see [llogiq's blog [INFO] [stderr] 64 | | /// post](http://llogiq.github.io/2015/07/30/traits.html) for further [INFO] [stderr] 65 | | /// information) instead of an inherent implementation. [INFO] [stderr] ... | [INFO] [stderr] 80 | | /// } [INFO] [stderr] 81 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 82 | / declare_clippy_lint! { [INFO] [stderr] 83 | | pub SHOULD_IMPLEMENT_TRAIT, [INFO] [stderr] 84 | | style, [INFO] [stderr] 85 | | "defining a method that should be implementing a std trait" [INFO] [stderr] 86 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:88:1 [INFO] [stderr] | [INFO] [stderr] 88 | / /// **What it does:** Checks for methods with certain name prefixes and which [INFO] [stderr] 89 | | /// doesn't match how self is taken. The actual rules are: [INFO] [stderr] 90 | | /// [INFO] [stderr] 91 | | /// |Prefix |`self` taken | [INFO] [stderr] ... | [INFO] [stderr] 109 | | /// } [INFO] [stderr] 110 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 111 | / declare_clippy_lint! { [INFO] [stderr] 112 | | pub WRONG_SELF_CONVENTION, [INFO] [stderr] 113 | | style, [INFO] [stderr] 114 | | "defining a method named with an established prefix (like \"into_\") that takes \ [INFO] [stderr] 115 | | `self` with the wrong convention" [INFO] [stderr] 116 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:118:1 [INFO] [stderr] | [INFO] [stderr] 118 | / /// **What it does:** This is the same as [INFO] [stderr] 119 | | /// [`wrong_self_convention`](#wrong_self_convention), but for public items. [INFO] [stderr] 120 | | /// [INFO] [stderr] 121 | | /// **Why is this bad?** See [`wrong_self_convention`](#wrong_self_convention). [INFO] [stderr] ... | [INFO] [stderr] 131 | | /// } [INFO] [stderr] 132 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 133 | / declare_clippy_lint! { [INFO] [stderr] 134 | | pub WRONG_PUB_SELF_CONVENTION, [INFO] [stderr] 135 | | restriction, [INFO] [stderr] 136 | | "defining a public method named with an established prefix (like \"into_\") that takes \ [INFO] [stderr] 137 | | `self` with the wrong convention" [INFO] [stderr] 138 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:140:1 [INFO] [stderr] | [INFO] [stderr] 140 | / /// **What it does:** Checks for usage of `ok().expect(..)`. [INFO] [stderr] 141 | | /// [INFO] [stderr] 142 | | /// **Why is this bad?** Because you usually call `expect()` on the `Result` [INFO] [stderr] 143 | | /// directly to get a better error message. [INFO] [stderr] ... | [INFO] [stderr] 149 | | /// x.ok().expect("why did I do this again?") [INFO] [stderr] 150 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 151 | / declare_clippy_lint! { [INFO] [stderr] 152 | | pub OK_EXPECT, [INFO] [stderr] 153 | | style, [INFO] [stderr] 154 | | "using `ok().expect()`, which gives worse error messages than \ [INFO] [stderr] 155 | | calling `expect` directly on the Result" [INFO] [stderr] 156 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:158:1 [INFO] [stderr] | [INFO] [stderr] 158 | / /// **What it does:** Checks for usage of `_.map(_).unwrap_or(_)`. [INFO] [stderr] 159 | | /// [INFO] [stderr] 160 | | /// **Why is this bad?** Readability, this can be written more concisely as [INFO] [stderr] 161 | | /// `_.map_or(_, _)`. [INFO] [stderr] ... | [INFO] [stderr] 167 | | /// x.map(|a| a + 1).unwrap_or(0) [INFO] [stderr] 168 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 169 | / declare_clippy_lint! { [INFO] [stderr] 170 | | pub OPTION_MAP_UNWRAP_OR, [INFO] [stderr] 171 | | pedantic, [INFO] [stderr] 172 | | "using `Option.map(f).unwrap_or(a)`, which is more succinctly expressed as \ [INFO] [stderr] 173 | | `map_or(a, f)`" [INFO] [stderr] 174 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:176:1 [INFO] [stderr] | [INFO] [stderr] 176 | / /// **What it does:** Checks for usage of `_.map(_).unwrap_or_else(_)`. [INFO] [stderr] 177 | | /// [INFO] [stderr] 178 | | /// **Why is this bad?** Readability, this can be written more concisely as [INFO] [stderr] 179 | | /// `_.map_or_else(_, _)`. [INFO] [stderr] ... | [INFO] [stderr] 185 | | /// x.map(|a| a + 1).unwrap_or_else(some_function) [INFO] [stderr] 186 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 187 | / declare_clippy_lint! { [INFO] [stderr] 188 | | pub OPTION_MAP_UNWRAP_OR_ELSE, [INFO] [stderr] 189 | | pedantic, [INFO] [stderr] 190 | | "using `Option.map(f).unwrap_or_else(g)`, which is more succinctly expressed as \ [INFO] [stderr] 191 | | `map_or_else(g, f)`" [INFO] [stderr] 192 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:194:1 [INFO] [stderr] | [INFO] [stderr] 194 | / /// **What it does:** Checks for usage of `result.map(_).unwrap_or_else(_)`. [INFO] [stderr] 195 | | /// [INFO] [stderr] 196 | | /// **Why is this bad?** Readability, this can be written more concisely as [INFO] [stderr] 197 | | /// `result.ok().map_or_else(_, _)`. [INFO] [stderr] ... | [INFO] [stderr] 203 | | /// x.map(|a| a + 1).unwrap_or_else(some_function) [INFO] [stderr] 204 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 205 | / declare_clippy_lint! { [INFO] [stderr] 206 | | pub RESULT_MAP_UNWRAP_OR_ELSE, [INFO] [stderr] 207 | | pedantic, [INFO] [stderr] 208 | | "using `Result.map(f).unwrap_or_else(g)`, which is more succinctly expressed as \ [INFO] [stderr] 209 | | `.ok().map_or_else(g, f)`" [INFO] [stderr] 210 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:212:1 [INFO] [stderr] | [INFO] [stderr] 212 | / /// **What it does:** Checks for usage of `_.map_or(None, _)`. [INFO] [stderr] 213 | | /// [INFO] [stderr] 214 | | /// **Why is this bad?** Readability, this can be written more concisely as [INFO] [stderr] 215 | | /// `_.and_then(_)`. [INFO] [stderr] ... | [INFO] [stderr] 221 | | /// opt.map_or(None, |a| a + 1) [INFO] [stderr] 222 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 223 | / declare_clippy_lint! { [INFO] [stderr] 224 | | pub OPTION_MAP_OR_NONE, [INFO] [stderr] 225 | | style, [INFO] [stderr] 226 | | "using `Option.map_or(None, f)`, which is more succinctly expressed as \ [INFO] [stderr] 227 | | `and_then(f)`" [INFO] [stderr] 228 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:230:1 [INFO] [stderr] | [INFO] [stderr] 230 | / /// **What it does:** Checks for usage of `_.filter(_).next()`. [INFO] [stderr] 231 | | /// [INFO] [stderr] 232 | | /// **Why is this bad?** Readability, this can be written more concisely as [INFO] [stderr] 233 | | /// `_.find(_)`. [INFO] [stderr] ... | [INFO] [stderr] 239 | | /// iter.filter(|x| x == 0).next() [INFO] [stderr] 240 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 241 | / declare_clippy_lint! { [INFO] [stderr] 242 | | pub FILTER_NEXT, [INFO] [stderr] 243 | | complexity, [INFO] [stderr] 244 | | "using `filter(p).next()`, which is more succinctly expressed as `.find(p)`" [INFO] [stderr] 245 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:247:1 [INFO] [stderr] | [INFO] [stderr] 247 | / /// **What it does:** Checks for usage of `_.filter(_).map(_)`, [INFO] [stderr] 248 | | /// `_.filter(_).flat_map(_)`, `_.filter_map(_).flat_map(_)` and similar. [INFO] [stderr] 249 | | /// [INFO] [stderr] 250 | | /// **Why is this bad?** Readability, this can be written more concisely as a [INFO] [stderr] ... | [INFO] [stderr] 258 | | /// iter.filter(|x| x == 0).map(|x| x * 2) [INFO] [stderr] 259 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 260 | / declare_clippy_lint! { [INFO] [stderr] 261 | | pub FILTER_MAP, [INFO] [stderr] 262 | | pedantic, [INFO] [stderr] 263 | | "using combinations of `filter`, `map`, `filter_map` and `flat_map` which can \ [INFO] [stderr] 264 | | usually be written as a single method call" [INFO] [stderr] 265 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:267:1 [INFO] [stderr] | [INFO] [stderr] 267 | / /// **What it does:** Checks for an iterator search (such as `find()`, [INFO] [stderr] 268 | | /// `position()`, or `rposition()`) followed by a call to `is_some()`. [INFO] [stderr] 269 | | /// [INFO] [stderr] 270 | | /// **Why is this bad?** Readability, this can be written more concisely as [INFO] [stderr] ... | [INFO] [stderr] 277 | | /// iter.find(|x| x == 0).is_some() [INFO] [stderr] 278 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 279 | / declare_clippy_lint! { [INFO] [stderr] 280 | | pub SEARCH_IS_SOME, [INFO] [stderr] 281 | | complexity, [INFO] [stderr] 282 | | "using an iterator search followed by `is_some()`, which is more succinctly \ [INFO] [stderr] 283 | | expressed as a call to `any()`" [INFO] [stderr] 284 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:286:1 [INFO] [stderr] | [INFO] [stderr] 286 | / /// **What it does:** Checks for usage of `.chars().next()` on a `str` to check [INFO] [stderr] 287 | | /// if it starts with a given char. [INFO] [stderr] 288 | | /// [INFO] [stderr] 289 | | /// **Why is this bad?** Readability, this can be written more concisely as [INFO] [stderr] ... | [INFO] [stderr] 296 | | /// name.chars().next() == Some('_') [INFO] [stderr] 297 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 298 | / declare_clippy_lint! { [INFO] [stderr] 299 | | pub CHARS_NEXT_CMP, [INFO] [stderr] 300 | | complexity, [INFO] [stderr] 301 | | "using `.chars().next()` to check if a string starts with a char" [INFO] [stderr] 302 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:304:1 [INFO] [stderr] | [INFO] [stderr] 304 | / /// **What it does:** Checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`, [INFO] [stderr] 305 | | /// etc., and suggests to use `or_else`, `unwrap_or_else`, etc., or [INFO] [stderr] 306 | | /// `unwrap_or_default` instead. [INFO] [stderr] 307 | | /// [INFO] [stderr] ... | [INFO] [stderr] 324 | | /// foo.unwrap_or_default() [INFO] [stderr] 325 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 326 | / declare_clippy_lint! { [INFO] [stderr] 327 | | pub OR_FUN_CALL, [INFO] [stderr] 328 | | perf, [INFO] [stderr] 329 | | "using any `*or` method with a function call, which suggests `*or_else`" [INFO] [stderr] 330 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:332:1 [INFO] [stderr] | [INFO] [stderr] 332 | / /// **What it does:** Checks for calls to `.expect(&format!(...))`, `.expect(foo(..))`, [INFO] [stderr] 333 | | /// etc., and suggests to use `unwrap_or_else` instead [INFO] [stderr] 334 | | /// [INFO] [stderr] 335 | | /// **Why is this bad?** The function will always be called. [INFO] [stderr] ... | [INFO] [stderr] 354 | | /// foo.unwrap_or_else(|_| panic!(format("Err {}: {}", err_code, err_msg).as_str())) [INFO] [stderr] 355 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 356 | / declare_clippy_lint! { [INFO] [stderr] 357 | | pub EXPECT_FUN_CALL, [INFO] [stderr] 358 | | perf, [INFO] [stderr] 359 | | "using any `expect` method with a function call" [INFO] [stderr] 360 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:362:1 [INFO] [stderr] | [INFO] [stderr] 362 | / /// **What it does:** Checks for usage of `.clone()` on a `Copy` type. [INFO] [stderr] 363 | | /// [INFO] [stderr] 364 | | /// **Why is this bad?** The only reason `Copy` types implement `Clone` is for [INFO] [stderr] 365 | | /// generics, not for using the `clone` method on a concrete type. [INFO] [stderr] ... | [INFO] [stderr] 371 | | /// 42u64.clone() [INFO] [stderr] 372 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 373 | / declare_clippy_lint! { [INFO] [stderr] 374 | | pub CLONE_ON_COPY, [INFO] [stderr] 375 | | complexity, [INFO] [stderr] 376 | | "using `clone` on a `Copy` type" [INFO] [stderr] 377 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:379:1 [INFO] [stderr] | [INFO] [stderr] 379 | / /// **What it does:** Checks for usage of `.clone()` on a ref-counted pointer, [INFO] [stderr] 380 | | /// (`Rc`, `Arc`, `rc::Weak`, or `sync::Weak`), and suggests calling Clone via unified [INFO] [stderr] 381 | | /// function syntax instead (e.g. `Rc::clone(foo)`). [INFO] [stderr] 382 | | /// [INFO] [stderr] ... | [INFO] [stderr] 389 | | /// x.clone() [INFO] [stderr] 390 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 391 | / declare_clippy_lint! { [INFO] [stderr] 392 | | pub CLONE_ON_REF_PTR, [INFO] [stderr] 393 | | restriction, [INFO] [stderr] 394 | | "using 'clone' on a ref-counted pointer" [INFO] [stderr] 395 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:397:1 [INFO] [stderr] | [INFO] [stderr] 397 | / /// **What it does:** Checks for usage of `.clone()` on an `&&T`. [INFO] [stderr] 398 | | /// [INFO] [stderr] 399 | | /// **Why is this bad?** Cloning an `&&T` copies the inner `&T`, instead of [INFO] [stderr] 400 | | /// cloning the underlying `T`. [INFO] [stderr] ... | [INFO] [stderr] 411 | | /// } [INFO] [stderr] 412 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 413 | / declare_clippy_lint! { [INFO] [stderr] 414 | | pub CLONE_DOUBLE_REF, [INFO] [stderr] 415 | | correctness, [INFO] [stderr] 416 | | "using `clone` on `&&T`" [INFO] [stderr] 417 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:419:1 [INFO] [stderr] | [INFO] [stderr] 419 | / /// **What it does:** Checks for `new` not returning `Self`. [INFO] [stderr] 420 | | /// [INFO] [stderr] 421 | | /// **Why is this bad?** As a convention, `new` methods are used to make a new [INFO] [stderr] 422 | | /// instance of a type. [INFO] [stderr] ... | [INFO] [stderr] 431 | | /// } [INFO] [stderr] 432 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 433 | / declare_clippy_lint! { [INFO] [stderr] 434 | | pub NEW_RET_NO_SELF, [INFO] [stderr] 435 | | style, [INFO] [stderr] 436 | | "not returning `Self` in a `new` method" [INFO] [stderr] 437 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:439:1 [INFO] [stderr] | [INFO] [stderr] 439 | / /// **What it does:** Checks for string methods that receive a single-character [INFO] [stderr] 440 | | /// `str` as an argument, e.g. `_.split("x")`. [INFO] [stderr] 441 | | /// [INFO] [stderr] 442 | | /// **Why is this bad?** Performing these methods using a `char` is faster than [INFO] [stderr] ... | [INFO] [stderr] 447 | | /// **Example:** [INFO] [stderr] 448 | | /// `_.split("x")` could be `_.split('x') [INFO] [stderr] | |_________________________________________^ [INFO] [stderr] 449 | / declare_clippy_lint! { [INFO] [stderr] 450 | | pub SINGLE_CHAR_PATTERN, [INFO] [stderr] 451 | | perf, [INFO] [stderr] 452 | | "using a single-character str where a char could be used, e.g. \ [INFO] [stderr] 453 | | `_.split(\"x\")`" [INFO] [stderr] 454 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:456:1 [INFO] [stderr] | [INFO] [stderr] 456 | / /// **What it does:** Checks for getting the inner pointer of a temporary [INFO] [stderr] 457 | | /// `CString`. [INFO] [stderr] 458 | | /// [INFO] [stderr] 459 | | /// **Why is this bad?** The inner pointer of a `CString` is only valid as long [INFO] [stderr] ... | [INFO] [stderr] 476 | | /// } [INFO] [stderr] 477 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 478 | / declare_clippy_lint! { [INFO] [stderr] 479 | | pub TEMPORARY_CSTRING_AS_PTR, [INFO] [stderr] 480 | | correctness, [INFO] [stderr] 481 | | "getting the inner pointer of a temporary `CString`" [INFO] [stderr] 482 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:484:1 [INFO] [stderr] | [INFO] [stderr] 484 | / /// **What it does:** Checks for use of `.iter().nth()` (and the related [INFO] [stderr] 485 | | /// `.iter_mut().nth()`) on standard library types with O(1) element access. [INFO] [stderr] 486 | | /// [INFO] [stderr] 487 | | /// **Why is this bad?** `.get()` and `.get_mut()` are more efficient and more [INFO] [stderr] ... | [INFO] [stderr] 502 | | /// let bad_slice = &some_vec[..].get(3); [INFO] [stderr] 503 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 504 | / declare_clippy_lint! { [INFO] [stderr] 505 | | pub ITER_NTH, [INFO] [stderr] 506 | | perf, [INFO] [stderr] 507 | | "using `.iter().nth()` on a standard library type with O(1) element access" [INFO] [stderr] 508 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:510:1 [INFO] [stderr] | [INFO] [stderr] 510 | / /// **What it does:** Checks for use of `.skip(x).next()` on iterators. [INFO] [stderr] 511 | | /// [INFO] [stderr] 512 | | /// **Why is this bad?** `.nth(x)` is cleaner [INFO] [stderr] 513 | | /// [INFO] [stderr] ... | [INFO] [stderr] 526 | | /// let bad_slice = &some_vec[..].iter().nth(3); [INFO] [stderr] 527 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 528 | / declare_clippy_lint! { [INFO] [stderr] 529 | | pub ITER_SKIP_NEXT, [INFO] [stderr] 530 | | style, [INFO] [stderr] 531 | | "using `.skip(x).next()` on an iterator" [INFO] [stderr] 532 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:534:1 [INFO] [stderr] | [INFO] [stderr] 534 | / /// **What it does:** Checks for use of `.get().unwrap()` (or [INFO] [stderr] 535 | | /// `.get_mut().unwrap`) on a standard library type which implements `Index` [INFO] [stderr] 536 | | /// [INFO] [stderr] 537 | | /// **Why is this bad?** Using the Index trait (`[]`) is more clear and more [INFO] [stderr] ... | [INFO] [stderr] 552 | | /// some_vec[0] = 1; [INFO] [stderr] 553 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 554 | / declare_clippy_lint! { [INFO] [stderr] 555 | | pub GET_UNWRAP, [INFO] [stderr] 556 | | style, [INFO] [stderr] 557 | | "using `.get().unwrap()` or `.get_mut().unwrap()` when using `[]` would work instead" [INFO] [stderr] 558 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:560:1 [INFO] [stderr] | [INFO] [stderr] 560 | / /// **What it does:** Checks for the use of `.extend(s.chars())` where s is a [INFO] [stderr] 561 | | /// `&str` or `String`. [INFO] [stderr] 562 | | /// [INFO] [stderr] 563 | | /// **Why is this bad?** `.push_str(s)` is clearer [INFO] [stderr] ... | [INFO] [stderr] 581 | | /// s.push_str(&def)); [INFO] [stderr] 582 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 583 | / declare_clippy_lint! { [INFO] [stderr] 584 | | pub STRING_EXTEND_CHARS, [INFO] [stderr] 585 | | style, [INFO] [stderr] 586 | | "using `x.extend(s.chars())` where s is a `&str` or `String`" [INFO] [stderr] 587 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:589:1 [INFO] [stderr] | [INFO] [stderr] 589 | / /// **What it does:** Checks for the use of `.cloned().collect()` on slice to [INFO] [stderr] 590 | | /// create a `Vec`. [INFO] [stderr] 591 | | /// [INFO] [stderr] 592 | | /// **Why is this bad?** `.to_vec()` is clearer [INFO] [stderr] ... | [INFO] [stderr] 604 | | /// let s2 : Vec = s.to_vec(); [INFO] [stderr] 605 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 606 | / declare_clippy_lint! { [INFO] [stderr] 607 | | pub ITER_CLONED_COLLECT, [INFO] [stderr] 608 | | style, [INFO] [stderr] 609 | | "using `.cloned().collect()` on slice to create a `Vec`" [INFO] [stderr] 610 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:612:1 [INFO] [stderr] | [INFO] [stderr] 612 | / /// **What it does:** Checks for usage of `.chars().last()` or [INFO] [stderr] 613 | | /// `.chars().next_back()` on a `str` to check if it ends with a given char. [INFO] [stderr] 614 | | /// [INFO] [stderr] 615 | | /// **Why is this bad?** Readability, this can be written more concisely as [INFO] [stderr] ... | [INFO] [stderr] 622 | | /// name.chars().last() == Some('_') || name.chars().next_back() == Some('-') [INFO] [stderr] 623 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 624 | / declare_clippy_lint! { [INFO] [stderr] 625 | | pub CHARS_LAST_CMP, [INFO] [stderr] 626 | | style, [INFO] [stderr] 627 | | "using `.chars().last()` or `.chars().next_back()` to check if a string ends with a char" [INFO] [stderr] 628 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:630:1 [INFO] [stderr] | [INFO] [stderr] 630 | / /// **What it does:** Checks for usage of `.as_ref()` or `.as_mut()` where the [INFO] [stderr] 631 | | /// types before and after the call are the same. [INFO] [stderr] 632 | | /// [INFO] [stderr] 633 | | /// **Why is this bad?** The call is unnecessary. [INFO] [stderr] ... | [INFO] [stderr] 645 | | /// do_stuff(x); [INFO] [stderr] 646 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 647 | / declare_clippy_lint! { [INFO] [stderr] 648 | | pub USELESS_ASREF, [INFO] [stderr] 649 | | complexity, [INFO] [stderr] 650 | | "using `as_ref` where the types before and after the call are the same" [INFO] [stderr] 651 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:654:1 [INFO] [stderr] | [INFO] [stderr] 654 | / /// **What it does:** Checks for using `fold` when a more succinct alternative exists. [INFO] [stderr] 655 | | /// Specifically, this checks for `fold`s which could be replaced by `any`, `all`, [INFO] [stderr] 656 | | /// `sum` or `product`. [INFO] [stderr] 657 | | /// [INFO] [stderr] ... | [INFO] [stderr] 668 | | /// let _ = (0..3).any(|x| x > 2); [INFO] [stderr] 669 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 670 | / declare_clippy_lint! { [INFO] [stderr] 671 | | pub UNNECESSARY_FOLD, [INFO] [stderr] 672 | | style, [INFO] [stderr] 673 | | "using `fold` when a more succinct alternative exists" [INFO] [stderr] 674 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/minmax.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for expressions where `std::cmp::min` and `max` are [INFO] [stderr] 8 | | /// used to clamp values, but switched so that the result is constant. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** This is in all probability not the intended outcome. At [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// It will always be equal to `0`. Probably the author meant to clamp the value [INFO] [stderr] 20 | | /// between 0 and 100, but has erroneously swapped `min` and `max`. [INFO] [stderr] | |___________________________________________________________________^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub MIN_MAX, [INFO] [stderr] 23 | | correctness, [INFO] [stderr] 24 | | "`min(_, max(_, _))` (or vice versa) with bounds clamping the result to a constant" [INFO] [stderr] 25 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:14:1 [INFO] [stderr] | [INFO] [stderr] 14 | / /// **What it does:** Checks for function arguments and let bindings denoted as [INFO] [stderr] 15 | | /// `ref`. [INFO] [stderr] 16 | | /// [INFO] [stderr] 17 | | /// **Why is this bad?** The `ref` declaration makes the function take an owned [INFO] [stderr] ... | [INFO] [stderr] 32 | | /// fn foo(ref x: u8) -> bool { .. } [INFO] [stderr] 33 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 34 | / declare_clippy_lint! { [INFO] [stderr] 35 | | pub TOPLEVEL_REF_ARG, [INFO] [stderr] 36 | | style, [INFO] [stderr] 37 | | "an entire binding declared as `ref`, in a function argument or a `let` statement" [INFO] [stderr] 38 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:40:1 [INFO] [stderr] | [INFO] [stderr] 40 | / /// **What it does:** Checks for comparisons to NaN. [INFO] [stderr] 41 | | /// [INFO] [stderr] 42 | | /// **Why is this bad?** NaN does not compare meaningfully to anything – not [INFO] [stderr] 43 | | /// even itself – so those comparisons are simply wrong. [INFO] [stderr] ... | [INFO] [stderr] 49 | | /// x == NAN [INFO] [stderr] 50 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 51 | / declare_clippy_lint! { [INFO] [stderr] 52 | | pub CMP_NAN, [INFO] [stderr] 53 | | correctness, [INFO] [stderr] 54 | | "comparisons to NAN, which will always return false, probably not intended" [INFO] [stderr] 55 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:57:1 [INFO] [stderr] | [INFO] [stderr] 57 | / /// **What it does:** Checks for (in-)equality comparisons on floating-point [INFO] [stderr] 58 | | /// values (apart from zero), except in functions called `*eq*` (which probably [INFO] [stderr] 59 | | /// implement equality for a type involving floats). [INFO] [stderr] 60 | | /// [INFO] [stderr] ... | [INFO] [stderr] 71 | | /// y != x // where both are floats [INFO] [stderr] 72 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 73 | / declare_clippy_lint! { [INFO] [stderr] 74 | | pub FLOAT_CMP, [INFO] [stderr] 75 | | correctness, [INFO] [stderr] 76 | | "using `==` or `!=` on float values instead of comparing difference with an epsilon" [INFO] [stderr] 77 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:79:1 [INFO] [stderr] | [INFO] [stderr] 79 | / /// **What it does:** Checks for conversions to owned values just for the sake [INFO] [stderr] 80 | | /// of a comparison. [INFO] [stderr] 81 | | /// [INFO] [stderr] 82 | | /// **Why is this bad?** The comparison can operate on a reference, so creating [INFO] [stderr] ... | [INFO] [stderr] 90 | | /// x.to_owned() == y [INFO] [stderr] 91 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 92 | / declare_clippy_lint! { [INFO] [stderr] 93 | | pub CMP_OWNED, [INFO] [stderr] 94 | | perf, [INFO] [stderr] 95 | | "creating owned instances for comparing with others, e.g. `x == \"foo\".to_string()`" [INFO] [stderr] 96 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:98:1 [INFO] [stderr] | [INFO] [stderr] 98 | / /// **What it does:** Checks for getting the remainder of a division by one. [INFO] [stderr] 99 | | /// [INFO] [stderr] 100 | | /// **Why is this bad?** The result can only ever be zero. No one will write [INFO] [stderr] 101 | | /// such code deliberately, unless trying to win an Underhanded Rust [INFO] [stderr] ... | [INFO] [stderr] 109 | | /// x % 1 [INFO] [stderr] 110 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 111 | / declare_clippy_lint! { [INFO] [stderr] 112 | | pub MODULO_ONE, [INFO] [stderr] 113 | | correctness, [INFO] [stderr] 114 | | "taking a number modulo 1, which always returns 0" [INFO] [stderr] 115 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:117:1 [INFO] [stderr] | [INFO] [stderr] 117 | / /// **What it does:** Checks for patterns in the form `name @ _`. [INFO] [stderr] 118 | | /// [INFO] [stderr] 119 | | /// **Why is this bad?** It's almost always more readable to just use direct [INFO] [stderr] 120 | | /// bindings. [INFO] [stderr] ... | [INFO] [stderr] 129 | | /// } [INFO] [stderr] 130 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 131 | / declare_clippy_lint! { [INFO] [stderr] 132 | | pub REDUNDANT_PATTERN, [INFO] [stderr] 133 | | style, [INFO] [stderr] 134 | | "using `name @ _` in a pattern" [INFO] [stderr] 135 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:137:1 [INFO] [stderr] | [INFO] [stderr] 137 | / /// **What it does:** Checks for the use of bindings with a single leading [INFO] [stderr] 138 | | /// underscore. [INFO] [stderr] 139 | | /// [INFO] [stderr] 140 | | /// **Why is this bad?** A single leading underscore is usually used to indicate [INFO] [stderr] ... | [INFO] [stderr] 151 | | /// // underscore. We should rename `_x` to `x` [INFO] [stderr] 152 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 153 | / declare_clippy_lint! { [INFO] [stderr] 154 | | pub USED_UNDERSCORE_BINDING, [INFO] [stderr] 155 | | pedantic, [INFO] [stderr] 156 | | "using a binding which is prefixed with an underscore" [INFO] [stderr] 157 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:159:1 [INFO] [stderr] | [INFO] [stderr] 159 | / /// **What it does:** Checks for the use of short circuit boolean conditions as [INFO] [stderr] 160 | | /// a [INFO] [stderr] 161 | | /// statement. [INFO] [stderr] 162 | | /// [INFO] [stderr] ... | [INFO] [stderr] 171 | | /// f() && g(); // We should write `if f() { g(); }`. [INFO] [stderr] 172 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 173 | / declare_clippy_lint! { [INFO] [stderr] 174 | | pub SHORT_CIRCUIT_STATEMENT, [INFO] [stderr] 175 | | complexity, [INFO] [stderr] 176 | | "using a short circuit boolean condition as a statement" [INFO] [stderr] 177 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:179:1 [INFO] [stderr] | [INFO] [stderr] 179 | / /// **What it does:** Catch casts from `0` to some pointer type [INFO] [stderr] 180 | | /// [INFO] [stderr] 181 | | /// **Why is this bad?** This generally means `null` and is better expressed as [INFO] [stderr] 182 | | /// {`std`, `core`}`::ptr::`{`null`, `null_mut`}. [INFO] [stderr] ... | [INFO] [stderr] 189 | | /// 0 as *const u32 [INFO] [stderr] 190 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 191 | / declare_clippy_lint! { [INFO] [stderr] 192 | | pub ZERO_PTR, [INFO] [stderr] 193 | | style, [INFO] [stderr] 194 | | "using 0 as *{const, mut} T" [INFO] [stderr] 195 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:197:1 [INFO] [stderr] | [INFO] [stderr] 197 | / /// **What it does:** Checks for (in-)equality comparisons on floating-point [INFO] [stderr] 198 | | /// value and constant, except in functions called `*eq*` (which probably [INFO] [stderr] 199 | | /// implement equality for a type involving floats). [INFO] [stderr] 200 | | /// [INFO] [stderr] ... | [INFO] [stderr] 211 | | /// x == ONE // where both are floats [INFO] [stderr] 212 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 213 | / declare_clippy_lint! { [INFO] [stderr] 214 | | pub FLOAT_CMP_CONST, [INFO] [stderr] 215 | | restriction, [INFO] [stderr] 216 | | "using `==` or `!=` on float constants instead of comparing difference with an epsilon" [INFO] [stderr] 217 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc_early.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for structure field patterns bound to wildcards. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** Using `..` instead is shorter and leaves the focus on [INFO] [stderr] 12 | | /// the fields that are actually bound. [INFO] [stderr] ... | [INFO] [stderr] 18 | | /// let { a: _, b: ref b, c: _ } = .. [INFO] [stderr] 19 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 20 | / declare_clippy_lint! { [INFO] [stderr] 21 | | pub UNNEEDED_FIELD_PATTERN, [INFO] [stderr] 22 | | style, [INFO] [stderr] 23 | | "struct fields bound to a wildcard instead of using `..`" [INFO] [stderr] 24 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc_early.rs:26:1 [INFO] [stderr] | [INFO] [stderr] 26 | / /// **What it does:** Checks for function arguments having the similar names [INFO] [stderr] 27 | | /// differing by an underscore. [INFO] [stderr] 28 | | /// [INFO] [stderr] 29 | | /// **Why is this bad?** It affects code readability. [INFO] [stderr] ... | [INFO] [stderr] 35 | | /// fn foo(a: i32, _a: i32) {} [INFO] [stderr] 36 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 37 | / declare_clippy_lint! { [INFO] [stderr] 38 | | pub DUPLICATE_UNDERSCORE_ARGUMENT, [INFO] [stderr] 39 | | style, [INFO] [stderr] 40 | | "function arguments having names which only differ by an underscore" [INFO] [stderr] 41 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc_early.rs:43:1 [INFO] [stderr] | [INFO] [stderr] 43 | / /// **What it does:** Detects closures called in the same expression where they [INFO] [stderr] 44 | | /// are defined. [INFO] [stderr] 45 | | /// [INFO] [stderr] 46 | | /// **Why is this bad?** It is unnecessarily adding to the expression's [INFO] [stderr] ... | [INFO] [stderr] 53 | | /// (|| 42)() [INFO] [stderr] 54 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 55 | / declare_clippy_lint! { [INFO] [stderr] 56 | | pub REDUNDANT_CLOSURE_CALL, [INFO] [stderr] 57 | | complexity, [INFO] [stderr] 58 | | "throwaway closures called in the expression they are defined" [INFO] [stderr] 59 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc_early.rs:61:1 [INFO] [stderr] | [INFO] [stderr] 61 | / /// **What it does:** Detects expressions of the form `--x`. [INFO] [stderr] 62 | | /// [INFO] [stderr] 63 | | /// **Why is this bad?** It can mislead C/C++ programmers to think `x` was [INFO] [stderr] 64 | | /// decremented. [INFO] [stderr] ... | [INFO] [stderr] 70 | | /// --x; [INFO] [stderr] 71 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 72 | / declare_clippy_lint! { [INFO] [stderr] 73 | | pub DOUBLE_NEG, [INFO] [stderr] 74 | | style, [INFO] [stderr] 75 | | "`--x`, which is a double negation of `x` and not a pre-decrement as in C/C++" [INFO] [stderr] 76 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc_early.rs:78:1 [INFO] [stderr] | [INFO] [stderr] 78 | / /// **What it does:** Warns on hexadecimal literals with mixed-case letter [INFO] [stderr] 79 | | /// digits. [INFO] [stderr] 80 | | /// [INFO] [stderr] 81 | | /// **Why is this bad?** It looks confusing. [INFO] [stderr] ... | [INFO] [stderr] 87 | | /// let y = 0x1a9BAcD; [INFO] [stderr] 88 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 89 | / declare_clippy_lint! { [INFO] [stderr] 90 | | pub MIXED_CASE_HEX_LITERALS, [INFO] [stderr] 91 | | style, [INFO] [stderr] 92 | | "hex literals whose letter digits are not consistently upper- or lowercased" [INFO] [stderr] 93 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc_early.rs:95:1 [INFO] [stderr] | [INFO] [stderr] 95 | / /// **What it does:** Warns if literal suffixes are not separated by an [INFO] [stderr] 96 | | /// underscore. [INFO] [stderr] 97 | | /// [INFO] [stderr] 98 | | /// **Why is this bad?** It is much less readable. [INFO] [stderr] ... | [INFO] [stderr] 104 | | /// let y = 123832i32; [INFO] [stderr] 105 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 106 | / declare_clippy_lint! { [INFO] [stderr] 107 | | pub UNSEPARATED_LITERAL_SUFFIX, [INFO] [stderr] 108 | | pedantic, [INFO] [stderr] 109 | | "literals whose suffix is not separated by an underscore" [INFO] [stderr] 110 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc_early.rs:112:1 [INFO] [stderr] | [INFO] [stderr] 112 | / /// **What it does:** Warns if an integral constant literal starts with `0`. [INFO] [stderr] 113 | | /// [INFO] [stderr] 114 | | /// **Why is this bad?** In some languages (including the infamous C language [INFO] [stderr] 115 | | /// and most of its [INFO] [stderr] ... | [INFO] [stderr] 142 | | /// [INFO] [stderr] 143 | | /// prints `83` (as `83 == 0o123` while `123 == 0o173`). [INFO] [stderr] | |________________________________________________________^ [INFO] [stderr] 144 | / declare_clippy_lint! { [INFO] [stderr] 145 | | pub ZERO_PREFIXED_LITERAL, [INFO] [stderr] 146 | | complexity, [INFO] [stderr] 147 | | "integer literals starting with `0`" [INFO] [stderr] 148 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc_early.rs:150:1 [INFO] [stderr] | [INFO] [stderr] 150 | / /// **What it does:** Warns if a generic shadows a built-in type. [INFO] [stderr] 151 | | /// [INFO] [stderr] 152 | | /// **Why is this bad?** This gives surprising type errors. [INFO] [stderr] 153 | | /// [INFO] [stderr] ... | [INFO] [stderr] 163 | | /// } [INFO] [stderr] 164 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 165 | / declare_clippy_lint! { [INFO] [stderr] 166 | | pub BUILTIN_TYPE_SHADOW, [INFO] [stderr] 167 | | style, [INFO] [stderr] 168 | | "shadowing a builtin type" [INFO] [stderr] 169 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/missing_doc.rs:29:1 [INFO] [stderr] | [INFO] [stderr] 29 | / /// **What it does:** Warns if there is missing doc for any documentable item [INFO] [stderr] 30 | | /// (public or private). [INFO] [stderr] 31 | | /// [INFO] [stderr] 32 | | /// **Why is this bad?** Doc is good. *rustc* has a `MISSING_DOCS` [INFO] [stderr] ... | [INFO] [stderr] 36 | | /// [INFO] [stderr] 37 | | /// **Known problems:** None. [INFO] [stderr] | |_____________________________^ [INFO] [stderr] 38 | / declare_clippy_lint! { [INFO] [stderr] 39 | | pub MISSING_DOCS_IN_PRIVATE_ITEMS, [INFO] [stderr] 40 | | restriction, [INFO] [stderr] 41 | | "detects missing documentation for public and private members" [INFO] [stderr] 42 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/missing_inline.rs:17:1 [INFO] [stderr] | [INFO] [stderr] 17 | / /// **What it does:** it lints if an exported function, method, trait method with default impl, [INFO] [stderr] 18 | | /// or trait method impl is not `#[inline]`. [INFO] [stderr] 19 | | /// [INFO] [stderr] 20 | | /// **Why is this bad?** In general, it is not. Functions can be inlined across [INFO] [stderr] ... | [INFO] [stderr] 60 | | /// } [INFO] [stderr] 61 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 62 | / declare_clippy_lint! { [INFO] [stderr] 63 | | pub MISSING_INLINE_IN_PUBLIC_ITEMS, [INFO] [stderr] 64 | | restriction, [INFO] [stderr] 65 | | "detects missing #[inline] attribute for public callables (functions, trait methods, methods...)" [INFO] [stderr] 66 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/multiple_crate_versions.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks to see if multiple versions of a crate are being [INFO] [stderr] 10 | | /// used. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** This bloats the size of targets, and can lead to [INFO] [stderr] ... | [INFO] [stderr] 24 | | /// ansi_term = "0.11.0" [INFO] [stderr] 25 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 26 | / declare_clippy_lint! { [INFO] [stderr] 27 | | pub MULTIPLE_CRATE_VERSIONS, [INFO] [stderr] 28 | | cargo, [INFO] [stderr] 29 | | "multiple versions of the same crate being used" [INFO] [stderr] 30 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/mut_mut.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for instances of `mut mut` references. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** Multiple `mut`s don't add anything meaningful to the [INFO] [stderr] 10 | | /// source. This is either a copy'n'paste error, or it shows a fundamental [INFO] [stderr] ... | [INFO] [stderr] 17 | | /// let x = &mut &mut y; [INFO] [stderr] 18 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 19 | / declare_clippy_lint! { [INFO] [stderr] 20 | | pub MUT_MUT, [INFO] [stderr] 21 | | pedantic, [INFO] [stderr] 22 | | "usage of double-mut refs, e.g. `&mut &mut ...`" [INFO] [stderr] 23 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/mut_reference.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Detects giving a mutable reference to a function that only [INFO] [stderr] 8 | | /// requires an immutable reference. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** The immutable reference rules out all other references [INFO] [stderr] ... | [INFO] [stderr] 17 | | /// my_vec.push(&mut value) [INFO] [stderr] 18 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 19 | / declare_clippy_lint! { [INFO] [stderr] 20 | | pub UNNECESSARY_MUT_PASSED, [INFO] [stderr] 21 | | style, [INFO] [stderr] 22 | | "an argument passed as a mutable reference although the callee only demands an \ [INFO] [stderr] 23 | | immutable reference" [INFO] [stderr] 24 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/mutex_atomic.rs:11:1 [INFO] [stderr] | [INFO] [stderr] 11 | / /// **What it does:** Checks for usages of `Mutex` where an atomic will do. [INFO] [stderr] 12 | | /// [INFO] [stderr] 13 | | /// **Why is this bad?** Using a mutex just to make access to a plain bool or [INFO] [stderr] 14 | | /// reference sequential is shooting flies with cannons. [INFO] [stderr] ... | [INFO] [stderr] 23 | | /// let x = Mutex::new(&y); [INFO] [stderr] 24 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 25 | / declare_clippy_lint! { [INFO] [stderr] 26 | | pub MUTEX_ATOMIC, [INFO] [stderr] 27 | | perf, [INFO] [stderr] 28 | | "using a mutex where an atomic value could be used instead" [INFO] [stderr] 29 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/mutex_atomic.rs:31:1 [INFO] [stderr] | [INFO] [stderr] 31 | / /// **What it does:** Checks for usages of `Mutex` where `X` is an integral [INFO] [stderr] 32 | | /// type. [INFO] [stderr] 33 | | /// [INFO] [stderr] 34 | | /// **Why is this bad?** Using a mutex just to make access to a plain integer [INFO] [stderr] ... | [INFO] [stderr] 43 | | /// let x = Mutex::new(0usize); [INFO] [stderr] 44 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 45 | / declare_clippy_lint! { [INFO] [stderr] 46 | | pub MUTEX_INTEGER, [INFO] [stderr] 47 | | nursery, [INFO] [stderr] 48 | | "using a mutex for an integer type" [INFO] [stderr] 49 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/needless_bool.rs:12:1 [INFO] [stderr] | [INFO] [stderr] 12 | / /// **What it does:** Checks for expressions of the form `if c { true } else { [INFO] [stderr] 13 | | /// false }` [INFO] [stderr] 14 | | /// (or vice versa) and suggest using the condition directly. [INFO] [stderr] 15 | | /// [INFO] [stderr] ... | [INFO] [stderr] 25 | | /// if x { false } else { true } [INFO] [stderr] 26 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 27 | / declare_clippy_lint! { [INFO] [stderr] 28 | | pub NEEDLESS_BOOL, [INFO] [stderr] 29 | | complexity, [INFO] [stderr] 30 | | "if-statements with plain booleans in the then- and else-clause, e.g. \ [INFO] [stderr] 31 | | `if p { true } else { false }`" [INFO] [stderr] 32 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/needless_bool.rs:34:1 [INFO] [stderr] | [INFO] [stderr] 34 | / /// **What it does:** Checks for expressions of the form `x == true` (or vice [INFO] [stderr] 35 | | /// versa) and suggest using the variable directly. [INFO] [stderr] 36 | | /// [INFO] [stderr] 37 | | /// **Why is this bad?** Unnecessary code. [INFO] [stderr] ... | [INFO] [stderr] 43 | | /// if x == true { } // could be `if x { }` [INFO] [stderr] 44 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 45 | / declare_clippy_lint! { [INFO] [stderr] 46 | | pub BOOL_COMPARISON, [INFO] [stderr] 47 | | complexity, [INFO] [stderr] 48 | | "comparing a variable to a boolean, e.g. `if x == true`" [INFO] [stderr] 49 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/needless_borrow.rs:11:1 [INFO] [stderr] | [INFO] [stderr] 11 | / /// **What it does:** Checks for address of operations (`&`) that are going to [INFO] [stderr] 12 | | /// be dereferenced immediately by the compiler. [INFO] [stderr] 13 | | /// [INFO] [stderr] 14 | | /// **Why is this bad?** Suggests that the receiver of the expression borrows [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// let x: &i32 = &&&&&&5; [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub NEEDLESS_BORROW, [INFO] [stderr] 25 | | nursery, [INFO] [stderr] 26 | | "taking a reference that is going to be automatically dereferenced" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/needless_borrowed_ref.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for useless borrowed references. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** It is mostly useless and make the code look more [INFO] [stderr] 12 | | /// complex than it [INFO] [stderr] ... | [INFO] [stderr] 43 | | /// de-referenced. [INFO] [stderr] 44 | | /// As such, it could just be |a| a.is_empty() [INFO] [stderr] | |______________________________________________^ [INFO] [stderr] 45 | / declare_clippy_lint! { [INFO] [stderr] 46 | | pub NEEDLESS_BORROWED_REFERENCE, [INFO] [stderr] 47 | | complexity, [INFO] [stderr] 48 | | "taking a needless borrowed reference" [INFO] [stderr] 49 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/needless_continue.rs:37:1 [INFO] [stderr] | [INFO] [stderr] 37 | / /// **What it does:** The lint checks for `if`-statements appearing in loops [INFO] [stderr] 38 | | /// that contain a `continue` statement in either their main blocks or their [INFO] [stderr] 39 | | /// `else`-blocks, when omitting the `else`-block possibly with some [INFO] [stderr] 40 | | /// rearrangement of code can make the code easier to understand. [INFO] [stderr] ... | [INFO] [stderr] 94 | | /// } [INFO] [stderr] 95 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 96 | / declare_clippy_lint! { [INFO] [stderr] 97 | | pub NEEDLESS_CONTINUE, [INFO] [stderr] 98 | | pedantic, [INFO] [stderr] 99 | | "`continue` statements that can be replaced by a rearrangement of code" [INFO] [stderr] 100 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/needless_pass_by_value.rs:19:1 [INFO] [stderr] | [INFO] [stderr] 19 | / /// **What it does:** Checks for functions taking arguments by value, but not [INFO] [stderr] 20 | | /// consuming them in its [INFO] [stderr] 21 | | /// body. [INFO] [stderr] 22 | | /// [INFO] [stderr] ... | [INFO] [stderr] 40 | | /// } [INFO] [stderr] 41 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 42 | / declare_clippy_lint! { [INFO] [stderr] 43 | | pub NEEDLESS_PASS_BY_VALUE, [INFO] [stderr] 44 | | style, [INFO] [stderr] 45 | | "functions taking arguments by value, but not consuming them in its body" [INFO] [stderr] 46 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/needless_update.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for needlessly including a base struct on update [INFO] [stderr] 7 | | /// when all fields are changed anyway. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** This will cost resources (because the base has to be [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// Point { x: 1, y: 0, ..zero_point } [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub NEEDLESS_UPDATE, [INFO] [stderr] 20 | | complexity, [INFO] [stderr] 21 | | "using `Foo { ..base }` when there are no missing fields" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/neg_cmp_op_on_partial_ord.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** [INFO] [stderr] 7 | | /// Checks for the usage of negated comparision operators on types which only implement [INFO] [stderr] 8 | | /// `PartialOrd` (e.g. `f64`). [INFO] [stderr] 9 | | /// [INFO] [stderr] ... | [INFO] [stderr] 35 | | /// }; [INFO] [stderr] 36 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 37 | / declare_clippy_lint! { [INFO] [stderr] 38 | | pub NEG_CMP_OP_ON_PARTIAL_ORD, [INFO] [stderr] 39 | | complexity, [INFO] [stderr] 40 | | "The use of negated comparision operators on partially orded types may produce confusing code." [INFO] [stderr] 41 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/neg_multiply.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for multiplication by -1 as a form of negation. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** It's more readable to just negate. [INFO] [stderr] 11 | | /// [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// x * -1 [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub NEG_MULTIPLY, [INFO] [stderr] 20 | | style, [INFO] [stderr] 21 | | "multiplying integers with -1" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/new_without_default.rs:10:1 [INFO] [stderr] | [INFO] [stderr] 10 | / /// **What it does:** Checks for types with a `fn new() -> Self` method and no [INFO] [stderr] 11 | | /// implementation of [INFO] [stderr] 12 | | /// [`Default`](https://doc.rust-lang.org/std/default/trait.Default.html). [INFO] [stderr] 13 | | /// [INFO] [stderr] ... | [INFO] [stderr] 43 | | /// [INFO] [stderr] 44 | | /// You can also have `new()` call `Default::default()`. [INFO] [stderr] | |________________________________________________________^ [INFO] [stderr] 45 | / declare_clippy_lint! { [INFO] [stderr] 46 | | pub NEW_WITHOUT_DEFAULT, [INFO] [stderr] 47 | | style, [INFO] [stderr] 48 | | "`fn new() -> Self` method without `Default` implementation" [INFO] [stderr] 49 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/new_without_default.rs:51:1 [INFO] [stderr] | [INFO] [stderr] 51 | / /// **What it does:** Checks for types with a `fn new() -> Self` method [INFO] [stderr] 52 | | /// and no implementation of [INFO] [stderr] 53 | | /// [`Default`](https://doc.rust-lang.org/std/default/trait.Default.html), [INFO] [stderr] 54 | | /// where the `Default` can be derived by `#[derive(Default)]`. [INFO] [stderr] ... | [INFO] [stderr] 73 | | /// [INFO] [stderr] 74 | | /// Just prepend `#[derive(Default)]` before the `struct` definition. [INFO] [stderr] | |_____________________________________________________________________^ [INFO] [stderr] 75 | / declare_clippy_lint! { [INFO] [stderr] 76 | | pub NEW_WITHOUT_DEFAULT_DERIVE, [INFO] [stderr] 77 | | style, [INFO] [stderr] 78 | | "`fn new() -> Self` without `#[derive]`able `Default` implementation" [INFO] [stderr] 79 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/no_effect.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for statements which have no effect. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** Similar to dead code, these statements are actually [INFO] [stderr] 10 | | /// executed. However, as they have no effect, all they do is make the code less [INFO] [stderr] ... | [INFO] [stderr] 17 | | /// 0; [INFO] [stderr] 18 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 19 | / declare_clippy_lint! { [INFO] [stderr] 20 | | pub NO_EFFECT, [INFO] [stderr] 21 | | complexity, [INFO] [stderr] 22 | | "statements with no effect" [INFO] [stderr] 23 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/no_effect.rs:25:1 [INFO] [stderr] | [INFO] [stderr] 25 | / /// **What it does:** Checks for expression statements that can be reduced to a [INFO] [stderr] 26 | | /// sub-expression. [INFO] [stderr] 27 | | /// [INFO] [stderr] 28 | | /// **Why is this bad?** Expressions by themselves often have no side-effects. [INFO] [stderr] ... | [INFO] [stderr] 35 | | /// compute_array()[0]; [INFO] [stderr] 36 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 37 | / declare_clippy_lint! { [INFO] [stderr] 38 | | pub UNNECESSARY_OPERATION, [INFO] [stderr] 39 | | complexity, [INFO] [stderr] 40 | | "outer expressions with no effect" [INFO] [stderr] 41 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/non_copy_const.rs:16:1 [INFO] [stderr] | [INFO] [stderr] 16 | / /// **What it does:** Checks for declaration of `const` items which is interior [INFO] [stderr] 17 | | /// mutable (e.g. contains a `Cell`, `Mutex`, `AtomicXxxx` etc). [INFO] [stderr] 18 | | /// [INFO] [stderr] 19 | | /// **Why is this bad?** Consts are copied everywhere they are referenced, i.e. [INFO] [stderr] ... | [INFO] [stderr] 44 | | /// assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance [INFO] [stderr] 45 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 46 | / declare_clippy_lint! { [INFO] [stderr] 47 | | pub DECLARE_INTERIOR_MUTABLE_CONST, [INFO] [stderr] 48 | | correctness, [INFO] [stderr] 49 | | "declaring const with interior mutability" [INFO] [stderr] 50 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/non_copy_const.rs:52:1 [INFO] [stderr] | [INFO] [stderr] 52 | / /// **What it does:** Checks if `const` items which is interior mutable (e.g. [INFO] [stderr] 53 | | /// contains a `Cell`, `Mutex`, `AtomicXxxx` etc) has been borrowed directly. [INFO] [stderr] 54 | | /// [INFO] [stderr] 55 | | /// **Why is this bad?** Consts are copied everywhere they are referenced, i.e. [INFO] [stderr] ... | [INFO] [stderr] 76 | | /// assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance [INFO] [stderr] 77 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 78 | / declare_clippy_lint! { [INFO] [stderr] 79 | | pub BORROW_INTERIOR_MUTABLE_CONST, [INFO] [stderr] 80 | | correctness, [INFO] [stderr] 81 | | "referencing const with interior mutability" [INFO] [stderr] 82 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/non_expressive_names.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for names that are very similar and thus confusing. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** It's hard to distinguish between names that differ only [INFO] [stderr] 12 | | /// by a single character. [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// let checked_expr = something_else; [INFO] [stderr] 20 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub SIMILAR_NAMES, [INFO] [stderr] 23 | | pedantic, [INFO] [stderr] 24 | | "similarly named items and bindings" [INFO] [stderr] 25 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/non_expressive_names.rs:27:1 [INFO] [stderr] | [INFO] [stderr] 27 | / /// **What it does:** Checks for too many variables whose name consists of a [INFO] [stderr] 28 | | /// single character. [INFO] [stderr] 29 | | /// [INFO] [stderr] 30 | | /// **Why is this bad?** It's hard to memorize what a variable means without a [INFO] [stderr] ... | [INFO] [stderr] 37 | | /// let (a, b, c, d, e, f, g) = (...); [INFO] [stderr] 38 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 39 | / declare_clippy_lint! { [INFO] [stderr] 40 | | pub MANY_SINGLE_CHAR_NAMES, [INFO] [stderr] 41 | | style, [INFO] [stderr] 42 | | "too many single character bindings" [INFO] [stderr] 43 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/non_expressive_names.rs:45:1 [INFO] [stderr] | [INFO] [stderr] 45 | / /// **What it does:** Checks if you have variables whose name consists of just [INFO] [stderr] 46 | | /// underscores and digits. [INFO] [stderr] 47 | | /// [INFO] [stderr] 48 | | /// **Why is this bad?** It's hard to memorize what a variable means without a [INFO] [stderr] ... | [INFO] [stderr] 57 | | /// let __1___2 = 11; [INFO] [stderr] 58 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 59 | / declare_clippy_lint! { [INFO] [stderr] 60 | | pub JUST_UNDERSCORES_AND_DIGITS, [INFO] [stderr] 61 | | style, [INFO] [stderr] 62 | | "unclear name" [INFO] [stderr] 63 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/ok_if_let.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:*** Checks for unnecessary `ok()` in if let. [INFO] [stderr] 6 | | /// [INFO] [stderr] 7 | | /// **Why is this bad?** Calling `ok()` in if let is unnecessary, instead match [INFO] [stderr] 8 | | /// on `Ok(pat)` [INFO] [stderr] ... | [INFO] [stderr] 27 | | /// } [INFO] [stderr] 28 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 29 | / declare_clippy_lint! { [INFO] [stderr] 30 | | pub IF_LET_SOME_RESULT, [INFO] [stderr] 31 | | style, [INFO] [stderr] 32 | | "usage of `ok()` in `if let Some(pat)` statements is unnecessary, match on `Ok(pat)` instead" [INFO] [stderr] 33 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:589:1 [INFO] [stderr] | [INFO] [stderr] 589 | / /// **What it does:** Checks for the use of `.cloned().collect()` on slice to [INFO] [stderr] 590 | | /// create a `Vec`. [INFO] [stderr] 591 | | /// [INFO] [stderr] 592 | | /// **Why is this bad?** `.to_vec()` is clearer [INFO] [stderr] ... | [INFO] [stderr] 604 | | /// let s2 : Vec = s.to_vec(); [INFO] [stderr] 605 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 606 | / declare_clippy_lint! { [INFO] [stderr] 607 | | pub ITER_CLONED_COLLECT, [INFO] [stderr] 608 | | style, [INFO] [stderr] 609 | | "using `.cloned().collect()` on slice to create a `Vec`" [INFO] [stderr] 610 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] | [INFO] [stderr] [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/open_options.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for duplicate open options as well as combinations [INFO] [stderr] 8 | | /// that make no sense. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** In the best case, the code will be harder to read than [INFO] [stderr] ... | [INFO] [stderr] 17 | | /// OpenOptions::new().read(true).truncate(true) [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:612:1 [INFO] [stderr] | [INFO] [stderr] 612 | / /// **What it does:** Checks for usage of `.chars().last()` or [INFO] [stderr] 613 | | /// `.chars().next_back()` on a `str` to check if it ends with a given char. [INFO] [stderr] 18 | | /// ``` [INFO] [stderr] 614 | | /// [INFO] [stderr] 615 | | /// **Why is this bad?** Readability, this can be written more concisely as [INFO] [stderr] | |_______^ [INFO] [stderr] ... | [INFO] [stderr] 622 | | /// name.chars().last() == Some('_') || name.chars().next_back() == Some('-') [INFO] [stderr] 623 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 624 | / declare_clippy_lint! { [INFO] [stderr] 625 | | pub CHARS_LAST_CMP, [INFO] [stderr] 626 | | style, [INFO] [stderr] 627 | | "using `.chars().last()` or `.chars().next_back()` to check if a string ends with a char" [INFO] [stderr] 628 | | } [INFO] [stderr] 19 | / declare_clippy_lint! { [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] 20 | | pub NONSENSICAL_OPEN_OPTIONS, [INFO] [stderr] 21 | | correctness, [INFO] [stderr] 22 | | "nonsensical combination of options for opening a file" [INFO] [stderr] 23 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:630:1 [INFO] [stderr] | [INFO] [stderr] 630 | / /// **What it does:** Checks for usage of `.as_ref()` or `.as_mut()` where the [INFO] [stderr] 631 | | /// types before and after the call are the same. [INFO] [stderr] 632 | | /// [INFO] [stderr] 633 | | /// **Why is this bad?** The call is unnecessary. [INFO] [stderr] ... | [INFO] [stderr] 645 | | /// do_stuff(x); [INFO] [stderr] 646 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 647 | / declare_clippy_lint! { [INFO] [stderr] 648 | | pub USELESS_ASREF, [INFO] [stderr] 649 | | complexity, [INFO] [stderr] 650 | | "using `as_ref` where the types before and after the call are the same" [INFO] [stderr] 651 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/overflow_check_conditional.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Detects classic underflow/overflow checks. [INFO] [stderr] 6 | | /// [INFO] [stderr] 7 | | /// **Why is this bad?** Most classic C underflow/overflow checks will fail in [INFO] [stderr] 8 | | /// Rust. Users can use functions like `overflowing_*` and `wrapping_*` instead. [INFO] [stderr] ... | [INFO] [stderr] 14 | | /// a + b < a [INFO] [stderr] 15 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 16 | / declare_clippy_lint! { [INFO] [stderr] 17 | | pub OVERFLOW_CHECK_CONDITIONAL, [INFO] [stderr] 18 | | complexity, [INFO] [stderr] 19 | | "overflow checks inspired by C which are likely to panic" [INFO] [stderr] 20 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/methods.rs:654:1 [INFO] [stderr] | [INFO] [stderr] 654 | / /// **What it does:** Checks for using `fold` when a more succinct alternative exists. [INFO] [stderr] 655 | | /// Specifically, this checks for `fold`s which could be replaced by `any`, `all`, [INFO] [stderr] 656 | | /// `sum` or `product`. [INFO] [stderr] 657 | | /// [INFO] [stderr] ... | [INFO] [stderr] 668 | | /// let _ = (0..3).any(|x| x > 2); [INFO] [stderr] 669 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 670 | / declare_clippy_lint! { [INFO] [stderr] 671 | | pub UNNECESSARY_FOLD, [INFO] [stderr] 672 | | style, [INFO] [stderr] 673 | | "using `fold` when a more succinct alternative exists" [INFO] [stderr] 674 | | } [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/panic_unimplemented.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for missing parameters in `panic!`. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** Contrary to the `format!` family of macros, there are [INFO] [stderr] 11 | | /// two forms of `panic!`: if there are no parameters given, the first argument [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// panic!("This `panic!` is probably missing a parameter there: {}"); [INFO] [stderr] 20 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub PANIC_PARAMS, [INFO] [stderr] 23 | | style, [INFO] [stderr] 24 | | "missing parameters in `panic!` calls" [INFO] [stderr] 25 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/panic_unimplemented.rs:27:1 [INFO] [stderr] | [INFO] [stderr] 27 | / /// **What it does:** Checks for usage of `unimplemented!`. [INFO] [stderr] 28 | | /// [INFO] [stderr] 29 | | /// **Why is this bad?** This macro should not be present in production code [INFO] [stderr] 30 | | /// [INFO] [stderr] ... | [INFO] [stderr] 35 | | /// unimplemented!(); [INFO] [stderr] 36 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 37 | / declare_clippy_lint! { [INFO] [stderr] 38 | | pub UNIMPLEMENTED, [INFO] [stderr] 39 | | restriction, [INFO] [stderr] 40 | | "`unimplemented!` should not be present in production code" [INFO] [stderr] 41 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/partialeq_ne_impl.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for manual re-implementations of `PartialEq::ne`. [INFO] [stderr] 6 | | /// [INFO] [stderr] 7 | | /// **Why is this bad?** `PartialEq::ne` is required to always return the [INFO] [stderr] 8 | | /// negated result of `PartialEq::eq`, which is exactly what the default [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// } [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub PARTIALEQ_NE_IMPL, [INFO] [stderr] 25 | | complexity, [INFO] [stderr] 26 | | "re-implementing `PartialEq::ne`" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/precedence.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for operations where precedence may be unclear [INFO] [stderr] 7 | | /// and suggests to add parentheses. Currently it catches the following: [INFO] [stderr] 8 | | /// * mixed usage of arithmetic and bit shifting/combining operators without [INFO] [stderr] 9 | | /// parentheses [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// * `1 << 2 + 3` equals 32, while `(1 << 2) + 3` equals 7 [INFO] [stderr] 22 | | /// * `-1i32.abs()` equals -1, while `(-1i32).abs()` equals 1 [INFO] [stderr] | |_____________________________________________________________^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub PRECEDENCE, [INFO] [stderr] 25 | | complexity, [INFO] [stderr] 26 | | "operations where precedence may be unclear" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/ptr.rs:15:1 [INFO] [stderr] | [INFO] [stderr] 15 | / /// **What it does:** This lint checks for function arguments of type `&String` [INFO] [stderr] 16 | | /// or `&Vec` unless the references are mutable. It will also suggest you [INFO] [stderr] 17 | | /// replace `.clone()` calls with the appropriate `.to_owned()`/`to_string()` [INFO] [stderr] 18 | | /// calls. [INFO] [stderr] ... | [INFO] [stderr] 43 | | /// fn foo(&Vec) { .. } [INFO] [stderr] 44 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 45 | / declare_clippy_lint! { [INFO] [stderr] 46 | | pub PTR_ARG, [INFO] [stderr] 47 | | style, [INFO] [stderr] 48 | | "fn arguments of the type `&Vec<...>` or `&String`, suggesting to use `&[...]` or `&str` \ [INFO] [stderr] 49 | | instead, respectively" [INFO] [stderr] 50 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/ptr.rs:52:1 [INFO] [stderr] | [INFO] [stderr] 52 | / /// **What it does:** This lint checks for equality comparisons with `ptr::null` [INFO] [stderr] 53 | | /// [INFO] [stderr] 54 | | /// **Why is this bad?** It's easier and more readable to use the inherent [INFO] [stderr] 55 | | /// `.is_null()` [INFO] [stderr] ... | [INFO] [stderr] 62 | | /// if x == ptr::null { .. } [INFO] [stderr] 63 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 64 | / declare_clippy_lint! { [INFO] [stderr] 65 | | pub CMP_NULL, [INFO] [stderr] 66 | | style, [INFO] [stderr] 67 | | "comparing a pointer to a null pointer, suggesting to use `.is_null()` instead." [INFO] [stderr] 68 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/ptr.rs:70:1 [INFO] [stderr] | [INFO] [stderr] 70 | / /// **What it does:** This lint checks for functions that take immutable [INFO] [stderr] 71 | | /// references and return [INFO] [stderr] 72 | | /// mutable ones. [INFO] [stderr] 73 | | /// [INFO] [stderr] ... | [INFO] [stderr] 87 | | /// fn foo(&Foo) -> &mut Bar { .. } [INFO] [stderr] 88 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 89 | / declare_clippy_lint! { [INFO] [stderr] 90 | | pub MUT_FROM_REF, [INFO] [stderr] 91 | | correctness, [INFO] [stderr] 92 | | "fns that create mutable refs from immutable ref args" [INFO] [stderr] 93 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/question_mark.rs:10:1 [INFO] [stderr] | [INFO] [stderr] 10 | / /// **What it does:** Checks for expressions that could be replaced by the question mark operator [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** Question mark usage is more idiomatic [INFO] [stderr] 13 | | /// [INFO] [stderr] ... | [INFO] [stderr] 26 | | /// option?; [INFO] [stderr] 27 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 28 | / declare_clippy_lint!{ [INFO] [stderr] 29 | | pub QUESTION_MARK, [INFO] [stderr] 30 | | style, [INFO] [stderr] 31 | | "checks for expressions that could be replaced by the question mark operator" [INFO] [stderr] 32 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/ranges.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for calling `.step_by(0)` on iterators, [INFO] [stderr] 10 | | /// which never terminates. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** This very much looks like an oversight, since with [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// for x in (5..5).step_by(0) { .. } [INFO] [stderr] 20 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub ITERATOR_STEP_BY_ZERO, [INFO] [stderr] 23 | | correctness, [INFO] [stderr] 24 | | "using `Iterator::step_by(0)`, which produces an infinite iterator" [INFO] [stderr] 25 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/ranges.rs:27:1 [INFO] [stderr] | [INFO] [stderr] 27 | / /// **What it does:** Checks for zipping a collection with the range of [INFO] [stderr] 28 | | /// `0.._.len()`. [INFO] [stderr] 29 | | /// [INFO] [stderr] 30 | | /// **Why is this bad?** The code is better expressed with `.enumerate()`. [INFO] [stderr] ... | [INFO] [stderr] 36 | | /// x.iter().zip(0..x.len()) [INFO] [stderr] 37 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 38 | / declare_clippy_lint! { [INFO] [stderr] 39 | | pub RANGE_ZIP_WITH_LEN, [INFO] [stderr] 40 | | complexity, [INFO] [stderr] 41 | | "zipping iterator with a range when `enumerate()` would do" [INFO] [stderr] 42 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/minmax.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for expressions where `std::cmp::min` and `max` are [INFO] [stderr] 8 | | /// used to clamp values, but switched so that the result is constant. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** This is in all probability not the intended outcome. At [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// It will always be equal to `0`. Probably the author meant to clamp the value [INFO] [stderr] [INFO] [stderr] 20 | | /// between 0 and 100, but has erroneously swapped `min` and `max`. [INFO] [stderr] | |___________________________________________________________________^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub MIN_MAX, [INFO] [stderr] 23 | | correctness, [INFO] [stderr] 24 | | "`min(_, max(_, _))` (or vice versa) with bounds clamping the result to a constant" [INFO] [stderr] 25 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/ranges.rs:44:1 [INFO] [stderr] | [INFO] [stderr] 44 | / /// **What it does:** Checks for exclusive ranges where 1 is added to the [INFO] [stderr] 45 | | /// upper bound, e.g. `x..(y+1)`. [INFO] [stderr] 46 | | /// [INFO] [stderr] 47 | | /// **Why is this bad?** The code is more readable with an inclusive range [INFO] [stderr] ... | [INFO] [stderr] 54 | | /// for x..(y+1) { .. } [INFO] [stderr] 55 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 56 | / declare_clippy_lint! { [INFO] [stderr] 57 | | pub RANGE_PLUS_ONE, [INFO] [stderr] 58 | | nursery, [INFO] [stderr] 59 | | "`x..(y+1)` reads better as `x..=y`" [INFO] [stderr] 60 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/ranges.rs:62:1 [INFO] [stderr] | [INFO] [stderr] 62 | / /// **What it does:** Checks for inclusive ranges where 1 is subtracted from [INFO] [stderr] 63 | | /// the upper bound, e.g. `x..=(y-1)`. [INFO] [stderr] 64 | | /// [INFO] [stderr] 65 | | /// **Why is this bad?** The code is more readable with an exclusive range [INFO] [stderr] ... | [INFO] [stderr] 72 | | /// for x..=(y-1) { .. } [INFO] [stderr] 73 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 74 | / declare_clippy_lint! { [INFO] [stderr] 75 | | pub RANGE_MINUS_ONE, [INFO] [stderr] 76 | | style, [INFO] [stderr] 77 | | "`x..=(y-1)` reads better as `x..y`" [INFO] [stderr] 78 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/redundant_field_names.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for fields in struct literals where shorthands [INFO] [stderr] 6 | | /// could be used. [INFO] [stderr] 7 | | /// [INFO] [stderr] 8 | | /// **Why is this bad?** If the field and variable names are the same, [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// let foo = Foo{ bar: bar } [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub REDUNDANT_FIELD_NAMES, [INFO] [stderr] 25 | | style, [INFO] [stderr] 26 | | "checks for fields in struct literals where shorthands could be used" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/reference.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for usage of `*&` and `*&mut` in expressions. [INFO] [stderr] 6 | | /// [INFO] [stderr] 7 | | /// **Why is this bad?** Immediately dereferencing a reference is no-op and [INFO] [stderr] 8 | | /// makes the code less clear. [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// let c = *&d; [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub DEREF_ADDROF, [INFO] [stderr] 20 | | complexity, [INFO] [stderr] 21 | | "use of `*&` or `*&mut` in an expression" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/reference.rs:58:1 [INFO] [stderr] | [INFO] [stderr] 58 | / /// **What it does:** Checks for references in expressions that use [INFO] [stderr] 59 | | /// auto dereference. [INFO] [stderr] 60 | | /// [INFO] [stderr] 61 | | /// **Why is this bad?** The reference is a no-op and is automatically [INFO] [stderr] ... | [INFO] [stderr] 68 | | /// let x = (&point).x; [INFO] [stderr] 69 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 70 | / declare_clippy_lint! { [INFO] [stderr] 71 | | pub REF_IN_DEREF, [INFO] [stderr] 72 | | complexity, [INFO] [stderr] 73 | | "Use of reference in auto dereference expression." [INFO] [stderr] 74 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/regex.rs:10:1 [INFO] [stderr] | [INFO] [stderr] 10 | / /// **What it does:** Checks [regex](https://crates.io/crates/regex) creation [INFO] [stderr] 11 | | /// (with `Regex::new`,`RegexBuilder::new` or `RegexSet::new`) for correct [INFO] [stderr] 12 | | /// regex syntax. [INFO] [stderr] 13 | | /// [INFO] [stderr] ... | [INFO] [stderr] 20 | | /// Regex::new("|") [INFO] [stderr] 21 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 22 | / declare_clippy_lint! { [INFO] [stderr] 23 | | pub INVALID_REGEX, [INFO] [stderr] 24 | | correctness, [INFO] [stderr] 25 | | "invalid regular expressions" [INFO] [stderr] 26 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/regex.rs:28:1 [INFO] [stderr] | [INFO] [stderr] 28 | / /// **What it does:** Checks for trivial [regex](https://crates.io/crates/regex) [INFO] [stderr] 29 | | /// creation (with `Regex::new`, `RegexBuilder::new` or `RegexSet::new`). [INFO] [stderr] 30 | | /// [INFO] [stderr] 31 | | /// **Why is this bad?** Matching the regex can likely be replaced by `==` or [INFO] [stderr] ... | [INFO] [stderr] 39 | | /// Regex::new("^foobar") [INFO] [stderr] 40 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 41 | / declare_clippy_lint! { [INFO] [stderr] 42 | | pub TRIVIAL_REGEX, [INFO] [stderr] 43 | | style, [INFO] [stderr] 44 | | "trivial regular expressions" [INFO] [stderr] 45 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/regex.rs:47:1 [INFO] [stderr] | [INFO] [stderr] 47 | / /// **What it does:** Checks for usage of `regex!(_)` which (as of now) is [INFO] [stderr] 48 | | /// usually slower than `Regex::new(_)` unless called in a loop (which is a bad [INFO] [stderr] 49 | | /// idea anyway). [INFO] [stderr] 50 | | /// [INFO] [stderr] ... | [INFO] [stderr] 58 | | /// regex!("foo|bar") [INFO] [stderr] 59 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 60 | / declare_clippy_lint! { [INFO] [stderr] 61 | | pub REGEX_MACRO, [INFO] [stderr] 62 | | style, [INFO] [stderr] 63 | | "use of `regex!(_)` instead of `Regex::new(_)`" [INFO] [stderr] 64 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/replace_consts.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for usage of `ATOMIC_X_INIT`, `ONCE_INIT`, and [INFO] [stderr] 7 | | /// `uX/iX::MIN/MAX`. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** `const fn`s exist [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// static FOO: AtomicIsize = AtomicIsize::new(0); [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub REPLACE_CONSTS, [INFO] [stderr] 25 | | pedantic, [INFO] [stderr] 26 | | "Lint usages of standard library `const`s that could be replaced by `const fn`s" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/returns.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for return statements at the end of a block. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** Removing the `return` and semicolon will make the code [INFO] [stderr] 11 | | /// more rusty. [INFO] [stderr] ... | [INFO] [stderr] 18 | | /// fn foo(x: usize) { return x; } [INFO] [stderr] 19 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 20 | / declare_clippy_lint! { [INFO] [stderr] 21 | | pub NEEDLESS_RETURN, [INFO] [stderr] 22 | | style, [INFO] [stderr] 23 | | "using a return statement like `return expr;` where an expression would suffice" [INFO] [stderr] 24 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/returns.rs:26:1 [INFO] [stderr] | [INFO] [stderr] 26 | / /// **What it does:** Checks for `let`-bindings, which are subsequently [INFO] [stderr] 27 | | /// returned. [INFO] [stderr] 28 | | /// [INFO] [stderr] 29 | | /// **Why is this bad?** It is just extraneous code. Remove it to make your code [INFO] [stderr] ... | [INFO] [stderr] 36 | | /// { let x = ..; x } [INFO] [stderr] 37 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 38 | / declare_clippy_lint! { [INFO] [stderr] 39 | | pub LET_AND_RETURN, [INFO] [stderr] 40 | | style, [INFO] [stderr] 41 | | "creating a let-binding and then immediately returning it like `let x = expr; x` at \ [INFO] [stderr] 42 | | the end of a block" [INFO] [stderr] 43 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/serde_api.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for mis-uses of the serde API. [INFO] [stderr] 6 | | /// [INFO] [stderr] 7 | | /// **Why is this bad?** Serde is very finnicky about how its API should be [INFO] [stderr] 8 | | /// used, but the type system can't be used to enforce it (yet?). [INFO] [stderr] ... | [INFO] [stderr] 12 | | /// **Example:** Implementing `Visitor::visit_string` but not [INFO] [stderr] 13 | | /// `Visitor::visit_str`. [INFO] [stderr] | |_________________________^ [INFO] [stderr] 14 | / declare_clippy_lint! { [INFO] [stderr] 15 | | pub SERDE_API_MISUSE, [INFO] [stderr] 16 | | correctness, [INFO] [stderr] 17 | | "various things that will negatively affect your serde experience" [INFO] [stderr] 18 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/shadow.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for bindings that shadow other bindings already in [INFO] [stderr] 10 | | /// scope, while just changing reference level or mutability. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** Not much, in fact it's a very common pattern in Rust [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// let x = &x; [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub SHADOW_SAME, [INFO] [stderr] 25 | | restriction, [INFO] [stderr] 26 | | "rebinding a name to itself, e.g. `let mut x = &mut x`" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/shadow.rs:29:1 [INFO] [stderr] | [INFO] [stderr] 29 | / /// **What it does:** Checks for bindings that shadow other bindings already in [INFO] [stderr] 30 | | /// scope, while reusing the original value. [INFO] [stderr] 31 | | /// [INFO] [stderr] 32 | | /// **Why is this bad?** Not too much, in fact it's a common pattern in Rust [INFO] [stderr] ... | [INFO] [stderr] 42 | | /// let x = x + 1; [INFO] [stderr] 43 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 44 | / declare_clippy_lint! { [INFO] [stderr] 45 | | pub SHADOW_REUSE, [INFO] [stderr] 46 | | restriction, [INFO] [stderr] 47 | | "rebinding a name to an expression that re-uses the original value, e.g. \ [INFO] [stderr] 48 | | `let x = x + 1`" [INFO] [stderr] 49 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/shadow.rs:51:1 [INFO] [stderr] | [INFO] [stderr] 51 | / /// **What it does:** Checks for bindings that shadow other bindings already in [INFO] [stderr] 52 | | /// scope, either without a initialization or with one that does not even use [INFO] [stderr] 53 | | /// the original value. [INFO] [stderr] 54 | | /// [INFO] [stderr] ... | [INFO] [stderr] 65 | | /// let x = y; let x = z; // shadows the earlier binding [INFO] [stderr] 66 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 67 | / declare_clippy_lint! { [INFO] [stderr] 68 | | pub SHADOW_UNRELATED, [INFO] [stderr] 69 | | restriction, [INFO] [stderr] 70 | | "rebinding a name without even using the original value" [INFO] [stderr] 71 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/strings.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for string appends of the form `x = x + y` (without [INFO] [stderr] 8 | | /// `let`!). [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** It's not really bad, but some people think that the [INFO] [stderr] ... | [INFO] [stderr] 20 | | /// x = x + ", World"; [INFO] [stderr] 21 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 22 | / declare_clippy_lint! { [INFO] [stderr] 23 | | pub STRING_ADD_ASSIGN, [INFO] [stderr] 24 | | pedantic, [INFO] [stderr] 25 | | "using `x = x + ..` where x is a `String` instead of `push_str()`" [INFO] [stderr] 26 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/strings.rs:28:1 [INFO] [stderr] | [INFO] [stderr] 28 | / /// **What it does:** Checks for all instances of `x + _` where `x` is of type [INFO] [stderr] 29 | | /// `String`, but only if [`string_add_assign`](#string_add_assign) does *not* [INFO] [stderr] 30 | | /// match. [INFO] [stderr] 31 | | /// [INFO] [stderr] ... | [INFO] [stderr] 48 | | /// x + ", World" [INFO] [stderr] 49 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 50 | / declare_clippy_lint! { [INFO] [stderr] 51 | | pub STRING_ADD, [INFO] [stderr] 52 | | restriction, [INFO] [stderr] 53 | | "using `x + ..` where x is a `String` instead of `push_str()`" [INFO] [stderr] 54 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/strings.rs:56:1 [INFO] [stderr] | [INFO] [stderr] 56 | / /// **What it does:** Checks for the `as_bytes` method called on string literals [INFO] [stderr] 57 | | /// that contain only ASCII characters. [INFO] [stderr] 58 | | /// [INFO] [stderr] 59 | | /// **Why is this bad?** Byte string literals (e.g. `b"foo"`) can be used [INFO] [stderr] ... | [INFO] [stderr] 66 | | /// let bs = "a byte string".as_bytes(); [INFO] [stderr] 67 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 68 | / declare_clippy_lint! { [INFO] [stderr] 69 | | pub STRING_LIT_AS_BYTES, [INFO] [stderr] 70 | | style, [INFO] [stderr] 71 | | "calling `as_bytes` on a string literal instead of using a byte string literal" [INFO] [stderr] 72 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/suspicious_trait_impl.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Lints for suspicious operations in impls of arithmetic operators, e.g. [INFO] [stderr] 8 | | /// subtracting elements in an Add impl. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why this is bad?** This is probably a typo or copy-and-paste error and not intended. [INFO] [stderr] ... | [INFO] [stderr] 22 | | /// } [INFO] [stderr] 23 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 24 | / declare_clippy_lint! { [INFO] [stderr] 25 | | pub SUSPICIOUS_ARITHMETIC_IMPL, [INFO] [stderr] 26 | | correctness, [INFO] [stderr] 27 | | "suspicious use of operators in impl of arithmetic trait" [INFO] [stderr] 28 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/suspicious_trait_impl.rs:30:1 [INFO] [stderr] | [INFO] [stderr] 30 | / /// **What it does:** Lints for suspicious operations in impls of OpAssign, e.g. [INFO] [stderr] 31 | | /// subtracting elements in an AddAssign impl. [INFO] [stderr] 32 | | /// [INFO] [stderr] 33 | | /// **Why this is bad?** This is probably a typo or copy-and-paste error and not intended. [INFO] [stderr] ... | [INFO] [stderr] 43 | | /// } [INFO] [stderr] 44 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 45 | / declare_clippy_lint! { [INFO] [stderr] 46 | | pub SUSPICIOUS_OP_ASSIGN_IMPL, [INFO] [stderr] 47 | | correctness, [INFO] [stderr] 48 | | "suspicious use of operators in impl of OpAssign trait" [INFO] [stderr] 49 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/swap.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for manual swapping. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** The `std::mem::swap` function exposes the intent better [INFO] [stderr] 10 | | /// without deinitializing or copying either variable. [INFO] [stderr] ... | [INFO] [stderr] 18 | | /// a = t; [INFO] [stderr] 19 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 20 | / declare_clippy_lint! { [INFO] [stderr] 21 | | pub MANUAL_SWAP, [INFO] [stderr] 22 | | complexity, [INFO] [stderr] 23 | | "manual swap of two variables" [INFO] [stderr] 24 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/swap.rs:26:1 [INFO] [stderr] | [INFO] [stderr] 26 | / /// **What it does:** Checks for `foo = bar; bar = foo` sequences. [INFO] [stderr] 27 | | /// [INFO] [stderr] 28 | | /// **Why is this bad?** This looks like a failed attempt to swap. [INFO] [stderr] 29 | | /// [INFO] [stderr] ... | [INFO] [stderr] 35 | | /// b = a; [INFO] [stderr] 36 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 37 | / declare_clippy_lint! { [INFO] [stderr] 38 | | pub ALMOST_SWAPPED, [INFO] [stderr] 39 | | correctness, [INFO] [stderr] 40 | | "`foo = bar; bar = foo` sequence" [INFO] [stderr] 41 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/temporary_assignment.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for construction of a structure or tuple just to [INFO] [stderr] 7 | | /// assign a value in it. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** Readability. If the structure is only created to be [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// (0, 0).0 = 1 [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub TEMPORARY_ASSIGNMENT, [INFO] [stderr] 20 | | complexity, [INFO] [stderr] 21 | | "assignments to temporaries" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for transmutes that can't ever be correct on any [INFO] [stderr] 10 | | /// architecture. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** It's basically guaranteed to be undefined behaviour. [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// let ptr: *const T = core::intrinsics::transmute('x') [INFO] [stderr] 20 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub WRONG_TRANSMUTE, [INFO] [stderr] 23 | | correctness, [INFO] [stderr] 24 | | "transmutes that are confusing at best, undefined behaviour at worst and always useless" [INFO] [stderr] 25 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:27:1 [INFO] [stderr] | [INFO] [stderr] 27 | / /// **What it does:** Checks for transmutes to the original type of the object [INFO] [stderr] 28 | | /// and transmutes that could be a cast. [INFO] [stderr] 29 | | /// [INFO] [stderr] 30 | | /// **Why is this bad?** Readability. The code tricks people into thinking that [INFO] [stderr] ... | [INFO] [stderr] 37 | | /// core::intrinsics::transmute(t) // where the result type is the same as `t`'s [INFO] [stderr] 38 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 39 | / declare_clippy_lint! { [INFO] [stderr] 40 | | pub USELESS_TRANSMUTE, [INFO] [stderr] 41 | | complexity, [INFO] [stderr] 42 | | "transmutes that have the same to and from types or could be a cast/coercion" [INFO] [stderr] 43 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:45:1 [INFO] [stderr] | [INFO] [stderr] 45 | / /// **What it does:** Checks for transmutes between a type `T` and `*T`. [INFO] [stderr] 46 | | /// [INFO] [stderr] 47 | | /// **Why is this bad?** It's easy to mistakenly transmute between a type and a [INFO] [stderr] 48 | | /// pointer to that type. [INFO] [stderr] ... | [INFO] [stderr] 55 | | /// // `*t` or `&t`'s [INFO] [stderr] 56 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 57 | / declare_clippy_lint! { [INFO] [stderr] 58 | | pub CROSSPOINTER_TRANSMUTE, [INFO] [stderr] 59 | | complexity, [INFO] [stderr] 60 | | "transmutes that have to or from types that are a pointer to the other" [INFO] [stderr] 61 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:63:1 [INFO] [stderr] | [INFO] [stderr] 63 | / /// **What it does:** Checks for transmutes from a pointer to a reference. [INFO] [stderr] 64 | | /// [INFO] [stderr] 65 | | /// **Why is this bad?** This can always be rewritten with `&` and `*`. [INFO] [stderr] 66 | | /// [INFO] [stderr] ... | [INFO] [stderr] 73 | | /// let _: &T = &*p; [INFO] [stderr] 74 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 75 | / declare_clippy_lint! { [INFO] [stderr] 76 | | pub TRANSMUTE_PTR_TO_REF, [INFO] [stderr] 77 | | complexity, [INFO] [stderr] 78 | | "transmutes from a pointer to a reference type" [INFO] [stderr] 79 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:81:1 [INFO] [stderr] | [INFO] [stderr] 81 | / /// **What it does:** Checks for transmutes from an integer to a `char`. [INFO] [stderr] 82 | | /// [INFO] [stderr] 83 | | /// **Why is this bad?** Not every integer is a Unicode scalar value. [INFO] [stderr] 84 | | /// [INFO] [stderr] ... | [INFO] [stderr] 100 | | /// let _ = std::char::from_u32(x).unwrap(); [INFO] [stderr] 101 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 102 | / declare_clippy_lint! { [INFO] [stderr] 103 | | pub TRANSMUTE_INT_TO_CHAR, [INFO] [stderr] 104 | | complexity, [INFO] [stderr] 105 | | "transmutes from an integer to a `char`" [INFO] [stderr] 106 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:108:1 [INFO] [stderr] | [INFO] [stderr] 108 | / /// **What it does:** Checks for transmutes from a `&[u8]` to a `&str`. [INFO] [stderr] 109 | | /// [INFO] [stderr] 110 | | /// **Why is this bad?** Not every byte slice is a valid UTF-8 string. [INFO] [stderr] 111 | | /// [INFO] [stderr] ... | [INFO] [stderr] 127 | | /// let _ = std::str::from_utf8(b).unwrap(); [INFO] [stderr] 128 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 129 | / declare_clippy_lint! { [INFO] [stderr] 130 | | pub TRANSMUTE_BYTES_TO_STR, [INFO] [stderr] 131 | | complexity, [INFO] [stderr] 132 | | "transmutes from a `&[u8]` to a `&str`" [INFO] [stderr] 133 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:135:1 [INFO] [stderr] | [INFO] [stderr] 135 | / /// **What it does:** Checks for transmutes from an integer to a `bool`. [INFO] [stderr] 136 | | /// [INFO] [stderr] 137 | | /// **Why is this bad?** This might result in an invalid in-memory representation of a `bool`. [INFO] [stderr] 138 | | /// [INFO] [stderr] ... | [INFO] [stderr] 145 | | /// let _: bool = x != 0; [INFO] [stderr] 146 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 147 | / declare_clippy_lint! { [INFO] [stderr] 148 | | pub TRANSMUTE_INT_TO_BOOL, [INFO] [stderr] 149 | | complexity, [INFO] [stderr] 150 | | "transmutes from an integer to a `bool`" [INFO] [stderr] 151 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:153:1 [INFO] [stderr] | [INFO] [stderr] 153 | / /// **What it does:** Checks for transmutes from an integer to a float. [INFO] [stderr] 154 | | /// [INFO] [stderr] 155 | | /// **Why is this bad?** This might result in an invalid in-memory representation of a float. [INFO] [stderr] 156 | | /// [INFO] [stderr] ... | [INFO] [stderr] 163 | | /// let _: f32 = f32::from_bits(x); [INFO] [stderr] 164 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 165 | / declare_clippy_lint! { [INFO] [stderr] 166 | | pub TRANSMUTE_INT_TO_FLOAT, [INFO] [stderr] 167 | | complexity, [INFO] [stderr] 168 | | "transmutes from an integer to a float" [INFO] [stderr] 169 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:171:1 [INFO] [stderr] | [INFO] [stderr] 171 | / /// **What it does:** Checks for transmutes from a pointer to a pointer, or [INFO] [stderr] 172 | | /// from a reference to a reference. [INFO] [stderr] 173 | | /// [INFO] [stderr] 174 | | /// **Why is this bad?** Transmutes are dangerous, and these can instead be [INFO] [stderr] ... | [INFO] [stderr] 190 | | /// let _ = unsafe{ &*(&1u32 as *const u32 as *const f32) }; [INFO] [stderr] 191 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 192 | / declare_clippy_lint! { [INFO] [stderr] 193 | | pub TRANSMUTE_PTR_TO_PTR, [INFO] [stderr] 194 | | complexity, [INFO] [stderr] 195 | | "transmutes from a pointer to a pointer / a reference to a reference" [INFO] [stderr] 196 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/trivially_copy_pass_by_ref.rs:15:1 [INFO] [stderr] | [INFO] [stderr] 15 | / /// **What it does:** Checks for functions taking arguments by reference, where [INFO] [stderr] 16 | | /// the argument type is `Copy` and small enough to be more efficient to always [INFO] [stderr] 17 | | /// pass by value. [INFO] [stderr] 18 | | /// [INFO] [stderr] ... | [INFO] [stderr] 39 | | /// } [INFO] [stderr] 40 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 41 | / declare_clippy_lint! { [INFO] [stderr] 42 | | pub TRIVIALLY_COPY_PASS_BY_REF, [INFO] [stderr] 43 | | perf, [INFO] [stderr] 44 | | "functions taking small copyable arguments by reference" [INFO] [stderr] 45 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:25:1 [INFO] [stderr] | [INFO] [stderr] 25 | / /// **What it does:** Checks for use of `Box>` anywhere in the code. [INFO] [stderr] 26 | | /// [INFO] [stderr] 27 | | /// **Why is this bad?** `Vec` already keeps its contents in a separate area on [INFO] [stderr] 28 | | /// the heap. So if you `Box` it, you just add another level of indirection [INFO] [stderr] ... | [INFO] [stderr] 45 | | /// } [INFO] [stderr] 46 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 47 | / declare_clippy_lint! { [INFO] [stderr] 48 | | pub BOX_VEC, [INFO] [stderr] 49 | | perf, [INFO] [stderr] 50 | | "usage of `Box>`, vector elements are already on the heap" [INFO] [stderr] 51 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:53:1 [INFO] [stderr] | [INFO] [stderr] 53 | / /// **What it does:** Checks for use of `Option>` in function signatures and type [INFO] [stderr] 54 | | /// definitions [INFO] [stderr] 55 | | /// [INFO] [stderr] 56 | | /// **Why is this bad?** `Option<_>` represents an optional value. `Option>` [INFO] [stderr] ... | [INFO] [stderr] 65 | | /// None [INFO] [stderr] 66 | | /// } [INFO] [stderr] | |_____^ [INFO] [stderr] 67 | / declare_clippy_lint! { [INFO] [stderr] 68 | | pub OPTION_OPTION, [INFO] [stderr] 69 | | complexity, [INFO] [stderr] 70 | | "usage of `Option>`" [INFO] [stderr] 71 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:73:1 [INFO] [stderr] | [INFO] [stderr] 73 | / /// **What it does:** Checks for usage of any `LinkedList`, suggesting to use a [INFO] [stderr] 74 | | /// `Vec` or a `VecDeque` (formerly called `RingBuf`). [INFO] [stderr] 75 | | /// [INFO] [stderr] 76 | | /// **Why is this bad?** Gankro says: [INFO] [stderr] ... | [INFO] [stderr] 100 | | /// let x = LinkedList::new(); [INFO] [stderr] 101 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 102 | / declare_clippy_lint! { [INFO] [stderr] 103 | | pub LINKEDLIST, [INFO] [stderr] 104 | | pedantic, [INFO] [stderr] 105 | | "usage of LinkedList, usually a vector is faster, or a more specialized data \ [INFO] [stderr] 106 | | structure like a VecDeque" [INFO] [stderr] 107 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:109:1 [INFO] [stderr] | [INFO] [stderr] 109 | / /// **What it does:** Checks for use of `&Box` anywhere in the code. [INFO] [stderr] 110 | | /// [INFO] [stderr] 111 | | /// **Why is this bad?** Any `&Box` can also be a `&T`, which is more [INFO] [stderr] 112 | | /// general. [INFO] [stderr] ... | [INFO] [stderr] 124 | | /// fn foo(bar: &T) { ... } [INFO] [stderr] 125 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 126 | / declare_clippy_lint! { [INFO] [stderr] 127 | | pub BORROWED_BOX, [INFO] [stderr] 128 | | complexity, [INFO] [stderr] 129 | | "a borrow of a boxed type" [INFO] [stderr] 130 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:362:1 [INFO] [stderr] | [INFO] [stderr] 362 | / /// **What it does:** Checks for binding a unit value. [INFO] [stderr] 363 | | /// [INFO] [stderr] 364 | | /// **Why is this bad?** A unit value cannot usefully be used anywhere. So [INFO] [stderr] 365 | | /// binding one is kind of pointless. [INFO] [stderr] ... | [INFO] [stderr] 371 | | /// let x = { 1; }; [INFO] [stderr] 372 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 373 | / declare_clippy_lint! { [INFO] [stderr] 374 | | pub LET_UNIT_VALUE, [INFO] [stderr] 375 | | style, [INFO] [stderr] 376 | | "creating a let binding to a value of unit type, which usually can't be used afterwards" [INFO] [stderr] 377 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:413:1 [INFO] [stderr] | [INFO] [stderr] 413 | / /// **What it does:** Checks for comparisons to unit. [INFO] [stderr] 414 | | /// [INFO] [stderr] 415 | | /// **Why is this bad?** Unit is always equal to itself, and thus is just a [INFO] [stderr] 416 | | /// clumsily written constant. Mostly this happens when someone accidentally [INFO] [stderr] ... | [INFO] [stderr] 427 | | /// { foo(); bar(); baz(); } [INFO] [stderr] 428 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 429 | / declare_clippy_lint! { [INFO] [stderr] 430 | | pub UNIT_CMP, [INFO] [stderr] 431 | | correctness, [INFO] [stderr] 432 | | "comparing unit values" [INFO] [stderr] 433 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:471:1 [INFO] [stderr] | [INFO] [stderr] 471 | / /// **What it does:** Checks for passing a unit value as an argument to a function without using a unit literal (`()`). [INFO] [stderr] 472 | | /// [INFO] [stderr] 473 | | /// **Why is this bad?** This is likely the result of an accidental semicolon. [INFO] [stderr] 474 | | /// [INFO] [stderr] ... | [INFO] [stderr] 482 | | /// }) [INFO] [stderr] 483 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 484 | / declare_clippy_lint! { [INFO] [stderr] 485 | | pub UNIT_ARG, [INFO] [stderr] 486 | | complexity, [INFO] [stderr] 487 | | "passing unit to a function" [INFO] [stderr] 488 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:565:1 [INFO] [stderr] | [INFO] [stderr] 565 | / /// **What it does:** Checks for casts from any numerical to a float type where [INFO] [stderr] 566 | | /// the receiving type cannot store all values from the original type without [INFO] [stderr] 567 | | /// rounding errors. This possible rounding is to be expected, so this lint is [INFO] [stderr] 568 | | /// `Allow` by default. [INFO] [stderr] ... | [INFO] [stderr] 581 | | /// let x = u64::MAX; x as f64 [INFO] [stderr] 582 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 583 | / declare_clippy_lint! { [INFO] [stderr] 584 | | pub CAST_PRECISION_LOSS, [INFO] [stderr] 585 | | pedantic, [INFO] [stderr] 586 | | "casts that cause loss of precision, e.g. `x as f32` where `x: u64`" [INFO] [stderr] 587 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:589:1 [INFO] [stderr] | [INFO] [stderr] 589 | / /// **What it does:** Checks for casts from a signed to an unsigned numerical [INFO] [stderr] 590 | | /// type. In this case, negative values wrap around to large positive values, [INFO] [stderr] 591 | | /// which can be quite surprising in practice. However, as the cast works as [INFO] [stderr] 592 | | /// defined, this lint is `Allow` by default. [INFO] [stderr] ... | [INFO] [stderr] 602 | | /// y as u128 // will return 18446744073709551615 [INFO] [stderr] 603 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 604 | / declare_clippy_lint! { [INFO] [stderr] 605 | | pub CAST_SIGN_LOSS, [INFO] [stderr] 606 | | pedantic, [INFO] [stderr] 607 | | "casts from signed types to unsigned types, e.g. `x as u32` where `x: i32`" [INFO] [stderr] 608 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:610:1 [INFO] [stderr] | [INFO] [stderr] 610 | / /// **What it does:** Checks for on casts between numerical types that may [INFO] [stderr] 611 | | /// truncate large values. This is expected behavior, so the cast is `Allow` by [INFO] [stderr] 612 | | /// default. [INFO] [stderr] 613 | | /// [INFO] [stderr] ... | [INFO] [stderr] 622 | | /// fn as_u8(x: u64) -> u8 { x as u8 } [INFO] [stderr] 623 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 624 | / declare_clippy_lint! { [INFO] [stderr] 625 | | pub CAST_POSSIBLE_TRUNCATION, [INFO] [stderr] 626 | | pedantic, [INFO] [stderr] 627 | | "casts that may cause truncation of the value, e.g. `x as u8` where `x: u32`, \ [INFO] [stderr] 628 | | or `x as i32` where `x: f32`" [INFO] [stderr] 629 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:631:1 [INFO] [stderr] | [INFO] [stderr] 631 | / /// **What it does:** Checks for casts from an unsigned type to a signed type of [INFO] [stderr] 632 | | /// the same size. Performing such a cast is a 'no-op' for the compiler, [INFO] [stderr] 633 | | /// i.e. nothing is changed at the bit level, and the binary representation of [INFO] [stderr] 634 | | /// the value is reinterpreted. This can cause wrapping if the value is too big [INFO] [stderr] ... | [INFO] [stderr] 646 | | /// u32::MAX as i32 // will yield a value of `-1` [INFO] [stderr] 647 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 648 | / declare_clippy_lint! { [INFO] [stderr] 649 | | pub CAST_POSSIBLE_WRAP, [INFO] [stderr] 650 | | pedantic, [INFO] [stderr] 651 | | "casts that may cause wrapping around the value, e.g. `x as i32` where `x: u32` \ [INFO] [stderr] 652 | | and `x > i32::MAX`" [INFO] [stderr] 653 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:655:1 [INFO] [stderr] | [INFO] [stderr] 655 | / /// **What it does:** Checks for on casts between numerical types that may [INFO] [stderr] 656 | | /// be replaced by safe conversion functions. [INFO] [stderr] 657 | | /// [INFO] [stderr] 658 | | /// **Why is this bad?** Rust's `as` keyword will perform many kinds of [INFO] [stderr] ... | [INFO] [stderr] 675 | | /// fn as_u64(x: u8) -> u64 { u64::from(x) } [INFO] [stderr] 676 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 677 | / declare_clippy_lint! { [INFO] [stderr] 678 | | pub CAST_LOSSLESS, [INFO] [stderr] 679 | | complexity, [INFO] [stderr] 680 | | "casts using `as` that are known to be lossless, e.g. `x as u64` where `x: u8`" [INFO] [stderr] 681 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:683:1 [INFO] [stderr] | [INFO] [stderr] 683 | / /// **What it does:** Checks for casts to the same type. [INFO] [stderr] 684 | | /// [INFO] [stderr] 685 | | /// **Why is this bad?** It's just unnecessary. [INFO] [stderr] 686 | | /// [INFO] [stderr] ... | [INFO] [stderr] 691 | | /// let _ = 2i32 as i32 [INFO] [stderr] 692 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 693 | / declare_clippy_lint! { [INFO] [stderr] 694 | | pub UNNECESSARY_CAST, [INFO] [stderr] 695 | | complexity, [INFO] [stderr] 696 | | "cast to the same type, e.g. `x as i32` where `x: i32`" [INFO] [stderr] 697 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:699:1 [INFO] [stderr] | [INFO] [stderr] 699 | / /// **What it does:** Checks for casts of a function pointer to a numeric type not enough to store address. [INFO] [stderr] 700 | | /// [INFO] [stderr] 701 | | /// **Why is this bad?** Casting a function pointer to not eligable type could truncate the address value. [INFO] [stderr] 702 | | /// [INFO] [stderr] ... | [INFO] [stderr] 708 | | /// let _ = test_fn as i32 [INFO] [stderr] 709 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 710 | / declare_clippy_lint! { [INFO] [stderr] 711 | | pub FN_TO_NUMERIC_CAST_WITH_TRUNCATION, [INFO] [stderr] 712 | | correctness, [INFO] [stderr] 713 | | "cast function pointer to the numeric type with value truncation" [INFO] [stderr] 714 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:716:1 [INFO] [stderr] | [INFO] [stderr] 716 | / /// **What it does:** Checks for casts of a function pointer to a numeric type except `usize`. [INFO] [stderr] 717 | | /// [INFO] [stderr] 718 | | /// **Why is this bad?** Casting a function pointer to something other than `usize` is not a good style. [INFO] [stderr] 719 | | /// [INFO] [stderr] ... | [INFO] [stderr] 725 | | /// let _ = test_fn as i128 [INFO] [stderr] 726 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 727 | / declare_clippy_lint! { [INFO] [stderr] 728 | | pub FN_TO_NUMERIC_CAST, [INFO] [stderr] 729 | | style, [INFO] [stderr] 730 | | "cast function pointer to the numeric type" [INFO] [stderr] 731 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:733:1 [INFO] [stderr] | [INFO] [stderr] 733 | / /// **What it does:** Checks for casts from a less-strictly-aligned pointer to a [INFO] [stderr] 734 | | /// more-strictly-aligned pointer [INFO] [stderr] 735 | | /// [INFO] [stderr] 736 | | /// **Why is this bad?** Dereferencing the resulting pointer may be undefined [INFO] [stderr] ... | [INFO] [stderr] 744 | | /// let _ = (&mut 1u8 as *mut u8) as *mut u16; [INFO] [stderr] 745 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 746 | / declare_clippy_lint! { [INFO] [stderr] 747 | | pub CAST_PTR_ALIGNMENT, [INFO] [stderr] 748 | | correctness, [INFO] [stderr] 749 | | "cast from a pointer to a more-strictly-aligned pointer" [INFO] [stderr] 750 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:14:1 [INFO] [stderr] | [INFO] [stderr] 14 | / /// **What it does:** Checks for function arguments and let bindings denoted as [INFO] [stderr] 15 | | /// `ref`. [INFO] [stderr] 16 | | /// [INFO] [stderr] 17 | | /// **Why is this bad?** The `ref` declaration makes the function take an owned [INFO] [stderr] ... | [INFO] [stderr] 32 | | /// fn foo(ref x: u8) -> bool { .. } [INFO] [stderr] 33 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 34 | / declare_clippy_lint! { [INFO] [stderr] 35 | | pub TOPLEVEL_REF_ARG, [INFO] [stderr] 36 | | style, [INFO] [stderr] 37 | | "an entire binding declared as `ref`, in a function argument or a `let` statement" [INFO] [stderr] 38 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:40:1 [INFO] [stderr] | [INFO] [stderr] 40 | / /// **What it does:** Checks for comparisons to NaN. [INFO] [stderr] 41 | | /// [INFO] [stderr] 42 | | /// **Why is this bad?** NaN does not compare meaningfully to anything – not [INFO] [stderr] 43 | | /// even itself – so those comparisons are simply wrong. [INFO] [stderr] ... | [INFO] [stderr] 49 | | /// x == NAN [INFO] [stderr] 50 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 51 | / declare_clippy_lint! { [INFO] [stderr] 52 | | pub CMP_NAN, [INFO] [stderr] 53 | | correctness, [INFO] [stderr] 54 | | "comparisons to NAN, which will always return false, probably not intended" [INFO] [stderr] 55 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:57:1 [INFO] [stderr] | [INFO] [stderr] 57 | / /// **What it does:** Checks for (in-)equality comparisons on floating-point [INFO] [stderr] 58 | | /// values (apart from zero), except in functions called `*eq*` (which probably [INFO] [stderr] 59 | | /// implement equality for a type involving floats). [INFO] [stderr] 60 | | /// [INFO] [stderr] ... | [INFO] [stderr] 71 | | /// y != x // where both are floats [INFO] [stderr] 72 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 73 | / declare_clippy_lint! { [INFO] [stderr] 74 | | pub FLOAT_CMP, [INFO] [stderr] 75 | | correctness, [INFO] [stderr] 76 | | "using `==` or `!=` on float values instead of comparing difference with an epsilon" [INFO] [stderr] 77 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:79:1 [INFO] [stderr] | [INFO] [stderr] 79 | / /// **What it does:** Checks for conversions to owned values just for the sake [INFO] [stderr] 80 | | /// of a comparison. [INFO] [stderr] 81 | | /// [INFO] [stderr] 82 | | /// **Why is this bad?** The comparison can operate on a reference, so creating [INFO] [stderr] ... | [INFO] [stderr] 90 | | /// x.to_owned() == y [INFO] [stderr] 91 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 92 | / declare_clippy_lint! { [INFO] [stderr] 93 | | pub CMP_OWNED, [INFO] [stderr] 94 | | perf, [INFO] [stderr] 95 | | "creating owned instances for comparing with others, e.g. `x == \"foo\".to_string()`" [INFO] [stderr] 96 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:98:1 [INFO] [stderr] | [INFO] [stderr] 98 | / /// **What it does:** Checks for getting the remainder of a division by one. [INFO] [stderr] 99 | | /// [INFO] [stderr] 100 | | /// **Why is this bad?** The result can only ever be zero. No one will write [INFO] [stderr] 101 | | /// such code deliberately, unless trying to win an Underhanded Rust [INFO] [stderr] ... | [INFO] [stderr] 109 | | /// x % 1 [INFO] [stderr] 110 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 111 | / declare_clippy_lint! { [INFO] [stderr] 112 | | pub MODULO_ONE, [INFO] [stderr] 113 | | correctness, [INFO] [stderr] 114 | | "taking a number modulo 1, which always returns 0" [INFO] [stderr] 115 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:117:1 [INFO] [stderr] | [INFO] [stderr] 117 | / /// **What it does:** Checks for patterns in the form `name @ _`. [INFO] [stderr] 118 | | /// [INFO] [stderr] 119 | | /// **Why is this bad?** It's almost always more readable to just use direct [INFO] [stderr] 120 | | /// bindings. [INFO] [stderr] ... | [INFO] [stderr] 129 | | /// } [INFO] [stderr] 130 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 131 | / declare_clippy_lint! { [INFO] [stderr] 132 | | pub REDUNDANT_PATTERN, [INFO] [stderr] 133 | | style, [INFO] [stderr] 134 | | "using `name @ _` in a pattern" [INFO] [stderr] 135 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:137:1 [INFO] [stderr] | [INFO] [stderr] 137 | / /// **What it does:** Checks for the use of bindings with a single leading [INFO] [stderr] 138 | | /// underscore. [INFO] [stderr] 139 | | /// [INFO] [stderr] 140 | | /// **Why is this bad?** A single leading underscore is usually used to indicate [INFO] [stderr] ... | [INFO] [stderr] 151 | | /// // underscore. We should rename `_x` to `x` [INFO] [stderr] 152 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 153 | / declare_clippy_lint! { [INFO] [stderr] 154 | | pub USED_UNDERSCORE_BINDING, [INFO] [stderr] 155 | | pedantic, [INFO] [stderr] 156 | | "using a binding which is prefixed with an underscore" [INFO] [stderr] 157 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:159:1 [INFO] [stderr] | [INFO] [stderr] 159 | / /// **What it does:** Checks for the use of short circuit boolean conditions as [INFO] [stderr] 160 | | /// a [INFO] [stderr] 161 | | /// statement. [INFO] [stderr] 162 | | /// [INFO] [stderr] ... | [INFO] [stderr] 171 | | /// f() && g(); // We should write `if f() { g(); }`. [INFO] [stderr] 172 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 173 | / declare_clippy_lint! { [INFO] [stderr] 174 | | pub SHORT_CIRCUIT_STATEMENT, [INFO] [stderr] 175 | | complexity, [INFO] [stderr] 176 | | "using a short circuit boolean condition as a statement" [INFO] [stderr] 177 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:179:1 [INFO] [stderr] | [INFO] [stderr] 179 | / /// **What it does:** Catch casts from `0` to some pointer type [INFO] [stderr] 180 | | /// [INFO] [stderr] 181 | | /// **Why is this bad?** This generally means `null` and is better expressed as [INFO] [stderr] 182 | | /// {`std`, `core`}`::ptr::`{`null`, `null_mut`}. [INFO] [stderr] ... | [INFO] [stderr] 189 | | /// 0 as *const u32 [INFO] [stderr] 190 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 191 | / declare_clippy_lint! { [INFO] [stderr] 192 | | pub ZERO_PTR, [INFO] [stderr] 193 | | style, [INFO] [stderr] 194 | | "using 0 as *{const, mut} T" [INFO] [stderr] 195 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc.rs:197:1 [INFO] [stderr] | [INFO] [stderr] 197 | / /// **What it does:** Checks for (in-)equality comparisons on floating-point [INFO] [stderr] 198 | | /// value and constant, except in functions called `*eq*` (which probably [INFO] [stderr] 199 | | /// implement equality for a type involving floats). [INFO] [stderr] 200 | | /// [INFO] [stderr] ... | [INFO] [stderr] 211 | | /// x == ONE // where both are floats [INFO] [stderr] 212 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 213 | / declare_clippy_lint! { [INFO] [stderr] 214 | | pub FLOAT_CMP_CONST, [INFO] [stderr] 215 | | restriction, [INFO] [stderr] 216 | | "using `==` or `!=` on float constants instead of comparing difference with an epsilon" [INFO] [stderr] 217 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc_early.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for structure field patterns bound to wildcards. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** Using `..` instead is shorter and leaves the focus on [INFO] [stderr] 12 | | /// the fields that are actually bound. [INFO] [stderr] ... | [INFO] [stderr] 18 | | /// let { a: _, b: ref b, c: _ } = .. [INFO] [stderr] 19 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 20 | / declare_clippy_lint! { [INFO] [stderr] 21 | | pub UNNEEDED_FIELD_PATTERN, [INFO] [stderr] 22 | | style, [INFO] [stderr] 23 | | "struct fields bound to a wildcard instead of using `..`" [INFO] [stderr] 24 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc_early.rs:26:1 [INFO] [stderr] | [INFO] [stderr] 26 | / /// **What it does:** Checks for function arguments having the similar names [INFO] [stderr] 27 | | /// differing by an underscore. [INFO] [stderr] 28 | | /// [INFO] [stderr] 29 | | /// **Why is this bad?** It affects code readability. [INFO] [stderr] ... | [INFO] [stderr] 35 | | /// fn foo(a: i32, _a: i32) {} [INFO] [stderr] 36 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 37 | / declare_clippy_lint! { [INFO] [stderr] 38 | | pub DUPLICATE_UNDERSCORE_ARGUMENT, [INFO] [stderr] 39 | | style, [INFO] [stderr] 40 | | "function arguments having names which only differ by an underscore" [INFO] [stderr] 41 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc_early.rs:43:1 [INFO] [stderr] | [INFO] [stderr] 43 | / /// **What it does:** Detects closures called in the same expression where they [INFO] [stderr] 44 | | /// are defined. [INFO] [stderr] 45 | | /// [INFO] [stderr] 46 | | /// **Why is this bad?** It is unnecessarily adding to the expression's [INFO] [stderr] ... | [INFO] [stderr] 53 | | /// (|| 42)() [INFO] [stderr] 54 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 55 | / declare_clippy_lint! { [INFO] [stderr] 56 | | pub REDUNDANT_CLOSURE_CALL, [INFO] [stderr] 57 | | complexity, [INFO] [stderr] 58 | | "throwaway closures called in the expression they are defined" [INFO] [stderr] 59 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc_early.rs:61:1 [INFO] [stderr] | [INFO] [stderr] 61 | / /// **What it does:** Detects expressions of the form `--x`. [INFO] [stderr] 62 | | /// [INFO] [stderr] 63 | | /// **Why is this bad?** It can mislead C/C++ programmers to think `x` was [INFO] [stderr] 64 | | /// decremented. [INFO] [stderr] ... | [INFO] [stderr] 70 | | /// --x; [INFO] [stderr] 71 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 72 | / declare_clippy_lint! { [INFO] [stderr] 73 | | pub DOUBLE_NEG, [INFO] [stderr] 74 | | style, [INFO] [stderr] 75 | | "`--x`, which is a double negation of `x` and not a pre-decrement as in C/C++" [INFO] [stderr] 76 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc_early.rs:78:1 [INFO] [stderr] | [INFO] [stderr] 78 | / /// **What it does:** Warns on hexadecimal literals with mixed-case letter [INFO] [stderr] 79 | | /// digits. [INFO] [stderr] 80 | | /// [INFO] [stderr] 81 | | /// **Why is this bad?** It looks confusing. [INFO] [stderr] ... | [INFO] [stderr] 87 | | /// let y = 0x1a9BAcD; [INFO] [stderr] 88 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 89 | / declare_clippy_lint! { [INFO] [stderr] 90 | | pub MIXED_CASE_HEX_LITERALS, [INFO] [stderr] 91 | | style, [INFO] [stderr] 92 | | "hex literals whose letter digits are not consistently upper- or lowercased" [INFO] [stderr] 93 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc_early.rs:95:1 [INFO] [stderr] | [INFO] [stderr] 95 | / /// **What it does:** Warns if literal suffixes are not separated by an [INFO] [stderr] 96 | | /// underscore. [INFO] [stderr] 97 | | /// [INFO] [stderr] 98 | | /// **Why is this bad?** It is much less readable. [INFO] [stderr] ... | [INFO] [stderr] 104 | | /// let y = 123832i32; [INFO] [stderr] 105 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 106 | / declare_clippy_lint! { [INFO] [stderr] 107 | | pub UNSEPARATED_LITERAL_SUFFIX, [INFO] [stderr] 108 | | pedantic, [INFO] [stderr] 109 | | "literals whose suffix is not separated by an underscore" [INFO] [stderr] 110 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc_early.rs:112:1 [INFO] [stderr] | [INFO] [stderr] 112 | / /// **What it does:** Warns if an integral constant literal starts with `0`. [INFO] [stderr] 113 | | /// [INFO] [stderr] 114 | | /// **Why is this bad?** In some languages (including the infamous C language [INFO] [stderr] 115 | | /// and most of its [INFO] [stderr] ... | [INFO] [stderr] 142 | | /// [INFO] [stderr] 143 | | /// prints `83` (as `83 == 0o123` while `123 == 0o173`). [INFO] [stderr] | |________________________________________________________^ [INFO] [stderr] 144 | / declare_clippy_lint! { [INFO] [stderr] 145 | | pub ZERO_PREFIXED_LITERAL, [INFO] [stderr] 146 | | complexity, [INFO] [stderr] 147 | | "integer literals starting with `0`" [INFO] [stderr] 148 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/misc_early.rs:150:1 [INFO] [stderr] | [INFO] [stderr] 150 | / /// **What it does:** Warns if a generic shadows a built-in type. [INFO] [stderr] 151 | | /// [INFO] [stderr] 152 | | /// **Why is this bad?** This gives surprising type errors. [INFO] [stderr] 153 | | /// [INFO] [stderr] ... | [INFO] [stderr] 163 | | /// } [INFO] [stderr] 164 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 165 | / declare_clippy_lint! { [INFO] [stderr] 166 | | pub BUILTIN_TYPE_SHADOW, [INFO] [stderr] 167 | | style, [INFO] [stderr] 168 | | "shadowing a builtin type" [INFO] [stderr] 169 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/missing_doc.rs:29:1 [INFO] [stderr] | [INFO] [stderr] 29 | / /// **What it does:** Warns if there is missing doc for any documentable item [INFO] [stderr] 30 | | /// (public or private). [INFO] [stderr] 31 | | /// [INFO] [stderr] 32 | | /// **Why is this bad?** Doc is good. *rustc* has a `MISSING_DOCS` [INFO] [stderr] ... | [INFO] [stderr] 36 | | /// [INFO] [stderr] 37 | | /// **Known problems:** None. [INFO] [stderr] | |_____________________________^ [INFO] [stderr] 38 | / declare_clippy_lint! { [INFO] [stderr] 39 | | pub MISSING_DOCS_IN_PRIVATE_ITEMS, [INFO] [stderr] 40 | | restriction, [INFO] [stderr] 41 | | "detects missing documentation for public and private members" [INFO] [stderr] 42 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/missing_inline.rs:17:1 [INFO] [stderr] | [INFO] [stderr] 17 | / /// **What it does:** it lints if an exported function, method, trait method with default impl, [INFO] [stderr] 18 | | /// or trait method impl is not `#[inline]`. [INFO] [stderr] 19 | | /// [INFO] [stderr] 20 | | /// **Why is this bad?** In general, it is not. Functions can be inlined across [INFO] [stderr] ... | [INFO] [stderr] 60 | | /// } [INFO] [stderr] 61 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 62 | / declare_clippy_lint! { [INFO] [stderr] 63 | | pub MISSING_INLINE_IN_PUBLIC_ITEMS, [INFO] [stderr] 64 | | restriction, [INFO] [stderr] 65 | | "detects missing #[inline] attribute for public callables (functions, trait methods, methods...)" [INFO] [stderr] 66 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/multiple_crate_versions.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks to see if multiple versions of a crate are being [INFO] [stderr] 10 | | /// used. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** This bloats the size of targets, and can lead to [INFO] [stderr] ... | [INFO] [stderr] 24 | | /// ansi_term = "0.11.0" [INFO] [stderr] 25 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 26 | / declare_clippy_lint! { [INFO] [stderr] 27 | | pub MULTIPLE_CRATE_VERSIONS, [INFO] [stderr] 28 | | cargo, [INFO] [stderr] 29 | | "multiple versions of the same crate being used" [INFO] [stderr] 30 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/mut_mut.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for instances of `mut mut` references. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** Multiple `mut`s don't add anything meaningful to the [INFO] [stderr] 10 | | /// source. This is either a copy'n'paste error, or it shows a fundamental [INFO] [stderr] ... | [INFO] [stderr] 17 | | /// let x = &mut &mut y; [INFO] [stderr] 18 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 19 | / declare_clippy_lint! { [INFO] [stderr] 20 | | pub MUT_MUT, [INFO] [stderr] 21 | | pedantic, [INFO] [stderr] 22 | | "usage of double-mut refs, e.g. `&mut &mut ...`" [INFO] [stderr] 23 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/mut_reference.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Detects giving a mutable reference to a function that only [INFO] [stderr] 8 | | /// requires an immutable reference. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** The immutable reference rules out all other references [INFO] [stderr] ... | [INFO] [stderr] 17 | | /// my_vec.push(&mut value) [INFO] [stderr] 18 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 19 | / declare_clippy_lint! { [INFO] [stderr] 20 | | pub UNNECESSARY_MUT_PASSED, [INFO] [stderr] 21 | | style, [INFO] [stderr] 22 | | "an argument passed as a mutable reference although the callee only demands an \ [INFO] [stderr] 23 | | immutable reference" [INFO] [stderr] 24 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/mutex_atomic.rs:11:1 [INFO] [stderr] | [INFO] [stderr] 11 | / /// **What it does:** Checks for usages of `Mutex` where an atomic will do. [INFO] [stderr] 12 | | /// [INFO] [stderr] 13 | | /// **Why is this bad?** Using a mutex just to make access to a plain bool or [INFO] [stderr] 14 | | /// reference sequential is shooting flies with cannons. [INFO] [stderr] ... | [INFO] [stderr] 23 | | /// let x = Mutex::new(&y); [INFO] [stderr] 24 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 25 | / declare_clippy_lint! { [INFO] [stderr] 26 | | pub MUTEX_ATOMIC, [INFO] [stderr] 27 | | perf, [INFO] [stderr] 28 | | "using a mutex where an atomic value could be used instead" [INFO] [stderr] 29 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/mutex_atomic.rs:31:1 [INFO] [stderr] | [INFO] [stderr] 31 | / /// **What it does:** Checks for usages of `Mutex` where `X` is an integral [INFO] [stderr] 32 | | /// type. [INFO] [stderr] 33 | | /// [INFO] [stderr] 34 | | /// **Why is this bad?** Using a mutex just to make access to a plain integer [INFO] [stderr] ... | [INFO] [stderr] 43 | | /// let x = Mutex::new(0usize); [INFO] [stderr] 44 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 45 | / declare_clippy_lint! { [INFO] [stderr] 46 | | pub MUTEX_INTEGER, [INFO] [stderr] 47 | | nursery, [INFO] [stderr] 48 | | "using a mutex for an integer type" [INFO] [stderr] 49 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/needless_bool.rs:12:1 [INFO] [stderr] | [INFO] [stderr] 12 | / /// **What it does:** Checks for expressions of the form `if c { true } else { [INFO] [stderr] 13 | | /// false }` [INFO] [stderr] 14 | | /// (or vice versa) and suggest using the condition directly. [INFO] [stderr] 15 | | /// [INFO] [stderr] ... | [INFO] [stderr] 25 | | /// if x { false } else { true } [INFO] [stderr] 26 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 27 | / declare_clippy_lint! { [INFO] [stderr] 28 | | pub NEEDLESS_BOOL, [INFO] [stderr] 29 | | complexity, [INFO] [stderr] 30 | | "if-statements with plain booleans in the then- and else-clause, e.g. \ [INFO] [stderr] 31 | | `if p { true } else { false }`" [INFO] [stderr] 32 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/needless_bool.rs:34:1 [INFO] [stderr] | [INFO] [stderr] 34 | / /// **What it does:** Checks for expressions of the form `x == true` (or vice [INFO] [stderr] 35 | | /// versa) and suggest using the variable directly. [INFO] [stderr] 36 | | /// [INFO] [stderr] 37 | | /// **Why is this bad?** Unnecessary code. [INFO] [stderr] ... | [INFO] [stderr] 43 | | /// if x == true { } // could be `if x { }` [INFO] [stderr] 44 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 45 | / declare_clippy_lint! { [INFO] [stderr] 46 | | pub BOOL_COMPARISON, [INFO] [stderr] 47 | | complexity, [INFO] [stderr] 48 | | "comparing a variable to a boolean, e.g. `if x == true`" [INFO] [stderr] 49 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/needless_borrow.rs:11:1 [INFO] [stderr] | [INFO] [stderr] 11 | / /// **What it does:** Checks for address of operations (`&`) that are going to [INFO] [stderr] 12 | | /// be dereferenced immediately by the compiler. [INFO] [stderr] 13 | | /// [INFO] [stderr] 14 | | /// **Why is this bad?** Suggests that the receiver of the expression borrows [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// let x: &i32 = &&&&&&5; [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub NEEDLESS_BORROW, [INFO] [stderr] 25 | | nursery, [INFO] [stderr] 26 | | "taking a reference that is going to be automatically dereferenced" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/needless_borrowed_ref.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for useless borrowed references. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** It is mostly useless and make the code look more [INFO] [stderr] 12 | | /// complex than it [INFO] [stderr] ... | [INFO] [stderr] 43 | | /// de-referenced. [INFO] [stderr] 44 | | /// As such, it could just be |a| a.is_empty() [INFO] [stderr] | |______________________________________________^ [INFO] [stderr] 45 | / declare_clippy_lint! { [INFO] [stderr] 46 | | pub NEEDLESS_BORROWED_REFERENCE, [INFO] [stderr] 47 | | complexity, [INFO] [stderr] 48 | | "taking a needless borrowed reference" [INFO] [stderr] 49 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/needless_continue.rs:37:1 [INFO] [stderr] | [INFO] [stderr] 37 | / /// **What it does:** The lint checks for `if`-statements appearing in loops [INFO] [stderr] 38 | | /// that contain a `continue` statement in either their main blocks or their [INFO] [stderr] 39 | | /// `else`-blocks, when omitting the `else`-block possibly with some [INFO] [stderr] 40 | | /// rearrangement of code can make the code easier to understand. [INFO] [stderr] ... | [INFO] [stderr] 94 | | /// } [INFO] [stderr] 95 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 96 | / declare_clippy_lint! { [INFO] [stderr] 97 | | pub NEEDLESS_CONTINUE, [INFO] [stderr] 98 | | pedantic, [INFO] [stderr] 99 | | "`continue` statements that can be replaced by a rearrangement of code" [INFO] [stderr] 100 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/needless_pass_by_value.rs:19:1 [INFO] [stderr] | [INFO] [stderr] 19 | / /// **What it does:** Checks for functions taking arguments by value, but not [INFO] [stderr] 20 | | /// consuming them in its [INFO] [stderr] 21 | | /// body. [INFO] [stderr] 22 | | /// [INFO] [stderr] ... | [INFO] [stderr] 40 | | /// } [INFO] [stderr] 41 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 42 | / declare_clippy_lint! { [INFO] [stderr] 43 | | pub NEEDLESS_PASS_BY_VALUE, [INFO] [stderr] 44 | | style, [INFO] [stderr] 45 | | "functions taking arguments by value, but not consuming them in its body" [INFO] [stderr] 46 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/needless_update.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for needlessly including a base struct on update [INFO] [stderr] 7 | | /// when all fields are changed anyway. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** This will cost resources (because the base has to be [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// Point { x: 1, y: 0, ..zero_point } [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub NEEDLESS_UPDATE, [INFO] [stderr] 20 | | complexity, [INFO] [stderr] 21 | | "using `Foo { ..base }` when there are no missing fields" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/neg_cmp_op_on_partial_ord.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** [INFO] [stderr] 7 | | /// Checks for the usage of negated comparision operators on types which only implement [INFO] [stderr] 8 | | /// `PartialOrd` (e.g. `f64`). [INFO] [stderr] 9 | | /// [INFO] [stderr] ... | [INFO] [stderr] 35 | | /// }; [INFO] [stderr] 36 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 37 | / declare_clippy_lint! { [INFO] [stderr] 38 | | pub NEG_CMP_OP_ON_PARTIAL_ORD, [INFO] [stderr] 39 | | complexity, [INFO] [stderr] 40 | | "The use of negated comparision operators on partially orded types may produce confusing code." [INFO] [stderr] 41 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/neg_multiply.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for multiplication by -1 as a form of negation. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** It's more readable to just negate. [INFO] [stderr] 11 | | /// [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// x * -1 [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub NEG_MULTIPLY, [INFO] [stderr] 20 | | style, [INFO] [stderr] 21 | | "multiplying integers with -1" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/new_without_default.rs:10:1 [INFO] [stderr] | [INFO] [stderr] 10 | / /// **What it does:** Checks for types with a `fn new() -> Self` method and no [INFO] [stderr] 11 | | /// implementation of [INFO] [stderr] 12 | | /// [`Default`](https://doc.rust-lang.org/std/default/trait.Default.html). [INFO] [stderr] 13 | | /// [INFO] [stderr] ... | [INFO] [stderr] 43 | | /// [INFO] [stderr] 44 | | /// You can also have `new()` call `Default::default()`. [INFO] [stderr] | |________________________________________________________^ [INFO] [stderr] 45 | / declare_clippy_lint! { [INFO] [stderr] 46 | | pub NEW_WITHOUT_DEFAULT, [INFO] [stderr] 47 | | style, [INFO] [stderr] 48 | | "`fn new() -> Self` method without `Default` implementation" [INFO] [stderr] 49 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/new_without_default.rs:51:1 [INFO] [stderr] | [INFO] [stderr] 51 | / /// **What it does:** Checks for types with a `fn new() -> Self` method [INFO] [stderr] 52 | | /// and no implementation of [INFO] [stderr] 53 | | /// [`Default`](https://doc.rust-lang.org/std/default/trait.Default.html), [INFO] [stderr] 54 | | /// where the `Default` can be derived by `#[derive(Default)]`. [INFO] [stderr] ... | [INFO] [stderr] 73 | | /// [INFO] [stderr] 74 | | /// Just prepend `#[derive(Default)]` before the `struct` definition. [INFO] [stderr] | |_____________________________________________________________________^ [INFO] [stderr] 75 | / declare_clippy_lint! { [INFO] [stderr] 76 | | pub NEW_WITHOUT_DEFAULT_DERIVE, [INFO] [stderr] 77 | | style, [INFO] [stderr] 78 | | "`fn new() -> Self` without `#[derive]`able `Default` implementation" [INFO] [stderr] 79 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/no_effect.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for statements which have no effect. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** Similar to dead code, these statements are actually [INFO] [stderr] 10 | | /// executed. However, as they have no effect, all they do is make the code less [INFO] [stderr] ... | [INFO] [stderr] 17 | | /// 0; [INFO] [stderr] 18 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 19 | / declare_clippy_lint! { [INFO] [stderr] 20 | | pub NO_EFFECT, [INFO] [stderr] 21 | | complexity, [INFO] [stderr] 22 | | "statements with no effect" [INFO] [stderr] 23 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/no_effect.rs:25:1 [INFO] [stderr] | [INFO] [stderr] 25 | / /// **What it does:** Checks for expression statements that can be reduced to a [INFO] [stderr] 26 | | /// sub-expression. [INFO] [stderr] 27 | | /// [INFO] [stderr] 28 | | /// **Why is this bad?** Expressions by themselves often have no side-effects. [INFO] [stderr] ... | [INFO] [stderr] 35 | | /// compute_array()[0]; [INFO] [stderr] 36 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 37 | / declare_clippy_lint! { [INFO] [stderr] 38 | | pub UNNECESSARY_OPERATION, [INFO] [stderr] 39 | | complexity, [INFO] [stderr] 40 | | "outer expressions with no effect" [INFO] [stderr] 41 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/non_copy_const.rs:16:1 [INFO] [stderr] | [INFO] [stderr] 16 | / /// **What it does:** Checks for declaration of `const` items which is interior [INFO] [stderr] 17 | | /// mutable (e.g. contains a `Cell`, `Mutex`, `AtomicXxxx` etc). [INFO] [stderr] 18 | | /// [INFO] [stderr] 19 | | /// **Why is this bad?** Consts are copied everywhere they are referenced, i.e. [INFO] [stderr] ... | [INFO] [stderr] 44 | | /// assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance [INFO] [stderr] 45 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 46 | / declare_clippy_lint! { [INFO] [stderr] 47 | | pub DECLARE_INTERIOR_MUTABLE_CONST, [INFO] [stderr] 48 | | correctness, [INFO] [stderr] 49 | | "declaring const with interior mutability" [INFO] [stderr] 50 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/non_copy_const.rs:52:1 [INFO] [stderr] | [INFO] [stderr] 52 | / /// **What it does:** Checks if `const` items which is interior mutable (e.g. [INFO] [stderr] 53 | | /// contains a `Cell`, `Mutex`, `AtomicXxxx` etc) has been borrowed directly. [INFO] [stderr] 54 | | /// [INFO] [stderr] 55 | | /// **Why is this bad?** Consts are copied everywhere they are referenced, i.e. [INFO] [stderr] ... | [INFO] [stderr] 76 | | /// assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance [INFO] [stderr] 77 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 78 | / declare_clippy_lint! { [INFO] [stderr] 79 | | pub BORROW_INTERIOR_MUTABLE_CONST, [INFO] [stderr] 80 | | correctness, [INFO] [stderr] 81 | | "referencing const with interior mutability" [INFO] [stderr] 82 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/non_expressive_names.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for names that are very similar and thus confusing. [INFO] [stderr] 10 | | /// [INFO] [stderr] 11 | | /// **Why is this bad?** It's hard to distinguish between names that differ only [INFO] [stderr] 12 | | /// by a single character. [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// let checked_expr = something_else; [INFO] [stderr] 20 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub SIMILAR_NAMES, [INFO] [stderr] 23 | | pedantic, [INFO] [stderr] 24 | | "similarly named items and bindings" [INFO] [stderr] 25 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/non_expressive_names.rs:27:1 [INFO] [stderr] | [INFO] [stderr] 27 | / /// **What it does:** Checks for too many variables whose name consists of a [INFO] [stderr] 28 | | /// single character. [INFO] [stderr] 29 | | /// [INFO] [stderr] 30 | | /// **Why is this bad?** It's hard to memorize what a variable means without a [INFO] [stderr] ... | [INFO] [stderr] 37 | | /// let (a, b, c, d, e, f, g) = (...); [INFO] [stderr] 38 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 39 | / declare_clippy_lint! { [INFO] [stderr] 40 | | pub MANY_SINGLE_CHAR_NAMES, [INFO] [stderr] 41 | | style, [INFO] [stderr] 42 | | "too many single character bindings" [INFO] [stderr] 43 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/non_expressive_names.rs:45:1 [INFO] [stderr] | [INFO] [stderr] 45 | / /// **What it does:** Checks if you have variables whose name consists of just [INFO] [stderr] 46 | | /// underscores and digits. [INFO] [stderr] 47 | | /// [INFO] [stderr] 48 | | /// **Why is this bad?** It's hard to memorize what a variable means without a [INFO] [stderr] ... | [INFO] [stderr] 57 | | /// let __1___2 = 11; [INFO] [stderr] 58 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 59 | / declare_clippy_lint! { [INFO] [stderr] 60 | | pub JUST_UNDERSCORES_AND_DIGITS, [INFO] [stderr] 61 | | style, [INFO] [stderr] 62 | | "unclear name" [INFO] [stderr] 63 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/ok_if_let.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:*** Checks for unnecessary `ok()` in if let. [INFO] [stderr] 6 | | /// [INFO] [stderr] 7 | | /// **Why is this bad?** Calling `ok()` in if let is unnecessary, instead match [INFO] [stderr] 8 | | /// on `Ok(pat)` [INFO] [stderr] ... | [INFO] [stderr] 27 | | /// } [INFO] [stderr] 28 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 29 | / declare_clippy_lint! { [INFO] [stderr] 30 | | pub IF_LET_SOME_RESULT, [INFO] [stderr] 31 | | style, [INFO] [stderr] 32 | | "usage of `ok()` in `if let Some(pat)` statements is unnecessary, match on `Ok(pat)` instead" [INFO] [stderr] 33 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/open_options.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for duplicate open options as well as combinations [INFO] [stderr] 8 | | /// that make no sense. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** In the best case, the code will be harder to read than [INFO] [stderr] ... | [INFO] [stderr] 17 | | /// OpenOptions::new().read(true).truncate(true) [INFO] [stderr] 18 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 19 | / declare_clippy_lint! { [INFO] [stderr] 20 | | pub NONSENSICAL_OPEN_OPTIONS, [INFO] [stderr] 21 | | correctness, [INFO] [stderr] 22 | | "nonsensical combination of options for opening a file" [INFO] [stderr] 23 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/overflow_check_conditional.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Detects classic underflow/overflow checks. [INFO] [stderr] 6 | | /// [INFO] [stderr] 7 | | /// **Why is this bad?** Most classic C underflow/overflow checks will fail in [INFO] [stderr] 8 | | /// Rust. Users can use functions like `overflowing_*` and `wrapping_*` instead. [INFO] [stderr] ... | [INFO] [stderr] 14 | | /// a + b < a [INFO] [stderr] 15 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 16 | / declare_clippy_lint! { [INFO] [stderr] 17 | | pub OVERFLOW_CHECK_CONDITIONAL, [INFO] [stderr] 18 | | complexity, [INFO] [stderr] 19 | | "overflow checks inspired by C which are likely to panic" [INFO] [stderr] 20 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/panic_unimplemented.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for missing parameters in `panic!`. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** Contrary to the `format!` family of macros, there are [INFO] [stderr] 11 | | /// two forms of `panic!`: if there are no parameters given, the first argument [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// panic!("This `panic!` is probably missing a parameter there: {}"); [INFO] [stderr] 20 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub PANIC_PARAMS, [INFO] [stderr] 23 | | style, [INFO] [stderr] 24 | | "missing parameters in `panic!` calls" [INFO] [stderr] 25 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/panic_unimplemented.rs:27:1 [INFO] [stderr] | [INFO] [stderr] 27 | / /// **What it does:** Checks for usage of `unimplemented!`. [INFO] [stderr] 28 | | /// [INFO] [stderr] 29 | | /// **Why is this bad?** This macro should not be present in production code [INFO] [stderr] 30 | | /// [INFO] [stderr] ... | [INFO] [stderr] 35 | | /// unimplemented!(); [INFO] [stderr] 36 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 37 | / declare_clippy_lint! { [INFO] [stderr] 38 | | pub UNIMPLEMENTED, [INFO] [stderr] 39 | | restriction, [INFO] [stderr] 40 | | "`unimplemented!` should not be present in production code" [INFO] [stderr] 41 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/partialeq_ne_impl.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for manual re-implementations of `PartialEq::ne`. [INFO] [stderr] 6 | | /// [INFO] [stderr] 7 | | /// **Why is this bad?** `PartialEq::ne` is required to always return the [INFO] [stderr] 8 | | /// negated result of `PartialEq::eq`, which is exactly what the default [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// } [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub PARTIALEQ_NE_IMPL, [INFO] [stderr] 25 | | complexity, [INFO] [stderr] 26 | | "re-implementing `PartialEq::ne`" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/precedence.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for operations where precedence may be unclear [INFO] [stderr] 7 | | /// and suggests to add parentheses. Currently it catches the following: [INFO] [stderr] 8 | | /// * mixed usage of arithmetic and bit shifting/combining operators without [INFO] [stderr] 9 | | /// parentheses [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// * `1 << 2 + 3` equals 32, while `(1 << 2) + 3` equals 7 [INFO] [stderr] 22 | | /// * `-1i32.abs()` equals -1, while `(-1i32).abs()` equals 1 [INFO] [stderr] | |_____________________________________________________________^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub PRECEDENCE, [INFO] [stderr] 25 | | complexity, [INFO] [stderr] 26 | | "operations where precedence may be unclear" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/ptr.rs:15:1 [INFO] [stderr] | [INFO] [stderr] 15 | / /// **What it does:** This lint checks for function arguments of type `&String` [INFO] [stderr] 16 | | /// or `&Vec` unless the references are mutable. It will also suggest you [INFO] [stderr] 17 | | /// replace `.clone()` calls with the appropriate `.to_owned()`/`to_string()` [INFO] [stderr] 18 | | /// calls. [INFO] [stderr] ... | [INFO] [stderr] 43 | | /// fn foo(&Vec) { .. } [INFO] [stderr] 44 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 45 | / declare_clippy_lint! { [INFO] [stderr] 46 | | pub PTR_ARG, [INFO] [stderr] 47 | | style, [INFO] [stderr] 48 | | "fn arguments of the type `&Vec<...>` or `&String`, suggesting to use `&[...]` or `&str` \ [INFO] [stderr] 49 | | instead, respectively" [INFO] [stderr] 50 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/ptr.rs:52:1 [INFO] [stderr] | [INFO] [stderr] 52 | / /// **What it does:** This lint checks for equality comparisons with `ptr::null` [INFO] [stderr] 53 | | /// [INFO] [stderr] 54 | | /// **Why is this bad?** It's easier and more readable to use the inherent [INFO] [stderr] 55 | | /// `.is_null()` [INFO] [stderr] ... | [INFO] [stderr] 62 | | /// if x == ptr::null { .. } [INFO] [stderr] 63 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 64 | / declare_clippy_lint! { [INFO] [stderr] 65 | | pub CMP_NULL, [INFO] [stderr] 66 | | style, [INFO] [stderr] 67 | | "comparing a pointer to a null pointer, suggesting to use `.is_null()` instead." [INFO] [stderr] 68 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/ptr.rs:70:1 [INFO] [stderr] | [INFO] [stderr] 70 | / /// **What it does:** This lint checks for functions that take immutable [INFO] [stderr] 71 | | /// references and return [INFO] [stderr] 72 | | /// mutable ones. [INFO] [stderr] 73 | | /// [INFO] [stderr] ... | [INFO] [stderr] 87 | | /// fn foo(&Foo) -> &mut Bar { .. } [INFO] [stderr] 88 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 89 | / declare_clippy_lint! { [INFO] [stderr] 90 | | pub MUT_FROM_REF, [INFO] [stderr] 91 | | correctness, [INFO] [stderr] 92 | | "fns that create mutable refs from immutable ref args" [INFO] [stderr] 93 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/question_mark.rs:10:1 [INFO] [stderr] | [INFO] [stderr] 10 | / /// **What it does:** Checks for expressions that could be replaced by the question mark operator [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** Question mark usage is more idiomatic [INFO] [stderr] 13 | | /// [INFO] [stderr] ... | [INFO] [stderr] 26 | | /// option?; [INFO] [stderr] 27 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 28 | / declare_clippy_lint!{ [INFO] [stderr] 29 | | pub QUESTION_MARK, [INFO] [stderr] 30 | | style, [INFO] [stderr] 31 | | "checks for expressions that could be replaced by the question mark operator" [INFO] [stderr] 32 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/ranges.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for calling `.step_by(0)` on iterators, [INFO] [stderr] 10 | | /// which never terminates. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** This very much looks like an oversight, since with [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// for x in (5..5).step_by(0) { .. } [INFO] [stderr] 20 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub ITERATOR_STEP_BY_ZERO, [INFO] [stderr] 23 | | correctness, [INFO] [stderr] 24 | | "using `Iterator::step_by(0)`, which produces an infinite iterator" [INFO] [stderr] 25 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/ranges.rs:27:1 [INFO] [stderr] | [INFO] [stderr] 27 | / /// **What it does:** Checks for zipping a collection with the range of [INFO] [stderr] 28 | | /// `0.._.len()`. [INFO] [stderr] 29 | | /// [INFO] [stderr] 30 | | /// **Why is this bad?** The code is better expressed with `.enumerate()`. [INFO] [stderr] ... | [INFO] [stderr] 36 | | /// x.iter().zip(0..x.len()) [INFO] [stderr] 37 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 38 | / declare_clippy_lint! { [INFO] [stderr] 39 | | pub RANGE_ZIP_WITH_LEN, [INFO] [stderr] 40 | | complexity, [INFO] [stderr] 41 | | "zipping iterator with a range when `enumerate()` would do" [INFO] [stderr] 42 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/ranges.rs:44:1 [INFO] [stderr] | [INFO] [stderr] 44 | / /// **What it does:** Checks for exclusive ranges where 1 is added to the [INFO] [stderr] 45 | | /// upper bound, e.g. `x..(y+1)`. [INFO] [stderr] 46 | | /// [INFO] [stderr] 47 | | /// **Why is this bad?** The code is more readable with an inclusive range [INFO] [stderr] ... | [INFO] [stderr] 54 | | /// for x..(y+1) { .. } [INFO] [stderr] 55 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 56 | / declare_clippy_lint! { [INFO] [stderr] 57 | | pub RANGE_PLUS_ONE, [INFO] [stderr] 58 | | nursery, [INFO] [stderr] 59 | | "`x..(y+1)` reads better as `x..=y`" [INFO] [stderr] 60 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/ranges.rs:62:1 [INFO] [stderr] | [INFO] [stderr] 62 | / /// **What it does:** Checks for inclusive ranges where 1 is subtracted from [INFO] [stderr] 63 | | /// the upper bound, e.g. `x..=(y-1)`. [INFO] [stderr] 64 | | /// [INFO] [stderr] 65 | | /// **Why is this bad?** The code is more readable with an exclusive range [INFO] [stderr] ... | [INFO] [stderr] 72 | | /// for x..=(y-1) { .. } [INFO] [stderr] 73 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 74 | / declare_clippy_lint! { [INFO] [stderr] 75 | | pub RANGE_MINUS_ONE, [INFO] [stderr] 76 | | style, [INFO] [stderr] 77 | | "`x..=(y-1)` reads better as `x..y`" [INFO] [stderr] 78 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/redundant_field_names.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for fields in struct literals where shorthands [INFO] [stderr] 6 | | /// could be used. [INFO] [stderr] 7 | | /// [INFO] [stderr] 8 | | /// **Why is this bad?** If the field and variable names are the same, [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// let foo = Foo{ bar: bar } [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub REDUNDANT_FIELD_NAMES, [INFO] [stderr] 25 | | style, [INFO] [stderr] 26 | | "checks for fields in struct literals where shorthands could be used" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/reference.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for usage of `*&` and `*&mut` in expressions. [INFO] [stderr] 6 | | /// [INFO] [stderr] 7 | | /// **Why is this bad?** Immediately dereferencing a reference is no-op and [INFO] [stderr] 8 | | /// makes the code less clear. [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// let c = *&d; [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub DEREF_ADDROF, [INFO] [stderr] 20 | | complexity, [INFO] [stderr] 21 | | "use of `*&` or `*&mut` in an expression" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/reference.rs:58:1 [INFO] [stderr] | [INFO] [stderr] 58 | / /// **What it does:** Checks for references in expressions that use [INFO] [stderr] 59 | | /// auto dereference. [INFO] [stderr] 60 | | /// [INFO] [stderr] 61 | | /// **Why is this bad?** The reference is a no-op and is automatically [INFO] [stderr] ... | [INFO] [stderr] 68 | | /// let x = (&point).x; [INFO] [stderr] 69 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 70 | / declare_clippy_lint! { [INFO] [stderr] 71 | | pub REF_IN_DEREF, [INFO] [stderr] 72 | | complexity, [INFO] [stderr] 73 | | "Use of reference in auto dereference expression." [INFO] [stderr] 74 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/regex.rs:10:1 [INFO] [stderr] | [INFO] [stderr] 10 | / /// **What it does:** Checks [regex](https://crates.io/crates/regex) creation [INFO] [stderr] 11 | | /// (with `Regex::new`,`RegexBuilder::new` or `RegexSet::new`) for correct [INFO] [stderr] 12 | | /// regex syntax. [INFO] [stderr] 13 | | /// [INFO] [stderr] ... | [INFO] [stderr] 20 | | /// Regex::new("|") [INFO] [stderr] 21 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 22 | / declare_clippy_lint! { [INFO] [stderr] 23 | | pub INVALID_REGEX, [INFO] [stderr] 24 | | correctness, [INFO] [stderr] 25 | | "invalid regular expressions" [INFO] [stderr] 26 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/regex.rs:28:1 [INFO] [stderr] | [INFO] [stderr] 28 | / /// **What it does:** Checks for trivial [regex](https://crates.io/crates/regex) [INFO] [stderr] 29 | | /// creation (with `Regex::new`, `RegexBuilder::new` or `RegexSet::new`). [INFO] [stderr] 30 | | /// [INFO] [stderr] 31 | | /// **Why is this bad?** Matching the regex can likely be replaced by `==` or [INFO] [stderr] ... | [INFO] [stderr] 39 | | /// Regex::new("^foobar") [INFO] [stderr] 40 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 41 | / declare_clippy_lint! { [INFO] [stderr] 42 | | pub TRIVIAL_REGEX, [INFO] [stderr] 43 | | style, [INFO] [stderr] 44 | | "trivial regular expressions" [INFO] [stderr] 45 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/regex.rs:47:1 [INFO] [stderr] | [INFO] [stderr] 47 | / /// **What it does:** Checks for usage of `regex!(_)` which (as of now) is [INFO] [stderr] 48 | | /// usually slower than `Regex::new(_)` unless called in a loop (which is a bad [INFO] [stderr] 49 | | /// idea anyway). [INFO] [stderr] 50 | | /// [INFO] [stderr] ... | [INFO] [stderr] 58 | | /// regex!("foo|bar") [INFO] [stderr] 59 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 60 | / declare_clippy_lint! { [INFO] [stderr] 61 | | pub REGEX_MACRO, [INFO] [stderr] 62 | | style, [INFO] [stderr] 63 | | "use of `regex!(_)` instead of `Regex::new(_)`" [INFO] [stderr] 64 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/replace_consts.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for usage of `ATOMIC_X_INIT`, `ONCE_INIT`, and [INFO] [stderr] 7 | | /// `uX/iX::MIN/MAX`. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** `const fn`s exist [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// static FOO: AtomicIsize = AtomicIsize::new(0); [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub REPLACE_CONSTS, [INFO] [stderr] 25 | | pedantic, [INFO] [stderr] 26 | | "Lint usages of standard library `const`s that could be replaced by `const fn`s" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/returns.rs:8:1 [INFO] [stderr] | [INFO] [stderr] 8 | / /// **What it does:** Checks for return statements at the end of a block. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** Removing the `return` and semicolon will make the code [INFO] [stderr] 11 | | /// more rusty. [INFO] [stderr] ... | [INFO] [stderr] 18 | | /// fn foo(x: usize) { return x; } [INFO] [stderr] 19 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 20 | / declare_clippy_lint! { [INFO] [stderr] 21 | | pub NEEDLESS_RETURN, [INFO] [stderr] 22 | | style, [INFO] [stderr] 23 | | "using a return statement like `return expr;` where an expression would suffice" [INFO] [stderr] 24 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/returns.rs:26:1 [INFO] [stderr] | [INFO] [stderr] 26 | / /// **What it does:** Checks for `let`-bindings, which are subsequently [INFO] [stderr] 27 | | /// returned. [INFO] [stderr] 28 | | /// [INFO] [stderr] 29 | | /// **Why is this bad?** It is just extraneous code. Remove it to make your code [INFO] [stderr] ... | [INFO] [stderr] 36 | | /// { let x = ..; x } [INFO] [stderr] 37 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 38 | / declare_clippy_lint! { [INFO] [stderr] 39 | | pub LET_AND_RETURN, [INFO] [stderr] 40 | | style, [INFO] [stderr] 41 | | "creating a let-binding and then immediately returning it like `let x = expr; x` at \ [INFO] [stderr] 42 | | the end of a block" [INFO] [stderr] 43 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/serde_api.rs:5:1 [INFO] [stderr] | [INFO] [stderr] 5 | / /// **What it does:** Checks for mis-uses of the serde API. [INFO] [stderr] 6 | | /// [INFO] [stderr] 7 | | /// **Why is this bad?** Serde is very finnicky about how its API should be [INFO] [stderr] 8 | | /// used, but the type system can't be used to enforce it (yet?). [INFO] [stderr] ... | [INFO] [stderr] 12 | | /// **Example:** Implementing `Visitor::visit_string` but not [INFO] [stderr] 13 | | /// `Visitor::visit_str`. [INFO] [stderr] | |_________________________^ [INFO] [stderr] 14 | / declare_clippy_lint! { [INFO] [stderr] 15 | | pub SERDE_API_MISUSE, [INFO] [stderr] 16 | | correctness, [INFO] [stderr] 17 | | "various things that will negatively affect your serde experience" [INFO] [stderr] 18 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/shadow.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for bindings that shadow other bindings already in [INFO] [stderr] 10 | | /// scope, while just changing reference level or mutability. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** Not much, in fact it's a very common pattern in Rust [INFO] [stderr] ... | [INFO] [stderr] 21 | | /// let x = &x; [INFO] [stderr] 22 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 23 | / declare_clippy_lint! { [INFO] [stderr] 24 | | pub SHADOW_SAME, [INFO] [stderr] 25 | | restriction, [INFO] [stderr] 26 | | "rebinding a name to itself, e.g. `let mut x = &mut x`" [INFO] [stderr] 27 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/shadow.rs:29:1 [INFO] [stderr] | [INFO] [stderr] 29 | / /// **What it does:** Checks for bindings that shadow other bindings already in [INFO] [stderr] 30 | | /// scope, while reusing the original value. [INFO] [stderr] 31 | | /// [INFO] [stderr] 32 | | /// **Why is this bad?** Not too much, in fact it's a common pattern in Rust [INFO] [stderr] ... | [INFO] [stderr] 42 | | /// let x = x + 1; [INFO] [stderr] 43 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 44 | / declare_clippy_lint! { [INFO] [stderr] 45 | | pub SHADOW_REUSE, [INFO] [stderr] 46 | | restriction, [INFO] [stderr] 47 | | "rebinding a name to an expression that re-uses the original value, e.g. \ [INFO] [stderr] 48 | | `let x = x + 1`" [INFO] [stderr] 49 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/shadow.rs:51:1 [INFO] [stderr] | [INFO] [stderr] 51 | / /// **What it does:** Checks for bindings that shadow other bindings already in [INFO] [stderr] 52 | | /// scope, either without a initialization or with one that does not even use [INFO] [stderr] 53 | | /// the original value. [INFO] [stderr] 54 | | /// [INFO] [stderr] ... | [INFO] [stderr] 65 | | /// let x = y; let x = z; // shadows the earlier binding [INFO] [stderr] 66 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 67 | / declare_clippy_lint! { [INFO] [stderr] 68 | | pub SHADOW_UNRELATED, [INFO] [stderr] 69 | | restriction, [INFO] [stderr] 70 | | "rebinding a name without even using the original value" [INFO] [stderr] 71 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/strings.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for string appends of the form `x = x + y` (without [INFO] [stderr] 8 | | /// `let`!). [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why is this bad?** It's not really bad, but some people think that the [INFO] [stderr] ... | [INFO] [stderr] 20 | | /// x = x + ", World"; [INFO] [stderr] 21 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 22 | / declare_clippy_lint! { [INFO] [stderr] 23 | | pub STRING_ADD_ASSIGN, [INFO] [stderr] 24 | | pedantic, [INFO] [stderr] 25 | | "using `x = x + ..` where x is a `String` instead of `push_str()`" [INFO] [stderr] 26 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/strings.rs:28:1 [INFO] [stderr] | [INFO] [stderr] 28 | / /// **What it does:** Checks for all instances of `x + _` where `x` is of type [INFO] [stderr] 29 | | /// `String`, but only if [`string_add_assign`](#string_add_assign) does *not* [INFO] [stderr] 30 | | /// match. [INFO] [stderr] 31 | | /// [INFO] [stderr] ... | [INFO] [stderr] 48 | | /// x + ", World" [INFO] [stderr] 49 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 50 | / declare_clippy_lint! { [INFO] [stderr] 51 | | pub STRING_ADD, [INFO] [stderr] 52 | | restriction, [INFO] [stderr] 53 | | "using `x + ..` where x is a `String` instead of `push_str()`" [INFO] [stderr] 54 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/strings.rs:56:1 [INFO] [stderr] | [INFO] [stderr] 56 | / /// **What it does:** Checks for the `as_bytes` method called on string literals [INFO] [stderr] 57 | | /// that contain only ASCII characters. [INFO] [stderr] 58 | | /// [INFO] [stderr] 59 | | /// **Why is this bad?** Byte string literals (e.g. `b"foo"`) can be used [INFO] [stderr] ... | [INFO] [stderr] 66 | | /// let bs = "a byte string".as_bytes(); [INFO] [stderr] 67 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 68 | / declare_clippy_lint! { [INFO] [stderr] 69 | | pub STRING_LIT_AS_BYTES, [INFO] [stderr] 70 | | style, [INFO] [stderr] 71 | | "calling `as_bytes` on a string literal instead of using a byte string literal" [INFO] [stderr] 72 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/suspicious_trait_impl.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Lints for suspicious operations in impls of arithmetic operators, e.g. [INFO] [stderr] 8 | | /// subtracting elements in an Add impl. [INFO] [stderr] 9 | | /// [INFO] [stderr] 10 | | /// **Why this is bad?** This is probably a typo or copy-and-paste error and not intended. [INFO] [stderr] ... | [INFO] [stderr] 22 | | /// } [INFO] [stderr] 23 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 24 | / declare_clippy_lint! { [INFO] [stderr] 25 | | pub SUSPICIOUS_ARITHMETIC_IMPL, [INFO] [stderr] 26 | | correctness, [INFO] [stderr] 27 | | "suspicious use of operators in impl of arithmetic trait" [INFO] [stderr] 28 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/suspicious_trait_impl.rs:30:1 [INFO] [stderr] | [INFO] [stderr] 30 | / /// **What it does:** Lints for suspicious operations in impls of OpAssign, e.g. [INFO] [stderr] 31 | | /// subtracting elements in an AddAssign impl. [INFO] [stderr] 32 | | /// [INFO] [stderr] 33 | | /// **Why this is bad?** This is probably a typo or copy-and-paste error and not intended. [INFO] [stderr] ... | [INFO] [stderr] 43 | | /// } [INFO] [stderr] 44 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 45 | / declare_clippy_lint! { [INFO] [stderr] 46 | | pub SUSPICIOUS_OP_ASSIGN_IMPL, [INFO] [stderr] 47 | | correctness, [INFO] [stderr] 48 | | "suspicious use of operators in impl of OpAssign trait" [INFO] [stderr] 49 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/swap.rs:7:1 [INFO] [stderr] | [INFO] [stderr] 7 | / /// **What it does:** Checks for manual swapping. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** The `std::mem::swap` function exposes the intent better [INFO] [stderr] 10 | | /// without deinitializing or copying either variable. [INFO] [stderr] ... | [INFO] [stderr] 18 | | /// a = t; [INFO] [stderr] 19 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 20 | / declare_clippy_lint! { [INFO] [stderr] 21 | | pub MANUAL_SWAP, [INFO] [stderr] 22 | | complexity, [INFO] [stderr] 23 | | "manual swap of two variables" [INFO] [stderr] 24 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/swap.rs:26:1 [INFO] [stderr] | [INFO] [stderr] 26 | / /// **What it does:** Checks for `foo = bar; bar = foo` sequences. [INFO] [stderr] 27 | | /// [INFO] [stderr] 28 | | /// **Why is this bad?** This looks like a failed attempt to swap. [INFO] [stderr] 29 | | /// [INFO] [stderr] ... | [INFO] [stderr] 35 | | /// b = a; [INFO] [stderr] 36 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 37 | / declare_clippy_lint! { [INFO] [stderr] 38 | | pub ALMOST_SWAPPED, [INFO] [stderr] 39 | | correctness, [INFO] [stderr] 40 | | "`foo = bar; bar = foo` sequence" [INFO] [stderr] 41 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/temporary_assignment.rs:6:1 [INFO] [stderr] | [INFO] [stderr] 6 | / /// **What it does:** Checks for construction of a structure or tuple just to [INFO] [stderr] 7 | | /// assign a value in it. [INFO] [stderr] 8 | | /// [INFO] [stderr] 9 | | /// **Why is this bad?** Readability. If the structure is only created to be [INFO] [stderr] ... | [INFO] [stderr] 16 | | /// (0, 0).0 = 1 [INFO] [stderr] 17 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 18 | / declare_clippy_lint! { [INFO] [stderr] 19 | | pub TEMPORARY_ASSIGNMENT, [INFO] [stderr] 20 | | complexity, [INFO] [stderr] 21 | | "assignments to temporaries" [INFO] [stderr] 22 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:9:1 [INFO] [stderr] | [INFO] [stderr] 9 | / /// **What it does:** Checks for transmutes that can't ever be correct on any [INFO] [stderr] 10 | | /// architecture. [INFO] [stderr] 11 | | /// [INFO] [stderr] 12 | | /// **Why is this bad?** It's basically guaranteed to be undefined behaviour. [INFO] [stderr] ... | [INFO] [stderr] 19 | | /// let ptr: *const T = core::intrinsics::transmute('x') [INFO] [stderr] 20 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 21 | / declare_clippy_lint! { [INFO] [stderr] 22 | | pub WRONG_TRANSMUTE, [INFO] [stderr] 23 | | correctness, [INFO] [stderr] 24 | | "transmutes that are confusing at best, undefined behaviour at worst and always useless" [INFO] [stderr] 25 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:27:1 [INFO] [stderr] | [INFO] [stderr] 27 | / /// **What it does:** Checks for transmutes to the original type of the object [INFO] [stderr] 28 | | /// and transmutes that could be a cast. [INFO] [stderr] 29 | | /// [INFO] [stderr] 30 | | /// **Why is this bad?** Readability. The code tricks people into thinking that [INFO] [stderr] ... | [INFO] [stderr] 37 | | /// core::intrinsics::transmute(t) // where the result type is the same as `t`'s [INFO] [stderr] 38 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 39 | / declare_clippy_lint! { [INFO] [stderr] 40 | | pub USELESS_TRANSMUTE, [INFO] [stderr] 41 | | complexity, [INFO] [stderr] 42 | | "transmutes that have the same to and from types or could be a cast/coercion" [INFO] [stderr] 43 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:45:1 [INFO] [stderr] | [INFO] [stderr] 45 | / /// **What it does:** Checks for transmutes between a type `T` and `*T`. [INFO] [stderr] 46 | | /// [INFO] [stderr] 47 | | /// **Why is this bad?** It's easy to mistakenly transmute between a type and a [INFO] [stderr] 48 | | /// pointer to that type. [INFO] [stderr] ... | [INFO] [stderr] 55 | | /// // `*t` or `&t`'s [INFO] [stderr] 56 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 57 | / declare_clippy_lint! { [INFO] [stderr] 58 | | pub CROSSPOINTER_TRANSMUTE, [INFO] [stderr] 59 | | complexity, [INFO] [stderr] 60 | | "transmutes that have to or from types that are a pointer to the other" [INFO] [stderr] 61 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:63:1 [INFO] [stderr] | [INFO] [stderr] 63 | / /// **What it does:** Checks for transmutes from a pointer to a reference. [INFO] [stderr] 64 | | /// [INFO] [stderr] 65 | | /// **Why is this bad?** This can always be rewritten with `&` and `*`. [INFO] [stderr] 66 | | /// [INFO] [stderr] ... | [INFO] [stderr] 73 | | /// let _: &T = &*p; [INFO] [stderr] 74 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 75 | / declare_clippy_lint! { [INFO] [stderr] 76 | | pub TRANSMUTE_PTR_TO_REF, [INFO] [stderr] 77 | | complexity, [INFO] [stderr] 78 | | "transmutes from a pointer to a reference type" [INFO] [stderr] 79 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:81:1 [INFO] [stderr] | [INFO] [stderr] 81 | / /// **What it does:** Checks for transmutes from an integer to a `char`. [INFO] [stderr] 82 | | /// [INFO] [stderr] 83 | | /// **Why is this bad?** Not every integer is a Unicode scalar value. [INFO] [stderr] 84 | | /// [INFO] [stderr] ... | [INFO] [stderr] 100 | | /// let _ = std::char::from_u32(x).unwrap(); [INFO] [stderr] 101 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 102 | / declare_clippy_lint! { [INFO] [stderr] 103 | | pub TRANSMUTE_INT_TO_CHAR, [INFO] [stderr] 104 | | complexity, [INFO] [stderr] 105 | | "transmutes from an integer to a `char`" [INFO] [stderr] 106 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:108:1 [INFO] [stderr] | [INFO] [stderr] 108 | / /// **What it does:** Checks for transmutes from a `&[u8]` to a `&str`. [INFO] [stderr] 109 | | /// [INFO] [stderr] 110 | | /// **Why is this bad?** Not every byte slice is a valid UTF-8 string. [INFO] [stderr] 111 | | /// [INFO] [stderr] ... | [INFO] [stderr] 127 | | /// let _ = std::str::from_utf8(b).unwrap(); [INFO] [stderr] 128 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 129 | / declare_clippy_lint! { [INFO] [stderr] 130 | | pub TRANSMUTE_BYTES_TO_STR, [INFO] [stderr] 131 | | complexity, [INFO] [stderr] 132 | | "transmutes from a `&[u8]` to a `&str`" [INFO] [stderr] 133 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:135:1 [INFO] [stderr] | [INFO] [stderr] 135 | / /// **What it does:** Checks for transmutes from an integer to a `bool`. [INFO] [stderr] 136 | | /// [INFO] [stderr] 137 | | /// **Why is this bad?** This might result in an invalid in-memory representation of a `bool`. [INFO] [stderr] 138 | | /// [INFO] [stderr] ... | [INFO] [stderr] 145 | | /// let _: bool = x != 0; [INFO] [stderr] 146 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 147 | / declare_clippy_lint! { [INFO] [stderr] 148 | | pub TRANSMUTE_INT_TO_BOOL, [INFO] [stderr] 149 | | complexity, [INFO] [stderr] 150 | | "transmutes from an integer to a `bool`" [INFO] [stderr] 151 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:153:1 [INFO] [stderr] | [INFO] [stderr] 153 | / /// **What it does:** Checks for transmutes from an integer to a float. [INFO] [stderr] 154 | | /// [INFO] [stderr] 155 | | /// **Why is this bad?** This might result in an invalid in-memory representation of a float. [INFO] [stderr] 156 | | /// [INFO] [stderr] ... | [INFO] [stderr] 163 | | /// let _: f32 = f32::from_bits(x); [INFO] [stderr] 164 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 165 | / declare_clippy_lint! { [INFO] [stderr] 166 | | pub TRANSMUTE_INT_TO_FLOAT, [INFO] [stderr] 167 | | complexity, [INFO] [stderr] 168 | | "transmutes from an integer to a float" [INFO] [stderr] 169 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/transmute.rs:171:1 [INFO] [stderr] | [INFO] [stderr] 171 | / /// **What it does:** Checks for transmutes from a pointer to a pointer, or [INFO] [stderr] 172 | | /// from a reference to a reference. [INFO] [stderr] 173 | | /// [INFO] [stderr] 174 | | /// **Why is this bad?** Transmutes are dangerous, and these can instead be [INFO] [stderr] ... | [INFO] [stderr] 190 | | /// let _ = unsafe{ &*(&1u32 as *const u32 as *const f32) }; [INFO] [stderr] 191 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 192 | / declare_clippy_lint! { [INFO] [stderr] 193 | | pub TRANSMUTE_PTR_TO_PTR, [INFO] [stderr] 194 | | complexity, [INFO] [stderr] 195 | | "transmutes from a pointer to a pointer / a reference to a reference" [INFO] [stderr] 196 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/trivially_copy_pass_by_ref.rs:15:1 [INFO] [stderr] | [INFO] [stderr] 15 | / /// **What it does:** Checks for functions taking arguments by reference, where [INFO] [stderr] 16 | | /// the argument type is `Copy` and small enough to be more efficient to always [INFO] [stderr] 17 | | /// pass by value. [INFO] [stderr] 18 | | /// [INFO] [stderr] ... | [INFO] [stderr] 39 | | /// } [INFO] [stderr] 40 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 41 | / declare_clippy_lint! { [INFO] [stderr] 42 | | pub TRIVIALLY_COPY_PASS_BY_REF, [INFO] [stderr] 43 | | perf, [INFO] [stderr] 44 | | "functions taking small copyable arguments by reference" [INFO] [stderr] 45 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:25:1 [INFO] [stderr] | [INFO] [stderr] 25 | / /// **What it does:** Checks for use of `Box>` anywhere in the code. [INFO] [stderr] 26 | | /// [INFO] [stderr] 27 | | /// **Why is this bad?** `Vec` already keeps its contents in a separate area on [INFO] [stderr] 28 | | /// the heap. So if you `Box` it, you just add another level of indirection [INFO] [stderr] ... | [INFO] [stderr] 45 | | /// } [INFO] [stderr] 46 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 47 | / declare_clippy_lint! { [INFO] [stderr] 48 | | pub BOX_VEC, [INFO] [stderr] 49 | | perf, [INFO] [stderr] 50 | | "usage of `Box>`, vector elements are already on the heap" [INFO] [stderr] 51 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:53:1 [INFO] [stderr] | [INFO] [stderr] 53 | / /// **What it does:** Checks for use of `Option>` in function signatures and type [INFO] [stderr] 54 | | /// definitions [INFO] [stderr] 55 | | /// [INFO] [stderr] 56 | | /// **Why is this bad?** `Option<_>` represents an optional value. `Option>` [INFO] [stderr] ... | [INFO] [stderr] 65 | | /// None [INFO] [stderr] 66 | | /// } [INFO] [stderr] | |_____^ [INFO] [stderr] 67 | / declare_clippy_lint! { [INFO] [stderr] 68 | | pub OPTION_OPTION, [INFO] [stderr] 69 | | complexity, [INFO] [stderr] 70 | | "usage of `Option>`" [INFO] [stderr] 71 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:73:1 [INFO] [stderr] | [INFO] [stderr] 73 | / /// **What it does:** Checks for usage of any `LinkedList`, suggesting to use a [INFO] [stderr] 74 | | /// `Vec` or a `VecDeque` (formerly called `RingBuf`). [INFO] [stderr] 75 | | /// [INFO] [stderr] 76 | | /// **Why is this bad?** Gankro says: [INFO] [stderr] ... | [INFO] [stderr] 100 | | /// let x = LinkedList::new(); [INFO] [stderr] 101 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 102 | / declare_clippy_lint! { [INFO] [stderr] 103 | | pub LINKEDLIST, [INFO] [stderr] 104 | | pedantic, [INFO] [stderr] 105 | | "usage of LinkedList, usually a vector is faster, or a more specialized data \ [INFO] [stderr] 106 | | structure like a VecDeque" [INFO] [stderr] 107 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:109:1 [INFO] [stderr] | [INFO] [stderr] 109 | / /// **What it does:** Checks for use of `&Box` anywhere in the code. [INFO] [stderr] 110 | | /// [INFO] [stderr] 111 | | /// **Why is this bad?** Any `&Box` can also be a `&T`, which is more [INFO] [stderr] 112 | | /// general. [INFO] [stderr] ... | [INFO] [stderr] 124 | | /// fn foo(bar: &T) { ... } [INFO] [stderr] 125 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 126 | / declare_clippy_lint! { [INFO] [stderr] 127 | | pub BORROWED_BOX, [INFO] [stderr] 128 | | complexity, [INFO] [stderr] 129 | | "a borrow of a boxed type" [INFO] [stderr] 130 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:362:1 [INFO] [stderr] | [INFO] [stderr] 362 | / /// **What it does:** Checks for binding a unit value. [INFO] [stderr] 363 | | /// [INFO] [stderr] 364 | | /// **Why is this bad?** A unit value cannot usefully be used anywhere. So [INFO] [stderr] 365 | | /// binding one is kind of pointless. [INFO] [stderr] ... | [INFO] [stderr] 371 | | /// let x = { 1; }; [INFO] [stderr] 372 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 373 | / declare_clippy_lint! { [INFO] [stderr] 374 | | pub LET_UNIT_VALUE, [INFO] [stderr] 375 | | style, [INFO] [stderr] 376 | | "creating a let binding to a value of unit type, which usually can't be used afterwards" [INFO] [stderr] 377 | | } [INFO] [stderr] | |_- rustdoc does not generate documentation for macro expansions [INFO] [stderr] | [INFO] [stderr] = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion [INFO] [stderr] [INFO] [stderr] warning: unused doc comment [INFO] [stderr] --> src/types.rs:413:1 [INFO] [stderr] | [INFO] [stderr] 413 | / /// **What it does:** Checks for comparisons to unit. [INFO] [stderr] 414 | | /// [INFO] [stderr] 415 | | /// **Why is this bad?** Unit is always equal to itself, and thus is just a [INFO] [stderr] 416 | | /// clumsily written constant. Mostly this happens when someone accidentally [INFO] [stderr] ... | [INFO] [stderr] 427 | | /// { foo(); bar(); baz(); } [INFO] [stderr] 428 | | /// ``` [INFO] [stderr] | |_______^ [INFO] [stderr] 429 | / declare_clippy_lint! { [INFO] [stderr] 430 | | pub UNIT_CMP, [INFO] [stderr] 431 | | correctness, [WARN] too many lines in the log, truncating it