• actix-httpbin 0.1.0/src/handlers/cookies.rs
    15
    		 
    /// Returns cookie data.
    16
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    17
    		 
    pub fn cookies(req: HttpRequest<State>) -> Result<Json<Value>> {
    45
    		 
    /// Set cookies based on the query string params.
    46
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    47
    		 
    pub fn cookies_set(req: HttpRequest<State>) -> Result<HttpResponse> {
    63
    		 
    /// Delete cookies based on the query string params.
    64
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    65
    		 
    pub fn cookies_delete(req: HttpRequest<State>) -> Result<HttpResponse> {
  • actix-httpbin 0.1.0/src/handlers/dynamic/delay.rs
    9
    		 
    /// Returns a delayed response (max of 10 seconds).
    10
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    11
    		 
    pub fn delay(info: Path<u64>) -> Box<Future<Item=HttpResponse, Error=error::InternalError<tokio_timer::Error>>> {
  • actix-httpbin 0.1.0/src/handlers/dynamic/mod.rs
    25
    		 
    /// Returns a generated `UUID4`.
    26
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    27
    		 
    pub fn uuid(_req: HttpRequest<State>) -> Json<UUID> {
    33
    		 
    /// Returns base64url-encoded string.
    34
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    35
    		 
    pub fn base64(info: Path<String>) -> Result<String> {
  • actix-httpbin 0.1.0/src/handlers/formats.rs
    47
    		 
    /// Returns an UTF-8 encoded HTML page.
    48
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    49
    		 
    pub fn encoding_utf8(req: HttpRequest<State>) -> HttpResponse {
    55
    		 
    /// Returns a simple XML document.
    56
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    57
    		 
    pub fn xml(req: HttpRequest<State>) -> HttpResponse {
    63
    		 
    /// Returns a simple HTML document.
    64
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    65
    		 
    pub fn html(req: HttpRequest<State>) -> HttpResponse {
    71
    		 
    /// Returns a simple JSON document.
    72
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    73
    		 
    pub fn json(_req: HttpRequest<State>) -> Json<Value> {
  • actori-http 1.0.1/src/ws/mask.rs
    52
    		 
    // a `ShortSlice` must be smaller than a u64.
    53
    		 
    #[allow(clippy::needless_pass_by_value)]
    54
    		 
    fn xor_short(buf: ShortSlice<'_>, mask: u64) {
  • adder-codec-rs 0.2.7/src/transcoder/source/video.rs
    319
    		 
        #[allow(clippy::needless_pass_by_value)]
    320
    		 
        pub(crate) fn integrate_matrix(
  • agb 0.13.0/src/display/tiled/vram_manager.rs
    276
    		 
        // This needs to take ownership of the dynamic tile because it will no longer be valid after this call
    277
    		 
        #[allow(clippy::needless_pass_by_value)]
    278
    		 
        pub fn remove_dynamic_tile(&mut self, dynamic_tile: DynamicTile<'_>) {
  • agb 0.13.0/src/interrupt.rs
    181
    		 
            inner_drop(unsafe { Pin::new_unchecked(self) });
    182
    		 
            #[allow(clippy::needless_pass_by_value)] // needed for safety reasons
    183
    		 
            fn inner_drop(this: Pin<&mut InterruptInner>) {
  • agb 0.13.0/src/sync/statics.rs
    229
    		 
        /// returns the old value.
    230
    		 
        #[allow(clippy::needless_pass_by_value)] // critical for safety
    231
    		 
        pub fn replace(&self, val: T) -> T {
  • agui_core 0.3.0/src/context/mod.rs
    75
    		 
        #[must_use]
    76
    		 
        #[allow(clippy::needless_pass_by_value)]
    77
    		 
        pub fn new(changed: Arc<Mutex<HashSet<ListenerId>>>) -> Self {
  • akinator-rs 0.1.8/src/enums.rs
    61
    		 
    /// used in [`FromStr`] and [`TryFrom`] implementations
    62
    		 
    #[allow(clippy::needless_pass_by_value)]
    63
    		 
    fn try_answer_from_string(ans: String) -> Result<Answer> {
    109
    		 
    /// used in [`FromStr`] and [`From`] implementations
    110
    		 
    #[allow(clippy::needless_pass_by_value)]
    111
    		 
    fn theme_from_string(theme: String) -> Theme {
    178
    		 
    /// used in [`FromStr`] and [`TryFrom`] implementations
    179
    		 
    #[allow(clippy::needless_pass_by_value)]
    180
    		 
    fn try_lang_from_string(lang: String) -> Result<Language> {
  • akinator-rs 0.1.8/src/lib.rs
    163
    		 
        #[must_use]
    164
    		 
        #[allow(clippy::needless_pass_by_value)]
    165
    		 
        fn handle_error_response(completion: String) -> Error {
    248
    		 
        #[must_use]
    249
    		 
        #[allow(clippy::needless_pass_by_value)]
    250
    		 
        fn parse_response(html: String) -> String {
  • amdguid 1.0.11/src/items/plot_image.rs
    69
    		 
        /// the legend.
    70
    		 
        #[allow(clippy::needless_pass_by_value)]
    71
    		 
        #[must_use]
  • amdguid 1.0.11/src/items/points.rs
    86
    		 
        /// the legend.
    87
    		 
        #[allow(clippy::needless_pass_by_value)]
    88
    		 
        #[must_use]
  • amdguid 1.0.11/src/items/polygons.rs
    79
    		 
        /// the legend.
    80
    		 
        #[allow(clippy::needless_pass_by_value)]
    81
    		 
        #[must_use]
  • amdguid 1.0.11/src/items/text.rs
    20
    		 
    impl Text {
    21
    		 
        #[allow(clippy::needless_pass_by_value)]
    22
    		 
        pub fn new(position: Value, text: impl ToString) -> Self {
    67
    		 
        /// the legend.
    68
    		 
        #[allow(clippy::needless_pass_by_value)]
    69
    		 
        #[must_use]
  • amdguid 1.0.11/src/items/v_line.rs
    117
    		 
        /// the legend.
    118
    		 
        #[allow(clippy::needless_pass_by_value)]
    119
    		 
        #[must_use]
  • ansirs 0.1.7/src/ansi/ansi.rs
    65
    		 
        /// Creates a new Ansi from the given foreground color.
    66
    		 
        #[allow(clippy::needless_pass_by_value)]
    67
    		 
        #[must_use]
    77
    		 
        /// Creates a new Ansi from the given background color.
    78
    		 
        #[allow(clippy::needless_pass_by_value)]
    79
    		 
        #[must_use]
    248
    		 
        /// Builder function to set the foreground color.
    249
    		 
        #[allow(clippy::needless_pass_by_value)]
    250
    		 
        #[must_use]
    265
    		 
        /// Builder function to set the background color.
    266
    		 
        #[allow(clippy::needless_pass_by_value)]
    267
    		 
        #[must_use]
  • aragog 0.17.0/src/query/comparison.rs
    358
    		 
        #[must_use]
    359
    		 
        #[allow(clippy::needless_pass_by_value)]
    360
    		 
        pub fn greater_than<T>(self, value: T) -> Comparison
    385
    		 
        #[must_use]
    386
    		 
        #[allow(clippy::needless_pass_by_value)]
    387
    		 
        pub fn greater_or_equal<T>(self, value: T) -> Comparison
    412
    		 
        #[must_use]
    413
    		 
        #[allow(clippy::needless_pass_by_value)]
    414
    		 
        pub fn lesser_than<T>(self, value: T) -> Comparison
    439
    		 
        #[must_use]
    440
    		 
        #[allow(clippy::needless_pass_by_value)]
    441
    		 
        pub fn lesser_or_equal<T>(self, value: T) -> Comparison
  • arc-swap 1.6.0/src/lib.rs
    236
    		 
    // reference is just annoying.
    237
    		 
    #[allow(clippy::needless_pass_by_value)]
    238
    		 
    fn ptr_eq<Base, A, B>(a: A, b: B) -> bool
  • arsert_failure 0.0.2/src/lib.rs
    20
    		 
    /// Panics with the given assertion information.
    21
    		 
    #[allow(clippy::needless_pass_by_value)] // necessary so we can use the trait in tests
    22
    		 
    pub fn panic_on_failed_assertion(expr: impl ExpressionInfo) {
  • asuran 0.1.6/src/repository/backend/multifile/manifest.rs
    281
    		 
        /// Adds an archive to the manifest
    282
    		 
        #[allow(clippy::needless_pass_by_value)]
    283
    		 
        fn write_archive(&mut self, archive: StoredArchive) -> Result<()> {
  • asyncgit 0.22.1/src/sync/commit_files.rs
    48
    		 
    /// get diff of two arbitrary commits
    49
    		 
    #[allow(clippy::needless_pass_by_value)]
    50
    		 
    pub fn get_compare_commits_diff(
  • automaat-server 0.1.0/src/handlers.rs
    38
    		 
    #[get("/graphql?<request>")]
    39
    		 
    #[allow(clippy::needless_pass_by_value)]
    40
    		 
    pub(super) fn query(
    48
    		 
    #[post("/graphql", data = "<request>")]
    49
    		 
    #[allow(clippy::needless_pass_by_value)]
    50
    		 
    pub(super) fn mutate(
  • av-scenechange 0.8.1/src/lib.rs
    159
    		 
    /// - If `opts.lookahead_distance` is 0.
    160
    		 
    #[allow(clippy::needless_pass_by_value)]
    161
    		 
    pub fn detect_scene_changes<R: Read, T: Pixel>(
  • babycat 0.0.14/src/frontends/python/batch.rs
    164
    		 
    #[allow(clippy::too_many_arguments)]
    165
    		 
    #[allow(clippy::needless_pass_by_value)]
    166
    		 
    pub fn waveforms_from_files(
    312
    		 
    #[allow(clippy::too_many_arguments)]
    313
    		 
    #[allow(clippy::needless_pass_by_value)]
    314
    		 
    pub fn waveforms_from_files_into_numpys(
    457
    		 
    #[allow(clippy::too_many_arguments)]
    458
    		 
    #[allow(clippy::needless_pass_by_value)]
    459
    		 
    pub fn waveforms_from_files_into_numpys_unwrapped(
  • babycat 0.0.14/src/frontends/python/waveform.rs
    228
    		 
        )")]
    229
    		 
        #[allow(clippy::needless_pass_by_value)]
    230
    		 
        pub fn from_numpy(frame_rate_hz: u32, arr: PyReadonlyArray2<f32>) -> PyResult<Self> {
  • beatrice 0.3.2/examples/events-sse.rs
    45
    		 
    #[allow(clippy::needless_pass_by_value)]
    46
    		 
    fn event_sender_thread(state: Arc<State>, permit: Permit) {
  • beatrice 0.3.2/src/http_error.rs
    38
    		 
        #[must_use]
    39
    		 
        #[allow(clippy::needless_pass_by_value)]
    40
    		 
        pub fn error_reading_file(e: std::io::Error) -> Self {
    44
    		 
        #[must_use]
    45
    		 
        #[allow(clippy::needless_pass_by_value)]
    46
    		 
        pub fn error_reading_response_body(e: std::io::Error) -> Self {
    50
    		 
        #[must_use]
    51
    		 
        #[allow(clippy::needless_pass_by_value)]
    52
    		 
        pub fn error_saving_file(e: std::io::Error) -> Self {
  • beatrice 0.3.2/src/lib.rs
    198
    		 
    #[allow(clippy::needless_pass_by_value)]
    199
    		 
    #[must_use]
  • beatrice 0.3.2/tests/test_util.rs
    178
    		 
        #[must_use]
    179
    		 
        #[allow(clippy::needless_pass_by_value)]
    180
    		 
        pub fn connect(e: std::io::Error) -> Self {
    183
    		 
        #[must_use]
    184
    		 
        #[allow(clippy::needless_pass_by_value)]
    185
    		 
        pub fn write(e: std::io::Error) -> Self {
    187
    		 
        }
    188
    		 
        #[allow(clippy::needless_pass_by_value)]
    189
    		 
        #[must_use]
  • bevy_adventure 0.4.0/src/animation.rs
    35
    		 
    #[allow(clippy::needless_pass_by_value)]
    36
    		 
    fn tween_transforms(time: Res<Time>, mut targets: Query<(&Tween<Transform>, &mut Transform)>) {
  • bevy_adventure 0.4.0/src/camera/next.rs
    31
    		 
    #[allow(clippy::needless_pass_by_value)]
    32
    		 
    #[allow(clippy::type_complexity)]
  • bevy_adventure 0.4.0/src/cursor.rs
    43
    		 
    #[allow(clippy::needless_pass_by_value)]
    44
    		 
    fn update_cursor(window: Res<Windows>, mut cursor: ResMut<Cursor>) {
  • bevy_adventure 0.4.0/src/interactives/hovering.rs
    22
    		 
    #[allow(clippy::needless_pass_by_value)]
    23
    		 
    #[allow(clippy::too_many_arguments)]
  • bevy_adventure 0.4.0/src/interactives/interact.rs
    88
    		 
    #[allow(clippy::needless_pass_by_value)]
    89
    		 
    #[allow(clippy::too_many_arguments)]
    161
    		 
    #[allow(clippy::too_many_arguments)]
    162
    		 
    #[allow(clippy::needless_pass_by_value)]
    163
    		 
    pub fn interactive<T: Interactive + Component>(
  • bevy_adventure 0.4.0/src/inventory.rs
    110
    		 
    #[allow(clippy::needless_pass_by_value)]
    111
    		 
    fn handle_combine(
  • bevy_adventure 0.4.0/src/scene.rs
    62
    		 
    #[allow(clippy::needless_pass_by_value)]
    63
    		 
    fn run_hooks(
    240
    		 
    #[allow(clippy::needless_pass_by_value)]
    241
    		 
    fn cleanup_scene(
  • bevy_adventure 0.4.0/src/state.rs
    50
    		 
        /// The value is converted to a string, so it must implement `ToString`.
    51
    		 
        #[allow(clippy::needless_pass_by_value)]
    52
    		 
        pub fn insert<T: ToString>(&mut self, key: &str, value: T) {
  • bevy_diagnostic_visualizer 0.1.0/src/lib.rs
    168
    		 
    #[allow(clippy::needless_pass_by_value)]
    169
    		 
    fn plot_diagnostics_system(
  • bevy_fundsp 0.2.0/src/dsp_manager.rs
    46
    		 
        /// Get the DSP source given a DSP graph.
    47
    		 
        #[allow(clippy::needless_pass_by_value)]
    48
    		 
        pub fn get_graph<D: DspGraph>(&self, dsp_graph: D) -> Option<&DspSource> {
  • bevy_life 0.6.0/src/systems/cells.rs
    41
    		 
    #[allow(clippy::needless_pass_by_value)]
    42
    		 
    pub fn handle_cells<C, S>(
    76
    		 
    #[allow(clippy::needless_pass_by_value)]
    77
    		 
    pub fn handle_new_cells<C>(query: Query<(Entity, &C), Added<C>>, mut map: ResMut<CellMap<C>>)
  • bevy_life 0.6.0/src/systems/coloring.rs
    4
    		 
    #[allow(clippy::needless_pass_by_value)]
    5
    		 
    pub fn color_sprites<S>(
  • bevy_oddio 0.3.0/src/output/spatial.rs
    123
    		 
    /// System to play queued spatial audio in [`Audio`].
    124
    		 
    #[allow(clippy::needless_pass_by_value, clippy::missing_panics_doc)]
    125
    		 
    pub fn play_queued_spatial_audio<Source>(
    157
    		 
    /// System to play queued spatial buffered audio in [`Audio`].
    158
    		 
    #[allow(clippy::needless_pass_by_value, clippy::missing_panics_doc)]
    159
    		 
    pub fn play_queued_spatial_buffered_audio<Source>(
  • bevy_oddio 0.3.0/src/output.rs
    97
    		 
    /// System to play queued audio in [`Audio`].
    98
    		 
    #[allow(clippy::needless_pass_by_value, clippy::missing_panics_doc)]
    99
    		 
    pub fn play_queued_audio<const N: usize, F, Source>(
  • bevy_verlet 0.5.0/src/systems/debug.rs
    27
    		 
    #[allow(clippy::needless_pass_by_value)]
    28
    		 
    pub fn debug_draw_sticks(
  • bevy_verlet 0.5.0/src/systems/points.rs
    18
    		 
    #[allow(clippy::needless_pass_by_value, clippy::cast_possible_truncation)]
    19
    		 
    pub fn update_points(
  • bevy_verlet 0.5.0/src/systems/sticks.rs
    1
    		 
    #![allow(clippy::needless_pass_by_value)]
    2
    		 
    use crate::components::{VerletLocked, VerletPoint, VerletStick};
    8
    		 
        clippy::type_complexity,
    9
    		 
        clippy::needless_pass_by_value,
    10
    		 
        clippy::similar_names
  • binrw 0.10.0/src/punctuated.rs
    77
    		 
        // Lint: Non-consumed argument is required to match the API.
    78
    		 
        #[allow(clippy::needless_pass_by_value)]
    79
    		 
        pub fn separated<R: Read + Seek>(
    105
    		 
        // Lint: Non-consumed argument is required to match the API.
    106
    		 
        #[allow(clippy::needless_pass_by_value)]
    107
    		 
        pub fn separated_trailing<R: Read + Seek>(
  • birli 0.8.0/src/flags.rs
    719
    		 
    /// Convert the given ndarray of boolean flags to an ndarray of float weights
    720
    		 
    #[allow(clippy::needless_pass_by_value)]
    721
    		 
    pub fn flag_to_weight_array<D>(flag_array: ArrayView<bool, D>, weight_factor: f64) -> Array<f32, D>
  • boa_engine 0.16.0/src/object/internal_methods/arguments.rs
    70
    		 
    /// [spec]: https://tc39.es/ecma262/#sec-arguments-exotic-objects-defineownproperty-p-desc
    71
    		 
    #[allow(clippy::needless_pass_by_value)]
    72
    		 
    pub(crate) fn arguments_exotic_define_own_property(
  • boa_engine 0.16.0/src/object/internal_methods/global.rs
    175
    		 
    #[inline]
    176
    		 
    #[allow(clippy::needless_pass_by_value)]
    177
    		 
    pub(crate) fn global_define_own_property(
    232
    		 
    #[inline]
    233
    		 
    #[allow(clippy::needless_pass_by_value)]
    234
    		 
    pub(crate) fn global_get(
    279
    		 
    #[inline]
    280
    		 
    #[allow(clippy::needless_pass_by_value)]
    281
    		 
    pub(crate) fn global_set(
  • bofh 0.0.8/src/lib.rs
    279
    		 
        /// Will normally never panic, unless the session identifier returned by the bofhd server is in an invalid format.
    280
    		 
        #[allow(clippy::needless_pass_by_value)]
    281
    		 
        pub fn login(
  • bonsaidb-local 0.4.1/src/open_trees.rs
    44
    		 
        #[allow(clippy::needless_pass_by_value)]
    45
    		 
        pub fn open_trees_for_document_change(
  • bounded-integer-macro 0.5.3/src/generate.rs
    1241
    		 
        #[allow(clippy::needless_pass_by_value)]
    1242
    		 
        fn assert_result(
  • bracket-color 0.8.7/src/palette.rs
    22
    		 
    /// ```
    23
    		 
    #[allow(clippy::needless_pass_by_value)]
    24
    		 
    pub fn register_palette_color<S: ToString, COLOR: Into<RGBA>>(name: S, color: COLOR) {
    42
    		 
    #[allow(clippy::module_name_repetitions)]
    43
    		 
    #[allow(clippy::needless_pass_by_value)]
    44
    		 
    pub fn palette_color<S: ToString>(name: S) -> Option<RGBA> {
  • buffett-core 0.1.1/src/ledger.rs
    77
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    78
    		 
    fn err_bincode_to_io(e: Box<bincode::ErrorKind>) -> io::Error {
  • build_id 0.2.1/src/lib.rs
    91
    		 
    #[allow(clippy::needless_pass_by_value)]
    92
    		 
    fn from_header<H: Hasher>(_hasher: H) -> Result<H, ()> {
  • build_uuid 0.3.0/src/lib.rs
    95
    		 
    #[allow(clippy::needless_pass_by_value)]
    96
    		 
    fn from_header<H: Hasher>(_hasher: H) -> Result<H, ()> {
  • bve-derive 0.0.1/src/kvp.rs
    17
    		 
    #[allow(clippy::needless_pass_by_value)] // Needed for type deduction
    18
    		 
    fn split_aliases(input: String) -> Vec<String> {
  • cadence 0.29.0/src/client.rs
    1086
    		 
    #[allow(clippy::needless_pass_by_value)]
    1087
    		 
    fn nop_error_handler(_err: MetricError) {
  • cadence 0.29.0/src/sinks/udp.rs
    31
    		 
    // there's no point in changing this to be pass by reference yet.
    32
    		 
    #[allow(clippy::needless_pass_by_value)]
    33
    		 
    fn get_addr<A: ToSocketAddrs>(addr: A) -> MetricResult<SocketAddr> {
  • cadence-with-flush 0.29.0/src/client.rs
    1093
    		 
    #[allow(clippy::needless_pass_by_value)]
    1094
    		 
    fn nop_error_handler(_err: MetricError) {
  • cadence-with-flush 0.29.0/src/sinks/udp.rs
    31
    		 
    // there's no point in changing this to be pass by reference yet.
    32
    		 
    #[allow(clippy::needless_pass_by_value)]
    33
    		 
    fn get_addr<A: ToSocketAddrs>(addr: A) -> MetricResult<SocketAddr> {
  • cambridge-asm 0.16.0/src/exec/mod.rs
    17
    		 
    /// Arithmetic instructions
    18
    		 
    #[allow(clippy::needless_pass_by_value, clippy::enum_glob_use)]
    19
    		 
    pub mod arith;
    22
    		 
    /// I/O, debugging, function call and return instructions
    23
    		 
    #[allow(clippy::needless_pass_by_value, clippy::enum_glob_use)]
    24
    		 
    pub mod io;
    27
    		 
    /// Instructions for moving data between registers and memory addresses
    28
    		 
    #[allow(clippy::needless_pass_by_value, clippy::enum_glob_use)]
    29
    		 
    pub mod mov;
    32
    		 
    /// Instructions for making logical comparisons
    33
    		 
    #[allow(clippy::needless_pass_by_value, clippy::enum_glob_use)]
    34
    		 
    pub mod cmp;
    37
    		 
    /// Instructions for logical bit manipulation
    38
    		 
    #[allow(clippy::needless_pass_by_value, clippy::enum_glob_use)]
    39
    		 
    pub mod bitman;
  • cambridge-asm-cli 0.14.0/src/main.rs
    110
    		 
    #[allow(clippy::enum_glob_use, clippy::needless_pass_by_value)]
    111
    		 
    fn run(
    160
    		 
    #[allow(clippy::enum_glob_use, clippy::needless_pass_by_value)]
    161
    		 
    fn compile(
  • cardpack 0.4.14/src/cards/decks/standard52.rs
    171
    		 
        #[must_use]
    172
    		 
        #[allow(clippy::needless_pass_by_value)]
    173
    		 
        pub fn card_from_string(index: String) -> Card {
  • cargo-hatch 0.4.1/src/settings/repo/validators.rs
    125
    		 
        #[allow(clippy::needless_pass_by_value)]
    126
    		 
        fn valid(result: Result<Validation, CustomUserError>) -> bool {
    130
    		 
        #[allow(clippy::needless_pass_by_value)]
    131
    		 
        fn invalid(result: Result<Validation, CustomUserError>) -> bool {
  • cargo-public-api 0.27.1/tests/cargo-public-api-bin-tests.rs
    936
    		 
        #[allow(clippy::needless_pass_by_value)]
    937
    		 
        fn new_with_variant(variant: TestRepoVariant) -> Self {
  • cargo-rdme 1.1.0/src/options.rs
    312
    		 
    #[allow(clippy::needless_pass_by_value)]
    313
    		 
    pub fn merge_options(
  • cargo-sonar 0.14.1/src/audit.rs
    25
    		 
        #[allow(clippy::needless_pass_by_value)]
    26
    		 
        fn to_issue(&self, vulnerability: Vulnerability) -> sonar::Issue {
  • cargo-sonar 0.14.1/src/outdated.rs
    41
    		 
        #[allow(clippy::needless_pass_by_value)]
    42
    		 
        fn to_issue(&self, crate_name: &str, metadata: Metadata) -> sonar::Issue {
  • cargo-sonar 0.14.1/src/udeps.rs
    72
    		 
        #[allow(clippy::needless_pass_by_value)]
    73
    		 
        fn to_issues(&self, outcome: Outcome) -> sonar::Issues {
  • cetkaik_yhuap_move_candidates 1.3.1/src/tests/mod.rs
    126
    		 
        #[allow(clippy::needless_pass_by_value)]
    127
    		 
        fn serialize_rotated(r: Rotated) -> String {
  • chemfiles 0.10.3/src/property.rs
    162
    		 
        #[allow(clippy::needless_pass_by_value)]  // raw property
    163
    		 
        pub(crate) fn from_raw(raw: RawProperty) -> Property {
  • chess-huffman 0.1.0/src/pgn.rs
    19
    		 
        #[allow(clippy::needless_pass_by_value)]
    20
    		 
        fn san_may_error(&mut self, san_plus: SanPlus) -> Result<(), GameEncodeError> {
    45
    		 
        #[allow(clippy::needless_pass_by_value)]
    46
    		 
        fn san(&mut self, san_plus: SanPlus) {
  • chrono-wasi 0.4.11/src/date.rs
    228
    		 
        /// as all possible output fits in the range of `Duration`.
    229
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    230
    		 
        #[inline]
  • chrono-wasi 0.4.11/src/datetime.rs
    229
    		 
        /// This does not overflow or underflow at all.
    230
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    231
    		 
        #[inline]
  • chrono-wasi07 0.4.10/src/date.rs
    228
    		 
        /// as all possible output fits in the range of `Duration`.
    229
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    230
    		 
        #[inline]
  • chrono-wasi07 0.4.10/src/datetime.rs
    229
    		 
        /// This does not overflow or underflow at all.
    230
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    231
    		 
        #[inline]
  • ciff 0.3.1/src/binary_collection.rs
    427
    		 
        #[allow(clippy::needless_pass_by_value)]
    428
    		 
        #[quickcheck]
  • ckb-sentry 0.21.0/tests/test_processors.rs
    74
    		 
    fn test_before_event_callback_drop() {
    75
    		 
        #[allow(clippy::needless_pass_by_value)]
    76
    		 
        fn before_send(
    100
    		 
    fn test_before_breadcrumb_callback_drop() {
    101
    		 
        #[allow(clippy::needless_pass_by_value)]
    102
    		 
        fn before_breadcrumb(_crumb: sentry::Breadcrumb) -> Option<sentry::Breadcrumb> {
  • ckb-sentry-core 0.21.0/src/scope/real.rs
    185
    		 
        /// Sets a tag to a specific value.
    186
    		 
        #[allow(clippy::needless_pass_by_value)]
    187
    		 
        pub fn set_tag<V: ToString>(&mut self, key: &str, value: V) {
  • cli-batteries 0.4.1/src/lib.rs
    80
    		 
    /// Run the program.
    81
    		 
    #[allow(clippy::needless_pass_by_value)]
    82
    		 
    pub fn run<A, O, F, E>(version: Version, app: A)
  • cli-batteries 0.4.1/src/prometheus.rs
    59
    		 
    #[allow(clippy::unnecessary_wraps)]
    60
    		 
    #[allow(clippy::needless_pass_by_value)]
    61
    		 
    #[allow(clippy::unused_async)]
  • cloudburst 0.0.3/src/dht/node.rs
    596
    		 
        #[quickcheck]
    597
    		 
        #[allow(clippy::needless_pass_by_value)]
    598
    		 
        fn id_try_from_slice(values: Vec<u8>) -> bool {
  • comfy-table 6.1.4/src/cell.rs
    26
    		 
        /// Create a new Cell
    27
    		 
        #[allow(clippy::needless_pass_by_value)]
    28
    		 
        pub fn new<T: ToString>(content: T) -> Self {
  • commandlines 0.8.0/src/lib.rs
    105
    		 
        // - arguments: (`Vec<String>`) - a Vector of ordered String items
    106
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    107
    		 
        fn new_with_vec(arguments: Vec<String>) -> Self {
    415
    		 
        /// ```
    416
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    417
    		 
        pub fn contains_sequence(&self, needle_vec: Vec<&str>) -> bool {
  • cpclib-asm 0.6.0/src/parser/parser.rs
    4102
    		 
    /// Generate a string from a parsing error. Probably deprecated
    4103
    		 
    #[allow(clippy::needless_pass_by_value)]
    4104
    		 
    pub fn decode_parsing_error(_orig: &str, _e: cpclib_common::nom::Err<&str>) -> String {
  • cs_serde_cbor 0.12.0/src/value/de.rs
    154
    		 
    /// Convert a `serde_cbor::Value` into a type `T`
    155
    		 
    #[allow(clippy::needless_pass_by_value)]
    156
    		 
    pub fn from_value<T>(value: Value) -> Result<T, crate::error::Error>
  • cs_serde_cbor 0.12.0/src/value/ser.rs
    435
    		 
    /// ```
    436
    		 
    #[allow(clippy::needless_pass_by_value)]
    437
    		 
    // Taking by value is more friendly to iterator adapters, option and result
  • culper 0.3.2/src/server/mod.rs
    114
    		 
    #[allow(clippy::needless_pass_by_value)]
    115
    		 
    #[post("/registeradmin", data = "<admin_data>")]
    139
    		 
    #[allow(clippy::needless_pass_by_value)]
    140
    		 
    #[post("/demo", data = "<body>")]
  • cursive_hexview 0.7.0/src/lib.rs
    462
    		 
        /// returns the displayed characters per field
    463
    		 
        #[allow(unknown_lints, clippy::needless_pass_by_value)]
    464
    		 
        fn get_field_length(&self, field: Field) -> usize {
  • cust 0.3.2/src/memory/device/device_slice.rs
    185
    		 
        /// ```
    186
    		 
        #[allow(clippy::needless_pass_by_value)]
    187
    		 
        pub unsafe fn from_raw_parts(ptr: DevicePointer<T>, len: usize) -> DeviceSlice<T> {
  • dangerous 0.10.0/src/input/span.rs
    253
    		 
        #[inline(always)]
    254
    		 
        #[allow(clippy::needless_pass_by_value)]
    255
    		 
        pub fn debug_for(self, input: MaybeString<'_>) -> DebugFor<'_> {
  • dangerous 0.10.0/src/input/string.rs
    85
    		 
        #[inline(always)]
    86
    		 
        #[allow(clippy::needless_pass_by_value)]
    87
    		 
        pub fn from_utf8<E>(utf8: Bytes<'i>) -> Result<String<'i>, E>
  • dcaf 0.3.1/src/common/scope/mod.rs
    1043
    		 
            fn try_from(value: Value) -> Result<Self, Self::Error> {
    1044
    		 
                #[allow(clippy::needless_pass_by_value)] // makes it easier to use later on
    1045
    		 
                fn value_to_aif_element(
  • deoxy 0.2.1/src/server/job.rs
    83
    		 
    // TODO: HEAD support
    84
    		 
    #[allow(clippy::needless_pass_by_value)]
    85
    		 
    pub fn status(req: HttpRequest<AppState>) -> Json<Option<Job>> {
    105
    		 
    /// Creates and starts a new job if the system is ready.
    106
    		 
    #[allow(clippy::needless_pass_by_value)]
    107
    		 
    pub fn start(req: HttpRequest<AppState>) -> Box<Future<Item = HttpResponse, Error = Error>> {
    168
    		 
    #[allow(clippy::needless_pass_by_value)]
    169
    		 
    fn message_uuid(
    188
    		 
    /// We require the user to specify the job in question so that there can be no ambiguity.
    189
    		 
    #[allow(clippy::needless_pass_by_value)]
    190
    		 
    pub fn resume(
    197
    		 
    /// Immediately stops the running job.
    198
    		 
    #[allow(clippy::needless_pass_by_value)]
    199
    		 
    pub fn halt(
  • dexios 8.8.1/src/subcommands/unpack.rs
    18
    		 
    #[allow(clippy::module_name_repetitions)]
    19
    		 
    #[allow(clippy::needless_pass_by_value)]
    20
    		 
    pub fn unpack(
  • diesel_cli 2.0.1/src/main.rs
    476
    		 
    #[allow(clippy::needless_pass_by_value)]
    477
    		 
    fn handle_error<E: Display, T>(error: E) -> T {
  • drone-cortexm 0.14.1/src/thr/init.rs
    60
    		 
    /// ```
    61
    		 
    #[allow(clippy::needless_pass_by_value)]
    62
    		 
    #[inline]
    121
    		 
    /// ```
    122
    		 
    #[allow(clippy::needless_pass_by_value)]
    123
    		 
    #[inline]
  • drone-riscv 0.14.0/src/thr/init.rs
    36
    		 
    /// Initializes the thread system and returns a set of thread tokens.
    37
    		 
    #[allow(clippy::needless_pass_by_value)]
    38
    		 
    #[inline]
  • easy-error 1.0.0/src/lib.rs
    95
    		 
    	/// Create a new error with the given cause.
    96
    		 
    	#[allow(clippy::needless_pass_by_value)] // `T: ToString` implies `&T: ToString`
    97
    		 
    	#[track_caller]
    206
    		 
    #[inline]
    207
    		 
    #[allow(clippy::needless_pass_by_value)] // `T: ToString` implies `&T: ToString`
    208
    		 
    #[track_caller]
  • eframe 0.20.1/src/lib.rs
    177
    		 
    #[cfg(not(target_arch = "wasm32"))]
    178
    		 
    #[allow(clippy::needless_pass_by_value)]
    179
    		 
    pub fn run_native(app_name: &str, native_options: NativeOptions, app_creator: AppCreator) {
  • eframe_tao 0.20.1/src/lib.rs
    163
    		 
    #[cfg(not(target_arch = "wasm32"))]
    164
    		 
    #[allow(clippy::needless_pass_by_value)]
    165
    		 
    pub fn run_native(app_name: &str, native_options: NativeOptions, app_creator: AppCreator) {
  • egui 0.20.1/src/containers/area.rs
    400
    		 
        #[allow(clippy::needless_pass_by_value)] // intentional to swallow up `content_ui`.
    401
    		 
        pub(crate) fn end(self, ctx: &Context, content_ui: Ui) -> Response {
  • egui 0.20.1/src/data/output.rs
    170
    		 
    impl OpenUrl {
    171
    		 
        #[allow(clippy::needless_pass_by_value)]
    172
    		 
        pub fn same_tab(url: impl ToString) -> Self {
    179
    		 
        #[allow(clippy::needless_pass_by_value)]
    180
    		 
        pub fn new_tab(url: impl ToString) -> Self {
    497
    		 
        #[allow(clippy::needless_pass_by_value)]
    498
    		 
        pub fn labeled(typ: WidgetType, label: impl ToString) -> Self {
    505
    		 
        /// checkboxes, radio-buttons etc
    506
    		 
        #[allow(clippy::needless_pass_by_value)]
    507
    		 
        pub fn selected(typ: WidgetType, selected: bool, label: impl ToString) -> Self {
    522
    		 
        #[allow(clippy::needless_pass_by_value)]
    523
    		 
        pub fn slider(value: f64, label: impl ToString) -> Self {
  • egui 0.20.1/src/painter.rs
    208
    		 
    impl Painter {
    209
    		 
        #[allow(clippy::needless_pass_by_value)]
    210
    		 
        pub fn debug_rect(&self, rect: Rect, color: Color32, text: impl ToString) {
    231
    		 
        /// text with a background
    232
    		 
        #[allow(clippy::needless_pass_by_value)]
    233
    		 
        pub fn debug_text(
    381
    		 
        /// Returns where the text ended up.
    382
    		 
        #[allow(clippy::needless_pass_by_value)]
    383
    		 
        pub fn text(
  • egui 0.20.1/src/widgets/button.rs
    52
    		 
        /// Creates a button with an image to the left of the text. The size of the image as displayed is defined by the provided size.
    53
    		 
        #[allow(clippy::needless_pass_by_value)]
    54
    		 
        pub fn image_and_text(
  • egui_demo_lib 0.20.0/src/demo/plot_demo.rs
    352
    		 
        #[allow(clippy::needless_pass_by_value)]
    353
    		 
        fn x_grid(input: GridInput) -> Vec<GridMark> {
  • egui-fltk-frontend 0.22.1/src/backend.rs
    713
    		 
        /// ignored.
    714
    		 
        #[allow(clippy::needless_pass_by_value)] // false positive
    715
    		 
        pub fn register_native_texture_with_sampler_options(
  • egui_glow 0.20.1/src/painter.rs
    592
    		 
        #[allow(clippy::needless_pass_by_value)] // False positive
    593
    		 
        pub fn register_native_texture(&mut self, native: glow::Texture) -> egui::TextureId {
    601
    		 
        #[allow(clippy::needless_pass_by_value)] // False positive
    602
    		 
        pub fn replace_native_texture(&mut self, id: egui::TextureId, replacing: glow::Texture) {
  • egui_glow 0.20.1/src/vao.rs
    29
    		 
    impl VertexArrayObject {
    30
    		 
        #[allow(clippy::needless_pass_by_value)] // false positive
    31
    		 
        pub(crate) unsafe fn new(
  • egui_glow_tao 0.20.1/src/painter.rs
    646
    		 
        #[allow(clippy::needless_pass_by_value)] // False positive
    647
    		 
        pub fn register_native_texture(&mut self, native: glow::Texture) -> egui::TextureId {
    655
    		 
        #[allow(clippy::needless_pass_by_value)] // False positive
    656
    		 
        pub fn replace_native_texture(&mut self, id: egui::TextureId, replacing: glow::Texture) {
  • egui_glow_tao 0.20.1/src/vao.rs
    29
    		 
    impl VertexArrayObject {
    30
    		 
        #[allow(clippy::needless_pass_by_value)] // false positive
    31
    		 
        pub(crate) unsafe fn new(
  • egui-wgpu 0.20.0/src/renderer.rs
    656
    		 
        /// ignored.
    657
    		 
        #[allow(clippy::needless_pass_by_value)] // false positive
    658
    		 
        pub fn register_native_texture_with_sampler_options(
    696
    		 
        /// This allows applications to reuse `TextureId`s created with custom sampler options.
    697
    		 
        #[allow(clippy::needless_pass_by_value)] // false positive
    698
    		 
        pub fn update_egui_texture_from_wgpu_texture_with_sampler_options(
  • ehttp 0.2.0/src/types.rs
    16
    		 
        /// Create a `GET` request with the given url.
    17
    		 
        #[allow(clippy::needless_pass_by_value)]
    18
    		 
        pub fn get(url: impl ToString) -> Self {
    27
    		 
        /// Create a `POST` request with the given url and body.
    28
    		 
        #[allow(clippy::needless_pass_by_value)]
    29
    		 
        pub fn post(url: impl ToString, body: Vec<u8>) -> Self {
  • enum_delegate_lib 0.2.0/src/macros/implement.rs
    42
    		 
    // we're mirroring how macro signatures look
    43
    		 
    #[allow(clippy::needless_pass_by_value)]
    44
    		 
    #[must_use]
  • enum_delegate_lib 0.2.0/src/macros/implement_conversions.rs
    12
    		 
    // we're mirroring how macro signatures look
    13
    		 
    #[allow(clippy::needless_pass_by_value)]
    14
    		 
    #[must_use]
  • enum_delegate_lib 0.2.0/src/macros/implement_for.rs
    30
    		 
    // we're mirroring how macro signatures look
    31
    		 
    #[allow(clippy::needless_pass_by_value)]
    32
    		 
    #[must_use]
  • enum_delegate_lib 0.2.0/src/macros/implement_trait_for_enum.rs
    40
    		 
    // we're mirroring how macro signatures look
    41
    		 
    #[allow(clippy::needless_pass_by_value)]
    42
    		 
    #[must_use]
  • enum_delegate_lib 0.2.0/src/macros/register.rs
    11
    		 
    // we're mirroring how macro signatures look
    12
    		 
    #[allow(clippy::needless_pass_by_value)]
    13
    		 
    #[must_use]
  • enve 0.4.0/src/core.rs
    26
    		 
    /// ```
    27
    		 
    #[allow(clippy::needless_pass_by_value)]
    28
    		 
    pub fn get_or_set_default<R>(key: &str, default: R) -> Result<R, Error>
    113
    		 
    /// ```
    114
    		 
    #[allow(clippy::needless_pass_by_value)]
    115
    		 
    pub fn sset<V>(key: &str, value: V) -> EString
  • eosio 0.3.1/src/bytes/data_stream.rs
    28
    		 
        /// Will return `Err` if there was a problem writing the data.
    29
    		 
        #[allow(clippy::needless_pass_by_value)]
    30
    		 
        #[inline]
  • epaint 0.20.0/src/shape.rs
    202
    		 
        #[allow(clippy::needless_pass_by_value)]
    203
    		 
        pub fn text(
  • eternal 0.3.2/src/ws/mask.rs
    52
    		 
    // a `ShortSlice` must be smaller than a u64.
    53
    		 
    #[allow(clippy::needless_pass_by_value)]
    54
    		 
    fn xor_short(buf: ShortSlice<'_>, mask: u64) {
  • ethereumvm-stateful 0.11.0/src/lib.rs
    145
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    146
    		 
        pub fn require_to_commit(&self, require: RequireError, root: Option<H256>) -> AccountCommitment {
  • evm-stateful 0.11.1/src/lib.rs
    145
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    146
    		 
        pub fn require_to_commit(&self, require: RequireError, root: Option<H256>) -> AccountCommitment {
  • exonum 1.0.0/src/blockchain/mod.rs
    547
    		 
        /// [`PersistentPool`]: struct.PersistentPool.html
    548
    		 
        #[allow(clippy::needless_pass_by_value)]
    549
    		 
        // ^-- `BlockParams` is passed by value for future compatibility.
  • exonum 1.0.0/src/helpers/mod.rs
    114
    		 
        /// Deserializes `semver::Version` from string.
    115
    		 
        #[allow(clippy::needless_pass_by_value)] // False positive, we need a `String` type here.
    116
    		 
        pub fn from_pb(pb: String) -> anyhow::Result<Version> {
  • exonum 1.0.0/src/runtime/types.rs
    184
    		 
    #[allow(clippy::needless_pass_by_value)] // required for work with `protobuf_convert(with)`
    185
    		 
    impl ArtifactId {
    716
    		 
        #[allow(clippy::needless_pass_by_value)] // required for work with `protobuf_convert(with)`
    717
    		 
        pub fn from_pb(pb: String) -> anyhow::Result<Option<Version>> {
  • exonum-crypto 1.0.0/src/crypto_lib/sodiumoxide/x25519.rs
    54
    		 
    /// ```
    55
    		 
    #[allow(clippy::needless_pass_by_value)]
    56
    		 
    pub fn into_x25519_keypair(
  • exonum-merkledb 1.0.0/src/indexes/list.rs
    455
    		 
        fn list_index_clear_in_family(db: &dyn Database, x: u32, y: u32, merge_before_clear: bool) {
    456
    		 
            #[allow(clippy::needless_pass_by_value)]
    457
    		 
            // ^-- better for type inference: we want `T == &Fork`, not `T == Fork`.
  • exonum-merkledb 1.0.0/src/indexes/proof_list/tests.rs
    603
    		 
        #[allow(clippy::needless_pass_by_value)] // references to ranges look awkward
    604
    		 
        fn check_bounds(
  • exonum-middleware-service 1.0.0/src/transactions.rs
    52
    		 
        #[allow(clippy::needless_pass_by_value)] // required by `exonum-proto`
    53
    		 
        pub fn from_pb(pb: String) -> anyhow::Result<VersionReq> {
  • exonum_sodiumoxide 0.0.24/src/crypto/sign/ed25519.rs
    169
    		 
    /// Converts Ed25519 keypair to Curve25519 keypair.
    170
    		 
    #[allow(clippy::needless_pass_by_value)]
    171
    		 
    pub fn convert_ed_keypair_to_curve25519(pk: PublicKey, sk: SecretKey) -> (PublicKey, SecretKey) {
  • externref 0.1.0/src/lib.rs
    206
    		 
            #[cfg(not(target_arch = "wasm32"))]
    207
    		 
            #[allow(clippy::needless_pass_by_value)]
    208
    		 
            unsafe fn insert_externref(id: ExternRef) -> usize {
    250
    		 
        #[inline(always)]
    251
    		 
        #[allow(clippy::needless_pass_by_value)]
    252
    		 
        pub unsafe fn take_raw(this: Option<Self>) -> ExternRef {
  • extrasafe 0.1.2/src/lib.rs
    98
    		 
        /// Gather unconditional and conditional rules to be provided to the seccomp context.
    99
    		 
        #[allow(clippy::needless_pass_by_value)]
    100
    		 
        fn gather_rules(rules: impl RuleSet) -> Vec<Rule> {
  • feroxfuzz 1.0.0-rc.8/src/client/utils.rs
    26
    		 
    /// internal helper to convert [`reqwest::Error`] to [`FeroxFuzzError`]
    27
    		 
    #[allow(clippy::needless_pass_by_value)]
    28
    		 
    #[instrument(skip_all, level = "trace")]
  • fetcher-core 0.10.0/src/action/transform/entry/html.rs
    221
    		 
    // I'm pretty sure this shouldn't capture from elem_query, so this is probably a bug in Soup
    222
    		 
    #[allow(clippy::needless_pass_by_value)]
    223
    		 
    fn find(html: HtmlNode, elem_query: &ElementQuery) -> impl Iterator<Item = HtmlNode> + '_ {
  • fibonacii-heap 0.1.2/src/ll.rs
    125
    		 
        // pass by value because we don't want dangling pointers :)
    126
    		 
        #[allow(clippy::needless_pass_by_value)]
    127
    		 
        pub fn append(&mut self, other: Self) {
  • fil-rustacuda 0.1.3/src/memory/device/device_slice.rs
    280
    		 
        /// ```
    281
    		 
        #[allow(clippy::needless_pass_by_value)]
    282
    		 
        pub unsafe fn from_raw_parts<'a>(data: DevicePointer<T>, len: usize) -> &'a DeviceSlice<T> {
  • fontfor 0.3.1/src/preview/browser/server.rs
    183
    		 
        #[allow(clippy::needless_pass_by_value)] // channel is designed to be used like this
    184
    		 
        fn server(
  • fontfor 0.3.1/src/preview/terminal/ui/event.rs
    56
    		 
    #[allow(clippy::needless_pass_by_value)] // because it is run in other thread
    57
    		 
    fn keyboard_event_generator(tick_interval: Duration, tx: mpsc::Sender<CTResult<TerminalEvent>>) {
  • forkfs 0.1.0/src/sessions.rs
    94
    		 
    #[allow(clippy::needless_pass_by_value)]
    95
    		 
    fn iter_op<S: AsRef<str>>(
  • formula 0.1.0/src/parsers/basic.rs
    4
    		 
    impl Formula<'_> {
    5
    		 
        #[allow(clippy::needless_pass_by_value, clippy::unnecessary_wraps)]
    6
    		 
        pub(crate) fn parse_num(pair: Pair<Rule>) -> Result<Expr> {
    26
    		 
        #[allow(clippy::needless_pass_by_value, clippy::unnecessary_wraps)]
    27
    		 
        pub(crate) fn parse_true(_pair: Pair<Rule>) -> Result<Expr> {
    31
    		 
        #[allow(clippy::needless_pass_by_value, clippy::unnecessary_wraps)]
    32
    		 
        pub(crate) fn parse_false(_pair: Pair<Rule>) -> Result<Expr> {
    36
    		 
        #[allow(clippy::needless_pass_by_value, clippy::unnecessary_wraps)]
    37
    		 
        pub(crate) fn parse_array(pair: Pair<Rule>) -> Result<Expr> {
  • formula 0.1.0/src/parsers/date_and_time.rs
    5
    		 
    impl Formula<'_> {
    6
    		 
        #[allow(clippy::needless_pass_by_value, clippy::unnecessary_wraps)]
    7
    		 
        pub(crate) fn parse_now(_pair: Pair<Rule>) -> Result<Expr> {
    11
    		 
        #[allow(clippy::needless_pass_by_value, clippy::unnecessary_wraps)]
    12
    		 
        pub(crate) fn parse_today(_pair: Pair<Rule>) -> Result<Expr> {
    30
    		 
        #[allow(clippy::needless_pass_by_value)]
    31
    		 
        pub(crate) fn parse_weeknum(pair: Pair<Rule>) -> Result<Expr> {
  • formula 0.1.0/src/parsers/math.rs
    176
    		 
        #[allow(clippy::needless_pass_by_value, clippy::unnecessary_wraps)]
    177
    		 
        pub(crate) fn parse_pi(_pair: Pair<Rule>) -> Result<Expr> {
    267
    		 
        #[allow(clippy::needless_pass_by_value, clippy::unnecessary_wraps)]
    268
    		 
        pub(crate) fn parse_rand(_pair: Pair<Rule>) -> Result<Expr> {
  • formula 0.1.0/src/parsers/web.rs
    18
    		 
        #[allow(clippy::needless_pass_by_value)]
    19
    		 
        pub(crate) fn parse_filterxml(pair: Pair<Rule>) -> Result<Expr> {
  • foxdie 0.6.1/src/cli.rs
    90
    		 
    #[allow(clippy::needless_pass_by_value)]
    91
    		 
    fn validate_date(s: String) -> Result<(), String> {
  • frugalos_segment 1.2.0/src/segment_gc.rs
    59
    		 
    impl SegmentGc {
    60
    		 
        #[allow(clippy::needless_pass_by_value, clippy::too_many_arguments)]
    61
    		 
        pub fn new(
  • frugalos_segment 1.2.0/src/service.rs
    122
    		 
        /// repair_idleness_threshold の変更要求を発行する。
    123
    		 
        #[allow(clippy::needless_pass_by_value)]
    124
    		 
        pub fn set_repair_config(&mut self, repair_config: RepairConfig) {
    550
    		 
        }
    551
    		 
        #[allow(clippy::needless_pass_by_value)]
    552
    		 
        fn handle_command(&mut self, command: SegmentNodeCommand) {
  • frugalos_segment 1.2.0/src/test_util.rs
    165
    		 
            /// Boots this cluster with the given members.
    166
    		 
            #[allow(clippy::needless_pass_by_value)]
    167
    		 
            pub fn boot(&mut self, members: Vec<(NodeId, DeviceId, DeviceHandle)>) -> Result<Client> {
  • fuc_engine 1.1.3/src/ops/copy.rs
    165
    		 
        #[allow(clippy::needless_pass_by_value)]
    166
    		 
        fn root_worker_thread(tasks: Receiver<TreeNode>) -> Result<(), Error> {
  • fuc_engine 1.1.3/src/ops/remove.rs
    144
    		 
        #[allow(clippy::needless_pass_by_value)]
    145
    		 
        fn root_worker_thread(tasks: Receiver<Message>) -> Result<(), Error> {
  • fudd 0.1.4/src/types/poker_cards.rs
    44
    		 
        #[must_use]
    45
    		 
        #[allow(clippy::needless_pass_by_value)]
    46
    		 
        pub fn from_index_string(index: String) -> Result<PokerCards, HandError> {
  • fudd 0.1.4/src/util/uci.rs
    8
    		 
    impl UCI {
    9
    		 
        #[allow(clippy::missing_panics_doc, clippy::needless_pass_by_value)]
    10
    		 
        #[must_use]
  • fuel-pest 3.0.4/src/error.rs
    104
    		 
        /// ```
    105
    		 
        #[allow(clippy::needless_pass_by_value)]
    106
    		 
        pub fn new_from_pos(variant: ErrorVariant<R>, pos: Position) -> Error<R> {
    145
    		 
        /// ```
    146
    		 
        #[allow(clippy::needless_pass_by_value)]
    147
    		 
        pub fn new_from_span(variant: ErrorVariant<R>, span: Span) -> Error<R> {
  • fuel-pest_generator 3.0.4/src/generator.rs
    18
    		 
    #[allow(clippy::needless_pass_by_value)]
    19
    		 
    pub fn generate(
  • fuel-pest_meta 3.0.4/src/validator.rs
    21
    		 
    #[allow(clippy::needless_pass_by_value)]
    22
    		 
    pub fn validate_pairs(pairs: Pairs<Rule>) -> Result<Vec<Span>, Vec<Error<Rule>>> {
    460
    		 
    #[allow(clippy::needless_pass_by_value)]
    461
    		 
    fn left_recursion<'a>(rules: HashMap<String, &'a ParserNode>) -> Vec<Error<Rule>> {
  • fumio-reactor 0.1.0/src/net/tcp_stream.rs
    54
    		 
    	/// Create a new TCP connection to the given target using a prepared socket.
    55
    		 
    	#[allow(clippy::needless_pass_by_value)] // builders should actually be consumed, even if net2 screwed this up
    56
    		 
    	pub fn connect_builder(builder: net2::TcpBuilder, target: SocketAddr, handle: LazyHandle) -> io::Result<TcpConnectFuture> {
  • fumio-reactor 0.1.0/src/reactor/task.rs
    87
    		 
    	#[allow(clippy::needless_pass_by_value)]
    88
    		 
    	fn local_remove(&self, task_inner: Arc<InnerTask>) {
  • ggetrs 0.1.69/src/enrichr/python.rs
    4
    		 
    #[pyfunction(name = "enrichr")]
    5
    		 
    #[allow(clippy::needless_pass_by_value)]
    6
    		 
    pub fn python_enrichr<'py>(
  • ggetrs 0.1.69/src/ensembl/python.rs
    10
    		 
    #[pyfunction(name = "search")]
    11
    		 
    #[allow(clippy::needless_pass_by_value)]
    12
    		 
    pub fn python_ensembl_search<'py>(
    41
    		 
    #[must_use]
    42
    		 
    #[allow(clippy::needless_pass_by_value)]
    43
    		 
    pub fn python_ensembl_database(_py: Python, filter: Option<String>) -> Vec<String> {
  • gimli 0.27.1/examples/dwarf-validate.rs
    33
    		 
    impl<W: Write + Send> ErrorWriter<W> {
    34
    		 
        #[allow(clippy::needless_pass_by_value)]
    35
    		 
        fn error(&self, s: String) {
  • girt-display 2.2.0/src/crossterm.rs
    164
    		 
    	#[allow(clippy::needless_pass_by_value)]
    165
    		 
    	fn map_err(err: io::Error) -> Error {
  • glib 0.16.7/src/signal.rs
    139
    		 
    #[allow(clippy::needless_pass_by_value)]
    140
    		 
    #[doc(alias = "g_signal_handler_disconnect")]
  • gpu-allocator 0.22.0/src/d3d12/mod.rs
    534
    		 
        #[allow(clippy::needless_pass_by_value)]
    535
    		 
        fn free(&mut self, allocation: Allocation) -> Result<()> {
  • gpu-allocator 0.22.0/src/vulkan/mod.rs
    468
    		 
        #[allow(clippy::needless_pass_by_value)]
    469
    		 
        fn free(&mut self, allocation: Allocation, device: &ash::Device) -> Result<()> {
  • grass_compiler 0.12.2/src/builtin/functions/meta.rs
    301
    		 
    #[allow(clippy::needless_pass_by_value)]
    302
    		 
    pub(crate) fn content_exists(args: ArgumentResult, visitor: &mut Visitor) -> SassResult<Value> {
  • grass_compiler 0.12.2/src/builtin/functions/string.rs
    191
    		 
    #[cfg(feature = "random")]
    192
    		 
    #[allow(clippy::needless_pass_by_value)]
    193
    		 
    pub(crate) fn unique_id(args: ArgumentResult, _: &mut Visitor) -> SassResult<Value> {
  • gurgle 0.5.0/src/detail.rs
    67
    		 
        /// If `lang` is `Language::Custom`
    68
    		 
        #[allow(clippy::needless_pass_by_value)] // because language is copy
    69
    		 
        pub fn set_global(lang: Self) {
  • hashbrown 0.13.2/src/raw/mod.rs
    559
    		 
        #[cfg_attr(feature = "inline-more", inline)]
    560
    		 
        #[allow(clippy::needless_pass_by_value)]
    561
    		 
        pub unsafe fn erase(&mut self, item: Bucket<T>) {
    584
    		 
        #[cfg_attr(feature = "inline-more", inline)]
    585
    		 
        #[allow(clippy::needless_pass_by_value)]
    586
    		 
        pub unsafe fn remove(&mut self, item: Bucket<T>) -> T {
  • hbbft 0.1.1/tests/binary_agreement.rs
    107
    		 
    /// Tests Binary Agreement on a given configuration.
    108
    		 
    #[allow(clippy::needless_pass_by_value)]
    109
    		 
    fn binary_agreement(cfg: TestConfig) {
  • hbbft 0.1.1/tests/net/mod.rs
    216
    		 
    // borrow-checker restrictions.
    217
    		 
    #[allow(clippy::needless_pass_by_value)]
    218
    		 
    fn process_step<'a, D>(
    670
    		 
        #[inline]
    671
    		 
        #[allow(clippy::needless_pass_by_value)]
    672
    		 
        pub fn get<'a>(&'a self, id: D::NodeId) -> Option<&'a Node<D>> {
    679
    		 
        #[inline]
    680
    		 
        #[allow(clippy::needless_pass_by_value)]
    681
    		 
        pub fn get_mut<'a>(&'a mut self, id: D::NodeId) -> Option<&'a mut Node<D>> {
  • hbbft 0.1.1/tests/net_dynamic_hb.rs
    89
    		 
    // TODO: Add an observer node to the test network.
    90
    		 
    #[allow(clippy::needless_pass_by_value, clippy::cyclomatic_complexity)]
    91
    		 
    fn do_drop_and_re_add(cfg: TestConfig) {
  • hbbft 0.1.1/tests/queueing_honey_badger.rs
    225
    		 
    // Allow passing `netinfo` by value. `TestNetwork` expects this function signature.
    226
    		 
    #[allow(clippy::needless_pass_by_value)]
    227
    		 
    fn new_queueing_hb(
  • hdf5 0.8.1/src/hl/selection.rs
    637
    		 
        #[doc(hidden)]
    638
    		 
        #[allow(clippy::needless_pass_by_value)]
    639
    		 
        pub fn from_raw(hyper: RawHyperslab) -> Result<Self> {
  • heph-rt 0.4.1/src/error.rs
    46
    		 
        /// is implemented for all type that implement [`fmt::Display`]).
    47
    		 
        #[allow(clippy::needless_pass_by_value)]
    48
    		 
        pub fn setup<E>(err: E) -> Error
  • heph-rt 0.4.1/src/lib.rs
    578
    		 
        /// [`actor`] module for additional information.
    579
    		 
        #[allow(clippy::needless_pass_by_value)]
    580
    		 
        pub fn spawn_local_future<Fut>(&mut self, future: Fut, options: FutureOptions)
  • heph-rt 0.4.1/src/net/mod.rs
    59
    		 
    /// Convert a `socket2:::SockAddr` into a `std::net::SocketAddr`.
    60
    		 
    #[allow(clippy::needless_pass_by_value)]
    61
    		 
    fn convert_address(address: SockAddr) -> io::Result<SocketAddr> {
  • heph-rt 0.4.1/src/shared/mod.rs
    217
    		 
        #[allow(clippy::needless_pass_by_value)] // For `ActorOptions`.
    218
    		 
        pub(crate) fn spawn_setup<S, NA, ArgFn, E>(
    258
    		 
        /// Spawn a thread-safe `future`.
    259
    		 
        #[allow(clippy::needless_pass_by_value)]
    260
    		 
        pub(crate) fn spawn_future<Fut>(&self, future: Fut, options: FutureOptions)
  • hexchat 0.6.3/src/hook.rs
    85
    		 
    /// Deregisters a command registered by `register_command`.
    86
    		 
    #[allow(clippy::needless_pass_by_value)]
    87
    		 
    pub fn deregister_command(command: Command) {
    136
    		 
    /// Removes a listener added by `add_print_event_listener`.
    137
    		 
    #[allow(clippy::needless_pass_by_value)]
    138
    		 
    pub fn remove_print_event_listener(listener: PrintEventListener) {
    186
    		 
    /// Removes a listener added by `add_window_event_listener`.
    187
    		 
    #[allow(clippy::needless_pass_by_value)]
    188
    		 
    pub fn remove_window_event_listener(listener: WindowEventListener) {
    238
    		 
    /// Removes a listener added by `add_raw_server_event_listener`.
    239
    		 
    #[allow(clippy::needless_pass_by_value)]
    240
    		 
    pub fn remove_raw_server_event_listener(listener: RawServerEventListener) {
    279
    		 
    /// Removes a timer task added by `add_timer_task`.
    280
    		 
    #[allow(clippy::needless_pass_by_value)]
    281
    		 
    pub fn remove_timer_task(task: TimerTask) {
  • hexchat 0.6.3/src/subplugin.rs
    36
    		 
    /// this list.
    37
    		 
    #[allow(clippy::needless_pass_by_value)]
    38
    		 
    pub fn remove_fake_plugin(plugin: FakePlugin) {
  • hls_m3u8 0.4.1/src/error.rs
    90
    		 
    #[allow(clippy::needless_pass_by_value)]
    91
    		 
    impl Error {
  • hls_m3u8 0.4.1/src/utils.rs
    93
    		 
    /// Puts a string inside quotes.
    94
    		 
    #[allow(clippy::needless_pass_by_value)]
    95
    		 
    pub(crate) fn quote<T: ToString>(value: T) -> String {
  • hoard 0.5.1/src/checkers/history/operation/v2.rs
    67
    		 
        ///   as an optimization technique while determining which files were created or deleted.
    68
    		 
        #[allow(clippy::needless_pass_by_value)]
    69
    		 
        #[tracing::instrument(level = "trace", name = "operation_v2_from_v1")]
  • holochain_core 0.0.52-alpha2/src/dht/dht_reducers.rs
    218
    		 
    #[allow(unknown_lints)]
    219
    		 
    #[allow(clippy::needless_pass_by_value)]
    220
    		 
    #[holochain_tracing_macros::newrelic_autotrace(HOLOCHAIN_CORE)]
    286
    		 
    #[allow(unknown_lints)]
    287
    		 
    #[allow(clippy::needless_pass_by_value)]
    288
    		 
    #[holochain_tracing_macros::newrelic_autotrace(HOLOCHAIN_CORE)]
  • holochain_core 0.0.52-alpha2/src/nucleus/reducers/init_application.rs
    10
    		 
    #[allow(unknown_lints)]
    11
    		 
    #[allow(clippy::needless_pass_by_value)]
    12
    		 
    #[holochain_tracing_macros::newrelic_autotrace(HOLOCHAIN_CORE)]
  • holochain_core 0.0.52-alpha2/src/nucleus/reducers/queue_zome_function_call.rs
    11
    		 
    #[allow(unknown_lints)]
    12
    		 
    #[allow(clippy::needless_pass_by_value)]
    13
    		 
    #[holochain_tracing_macros::newrelic_autotrace(HOLOCHAIN_CORE)]
  • holochain_core 0.0.52-alpha2/src/nucleus/reducers/return_initialization_result.rs
    10
    		 
    #[allow(unknown_lints)]
    11
    		 
    #[allow(clippy::needless_pass_by_value)]
    12
    		 
    #[holochain_tracing_macros::newrelic_autotrace(HOLOCHAIN_CORE)]
  • hpk 0.3.10/src/commands/create.rs
    24
    		 
    pub fn clap<'a, 'b>() -> App<'a, 'b> {
    25
    		 
        #[allow(clippy::needless_pass_by_value)]
    26
    		 
        fn validate_chunk_size(value: String) -> Result<(), String> {
    31
    		 
        }
    32
    		 
        #[allow(clippy::needless_pass_by_value)]
    33
    		 
        fn validate_dir(value: String) -> Result<(), String> {
  • hpk 0.3.10/src/commands/extract.rs
    9
    		 
    pub fn clap<'a, 'b>() -> App<'a, 'b> {
    10
    		 
        #[allow(clippy::needless_pass_by_value)]
    11
    		 
        fn validate_input(value: String) -> Result<(), String> {
    18
    		 
        }
    19
    		 
        #[allow(clippy::needless_pass_by_value)]
    20
    		 
        fn validate_dest(value: String) -> Result<(), String> {
  • hpk 0.3.10/src/commands/list.rs
    9
    		 
    pub fn clap<'a, 'b>() -> App<'a, 'b> {
    10
    		 
        #[allow(clippy::needless_pass_by_value)]
    11
    		 
        fn validate_input(value: String) -> Result<(), String> {
  • hpk 0.3.10/src/commands/print.rs
    7
    		 
    pub fn clap<'a, 'b>() -> App<'a, 'b> {
    8
    		 
        #[allow(clippy::needless_pass_by_value)]
    9
    		 
        fn validate_input(value: String) -> Result<(), String> {
  • html5minify 0.3.3/src/lib.rs
    442
    		 
        #[allow(clippy::needless_pass_by_value)]
    443
    		 
        fn minify_children(&mut self, ctx: &Option<Context>, node: &Node) -> io::Result<()> {
  • http_halforms 0.1.0/src/response.rs
    103
    		 
        #[must_use]
    104
    		 
        #[allow(clippy::needless_pass_by_value)] // Making this a reference just makes the caller slightly more awkward for no benefit
    105
    		 
        pub fn with_header<H>(mut self, header: H) -> Self
  • http_siren 0.1.0/src/response.rs
    53
    		 
        #[must_use]
    54
    		 
        #[allow(clippy::needless_pass_by_value)] // Making this a reference just makes the caller slightly more awkward for no benefit
    55
    		 
        pub fn with_header<H>(mut self, header: H) -> Self
  • hubcaps 0.6.2/src/issues.rs
    137
    		 
        /// add a set of labels to this issue ref
    138
    		 
        #[allow(clippy::needless_pass_by_value)] // shipped public API
    139
    		 
        pub fn add(&self, labels: Vec<&str>) -> Future<Vec<Label>> {
    151
    		 
        /// current labels
    152
    		 
        #[allow(clippy::needless_pass_by_value)] // shipped public API
    153
    		 
        pub fn set(&self, labels: Vec<&str>) -> Future<Vec<Label>> {
  • hubcaps 0.6.2/src/repositories.rs
    595
    		 
        /// that language.
    596
    		 
        #[allow(clippy::needless_pass_by_value)] // shipped public API
    597
    		 
        pub fn languages(&self, github: Github) -> Future<HashMap<String, i64>> {
  • hubcaps-ex 0.6.2/src/issues.rs
    138
    		 
        /// add a set of labels to this issue ref
    139
    		 
        #[allow(clippy::needless_pass_by_value)] // shipped public API
    140
    		 
        pub fn add(&self, labels: Vec<&str>) -> Future<Vec<Label>> {
    152
    		 
        /// current labels
    153
    		 
        #[allow(clippy::needless_pass_by_value)] // shipped public API
    154
    		 
        pub fn set(&self, labels: Vec<&str>) -> Future<Vec<Label>> {
  • hubcaps-ex 0.6.2/src/repositories.rs
    600
    		 
        /// that language.
    601
    		 
        #[allow(clippy::needless_pass_by_value)] // shipped public API
    602
    		 
        pub fn languages(&self, github: Github) -> Future<HashMap<String, i64>> {
  • iced_aw 0.3.0/src/native/number_input.rs
    161
    		 
        /// [`Text`]: crate::widget::Text
    162
    		 
        #[allow(clippy::needless_pass_by_value)]
    163
    		 
        #[must_use]
  • intaglio 1.8.0/src/bytes.rs
    854
    		 
    #[cfg(test)]
    855
    		 
    #[allow(clippy::needless_pass_by_value)]
    856
    		 
    mod tests {
  • intaglio 1.8.0/src/cstr.rs
    882
    		 
    #[cfg(test)]
    883
    		 
    #[allow(clippy::needless_pass_by_value)]
    884
    		 
    mod tests {
  • intaglio 1.8.0/src/osstr.rs
    882
    		 
    #[cfg(test)]
    883
    		 
    #[allow(clippy::needless_pass_by_value)]
    884
    		 
    mod tests {
  • intaglio 1.8.0/src/path.rs
    882
    		 
    #[cfg(test)]
    883
    		 
    #[allow(clippy::needless_pass_by_value)]
    884
    		 
    mod tests {
  • intaglio 1.8.0/src/str.rs
    792
    		 
    #[cfg(test)]
    793
    		 
    #[allow(clippy::needless_pass_by_value)]
    794
    		 
    mod tests {
  • interactive-actions 1.0.0/src/lib.rs
    113
    		 
        /// This function will return an error when actions fail
    114
    		 
        #[allow(clippy::needless_pass_by_value)]
    115
    		 
        pub fn run<P>(
  • jpegxl-rs 0.8.1+libjxl-0.8.0/src/decode.rs
    193
    		 
    impl<'pr, 'mm> JxlDecoder<'pr, 'mm> {
    194
    		 
        #[allow(clippy::needless_pass_by_value)]
    195
    		 
        pub(crate) fn decode_internal(
  • json-api-rocket 0.4.1/src/response.rs
    151
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    152
    		 
    pub(crate) fn fail(e: Error) -> Result<Response<'static>, Status> {
  • jsonschema-equivalent 0.1.0/src/keywords/type_.rs
    160
    		 
        #[test_case(json!({"type": "string", "pattern": "key[0-9]+"}))]
    161
    		 
        #[allow(clippy::needless_pass_by_value)]
    162
    		 
        fn test_remove_extraneous_keys_keyword_type_does_not_remove_keys(schema: Value) {
  • k 0.29.1/src/chain.rs
    126
    		 
        /// ```
    127
    		 
        #[allow(clippy::needless_pass_by_value)]
    128
    		 
        pub fn from_root(root_joint: Node<T>) -> Self {
  • kdbx4 0.5.1/src/kdbx.rs
    60
    		 
        /// ```
    61
    		 
        #[allow(clippy::needless_pass_by_value)]
    62
    		 
        pub fn open(file: impl AsRef<Path>, key: CompositeKey) -> KdbxResult<Database> {
    84
    		 
        /// ```
    85
    		 
        #[allow(clippy::needless_pass_by_value)]
    86
    		 
        pub fn open_bytes(bytes: impl AsRef<[u8]>, key: CompositeKey) -> KdbxResult<Database> {
    380
    		 
    #[allow(clippy::needless_pass_by_value)]
    381
    		 
    fn debug_kv(kv: (&u8, impl AsRef<[u8]>)) {
  • kicad_parse_gen 7.0.2/src/lib.rs
    136
    		 
    /// and matching it against the Expected type
    137
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    138
    		 
    pub fn read_kicad_file(name: &Path, expected: Expected) -> Result<KicadFile, KicadError> {
  • kicad_parse_gen 7.0.2/src/symbol_lib.rs
    730
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    731
    		 
    fn bool_from<T: PartialEq + fmt::Display>(i: T, t: T, f: T) -> Result<bool, KicadError> {
  • kludgine-core 0.4.0/src/sprite/source.rs
    155
    		 
        /// `scene`.
    156
    		 
        #[allow(clippy::needless_pass_by_value)]
    157
    		 
        pub fn render_at_with_alpha(
    180
    		 
        /// `scene`.
    181
    		 
        #[allow(clippy::needless_pass_by_value)]
    182
    		 
        pub fn render_with_alpha(
    198
    		 
        /// `scene`.
    199
    		 
        #[allow(clippy::needless_pass_by_value)]
    200
    		 
        pub fn render_with_alpha_in_box(
    217
    		 
        /// `scene`.
    218
    		 
        #[allow(clippy::needless_pass_by_value)]
    219
    		 
        pub fn render_raw_with_alpha_in_box(
  • kludgine-core 0.4.0/src/text/prepared.rs
    88
    		 
        /// Renders the text in `scene` with the baseline at `location`
    89
    		 
        #[allow(clippy::needless_pass_by_value)]
    90
    		 
        pub fn render_baseline_at(
  • knope 0.7.0/src/workflow.rs
    64
    		 
    #[allow(clippy::needless_pass_by_value)] // Lifetime errors if State is passed by ref.
    65
    		 
    pub(crate) fn validate(
  • kpgres 0.5.0/src/error/mod.rs
    428
    		 
        #[allow(clippy::needless_pass_by_value)]
    429
    		 
        pub(crate) fn db(error: ErrorResponseBody) -> Error {
  • ksql 0.8.0/src/parser.rs
    273
    		 
        #[allow(clippy::too_many_lines, clippy::needless_pass_by_value)]
    274
    		 
        fn next_operator_token(&mut self, operation_token: Token) -> anyhow::Result<Token> {
  • kukoo 0.1.0/src/map_inner.rs
    256
    		 
        /// `WriteResult::Retry`, and the caller need to retry.
    257
    		 
        #[allow(clippy::needless_pass_by_value, clippy::too_many_lines)]
    258
    		 
        pub fn insert(
  • kvarn 0.5.0/src/application.rs
    549
    		 
            #[inline]
    550
    		 
            #[allow(clippy::needless_pass_by_value)]
    551
    		 
            pub fn push_request(
    588
    		 
            #[inline]
    589
    		 
            #[allow(clippy::needless_pass_by_value)]
    590
    		 
            pub fn send_response(
  • legacylisten 0.2.0/src/audio.rs
    158
    		 
    // Look in lib.rs for justification.
    159
    		 
    #[allow(clippy::needless_pass_by_value)]
    160
    		 
    fn get_size<P: AsRef<Path>, D>(path: P, diskit: D) -> Result<usize, Error>
    169
    		 
    // Look in lib.rs for justification.
    170
    		 
    #[allow(clippy::needless_pass_by_value)]
    171
    		 
    fn get_ogg_len<P: AsRef<Path>, D>(path: P, diskit: D) -> Option<Duration>
    203
    		 
    // Look in lib.rs for justification.
    204
    		 
    #[allow(clippy::needless_pass_by_value)]
    205
    		 
    fn read_mp3_metadata_from_file<P: AsRef<Path>, D>(diskit: D, path: P) -> Option<MP3Metadata>
  • legacylisten 0.2.0/src/csv.rs
    110
    		 
        // Look in lib.rs for justification.
    111
    		 
        #[allow(clippy::needless_pass_by_value)]
    112
    		 
        pub(crate) fn new<P: AsRef<Path>, D>(path: P, diskit: D) -> Result<Self, Error>
  • legacylisten 0.2.0/src/dbus.rs
    284
    		 
    // Look in lib.rs for justification.
    285
    		 
    #[allow(clippy::needless_pass_by_value)]
    286
    		 
    pub fn handle_mpris<D>(
  • legacylisten 0.2.0/src/files.rs
    7
    		 
    // Look in lib.rs for justification.
    8
    		 
    #[allow(clippy::needless_pass_by_value)]
    9
    		 
    pub fn ensure_file_existence<D>(home: &Path, diskit: D) -> Result<(), Error>
  • legacylisten 0.2.0/src/parser.rs
    20
    		 
        // Look in lib.rs for justification.
    21
    		 
        #[allow(clippy::needless_pass_by_value)]
    22
    		 
        fn from<D>(s: &str, config: &Arc<ArcConfig>, diskit: D) -> Option<Self>
  • legacylisten 0.2.0/src/runner.rs
    31
    		 
    // Look in lib.rs for justification.
    32
    		 
    #[allow(clippy::needless_pass_by_value)]
    33
    		 
    // Called by songs::choose_random.
    179
    		 
    // Look in lib.rs for justification.
    180
    		 
    #[allow(clippy::needless_pass_by_value)]
    181
    		 
    pub fn run<C, A, D, R>(
  • libafl 0.9.0/src/bolts/llmp.rs
    2529
    		 
        /// else reattach will get a new, empty page, from the OS, or fail
    2530
    		 
        #[allow(clippy::needless_pass_by_value)]
    2531
    		 
        pub fn on_existing_shmem(
  • libafl 0.9.0/src/events/simple.rs
    285
    		 
        // Handle arriving events in the client
    286
    		 
        #[allow(clippy::needless_pass_by_value, clippy::unused_self)]
    287
    		 
        fn handle_in_client(&mut self, state: &mut S, event: Event<S::Input>) -> Result<(), Error> {
  • libafl 0.9.0/src/state/mod.rs
    807
    		 
            #[allow(clippy::needless_pass_by_value)]
    808
    		 
            fn load_initial_inputs(
  • libafl_qemu 0.9.0/src/emu.rs
    1174
    		 
        impl Emulator {
    1175
    		 
            #[allow(clippy::needless_pass_by_value)]
    1176
    		 
            #[new]
  • libafl_sugar 0.9.0/src/forkserver.rs
    345
    		 
            /// Run the fuzzer
    346
    		 
            #[allow(clippy::needless_pass_by_value)]
    347
    		 
            pub fn run(&self, program: String, arguments: Vec<String>) {
  • libafl_sugar 0.9.0/src/inmemory.rs
    406
    		 
            /// Run the fuzzer
    407
    		 
            #[allow(clippy::needless_pass_by_value)]
    408
    		 
            pub fn run(&self, harness: PyObject) {
  • libafl_sugar 0.9.0/src/qemu.rs
    486
    		 
            /// Run the fuzzer
    487
    		 
            #[allow(clippy::needless_pass_by_value)]
    488
    		 
            pub fn run(&self, emulator: &Emulator, harness: PyObject) {
  • libasuran 0.0.3/src/repository/backend/multifile/manifest.rs
    255
    		 
        /// Adds an archive to the manifest
    256
    		 
        #[allow(clippy::needless_pass_by_value)]
    257
    		 
        fn write_archive(&mut self, archive: StoredArchive) {
  • lifxi 0.1.1/src/http/client/mod.rs
    96
    		 
        /// ```
    97
    		 
        #[allow(clippy::needless_pass_by_value)]
    98
    		 
        pub fn new<S: ToString>(token: S) -> Self {
  • lifxi 0.1.1/src/http/client/scenes.rs
    55
    		 
        /// ```
    56
    		 
        #[allow(clippy::needless_pass_by_value)]
    57
    		 
        pub fn activate<S: ToString>(&'a self, uuid: S) -> Activate<'a> {
    143
    		 
        /// ```
    144
    		 
        #[allow(clippy::needless_pass_by_value)]
    145
    		 
        pub fn ignore(&mut self, s: impl ToString) -> &'_ mut Self {
  • lifxi 0.1.1/src/http/client/states.rs
    324
    		 
        /// Adds the given state to the list.
    325
    		 
        #[allow(clippy::needless_pass_by_value)]
    326
    		 
        pub fn add<T: Select>(&mut self, selector: T, state: State) -> &'_ mut Self {
  • lifxi 0.1.1/src/http/selector.rs
    27
    		 
        /// ```
    28
    		 
        #[allow(clippy::needless_pass_by_value)]
    29
    		 
        pub fn combine<T: PureSelect>(mut self, sel: T) -> Self {
  • lignin 0.1.0/src/callback_registry.rs
    305
    		 
    #[allow(clippy::let_underscore_drop)]
    306
    		 
    #[allow(clippy::needless_pass_by_value)]
    307
    		 
    mod callbacks_off {
  • livesplit-core 0.13.0/src/component/separator.rs
    59
    		 
        /// the setting provided is out of bounds.
    60
    		 
        #[allow(clippy::needless_pass_by_value)]
    61
    		 
        pub fn set_value(&mut self, _index: usize, _value: Value) {}
  • livesplit-core 0.13.0/src/run/editor/cleaning.rs
    148
    		 
        /// Applies a clean up to the Run.
    149
    		 
        #[allow(clippy::needless_pass_by_value)]
    150
    		 
        pub fn apply(&mut self, clean_up: CleanUp) {
  • lockfree-cuckoohash 0.1.0/src/map_inner.rs
    239
    		 
        /// `WriteResult::Retry`, and the caller need to retry.
    240
    		 
        #[allow(clippy::needless_pass_by_value, clippy::too_many_lines)]
    241
    		 
        pub fn insert(
  • lpn 0.2.0/src/gauss.rs
    17
    		 
    /// Solves an LPN problem using Pooled Gauss
    18
    		 
    #[allow(clippy::many_single_char_names, clippy::needless_pass_by_value)]
    19
    		 
    pub fn pooled_gauss_solve(oracle: LpnOracle) -> BinVector {
  • madsim-tokio-postgres 0.2.0/src/error/mod.rs
    448
    		 
        #[allow(clippy::needless_pass_by_value)]
    449
    		 
        pub(crate) fn db(error: ErrorResponseBody) -> Error {
  • malachite-base 0.3.2/tests/num/conversion/froms/try_from_and_exact_from.rs
    18
    		 
    #[allow(clippy::needless_pass_by_value)]
    19
    		 
    #[test]
  • malachite-base 0.3.2/tests/options/option_from_str.rs
    8
    		 
    #[allow(clippy::needless_pass_by_value)]
    9
    		 
    fn option_from_str_helper<T: Debug + Eq + FromStr>(s: &str, out: Option<Option<T>>) {
    22
    		 
    #[allow(clippy::needless_pass_by_value)]
    23
    		 
    fn option_from_str_custom_helper<T: Debug + Eq>(
  • malachite-base 0.3.2/tests/rounding_modes/from_str.rs
    23
    		 
    #[allow(clippy::needless_pass_by_value)]
    24
    		 
    fn from_str_helper(s: String) {
  • malachite-base 0.3.2/tests/tuples/exhaustive/exhaustive_custom_tuples.rs
    16
    		 
    #[allow(clippy::needless_pass_by_value)]
    17
    		 
    fn exhaustive_triples_xxy_helper<
    280
    		 
    #[allow(clippy::needless_pass_by_value)]
    281
    		 
    fn exhaustive_triples_xyx_helper<
  • malachite-base 0.3.2/tests/tuples/exhaustive/exhaustive_tuples_custom_output.rs
    17
    		 
    #[allow(clippy::needless_pass_by_value)]
    18
    		 
    fn exhaustive_pairs_helper<
    234
    		 
    #[allow(clippy::needless_pass_by_value)]
    235
    		 
    fn exhaustive_triples_helper<
  • malachite-base 0.3.2/tests/vecs/vec_from_str.rs
    9
    		 
    #[allow(clippy::needless_pass_by_value)]
    10
    		 
    fn vec_from_str_helper<T: Debug + Eq + FromStr>(s: &str, out: Option<Vec<T>>) {
    37
    		 
    #[allow(clippy::needless_pass_by_value)]
    38
    		 
    fn vec_from_str_custom_helper<T: Debug + Eq>(
  • malachite-nz 0.3.2/tests/natural/arithmetic/div.rs
    31754
    		 
    // It would be a little confusing to only pass y by value
    31755
    		 
    #[allow(clippy::needless_pass_by_value)]
    31756
    		 
    fn div_properties_helper(x: Natural, y: Natural) {
  • malachite-nz 0.3.2/tests/natural/arithmetic/div_mod.rs
    23917
    		 
    // It would be a little confusing to only pass y by value
    23918
    		 
    #[allow(clippy::needless_pass_by_value)]
    23919
    		 
    fn div_mod_and_div_rem_properties_helper(x: Natural, y: Natural) {
    24054
    		 
    // It would be a little confusing to only pass y by value
    24055
    		 
    #[allow(clippy::needless_pass_by_value)]
    24056
    		 
    fn ceiling_div_neg_mod_properties_helper(x: Natural, y: Natural) {
  • malachite-nz 0.3.2/tests/natural/arithmetic/mod_op.rs
    12884
    		 
    #[allow(clippy::needless_pass_by_value)]
    12885
    		 
    fn mod_properties_helper(x: Natural, y: Natural) {
    12994
    		 
    #[allow(clippy::needless_pass_by_value)]
    12995
    		 
    fn neg_mod_properties_helper(x: Natural, y: Natural) {
  • matterdb 1.2.0/src/indexes/list.rs
    441
    		 
        fn list_index_clear_in_family(db: &dyn Database, x: u32, y: u32, merge_before_clear: bool) {
    442
    		 
            #[allow(clippy::needless_pass_by_value)]
    443
    		 
            // ^-- better for type inference: we want `T == &Fork`, not `T == Fork`.
  • mcp794xx 0.3.0/src/common/mod.rs
    135
    		 
        #[allow(clippy::needless_pass_by_value)]
    136
    		 
        fn check_lt<T: PartialOrd>(value: T, reference: T) -> Result<(), Error<E>> {
    144
    		 
        #[allow(clippy::needless_pass_by_value)]
    145
    		 
        fn check_gt<T: PartialOrd>(value: T, reference: T) -> Result<(), Error<E>> {
  • mcsdf-font-tech-demo 1.0.1/src/renderer_thread.rs
    23
    		 
    #[allow(clippy::needless_pass_by_value)]
    24
    		 
    pub fn renderer_entry_point(context: RendererContext) -> Result<(), RecvError> {
  • meansd-cli 1.3.0/src/cli.rs
    109
    		 
    // [clippy] can't fix, due to clap validator API, will change with clap 3
    110
    		 
    #[allow(clippy::needless_pass_by_value)]
    111
    		 
    fn is_non_zero_u32(s: String) -> Result<(), String> {
    119
    		 
    // [clippy] can't fix, due to clap validator API, will change with clap 3
    120
    		 
    #[allow(clippy::needless_pass_by_value)]
    121
    		 
    fn is_f64(s: String) -> Result<(), String> {
    129
    		 
    // [clippy] can't fix, due to clap validator API, will change with clap 3
    130
    		 
    #[allow(clippy::needless_pass_by_value)]
    131
    		 
    fn is_u32(s: String) -> Result<(), String> {
  • medea-jason 0.2.0/src/api/mod.rs
    85
    		 
        /// Closes the provided [`RoomHandle`].
    86
    		 
        #[allow(clippy::needless_pass_by_value)]
    87
    		 
        pub fn close_room(&self, room_to_delete: RoomHandle) {
  • medea-jason 0.2.0/src/media/manager.rs
    314
    		 
        /// [1]: https://tinyurl.com/w3-streams#idl-def-MediaStreamTrackState.ended
    315
    		 
        #[allow(clippy::needless_pass_by_value)]
    316
    		 
        fn parse_and_save_tracks(
  • medea-macro 0.2.1/src/js_caused.rs
    16
    		 
    ///    methods from step 1 and 2.
    17
    		 
    #[allow(clippy::needless_pass_by_value)]
    18
    		 
    pub fn derive(mut s: Structure) -> Result<TokenStream> {
  • medea-macro 0.2.1/src/lib.rs
    91
    		 
    /// ```
    92
    		 
    #[allow(clippy::needless_pass_by_value)]
    93
    		 
    #[proc_macro_attribute]
  • meiosis 0.1.0/src/algorithm/fitness.rs
    485
    		 
        /// instantiate one using [`Population::seeded`].
    486
    		 
        #[allow(clippy::todo, clippy::needless_pass_by_value, clippy::missing_panics_doc)]
    487
    		 
        pub fn with_seeded_population(
  • metaldb 1.0.0/src/indexes/list.rs
    483
    		 
        fn list_index_clear_in_family(db: &dyn Database, x: u32, y: u32, merge_before_clear: bool) {
    484
    		 
            #[allow(clippy::needless_pass_by_value)]
    485
    		 
            // ^-- better for type inference: we want `T == &Fork`, not `T == Fork`.
  • minify 1.3.0/src/io/reader.rs
    35
    		 
        #[allow(clippy::needless_pass_by_value)]
    36
    		 
        fn filter_map_result_error(result: result::Result<char, CharsError>) -> Option<char> {
  • minus 5.1.0/src/static_pager.rs
    26
    		 
    #[cfg_attr(docsrs, doc(cfg(feature = "static_output")))]
    27
    		 
    #[allow(clippy::needless_pass_by_value)]
    28
    		 
    pub fn page_all(pager: Pager) -> Result<(), MinusError> {
  • mit-commit 3.1.5/src/commit_message_test.rs
    374
    		 
    #[allow(clippy::needless_pass_by_value)]
    375
    		 
    #[quickcheck]
    391
    		 
    #[allow(clippy::needless_pass_by_value)]
    392
    		 
    #[quickcheck]
    404
    		 
    #[allow(clippy::needless_pass_by_value)]
    405
    		 
    #[quickcheck]
  • mit-lint 3.2.3/src/checks/body_wider_than_72_characters_test.rs
    278
    		 
    #[allow(clippy::needless_pass_by_value)]
    279
    		 
    #[quickcheck]
    296
    		 
    #[allow(clippy::needless_pass_by_value)]
    297
    		 
    #[quickcheck]
  • mit-lint 3.2.3/src/checks/duplicate_trailers_test.rs
    251
    		 
    #[allow(clippy::needless_pass_by_value)]
    252
    		 
    #[quickcheck]
    285
    		 
    #[allow(clippy::needless_pass_by_value)]
    286
    		 
    #[quickcheck]
  • mit-lint 3.2.3/src/checks/missing_github_id_test.rs
    288
    		 
    #[allow(clippy::needless_pass_by_value)]
    289
    		 
    #[quickcheck]
    300
    		 
    #[allow(clippy::needless_pass_by_value)]
    301
    		 
    #[quickcheck]
    325
    		 
    #[allow(clippy::needless_pass_by_value)]
    326
    		 
    #[quickcheck]
    348
    		 
    #[allow(clippy::needless_pass_by_value)]
    349
    		 
    #[quickcheck]
  • mit-lint 3.2.3/src/checks/missing_jira_issue_key_test.rs
    181
    		 
    #[allow(clippy::needless_pass_by_value)]
    182
    		 
    #[quickcheck]
    189
    		 
    #[allow(clippy::needless_pass_by_value)]
    190
    		 
    #[quickcheck]
  • modbot 0.5.3/src/db/subscriptions.rs
    337
    		 
        #[allow(clippy::needless_pass_by_value)]
    338
    		 
        pub fn remove(
  • mpi 0.6.0/src/collective.rs
    1903
    		 
    /// 5.9.7
    1904
    		 
    #[allow(clippy::needless_pass_by_value)]
    1905
    		 
    pub fn reduce_local_into<S: ?Sized, R: ?Sized, O>(inbuf: &S, inoutbuf: &mut R, op: O)
  • mpi-fork-fnsp 0.6.0/src/collective.rs
    1886
    		 
    /// 5.9.7
    1887
    		 
    #[allow(clippy::needless_pass_by_value)]
    1888
    		 
    pub fn reduce_local_into<S: ?Sized, R: ?Sized, O>(inbuf: &S, inoutbuf: &mut R, op: O)
  • ndarray-stats 0.5.1/src/histogram/bins.rs
    492
    		 
        #[quickcheck]
    493
    		 
        #[allow(clippy::needless_pass_by_value)]
    494
    		 
        fn edges_are_deduped(v: Vec<i32>) -> bool {
  • nebari 0.5.4/src/io/memory.rs
    46
    		 
    #[allow(clippy::needless_pass_by_value)]
    47
    		 
    fn lookup_buffer(
  • nebari 0.5.4/src/roots.rs
    857
    		 
        /// omitted from the results. Keys are required to be pre-sorted.
    858
    		 
        #[allow(clippy::needless_pass_by_value)]
    859
    		 
        pub fn get_multiple<'keys, Keys>(
    1233
    		 
    #[allow(clippy::needless_pass_by_value)]
    1234
    		 
    fn transaction_commit_thread<File: ManagedFile>(receiver: flume::Receiver<ThreadCommit<File>>) {
  • netcdf 0.7.0/src/attribute.rs
    532
    		 
    impl<'a> Attribute<'a> {
    533
    		 
        #[allow(clippy::needless_pass_by_value)] // All values will be small
    534
    		 
        #[allow(clippy::too_many_lines)]
  • netcdf 0.7.0/src/variable.rs
    1146
    		 
        /// Not a `netCDF-4` file, late define, `fill_value` has the wrong type
    1147
    		 
        #[allow(clippy::needless_pass_by_value)] // All values will be small
    1148
    		 
        pub fn set_fill_value<T>(&mut self, fill_value: T) -> error::Result<()>
  • nixpacks 1.1.1/src/nixpacks/plan/phase.rs
    269
    		 
    #[allow(clippy::needless_pass_by_value)]
    270
    		 
    fn prevent_duplicates_vec<T: Clone + Eq + Hash>(values: Vec<T>) -> Vec<T> {
  • nokhwa-bindings-linux 0.1.0/src/lib.rs
    291
    		 
            #[deprecated(since = "0.10.0", note = "please use `new` instead.")]
    292
    		 
            #[allow(clippy::needless_pass_by_value)]
    293
    		 
            pub fn new_with(
  • nokhwa-bindings-windows 0.4.0/src/lib.rs
    1214
    		 
    #[allow(clippy::unused_self)]
    1215
    		 
    #[allow(clippy::needless_pass_by_value)]
    1216
    		 
    #[allow(clippy::must_use_candidate)]
  • nonogrid 0.7.3/src/solver.rs
    47
    		 
    #[cfg(feature = "sat")]
    48
    		 
    #[allow(clippy::needless_pass_by_value)]
    49
    		 
    pub fn run<B, S, P>(
  • notation_bevy_utils 0.4.2/src/egui/easy_link.rs
    42
    		 
        pub const INTERNAL_LINK_PREFIX: &'static str = ":";
    43
    		 
        #[allow(clippy::needless_pass_by_value)]
    44
    		 
        pub fn new(url: impl ToString, text: impl ToString, style: Style) -> Self {
  • ntex 0.6.3/src/ws/mask.rs
    52
    		 
    // a `ShortSlice` must be smaller than a u64.
    53
    		 
    #[allow(clippy::needless_pass_by_value)]
    54
    		 
    fn xor_short(buf: ShortSlice<'_>, mask: u64) {
  • opa 0.9.0/src/wasm/mod.rs
    106
    		 
        #[allow(clippy::needless_pass_by_value)]
    107
    		 
        fn build_module(self, module: Module) -> Result<Opa, anyhow::Error> {
  • openstack 0.4.2/src/utils.rs
    52
    		 
        /// Add an item to the query.
    53
    		 
        #[allow(clippy::needless_pass_by_value)] // TODO: fix
    54
    		 
        pub fn push<K, V>(&mut self, param: K, value: V)
  • oxigraph 0.3.11/src/sparql/http/dummy.rs
    21
    		 
        #[allow(clippy::unused_self, clippy::needless_pass_by_value)]
    22
    		 
        pub fn post(
  • oxigraph 0.3.11/src/sparql/mod.rs
    34
    		 
    #[allow(clippy::needless_pass_by_value)]
    35
    		 
    pub(crate) fn evaluate_query(
  • pane 0.4.0/src/lib.rs
    45
    		 
        /// Create a new `Context::Text`
    46
    		 
        #[allow(clippy::needless_pass_by_value)]
    47
    		 
        pub fn text<T, F>(text: T, format: F) -> Self
  • parallel-sh 0.1.11/src/main.rs
    84
    		 
    #[allow(clippy::needless_pass_by_value)]
    85
    		 
    fn add_jobs(
    130
    		 
    #[allow(clippy::needless_pass_by_value)]
    131
    		 
    fn start_workers(
  • parker 0.0.0/src/render.rs
    9
    		 
    #[allow(clippy::needless_pass_by_value)] // Tera requires pass-by-value
    10
    		 
    fn markdown_filter(
  • parsley 0.10.0/src/ctx/base/vec.rs
    67
    		 
    #[allow(clippy::needless_pass_by_value)]
    68
    		 
    #[allow(clippy::unnecessary_wraps)]
  • parsley 0.10.0/src/sexp/parse/tests.rs
    5
    		 
    #[allow(clippy::needless_pass_by_value)]
    6
    		 
    fn do_parse_and_assert(test_val: &str, expected_val: SExp) {
  • pathfinding 4.2.1/src/matrix.rs
    63
    		 
        /// are outside the original matrix.
    64
    		 
        #[allow(clippy::needless_pass_by_value)]
    65
    		 
        pub fn slice(
  • pest-ast 0.3.3/src/from_pest/mod.rs
    165
    		 
    #[allow(unused)]
    166
    		 
    #[allow(clippy::needless_pass_by_value)]
    167
    		 
    fn derive_for_enum(
  • pest_generator_tmp 2.1.0/src/generator.rs
    21
    		 
    #[allow(clippy::needless_pass_by_value)]
    22
    		 
    pub fn generate(
  • pest_meta_tmp 2.1.1/src/validator.rs
    19
    		 
    #[allow(clippy::needless_pass_by_value)]
    20
    		 
    pub fn validate_pairs<'i>(pairs: Pairs<'i, Rule>) -> Result<Vec<&'i str>, Vec<Error<Rule>>> {
    452
    		 
    #[allow(clippy::needless_pass_by_value)]
    453
    		 
    fn left_recursion<'a, 'i: 'a>(rules: HashMap<String, &'a ParserNode<'i>>) -> Vec<Error<Rule>> {
  • pest_tmp 2.1.1/src/error.rs
    96
    		 
        /// ```
    97
    		 
        #[allow(clippy::needless_pass_by_value)]
    98
    		 
        pub fn new_from_pos(variant: ErrorVariant<R>, pos: Position) -> Error<R> {
    136
    		 
        /// ```
    137
    		 
        #[allow(clippy::needless_pass_by_value)]
    138
    		 
        pub fn new_from_span(variant: ErrorVariant<R>, span: Span) -> Error<R> {
  • phile 0.1.4/tests/lexer.rs
    1586
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    1587
    		 
    fn quickcheck_valid_lexeme<T: Lexeme>(lexeme: T) -> bool {
  • phile 0.1.4/tests/parser.rs
    80
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    81
    		 
    fn oneline_range(src_idx: usize, char_range: std::ops::Range<usize>) -> Range {
  • pin-project 1.0.12/examples/pinned_drop-expanded.rs
    142
    		 
        unsafe fn drop(self: Pin<&mut Self>) {
    143
    		 
            #[allow(clippy::needless_pass_by_value)]
    144
    		 
            fn __drop_inner<T>(__self: Pin<&mut Struct<'_, T>>) {
  • pin-project 1.0.12/tests/expand/pinned_drop/enum.expanded.rs
    148
    		 
        unsafe fn drop(self: Pin<&mut Self>) {
    149
    		 
            #[allow(clippy::needless_pass_by_value)]
    150
    		 
            fn __drop_inner<T, U>(__self: Pin<&mut Enum<T, U>>) {
  • pin-project 1.0.12/tests/expand/pinned_drop/struct.expanded.rs
    107
    		 
        unsafe fn drop(self: Pin<&mut Self>) {
    108
    		 
            #[allow(clippy::needless_pass_by_value)]
    109
    		 
            fn __drop_inner<T, U>(__self: Pin<&mut Struct<T, U>>) {
  • pin-project 1.0.12/tests/expand/pinned_drop/tuple_struct.expanded.rs
    101
    		 
        unsafe fn drop(self: Pin<&mut Self>) {
    102
    		 
            #[allow(clippy::needless_pass_by_value)]
    103
    		 
            fn __drop_inner<T, U>(__self: Pin<&mut TupleStruct<T, U>>) {
  • pinned-aliasable 0.1.3/src/lib.rs
    385
    		 
            #[inline(never)]
    386
    		 
            #[allow(clippy::needless_pass_by_value)]
    387
    		 
            fn helper(
  • pmd_flow 1.0.2/src/output.rs
    1412
    		 
        /// This function will panic if anything in the [`FlowData`] is invalid
    1413
    		 
        #[allow(clippy::needless_pass_by_value)]
    1414
    		 
        pub fn new(source: FlowData) -> FlowDataOutput {
  • podserve 0.2.0/src/main.rs
    132
    		 
    #[allow(clippy::needless_pass_by_value)]
    133
    		 
    #[get("/")]
  • pooled-writer 0.3.0/src/lib.rs
    540
    		 
        /// - `shutdown_rx` - Sentinel channel to tell the pool management thread to shutdown.
    541
    		 
        #[allow(clippy::unnecessary_wraps, clippy::needless_collect, clippy::needless_pass_by_value)]
    542
    		 
        fn pool_main<W, C>(
  • posix-errors 1.2.1/src/lib.rs
    366
    		 
    /// Convert [`std::io::Error`] to a [`PosixError`]
    367
    		 
    #[allow(clippy::needless_pass_by_value)]
    368
    		 
    #[deprecated(since = "1.1.0", note = "Please use PosixError::from")]
  • prometheus-weathermen 0.5.0/src/http_server.rs
    17
    		 
    #[get("/")]
    18
    		 
    #[allow(clippy::needless_pass_by_value)]
    19
    		 
    pub fn index(
  • ptx-builder 0.5.3/src/reporter.rs
    47
    		 
        /// call `exit(0)` or `exit(1)` and print error log to `stderr`.
    48
    		 
        #[allow(clippy::needless_pass_by_value)]
    49
    		 
        pub fn build(&self, builder: Builder) -> ! {
  • pty_closure 0.1.2/src/lib.rs
    162
    		 
        #[allow(clippy::needless_pass_by_value)]
    163
    		 
        fn assert_exit_code(exit_code: i32, result: Result<(), Error>) {
  • public-api 0.27.1/src/render.rs
    265
    		 
        #[allow(clippy::needless_pass_by_value)]
    266
    		 
        fn render_sequence<T>(
    277
    		 
        #[allow(clippy::needless_pass_by_value)]
    278
    		 
        fn render_sequence_if_not_empty<T>(
    289
    		 
        #[allow(clippy::needless_pass_by_value)]
    290
    		 
        fn render_sequence_impl<T>(
    1307
    		 
        #[allow(clippy::needless_pass_by_value)]
    1308
    		 
        fn assert_render(
  • pyrpds 0.0.7/src/map.rs
    113
    		 
        #[allow(clippy::needless_pass_by_value)]
    114
    		 
        #[args(args = "*")]
  • pyrpds 0.0.7/src/set.rs
    69
    		 
        #[allow(clippy::needless_pass_by_value)]
    70
    		 
        pub fn update(&self, iterator: PyObject) -> PyResult<Self> {
  • pyrpds 0.0.7/src/vector.rs
    81
    		 
        #[allow(clippy::needless_pass_by_value)]
    82
    		 
        pub fn extend(&self, iterator: PyObject) -> PyResult<Self> {
  • qsv 0.87.0/src/cmd/jsonl.rs
    42
    		 
    #[allow(clippy::needless_pass_by_value)]
    43
    		 
    fn recurse_to_infer_headers(value: &Value, headers: &mut Vec<Vec<String>>, path: Vec<String>) {
  • qsv-stats 0.7.0/src/online.rs
    89
    		 
        #[inline]
    90
    		 
        #[allow(clippy::needless_pass_by_value)]
    91
    		 
        pub fn add<T: ToPrimitive>(&mut self, sample: T) {
  • quadtree_rs 0.1.2/src/lib.rs
    582
    		 
        #[allow(clippy::needless_pass_by_value)]
    583
    		 
        fn delete_handles_and_return(&mut self, handles: HashSet<u64>) -> IntoIter<U, V> {
  • ratsio 0.4.1/src/parser.rs
    10
    		 
    #[allow(dead_code, clippy::needless_pass_by_value)]
    11
    		 
    fn whitespace<'a, T>(input: T) -> IResult<T, T>
    36
    		 
    #[allow(dead_code, clippy::needless_pass_by_value)]
    37
    		 
    fn space<'a, T>(input: T) -> IResult<T, T>
    70
    		 
    #[allow(dead_code, clippy::needless_pass_by_value)]
    71
    		 
    fn to_str(i: Vec<u8>) -> String {
    75
    		 
    #[allow(dead_code, clippy::needless_pass_by_value)]
    76
    		 
    fn allowed_char_in_key<T>(input: T) -> IResult<T, T, u32>
    163
    		 
    #[allow(dead_code, clippy::needless_pass_by_value)]
    164
    		 
    fn allowed_char_in_err_msg<T>(input: T) -> IResult<T, T, u32>
  • ratsio_fork_040 0.4.1/src/parser.rs
    9
    		 
    #[allow(dead_code, clippy::needless_pass_by_value)]
    10
    		 
    fn whitespace<'a, T>(input: T) -> IResult<T, T>
    35
    		 
    #[allow(dead_code, clippy::needless_pass_by_value)]
    36
    		 
    fn space<'a, T>(input: T) -> IResult<T, T>
    74
    		 
    #[allow(dead_code, clippy::needless_pass_by_value)]
    75
    		 
    fn to_str(i: Vec<u8>) -> String {
    79
    		 
    #[allow(dead_code, clippy::needless_pass_by_value)]
    80
    		 
    fn allowed_char_in_key<T>(input: T) -> IResult<T, T, u32>
    181
    		 
    #[allow(dead_code, clippy::needless_pass_by_value)]
    182
    		 
    fn allowed_char_in_err_msg<T>(input: T) -> IResult<T, T, u32>
  • raw-parts 1.1.2/src/lib.rs
    276
    		 
        #[must_use]
    277
    		 
        #[allow(clippy::needless_pass_by_value)]
    278
    		 
        pub unsafe fn into_vec(this: Self) -> Vec<T> {
  • relearn 0.3.1/src/agents/buffers/vec.rs
    151
    		 
    #[allow(clippy::needless_pass_by_value)]
    152
    		 
    #[cfg(test)]
  • relearn 0.3.1/src/simulation/take_steps.rs
    122
    		 
    #[cfg(test)]
    123
    		 
    #[allow(clippy::needless_pass_by_value)]
    124
    		 
    mod tests {
  • relearn 0.3.1/src/torch/agents/features.rs
    263
    		 
    #[cfg(test)]
    264
    		 
    #[allow(clippy::needless_pass_by_value)]
    265
    		 
    pub(crate) mod tests {
  • relearn 0.3.1/src/torch/modules/chain.rs
    356
    		 
    #[allow(
    357
    		 
        clippy::needless_pass_by_value,
    358
    		 
        clippy::used_underscore_binding,
  • relearn 0.3.1/src/torch/modules/ff/linear.rs
    156
    		 
    #[allow(
    157
    		 
        clippy::needless_pass_by_value,
    158
    		 
        clippy::used_underscore_binding,
  • relearn 0.3.1/src/torch/modules/ff/mlp.rs
    179
    		 
    #[allow(
    180
    		 
        clippy::needless_pass_by_value,
    181
    		 
        clippy::used_underscore_binding,
  • relearn 0.3.1/src/torch/modules/seq/rnn/gru.rs
    106
    		 
    #[allow(
    107
    		 
        clippy::needless_pass_by_value,
    108
    		 
        clippy::used_underscore_binding,
  • relearn 0.3.1/src/torch/modules/seq/rnn/lstm.rs
    120
    		 
    #[allow(
    121
    		 
        clippy::needless_pass_by_value,
    122
    		 
        clippy::used_underscore_binding,
  • relearn 0.3.1/src/torch/packed.rs
    893
    		 
    #[cfg(test)]
    894
    		 
    #[allow(clippy::needless_pass_by_value)]
    895
    		 
    mod packed_tensor {
  • replicante_logging 0.1.4/src/decorator/async_flush.rs
    14
    		 
    /// [`Async`]: slog_async/struct.Async.html
    15
    		 
    #[allow(clippy::needless_pass_by_value)]
    16
    		 
    pub fn async_flush<D>(config: Config, opts: &Opts, drain: D) -> Logger
  • replicante_util_iron 0.3.0/src/error.rs
    30
    		 
    /// Convert an OpenTracingRust error into an IronError.
    31
    		 
    #[allow(clippy::needless_pass_by_value)]
    32
    		 
    pub fn otr_into_ironerror(error: OTError) -> IronError {
  • requiem-http 1.0.1/src/ws/mask.rs
    52
    		 
    // a `ShortSlice` must be smaller than a u64.
    53
    		 
    #[allow(clippy::needless_pass_by_value)]
    54
    		 
    fn xor_short(buf: ShortSlice<'_>, mask: u64) {
  • revolver 0.2.0/src/command.rs
    208
    		 
        /// the original. This is mostly used in error conversion; e.g., in [`Result::map_err()`].
    209
    		 
        #[allow(clippy::needless_pass_by_value)]
    210
    		 
        pub fn convert<E: ToString>(err: E) -> Self {
  • rhai 1.12.0/src/packages/blob_basic.rs
    515
    		 
        /// ```
    516
    		 
        #[allow(clippy::cast_sign_loss, clippy::needless_pass_by_value)]
    517
    		 
        pub fn chop(blob: &mut Blob, len: INT) {
  • rhai 1.12.0/src/packages/iter_basic.rs
    24
    		 
    #[inline(always)]
    25
    		 
    #[allow(clippy::needless_pass_by_value)]
    26
    		 
    fn std_add<T>(x: T, y: T) -> Option<T>
    33
    		 
    #[allow(dead_code)]
    34
    		 
    #[allow(clippy::unnecessary_wraps, clippy::needless_pass_by_value)]
    35
    		 
    fn regular_add<T>(x: T, y: T) -> Option<T>
  • ril 0.9.0/src/image.rs
    1624
    		 
        )]
    1625
    		 
        #[allow(clippy::needless_pass_by_value)] // would require a major refactor
    1626
    		 
        pub fn run_decoder<P: Pixel>(&self, stream: impl Read) -> Result<Image<P>> {
    1653
    		 
        )]
    1654
    		 
        #[allow(clippy::needless_pass_by_value)] // would require a major refactor
    1655
    		 
        pub fn run_sequence_decoder<P: Pixel, R: Read>(
  • rlbot 0.5.0/src/init.rs
    45
    		 
    /// [`examples/simple`]: https://github.com/whatisaphone/rlbot-rust/blob/master/examples/simple.rs
    46
    		 
    #[allow(clippy::needless_pass_by_value)]
    47
    		 
    pub fn init_with_options(options: InitOptions) -> Result<RLBot, Box<dyn Error>> {
  • rmx 0.1.6/src/interact.rs
    18
    		 
    #[cfg(feature = "auto-interactive")]
    19
    		 
    #[allow(clippy::needless_pass_by_value)]
    20
    		 
    pub fn with_message(message: String) -> Result<bool> {
  • rosrust 0.9.10/src/rosxmlrpc/server.rs
    45
    		 
    #[allow(clippy::needless_pass_by_value)]
    46
    		 
    #[inline]
  • rpi-led-matrix 0.4.0/src/matrix.rs
    89
    		 
        #[must_use]
    90
    		 
        #[allow(clippy::needless_pass_by_value)]
    91
    		 
        pub fn swap(&self, canvas: LedCanvas) -> LedCanvas {
  • rrule 0.10.0/src/tests/common.rs
    52
    		 
    #[allow(clippy::needless_pass_by_value)]
    53
    		 
    pub fn test_recurring_rrule_set(rrule_set: RRuleSet, expected_dates: &[DateTime<Tz>]) {
  • rsst 0.1.0/src/downstream.rs
    20
    		 
    /// Returns `<td>value</td>` or `<th>value</td>`.
    21
    		 
    #[allow(clippy::needless_pass_by_value)]
    22
    		 
    fn to_entry(dom: &mut RcDom, value: &str, tag: Tag) -> Rc<Node> {
    74
    		 
    /// Returns `<title>value</title>`.
    75
    		 
    #[allow(clippy::needless_pass_by_value)]
    76
    		 
    fn to_title(dom: &mut RcDom, value: &str) -> Rc<Node> {
  • ruint 1.7.0/src/support/postgres.rs
    325
    		 
            ]);
    326
    		 
            #[allow(clippy::needless_pass_by_value)]
    327
    		 
            fn bytes(ty: Type) -> Vec<u8> {
  • rust_wasm_websocket 0.5.5/src/websocket_mod.rs
    63
    		 
        // but I don't want references, because they have the lifetime problem.
    64
    		 
        #[allow(clippy::needless_pass_by_value)]
    65
    		 
        /// setup WebSocket connection
  • rustacuda 0.1.3/src/memory/device/device_slice.rs
    280
    		 
        /// ```
    281
    		 
        #[allow(clippy::needless_pass_by_value)]
    282
    		 
        pub unsafe fn from_raw_parts<'a>(data: DevicePointer<T>, len: usize) -> &'a DeviceSlice<T> {
  • rustfmt-core 0.4.0/src/visitor.rs
    515
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    516
    		 
        fn push_rewrite_inner(&mut self, span: Span, rewrite: Option<String>) {
  • rustfmt_lib 2.0.0-rc.2/src/formatting/visitor.rs
    739
    		 
        #[allow(clippy::needless_pass_by_value)]
    740
    		 
        fn push_rewrite_inner(&mut self, span: Span, rewrite: Option<String>) {
  • rustfmt-nightly 1.4.21/src/visitor.rs
    729
    		 
        #[allow(clippy::needless_pass_by_value)]
    730
    		 
        fn push_rewrite_inner(&mut self, span: Span, rewrite: Option<String>) {
  • rustus 0.5.10/src/protocol/core/server_info.rs
    7
    		 
    #[allow(clippy::needless_pass_by_value)]
    8
    		 
    #[allow(clippy::unused_async)]
  • rusty_v8 0.32.1/examples/process.rs
    5
    		 
    #[allow(clippy::needless_pass_by_value)] // this function should follow the callback type
    6
    		 
    fn log_callback(
    290
    		 
      /// This handles the properties of `HttpRequest`
    291
    		 
      #[allow(clippy::needless_pass_by_value)] // this function should follow the callback type
    292
    		 
      fn request_prop_handler(
  • rustysecrets-cli 0.2.0/src/cli.rs
    94
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    95
    		 
    pub mod validators {
  • safe_core 0.43.1/src/nfs/file_helper.rs
    97
    		 
    // Allow pass by value for consistency with other functions.
    98
    		 
    #[allow(clippy::needless_pass_by_value)]
    99
    		 
    pub async fn delete<S>(
  • safe-regex-compiler 0.2.5/tests/impl_regex.rs
    7
    		 
    fn syntax_errors() {
    8
    		 
        #[allow(clippy::needless_pass_by_value)]
    9
    		 
        fn to_s(s: TokenStream) -> String {
  • safecoin-exchange-program 1.6.16/src/exchange_processor.rs
    45
    		 
    impl ExchangeProcessor {
    46
    		 
        #[allow(clippy::needless_pass_by_value)]
    47
    		 
        fn map_to_invalid_arg(err: std::boxed::Box<bincode::ErrorKind>) -> InstructionError {
  • safina-executor 0.3.3/src/lib.rs
    419
    		 
    #[allow(clippy::needless_pass_by_value)]
    420
    		 
    fn poll_task(
  • safina-timer 0.1.11/src/lib.rs
    249
    		 
    #[allow(clippy::needless_pass_by_value)]
    250
    		 
    fn timer_thread(receiver: Receiver<ScheduledWake>) {
  • saltyrtc-client 0.9.0/src/lib.rs
    730
    		 
    /// Only call this function once you have finished the handshake!
    731
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    732
    		 
    pub fn task_loop(
  • saltyrtc-client 0.9.0/src/protocol/mod.rs
    1470
    		 
        /// Handle an incoming [`Token`](messages/struct.Token.html) message.
    1471
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    1472
    		 
        fn handle_token(&mut self, msg: Token, source: Address) -> SignalingResult<Vec<HandleAction>> {
    1505
    		 
        /// Handle an incoming [`Key`](messages/struct.Key.html) message.
    1506
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    1507
    		 
        fn handle_key(&mut self, msg: Key, source: Address) -> SignalingResult<Vec<HandleAction>> {
    2139
    		 
        /// The token is consumed to avoid accidentally reusing it.
    2140
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    2141
    		 
        fn send_token(&self, token: AuthToken) -> SignalingResult<HandleAction> {
    2190
    		 
        /// Handle an incoming [`Key`](messages/struct.Key.html) message.
    2191
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    2192
    		 
        fn handle_key(&mut self, msg: Key, nonce: &Nonce) -> SignalingResult<Vec<HandleAction>> {
    2331
    		 
        /// Handle an incoming [`Close`](messages/struct.Close.html) message during peer handshake.
    2332
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    2333
    		 
        fn handle_peer_handshake_close(&mut self, msg: Close) -> SignalingResult<Vec<HandleAction>> {
  • sawtooth 0.8.0/src/journal/block_manager.rs
    834
    		 
        #[allow(clippy::needless_pass_by_value)]
    835
    		 
        fn remove_blocks_from_blockstore(
  • sciter-rs 0.5.58/src/dom.rs
    987
    		 
    	/// Append element as last child of this element.
    988
    		 
    	#[allow(clippy::needless_pass_by_value)]
    989
    		 
    	pub fn push(&mut self, element: Element) {
  • scrappy-http 0.0.1/src/ws/mask.rs
    52
    		 
    // a `ShortSlice` must be smaller than a u64.
    53
    		 
    #[allow(clippy::needless_pass_by_value)]
    54
    		 
    fn xor_short(buf: ShortSlice<'_>, mask: u64) {
  • seed 0.9.2/src/browser/service/routing.rs
    52
    		 
    #[allow(clippy::needless_pass_by_value)]
    53
    		 
    pub fn url_request_handler(
  • sentry-contrib-native 0.3.1/src/transport.rs
    679
    		 
        #[allow(clippy::needless_pass_by_value)]
    680
    		 
        fn send(envelope: RawEnvelope) {
  • sequent-repl 0.3.0/src/commands/test_fixtures.rs
    55
    		 
        /// the original. This is mostly used in error conversion; e.g., in [`Result::map_err()`].
    56
    		 
        #[allow(clippy::needless_pass_by_value)]
    57
    		 
        pub fn convert<E: ToString>(err: E) -> Self {
  • serde_cbor 0.11.2/src/value/de.rs
    154
    		 
    /// Convert a `serde_cbor::Value` into a type `T`
    155
    		 
    #[allow(clippy::needless_pass_by_value)]
    156
    		 
    pub fn from_value<T>(value: Value) -> Result<T, crate::error::Error>
  • serde_cbor 0.11.2/src/value/ser.rs
    435
    		 
    /// ```
    436
    		 
    #[allow(clippy::needless_pass_by_value)]
    437
    		 
    // Taking by value is more friendly to iterator adapters, option and result
  • serde_cbor_2 0.12.0-dev/src/value/de.rs
    154
    		 
    /// Convert a `serde_cbor::Value` into a type `T`
    155
    		 
    #[allow(clippy::needless_pass_by_value)]
    156
    		 
    pub fn from_value<T>(value: Value) -> Result<T, crate::error::Error>
  • serde_cbor_2 0.12.0-dev/src/value/ser.rs
    435
    		 
    /// ```
    436
    		 
    #[allow(clippy::needless_pass_by_value)]
    437
    		 
    // Taking by value is more friendly to iterator adapters, option and result
  • servlin 0.1.1/examples/events-sse.rs
    45
    		 
    #[allow(clippy::needless_pass_by_value)]
    46
    		 
    fn event_sender_thread(state: Arc<State>, permit: Permit) {
  • servlin 0.1.1/src/http_error.rs
    38
    		 
        #[must_use]
    39
    		 
        #[allow(clippy::needless_pass_by_value)]
    40
    		 
        pub fn error_reading_file(e: std::io::Error) -> Self {
    44
    		 
        #[must_use]
    45
    		 
        #[allow(clippy::needless_pass_by_value)]
    46
    		 
        pub fn error_reading_response_body(e: std::io::Error) -> Self {
    50
    		 
        #[must_use]
    51
    		 
        #[allow(clippy::needless_pass_by_value)]
    52
    		 
        pub fn error_saving_file(e: std::io::Error) -> Self {
  • servlin 0.1.1/src/lib.rs
    193
    		 
    #[allow(clippy::needless_pass_by_value)]
    194
    		 
    #[must_use]
  • servlin 0.1.1/tests/test_util.rs
    178
    		 
        #[must_use]
    179
    		 
        #[allow(clippy::needless_pass_by_value)]
    180
    		 
        pub fn connect(e: std::io::Error) -> Self {
    183
    		 
        #[must_use]
    184
    		 
        #[allow(clippy::needless_pass_by_value)]
    185
    		 
        pub fn write(e: std::io::Error) -> Self {
    187
    		 
        }
    188
    		 
        #[allow(clippy::needless_pass_by_value)]
    189
    		 
        #[must_use]
  • sgx_trts 1.1.1/src/oom.rs
    25
    		 
    #[allow(clippy::needless_pass_by_value)]
    26
    		 
    fn default_oom_handler( _err: AllocErr) -> ! {
  • shio 0.3.0/src/handler.rs
    11
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value, use_debug))]
    12
    		 
    pub(crate) fn default_catch<E: fmt::Debug + Send>(err: E) -> Response {
  • shipcat 0.66.0/src/manifest/template.rs
    13
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    14
    		 
    fn indent(v: Value, m: HashMap<String, Value>) -> tera::Result<Value> {
    28
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    29
    		 
    fn as_secret(v: Value, _: HashMap<String, Value>) -> tera::Result<Value> {
  • simd-json 0.7.0/src/serde/value/owned/de.rs
    227
    		 
    impl ObjectDeserializer {
    228
    		 
        #[allow(clippy::boxed_local, clippy::needless_pass_by_value)]
    229
    		 
        fn new(map: Box<Object>) -> Self {
  • slaps 0.2.3/src/clap.rs
    893
    		 
        fn test_clap_error_value_validation() {
    894
    		 
            #[allow(clippy::needless_pass_by_value)]
    895
    		 
            fn is_numeric(val: String) -> Result<(), String> {
  • sled 0.34.7/src/pagecache/mod.rs
    262
    		 
    #[allow(clippy::needless_pass_by_value)]
    263
    		 
    pub(crate) fn maybe_decompress(in_buf: Vec<u8>) -> std::io::Result<Vec<u8>> {
  • sled 0.34.7/src/tree.rs
    525
    		 
        /// ```
    526
    		 
        #[allow(clippy::needless_pass_by_value)]
    527
    		 
        pub fn compare_and_swap<K, OV, NV>(
  • slice-deque 0.3.0/src/lib.rs
    1220
    		 
        #[inline]
    1221
    		 
        #[allow(clippy::needless_pass_by_value)]
    1222
    		 
        pub fn drain<R>(&mut self, range: R) -> Drain<T>
  • slice-ring-buffer 0.3.2/src/lib.rs
    1220
    		 
        #[inline]
    1221
    		 
        #[allow(clippy::needless_pass_by_value)]
    1222
    		 
        pub fn drain<R>(&mut self, range: R) -> Drain<T>
  • socket-collection 0.4.0/src/udt/udt_event_loop.rs
    96
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    97
    		 
    fn event_loop_impl<T: Notifier + Send + 'static>(
  • solana-btc-spv-api 0.20.5/src/spv_processor.rs
    26
    		 
        #[allow(clippy::needless_pass_by_value)]
    27
    		 
        fn map_to_invalid_arg(err: std::boxed::Box<bincode::ErrorKind>) -> InstructionError {
  • solana-btc-spv-program 1.2.32/src/spv_processor.rs
    25
    		 
        #[allow(clippy::needless_pass_by_value)]
    26
    		 
        fn map_to_invalid_arg(err: std::boxed::Box<bincode::ErrorKind>) -> InstructionError {
  • solana-exchange-api 0.20.5/src/exchange_processor.rs
    16
    		 
    impl ExchangeProcessor {
    17
    		 
        #[allow(clippy::needless_pass_by_value)]
    18
    		 
        fn map_to_invalid_arg(err: std::boxed::Box<bincode::ErrorKind>) -> InstructionError {
  • solana-exchange-program 1.8.16/src/exchange_processor.rs
    45
    		 
    impl ExchangeProcessor {
    46
    		 
        #[allow(clippy::needless_pass_by_value)]
    47
    		 
        fn map_to_invalid_arg(err: std::boxed::Box<bincode::ErrorKind>) -> InstructionError {
  • solana-move-loader-api 0.20.1/src/error_mappers.rs
    9
    		 
    #[allow(clippy::needless_pass_by_value)]
    10
    		 
    pub fn map_data_error(err: std::boxed::Box<bincode::ErrorKind>) -> InstructionError {
    18
    		 
    #[allow(clippy::needless_pass_by_value)]
    19
    		 
    pub fn map_json_error(err: serde_json::error::Error) -> InstructionError {
    29
    		 
    #[allow(clippy::needless_pass_by_value)]
    30
    		 
    pub fn missing_account() -> InstructionError {
  • solana-move-loader-api 0.20.1/src/processor.rs
    75
    		 
    impl MoveProcessor {
    76
    		 
        #[allow(clippy::needless_pass_by_value)]
    77
    		 
        fn missing_account() -> InstructionError {
  • solana-token-api 0.19.1/src/token_state.rs
    93
    		 
    impl TokenState {
    94
    		 
        #[allow(clippy::needless_pass_by_value)]
    95
    		 
        fn map_to_invalid_args(err: std::boxed::Box<bincode::ErrorKind>) -> TokenError {
  • sounding-bufkit 0.16.0/src/bufkit_data/combine.rs
    10
    		 
    #[allow(clippy::needless_pass_by_value)]
    11
    		 
    pub fn combine_data(
  • spinta 0.1.5/src/web.rs
    5
    		 
    #[allow(clippy::needless_pass_by_value)]
    6
    		 
    fn string_from_js_string(s: js_sys::JsString) -> String {
  • sputnikvm-stateful 0.11.0-beta.0/src/lib.rs
    152
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    153
    		 
        pub fn require_to_commit(
  • sqsquatch 0.2.2/src/client/publish.rs
    371
    		 
    #[allow(clippy::needless_pass_by_value)]
    372
    		 
    fn map_re(e: RusotoError<GetQueueUrlError>) -> RusotoError<SendMessageError> {
  • sqsquatch 0.2.2/src/client/subscribe.rs
    482
    		 
    #[allow(clippy::needless_pass_by_value)]
    483
    		 
    fn map_re(e: RusotoError<GetQueueUrlError>) -> RusotoError<ReceiveMessageError> {
    487
    		 
    #[allow(clippy::needless_pass_by_value)]
    488
    		 
    fn map_del(e: RusotoError<GetQueueUrlError>) -> RusotoError<DeleteMessageError> {
    500
    		 
    #[allow(clippy::needless_pass_by_value)]
    501
    		 
    fn receive_message_request(
  • stdweb 0.4.20/src/ecosystem/serde.rs
    528
    		 
    #[doc(hidden)]
    529
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    530
    		 
    #[inline]
  • stratum-server 4.2.0/src/session.rs
    130
    		 
        //@todo remove this if/when we
    131
    		 
        #[allow(clippy::needless_pass_by_value)]
    132
    		 
        pub fn new(
  • summavy 0.25.3/src/core/inverted_index_reader.rs
    31
    		 
    impl InvertedIndexReader {
    32
    		 
        #[allow(clippy::needless_pass_by_value)] // for symmetry
    33
    		 
        pub(crate) fn new(
  • sunk 0.1.2/src/client.rs
    145
    		 
        /// not required.
    146
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    147
    		 
        pub(crate) fn build_url(&self, query: &str, args: Query) -> Result<String> {
  • system-configuration 0.5.0/examples/watch_dns.rs
    52
    		 
    #[allow(clippy::needless_pass_by_value)]
    53
    		 
    fn my_callback(store: SCDynamicStore, changed_keys: CFArray<CFString>, context: &mut Context) {
  • t-rust-less-lib 0.2.16/src/memguard/memory.rs
    198
    		 
      fn memeq_test() {
    199
    		 
        #[allow(clippy::needless_pass_by_value)]
    200
    		 
        fn check_memeq(x: Vec<u8>, y: Vec<u8>) -> bool {
    216
    		 
      fn memcmp_test() {
    217
    		 
        #[allow(clippy::needless_pass_by_value)]
    218
    		 
        fn check_memcmp(x: Vec<u8>, y: Vec<u8>) -> bool {
  • t-rust-less-lib 0.2.16/src/secrets_store/padding/tests.rs
    50
    		 
    fn test_non_zero_padding_quick() {
    51
    		 
      #[allow(clippy::needless_pass_by_value)]
    52
    		 
      fn check_padding(mut data: Vec<u8>) -> bool {
    79
    		 
    fn test_randon_front_back_padding_quick() {
    80
    		 
      #[allow(clippy::needless_pass_by_value)]
    81
    		 
      fn check_padding(data: Vec<u8>) -> bool {
  • tabular 0.2.0/src/width_string.rs
    12
    		 
    impl WidthString {
    13
    		 
        #[allow(clippy::needless_pass_by_value)]
    14
    		 
        pub fn new<T: ToString>(thing: T) -> Self {
  • tantivy 0.19.1/src/core/inverted_index_reader.rs
    31
    		 
    impl InvertedIndexReader {
    32
    		 
        #[allow(clippy::needless_pass_by_value)] // for symmetry
    33
    		 
        pub(crate) fn new(
  • telexide 0.1.10/src/api/api_client.rs
    42
    		 
        /// it is Some).
    43
    		 
        #[allow(clippy::needless_pass_by_value)]
    44
    		 
        pub fn new(
    61
    		 
        /// client.
    62
    		 
        #[allow(clippy::needless_pass_by_value)]
    63
    		 
        pub fn new_default(token: impl ToString) -> Self {
  • telexide 0.1.10/src/client/builder.rs
    54
    		 
        /// Sets the token to be used in authorizing the API requests of your bot
    55
    		 
        #[allow(clippy::needless_pass_by_value)]
    56
    		 
        pub fn set_token(&mut self, token: impl ToString) -> &mut Self {
  • telexide 0.1.10/src/framework/framework.rs
    38
    		 
        #[allow(clippy::needless_pass_by_value)]
    39
    		 
        fn fire_message_commands(&self, context: Context, message: Message) {
  • telexide-fork 0.2.1/src/framework/framework.rs
    38
    		 
        #[allow(clippy::needless_pass_by_value)]
    39
    		 
        fn fire_message_commands(&self, context: Context, message: Message) {
  • template-eyre 0.1.0-alpha.6/src/tests.rs
    84
    		 
    impl AdhocError {
    85
    		 
        #[allow(clippy::needless_pass_by_value)]
    86
    		 
        pub fn new(e: impl ToString) -> Self {
  • tensorgraph-math 0.1.11/src/tensor/matrix.rs
    191
    		 
        clippy::cast_possible_truncation,
    192
    		 
        clippy::needless_pass_by_value
    193
    		 
    )]
    302
    		 
        clippy::cast_possible_truncation,
    303
    		 
        clippy::needless_pass_by_value
    304
    		 
    )]
  • tensorgraph-math 0.1.11/src/tensor/vector.rs
    93
    		 
        clippy::cast_possible_truncation,
    94
    		 
        clippy::needless_pass_by_value
    95
    		 
    )]
    164
    		 
        clippy::cast_possible_truncation,
    165
    		 
        clippy::needless_pass_by_value
    166
    		 
    )]
  • termusic 0.7.8/src/player/rusty_backend/mod.rs
    15
    		 
        clippy::unnecessary_wraps,
    16
    		 
        clippy::needless_pass_by_value,
    17
    		 
        clippy::manual_assert,
  • termusic 0.7.8/src/ui/components/config_editor/general.rs
    94
    		 
    #[allow(clippy::needless_pass_by_value)]
    95
    		 
    fn handle_input_ev(
    216
    		 
    #[allow(clippy::needless_pass_by_value)]
    217
    		 
    fn handle_radio_ev(
  • termusic 0.7.8/src/ui/components/tag_editor/te_input.rs
    136
    		 
    #[allow(clippy::needless_pass_by_value)]
    137
    		 
    fn handle_input_ev(
  • tinkerforge 2.0.20/src/ip_connection.rs
    89
    		 
    #[allow(clippy::needless_pass_by_value)] //All parameters are moved into the thread closure anyway.
    90
    		 
    fn socket_read_thread_fn(mut tcp_stream: TcpStream, response_tx: Sender<SocketThreadRequest>, session_id: u64) {
    361
    		 
    #[allow(clippy::needless_pass_by_value)] //All parameters are moved into the thread closure anyway.
    362
    		 
    fn socket_thread_fn(
  • tokio-postgres 0.7.7/src/error/mod.rs
    448
    		 
        #[allow(clippy::needless_pass_by_value)]
    449
    		 
        pub(crate) fn db(error: ErrorResponseBody) -> Error {
  • tor-config 0.7.0/src/misc.rs
    472
    		 
            #[allow(clippy::needless_pass_by_value)] // we do this for consistency
    473
    		 
            fn chk(
  • tor-dirmgr 0.9.0/src/bridgedesc.rs
    528
    		 
        // Allow passing `runtime` by value, which is usual API for this kind of setup function.
    529
    		 
        #[allow(clippy::needless_pass_by_value)]
    530
    		 
        fn new_internal(
  • tor-proto 0.8.0/src/crypto/handshake/ntor_v3.rs
    225
    		 
        /// with the message to send.
    226
    		 
        #[allow(clippy::needless_pass_by_value)]
    227
    		 
        fn client1<R: RngCore + CryptoRng>(
  • tor-ptmgr 0.2.0/src/lib.rs
    142
    		 
        /// Called when a spawn request completes.
    143
    		 
        #[allow(clippy::needless_pass_by_value)]
    144
    		 
        fn handle_spawned(
  • tox_binary_io 0.1.1/src/lib.rs
    89
    		 
    /// Generator that returns specified error.
    90
    		 
    #[allow(clippy::needless_pass_by_value)]
    91
    		 
    pub fn gen_error(_buf: (&mut [u8], usize), error: u32) -> Result<(&mut [u8], usize), GenError> {
  • tox_packet 0.1.1/src/onion/mod.rs
    137
    		 
    impl OnionReturn {
    138
    		 
        #[allow(clippy::needless_pass_by_value)]
    139
    		 
        fn inner_to_bytes<'a>(ip_port: &IpPort, inner: Option<&OnionReturn>, buf: (&'a mut [u8], usize)) -> Result<(&'a mut [u8], usize), GenError> {
  • trait_tests 0.3.3/src/lib.rs
    24
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    25
    		 
    #[proc_macro_attribute]
    92
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    93
    		 
    #[proc_macro_attribute]
  • tsukuyomi-askama 0.2.1/src/lib.rs
    66
    		 
    #[inline]
    67
    		 
    #[allow(clippy::needless_pass_by_value)]
    68
    		 
    pub fn into_response<T>(t: T, _: &Request<()>) -> tsukuyomi::Result<Response<String>>
  • tui-markup 0.3.0/src/generator/helper/flatten.rs
    23
    		 
    #[allow(clippy::needless_pass_by_value)] // Style usually is a small type
    24
    		 
    fn plain_text<'a, R, S>(escaped: &'a str, style: Option<S>) -> Vec<R>
    54
    		 
    #[allow(clippy::needless_pass_by_value)] // Style usually is a small type
    55
    		 
    fn items<'a, C, R, S>(items: Vec<ItemC<'a, C>>, style: Option<S>) -> Vec<R>
  • tvis 0.15.3/src/input/windows.rs
    222
    		 
    #[cfg_attr(feature = "cargo-clippy",
    223
    		 
               allow(needless_range_loop, needless_pass_by_value))]
    224
    		 
    fn event_loop(tx: Sender<Box<Event>>) -> Result<()> {
  • twilight-cache-inmemory 0.15.0-rc.1/src/model/member.rs
    135
    		 
        // clippy: the contents of `fields` is consumed
    136
    		 
        #[allow(clippy::missing_const_for_fn, clippy::needless_pass_by_value)]
    137
    		 
        pub(crate) fn from_interaction_member(
  • twilight-cache-inmemory 0.15.0-rc.1/src/permission.rs
    94
    		 
        // clippy: the contents of `member_roles_error` is consumed
    95
    		 
        #[allow(clippy::needless_pass_by_value)]
    96
    		 
        fn from_member_roles(member_roles_error: MemberRolesErrorType) -> Self {
    219
    		 
        // clippy: the contents of `member_roles_error` is consumed
    220
    		 
        #[allow(clippy::needless_pass_by_value)]
    221
    		 
        fn from_member_roles(member_roles_error: MemberRolesErrorType) -> Self {
  • twilight-http 0.15.0-rc.1/src/request/scheduled_event/create_guild_scheduled_event/external.rs
    23
    		 
    #[allow(clippy::needless_pass_by_value)]
    24
    		 
    impl<'a> CreateGuildExternalScheduledEvent<'a> {
  • unrest_tmp_syn 0.1.0/src/fold.rs
    320
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))] // clippy lies
    321
    		 
    fn noop_fold_qself<F: ?Sized + Folder>(folder: &mut F, qself: QSelf) -> QSelf {
  • v8 0.62.0/examples/process.rs
    4
    		 
    #[allow(clippy::needless_pass_by_value)] // this function should follow the callback type
    5
    		 
    fn log_callback(
    289
    		 
      /// This handles the properties of `HttpRequest`
    290
    		 
      #[allow(clippy::needless_pass_by_value)] // this function should follow the callback type
    291
    		 
      fn request_prop_handler(
  • vergen 8.0.0-beta.3/src/feature/git/cmd.rs
    507
    		 
        #[allow(clippy::needless_pass_by_value)]
    508
    		 
        fn inner_add_git_map_entries(
  • vergen-pretty 0.1.1/src/utils.rs
    56
    		 
    #[allow(clippy::needless_pass_by_value)]
    57
    		 
    fn caps_proper(val: String) -> String {
  • vpncloud 2.3.0/src/util.rs
    215
    		 
    #[allow(unknown_lints, clippy::needless_pass_by_value)]
    216
    		 
    pub fn resolve<Addr: ToSocketAddrs + fmt::Debug>(addr: Addr) -> Result<SmallVec<[SocketAddr; 4]>, Error> {
  • vsdbsled 0.34.7-patched/src/pagecache/mod.rs
    262
    		 
    #[allow(clippy::needless_pass_by_value)]
    263
    		 
    pub(crate) fn maybe_decompress(in_buf: Vec<u8>) -> std::io::Result<Vec<u8>> {
  • vsdbsled 0.34.7-patched/src/tree.rs
    525
    		 
        /// ```
    526
    		 
        #[allow(clippy::needless_pass_by_value)]
    527
    		 
        pub fn compare_and_swap<K, OV, NV>(
  • vsmtp-plugin-csv 1.4.0-rc.10/src/api.rs
    126
    		 
        /// Remove a record.
    127
    		 
        #[allow(clippy::needless_pass_by_value)]
    128
    		 
        #[rhai_fn(global, name = "rm", return_raw, pure)]
    145
    		 
        /// Query the database.
    146
    		 
        #[allow(clippy::needless_pass_by_value)]
    147
    		 
        #[rhai_fn(global, name = "get", return_raw, pure)]
  • vsmtp-plugin-mysql 1.4.0-rc.10/src/api.rs
    279
    		 
        #[rhai_fn(global, name = "query", return_raw, pure)]
    280
    		 
        #[allow(clippy::needless_pass_by_value)]
    281
    		 
        pub fn query_obj(
  • vsmtp-plugin-vsl 2.0.1-rc.4/src/objects.rs
    568
    		 
        /// Operator `==` for `SharedObject`
    569
    		 
        #[allow(clippy::needless_pass_by_value)]
    570
    		 
        #[rhai_fn(global, name = "==", pure)]
    575
    		 
        /// Operator `!=` for `SharedObject`
    576
    		 
        #[allow(clippy::needless_pass_by_value)]
    577
    		 
        #[rhai_fn(global, name = "!=", pure)]
    594
    		 
        /// Operator `==` for `&str` and `SharedObject`
    595
    		 
        #[allow(clippy::needless_pass_by_value)]
    596
    		 
        #[rhai_fn(global, name = "==", return_raw)]
    601
    		 
        /// Operator `!=` for `&str` and `SharedObject`
    602
    		 
        #[allow(clippy::needless_pass_by_value)]
    603
    		 
        #[rhai_fn(global, name = "!=", return_raw)]
    615
    		 
        /// Operator `contains`
    616
    		 
        #[allow(clippy::needless_pass_by_value)]
    617
    		 
        #[rhai_fn(global, name = "contains", pure)]
  • vsmtp-plugin-vsl 2.0.1-rc.4/src/unix.rs
    89
    		 
        /// ```
    90
    		 
        #[allow(clippy::needless_pass_by_value)]
    91
    		 
        #[must_use]
  • vsmtp-rule-engine 2.0.1-rc.4/src/api/auth.rs
    44
    		 
        /// A native implementation will be provided in the future.
    45
    		 
        #[allow(clippy::needless_pass_by_value)]
    46
    		 
        #[rhai_fn(name = "unix_users", return_raw)]
    93
    		 
        /// ```
    94
    		 
        #[allow(clippy::needless_pass_by_value)]
    95
    		 
        #[rhai_fn(name = "is_authenticated", return_raw)]
    123
    		 
        /// ```
    124
    		 
        #[allow(clippy::needless_pass_by_value)]
    125
    		 
        #[rhai_fn(name = "credentials", return_raw)]
  • vsmtp-rule-engine 2.0.1-rc.4/src/api/dkim.rs
    38
    		 
        /// Has the `ctx()` a DKIM signature verification result ?
    39
    		 
        #[allow(clippy::needless_pass_by_value)]
    40
    		 
        #[rhai_fn(name = "has_result", return_raw)]
    46
    		 
        /// an error if no result is found.
    47
    		 
        #[allow(clippy::needless_pass_by_value)]
    48
    		 
        #[rhai_fn(name = "result", return_raw)]
    56
    		 
        /// * The `status` field is missing in the DKIM verification results.
    57
    		 
        #[allow(clippy::needless_pass_by_value)]
    58
    		 
        #[rhai_fn(return_raw)]
    63
    		 
        /// Get the list of DKIM private keys associated with this sdid
    64
    		 
        #[allow(clippy::needless_pass_by_value)]
    65
    		 
        #[rhai_fn(return_raw)]
    246
    		 
        /// ```
    247
    		 
        #[allow(clippy::needless_pass_by_value)]
    248
    		 
        #[rhai_fn(return_raw)]
  • vsmtp-rule-engine 2.0.1-rc.4/src/api/dmarc.rs
    48
    		 
        /// ```
    49
    		 
        #[allow(clippy::needless_pass_by_value)]
    50
    		 
        #[rhai_fn(name = "check", return_raw)]
  • vsmtp-rule-engine 2.0.1-rc.4/src/api/dns.rs
    70
    		 
        /// ```
    71
    		 
        #[allow(clippy::needless_pass_by_value)]
    72
    		 
        #[rhai_fn(name = "lookup", return_raw)]
  • web-audio-api 0.28.0/src/context/online.rs
    154
    		 
        /// never panics.
    155
    		 
        #[allow(clippy::needless_pass_by_value)]
    156
    		 
        #[must_use]
  • websocat 1.11.0/src/http_serve.rs
    41
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    42
    		 
    pub fn http_serve(
  • websocat 1.11.0/src/sessionserve.rs
    120
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    121
    		 
    fn serve_impl<OE>(
  • wundergraph 0.1.2/src/helper/primary_keys.rs
    251
    		 
    #[allow(clippy::needless_pass_by_value)]
    252
    		 
    fn uppercase_first_letter(s: Cow<'_, str>) -> Cow<'_, str> {
  • wyrm 0.9.1/src/nn/lstm.rs
    226
    		 
        /// otherwise pass the cell and hidden states from previous iterations.
    227
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value, type_complexity))]
    228
    		 
        pub fn forward<C, H, I>(
  • yad 0.2.0/src/lib.rs
    366
    		 
        // Allow(clippy::needless_pass_by_value): For the filter_map flow
    367
    		 
        #[allow(clippy::needless_pass_by_value)]
    368
    		 
        fn file_to_fd(entry: std::fs::DirEntry) -> Option<i32> {
    375
    		 
        // Allow(clippy::needless_pass_by_value): For the map_err flow
    376
    		 
        #[allow(clippy::needless_pass_by_value)]
    377
    		 
        fn err_list(err: std::io::Error) -> Error {
  • yata 0.6.1/src/methods/tr.rs
    42
    		 
    	/// It's a simple shortcut for [`Method::new`](crate::core::Method::new) method.
    43
    		 
    	#[allow(clippy::needless_pass_by_value)]
    44
    		 
    	pub fn new(value: &<Self as Method>::Input) -> Result<Self, Error> {
  • yowsl 0.1.3/src/bin/yowsl/main.rs
    16
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    17
    		 
    fn default_uid_validator(s: String) -> Result<(), String> {
    25
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    26
    		 
    fn flags_validator(s: String) -> Result<(), String> {
  • zkp-merkle-tree 0.2.0/src/tree.rs
    196
    		 
    // Quickcheck requires pass by value
    197
    		 
    #[allow(clippy::needless_pass_by_value)]
    198
    		 
    #[cfg(test)]
  • zoog 0.8.1/src/opus/volume_analyzer.rs
    140
    		 
        /// Submits a new Ogg packet to the analyzer
    141
    		 
        #[allow(clippy::needless_pass_by_value)]
    142
    		 
        pub fn submit(&mut self, packet: Packet) -> Result<(), Error> {
  • zss 1.0.1/src/images.rs
    115
    		 
    /// Image loader to run in a background thread
    116
    		 
    #[allow(clippy::needless_pass_by_value)] // It's better for this function to own the sender
    117
    		 
    fn image_loader(
  • zune-jpeg 0.2.0/src/worker.rs
    139
    		 
        clippy::too_many_arguments,
    140
    		 
        clippy::needless_pass_by_value,
    141
    		 
        clippy::unwrap_used
  • aerospike 1.2.0/src/lib.rs
    34
    		 
        clippy::must_use_candidate,
    35
    		 
        clippy::needless_pass_by_value,
    36
    		 
        clippy::similar_names,
  • aliasable 0.1.3/src/lib.rs
    24
    		 
    #![allow(
    25
    		 
        clippy::needless_pass_by_value,
    26
    		 
        clippy::wrong_self_convention,
  • alt_serde 1.0.119/src/lib.rs
    126
    		 
            // not practical
    127
    		 
            needless_pass_by_value,
    128
    		 
            similar_names,
  • alt_serde_derive 1.0.119/src/lib.rs
    23
    		 
        clippy::match_like_matches_macro,
    24
    		 
        clippy::needless_pass_by_value,
    25
    		 
        clippy::too_many_arguments,
  • amadeus-core 0.4.3/src/lib.rs
    34
    		 
    	clippy::wildcard_imports,
    35
    		 
    	clippy::needless_pass_by_value,
    36
    		 
    	clippy::unnecessary_wraps,
  • amadeus-serde 0.4.3/src/lib.rs
    27
    		 
    	clippy::missing_errors_doc,
    28
    		 
    	clippy::needless_pass_by_value,
    29
    		 
    	clippy::default_trait_access,
  • amadeus-streaming 0.4.3/src/lib.rs
    50
    		 
    	clippy::if_not_else,
    51
    		 
    	clippy::needless_pass_by_value,
    52
    		 
    	clippy::suspicious_op_assign_impl,
  • anyhow 1.0.68/tests/test_macros.rs
    4
    		 
        clippy::items_after_statements,
    5
    		 
        clippy::needless_pass_by_value,
    6
    		 
        clippy::shadow_unrelated,
  • archetect-core 0.7.3/src/vendor/read_input/mod.rs
    5
    		 
    // `impl ToString` is better than `&impl ToString`. Clippy is not ready for impl trait.
    6
    		 
    #![allow(clippy::needless_pass_by_value)]
  • arn-language 1.2.1/src/main.rs
    14
    		 
        // It's a ******* Rc
    15
    		 
        clippy::needless_pass_by_value
    16
    		 
    )]
  • async-graphql 5.0.5/src/lib.rs
    154
    		 
    #![allow(clippy::missing_errors_doc)]
    155
    		 
    #![allow(clippy::needless_pass_by_value)]
    156
    		 
    #![deny(clippy::redundant_closure_for_method_calls)]
  • async-resol-vbus 0.1.0/src/lib.rs
    81
    		 
    #![allow(clippy::needless_bool)]
    82
    		 
    #![allow(clippy::needless_pass_by_value)]
    83
    		 
    #![allow(clippy::trivially_copy_pass_by_ref)]
  • automod 1.0.6/src/lib.rs
    61
    		 
    #![allow(clippy::enum_glob_use, clippy::needless_pass_by_value)]
  • av1an-core 0.4.0/src/lib.rs
    17
    		 
    #![allow(clippy::unsafe_derive_deserialize)]
    18
    		 
    #![allow(clippy::needless_pass_by_value)]
    19
    		 
    #![allow(clippy::use_self)]
  • avocado 0.6.0/src/lib.rs
    675
    		 
    #![allow(clippy::single_match, clippy::match_same_arms, clippy::match_ref_pats,
    676
    		 
             clippy::clone_on_ref_ptr, clippy::needless_pass_by_value)]
    677
    		 
    #![deny(clippy::wrong_pub_self_convention, clippy::used_underscore_binding,
  • avocado_derive 0.6.0/src/lib.rs
    17
    		 
    #![allow(clippy::single_match, clippy::match_same_arms, clippy::match_ref_pats,
    18
    		 
             clippy::clone_on_ref_ptr, clippy::needless_pass_by_value)]
    19
    		 
    #![deny(clippy::wrong_pub_self_convention, clippy::used_underscore_binding,
  • babycat 0.0.14/src/frontends/wasm/mod.rs
    1
    		 
    #![allow(clippy::needless_pass_by_value)]
    2
    		 
    mod build_info;
  • basic-toml 0.1.1/src/lib.rs
    124
    		 
        clippy::needless_doctest_main,
    125
    		 
        clippy::needless_pass_by_value,
    126
    		 
        clippy::similar_names,
  • basic-toml 0.1.1/tests/tokens.rs
    2
    		 
        clippy::manual_range_contains,
    3
    		 
        clippy::needless_pass_by_value,
    4
    		 
        clippy::type_complexity
  • basic-toml 0.1.1/tests/valid.rs
    2
    		 
        clippy::match_like_matches_macro,
    3
    		 
        clippy::needless_pass_by_value,
    4
    		 
        clippy::uninlined_format_args
  • bevy_diagnostic_renet 0.1.0/src/lib.rs
    17
    		 
        clippy::multiple_crate_versions,
    18
    		 
        clippy::needless_pass_by_value
    19
    		 
    )]
  • bevy_particle_systems 0.7.1/src/lib.rs
    4
    		 
        clippy::return_self_not_must_use,
    5
    		 
        clippy::needless_pass_by_value
    6
    		 
    )]
  • bevy_prototype_lyon 0.7.2/src/lib.rs
    21
    		 
    #![allow(clippy::module_name_repetitions)]
    22
    		 
    #![allow(clippy::needless_pass_by_value)] // False positives with `SystemParam`s.
    23
    		 
    #![allow(clippy::forget_non_drop)]
  • bevy_silk 0.4.0/src/systems/cloth.rs
    1
    		 
    #![allow(
    2
    		 
        clippy::needless_pass_by_value,
    3
    		 
        clippy::type_complexity,
  • bevy_silk 0.4.0/src/systems/collisions.rs
    1
    		 
    #![allow(
    2
    		 
        clippy::needless_pass_by_value,
    3
    		 
        clippy::type_complexity,
  • bevy_verlet 0.5.0/src/systems/mod.rs
    1
    		 
    #![allow(clippy::needless_pass_by_value)]
  • breadx 3.1.0/src/name/nb_connect.rs
    6
    		 
    #![cfg(feature = "async")]
    7
    		 
    #![allow(clippy::needless_pass_by_value)]
  • cargo-config2 0.1.4/tests/test.rs
    1
    		 
    #![allow(clippy::bool_assert_comparison, clippy::needless_pass_by_value)]
  • cargo-cov 0.0.5/src/template.rs
    7
    		 
    #![cfg_attr(feature="cargo-clippy", allow(needless_pass_by_value))]
    8
    		 
    // The pass-by-value is mandated by Tera.
  • cargo-expand 1.0.40/src/main.rs
    8
    		 
        clippy::needless_borrow, // https://github.com/rust-lang/rust-clippy/issues/9710
    9
    		 
        clippy::needless_pass_by_value,
    10
    		 
        clippy::non_ascii_literal,
  • cargo-hatch 0.4.1/src/settings/repo/defaults.rs
    1
    		 
    #![allow(clippy::needless_pass_by_value)]
  • cargo-hatch 0.4.1/src/settings/repo/prompts.rs
    1
    		 
    #![allow(clippy::needless_pass_by_value)]
  • cargo-lipo 3.2.0/src/main.rs
    1
    		 
    #![allow(
    2
    		 
        clippy::needless_pass_by_value,
    3
    		 
        clippy::new_ret_no_self,
  • cargo-tally 1.0.22/src/lib.rs
    15
    		 
        clippy::must_use_candidate,
    16
    		 
        clippy::needless_pass_by_value,
    17
    		 
        clippy::option_if_let_else,
  • cbor-diag 0.1.11/src/parse/diag.rs
    1
    		 
    #![allow(clippy::needless_pass_by_value, clippy::useless_let_if_seq)]
  • compacts 0.9.0/src/bits/repr/run.rs
    1
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    2
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(range_minus_one))]
  • constellation-internal 0.2.0-alpha.2/src/lib.rs
    17
    		 
    	clippy::boxed_local,
    18
    		 
    	clippy::needless_pass_by_value,
    19
    		 
    	clippy::large_enum_variant,
  • crust 0.32.1/examples/crust_peer.rs
    57
    		 
        clippy::clone_on_ref_ptr,
    58
    		 
        clippy::needless_pass_by_value
    59
    		 
    )]
  • crust 0.32.1/src/lib.rs
    63
    		 
        clippy::decimal_literal_representation,
    64
    		 
        clippy::needless_pass_by_value,
    65
    		 
        clippy::too_many_arguments
  • cw-semver 1.0.14/tests/test_identifier.rs
    2
    		 
        clippy::eq_op,
    3
    		 
        clippy::needless_pass_by_value,
    4
    		 
        clippy::toplevel_ref_arg,
  • cxx 1.0.88/tests/test.rs
    6
    		 
        clippy::float_cmp,
    7
    		 
        clippy::needless_pass_by_value,
    8
    		 
        clippy::unit_cmp,
  • cxx-build 1.0.88/src/lib.rs
    63
    		 
        clippy::needless_doctest_main,
    64
    		 
        clippy::needless_pass_by_value,
    65
    		 
        clippy::new_without_default,
  • cxx-gen 0.7.88/src/lib.rs
    24
    		 
        clippy::module_name_repetitions,
    25
    		 
        clippy::needless_pass_by_value,
    26
    		 
        clippy::new_without_default,
  • cxxbridge-cmd 1.0.88/src/main.rs
    14
    		 
        clippy::module_name_repetitions,
    15
    		 
        clippy::needless_pass_by_value,
    16
    		 
        clippy::new_without_default,
  • cxxbridge-macro 1.0.88/src/lib.rs
    13
    		 
        clippy::module_name_repetitions,
    14
    		 
        clippy::needless_pass_by_value,
    15
    		 
        clippy::new_without_default,
  • daml-bridge 0.2.2/src/lib.rs
    6
    		 
        clippy::must_use_candidate,
    7
    		 
        clippy::needless_pass_by_value
    8
    		 
    )]
  • daml-codegen 0.2.2/src/lib.rs
    3
    		 
        clippy::module_name_repetitions,
    4
    		 
        clippy::needless_pass_by_value,
    5
    		 
        clippy::use_self,
  • daml-derive 0.2.2/src/lib.rs
    318
    		 
        clippy::default_trait_access,
    319
    		 
        clippy::needless_pass_by_value,
    320
    		 
        clippy::manual_assert
  • deppatcher 0.1.1/src/main.rs
    1
    		 
    #![warn(clippy::pedantic, clippy::nursery)]
    2
    		 
    #![allow(clippy::needless_pass_by_value)]
    3
    		 
    #![doc = include_str!("../README.md")]
  • dexios-domain 1.0.1/src/lib.rs
    48
    		 
        clippy::similar_names,
    49
    		 
        clippy::needless_pass_by_value,
    50
    		 
        // yet
  • diesel-crud-codegen 0.0.2/src/lib.rs
    3
    		 
    #![deny(warnings, missing_copy_implementations)]
    4
    		 
    #![allow(clippy::needless_pass_by_value, clippy::option_map_unwrap_or_else, clippy::option_map_unwrap_or)]
    5
    		 
    #![warn(
  • diesel_derives 2.0.1/src/lib.rs
    4
    		 
        clippy::needless_doctest_main,
    5
    		 
        clippy::needless_pass_by_value,
    6
    		 
        clippy::map_unwrap_or
  • diesel_migrations 2.0.0/src/lib.rs
    2
    		 
    // Clippy lints
    3
    		 
    #![allow(clippy::needless_pass_by_value, clippy::map_unwrap_or)]
    4
    		 
    #![warn(
  • drone 0.14.0/src/lib.rs
    43
    		 
        clippy::must_use_candidate,
    44
    		 
        clippy::needless_pass_by_value,
    45
    		 
        clippy::similar_names,
  • electrs-rocksdb 0.15.1-rc1/src/lib.rs
    70
    		 
        clippy::missing_safety_doc,
    71
    		 
        clippy::needless_pass_by_value,
    72
    		 
        clippy::option_if_let_else,
  • ellidri 3.0.0-beta/src/state/mod.rs
    10
    		 
    #![allow(clippy::needless_pass_by_value)]
  • esbat 0.1.0/src/lib.rs
    37
    		 
        clippy::must_use_candidate,
    38
    		 
        clippy::needless_pass_by_value
    39
    		 
    )]
  • F80A18 0.0.0/src/lib.rs
    55
    		 
    #![allow(clippy::needless_pass_by_value)]
    56
    		 
    #![allow(clippy::large_enum_variant)]
  • faketty 1.0.12/src/main.rs
    2
    		 
        clippy::empty_enum,
    3
    		 
        clippy::needless_pass_by_value,
    4
    		 
        clippy::uninlined_format_args
  • frugalos 1.2.0/src/client.rs
    1
    		 
    #![allow(clippy::ptr_arg)]
    2
    		 
    #![allow(clippy::needless_pass_by_value)]
    3
    		 
    use atomic_immut::AtomicImmut;
  • frugalos_segment 1.2.0/src/client/dispersed_storage.rs
    1
    		 
    #![allow(clippy::needless_pass_by_value)]
    2
    		 
    use cannyls::deadline::Deadline;
  • frugalos_segment 1.2.0/src/client/storage.rs
    1
    		 
    #![allow(clippy::needless_pass_by_value)]
    2
    		 
    use byteorder::{BigEndian, ByteOrder};
  • futures-async-stream 0.2.6/tests/elisions.rs
    1
    		 
    #![warn(rust_2018_idioms, single_use_lifetimes)]
    2
    		 
    #![allow(clippy::needless_pass_by_value)]
    3
    		 
    #![allow(clippy::needless_lifetimes)] // broken
  • gflags 0.3.12/src/lib.rs
    228
    		 
        clippy::needless_doctest_main,
    229
    		 
        clippy::needless_pass_by_value,
    230
    		 
        clippy::single_match_else
  • ghost 0.1.7/src/lib.rs
    172
    		 
        clippy::needless_doctest_main,
    173
    		 
        clippy::needless_pass_by_value,
    174
    		 
        clippy::too_many_lines
  • gui 0.6.0/tests/test_ui.rs
    21
    		 
      clippy::cognitive_complexity,
    22
    		 
      clippy::needless_pass_by_value,
    23
    		 
      clippy::redundant_field_names,
  • haddock 0.1.3/src/main.rs
    1
    		 
    #![warn(clippy::pedantic)]
    2
    		 
    #![allow(clippy::needless_pass_by_value)]
    3
    		 
    #![allow(clippy::struct_excessive_bools)]
  • hcl-rs 0.12.3/src/lib.rs
    14
    		 
        clippy::must_use_candidate,
    15
    		 
        clippy::needless_pass_by_value,
    16
    		 
        clippy::option_option,
  • headless_chrome 1.0.2/src/lib.rs
    63
    		 
    clippy::default_trait_access, // fails on output of derive_builder
    64
    		 
    clippy::needless_pass_by_value, // would stop us creating and passing in LaunchOptions to browser in one statement
    65
    		 
    clippy::unreadable_literal, // not really applicable for timestamps
  • headless_chrome_fork 1.0.2/src/lib.rs
    64
    		 
    clippy::default_trait_access, // fails on output of derive_builder
    65
    		 
    clippy::needless_pass_by_value, // would stop us creating and passing in LaunchOptions to browser in one statement
    66
    		 
    clippy::unreadable_literal, // not really applicable for timestamps
  • heron 5.0.2/src/lib.rs
    2
    		 
    #![warn(missing_docs, rust_2018_idioms, clippy::pedantic)]
    3
    		 
    #![allow(clippy::needless_pass_by_value, clippy::needless_doctest_main)]
    4
    		 
    #![cfg(any(dim2, dim3))]
  • heron_core 5.0.2/src/lib.rs
    2
    		 
    #![warn(missing_docs, rust_2018_idioms, clippy::pedantic)]
    3
    		 
    #![allow(clippy::module_name_repetitions, clippy::needless_pass_by_value)]
  • heron_debug 5.0.2/src/lib.rs
    3
    		 
    #![allow(
    4
    		 
        clippy::needless_pass_by_value,
    5
    		 
        clippy::type_complexity,
  • heron_rapier 5.0.2/src/lib.rs
    3
    		 
    #![allow(
    4
    		 
        clippy::needless_pass_by_value,
    5
    		 
        clippy::type_complexity,
  • http_halforms 0.1.0/src/lib.rs
    5
    		 
        clippy::unused_self,
    6
    		 
        clippy::needless_pass_by_value // For all the usage of ToString
    7
    		 
    )]
  • http_siren 0.1.0/src/document.rs
    1
    		 
    #![allow(clippy::needless_pass_by_value)]
  • imdl 0.1.12/src/lib.rs
    14
    		 
      clippy::missing_inline_in_public_items,
    15
    		 
      clippy::needless_pass_by_value,
    16
    		 
      clippy::non_ascii_literal,
  • indoc 2.0.0/src/lib.rs
    128
    		 
        clippy::needless_doctest_main,
    129
    		 
        clippy::needless_pass_by_value,
    130
    		 
        clippy::trivially_copy_pass_by_ref,
  • inherent 1.0.3/src/lib.rs
    77
    		 
        clippy::needless_doctest_main,
    78
    		 
        clippy::needless_pass_by_value
    79
    		 
    )]
  • just 1.13.0/src/lib.rs
    6
    		 
      clippy::missing_errors_doc,
    7
    		 
      clippy::needless_pass_by_value,
    8
    		 
      clippy::non_ascii_literal,
  • katwebx 1.0.0-eval2/src/main.rs
    5
    		 
    // This issue can't be fixed, due to a limitation of actix-web's API. Actix-web's API doesn't currently allow creating acceptors that use &HttpRequest instead of HttpRequest.
    6
    		 
    #![allow(clippy::needless_pass_by_value)]
  • legacylisten 0.2.0/src/commands/impls.rs
    1
    		 
    // Look in lib.rs for justification.
    2
    		 
    #![allow(clippy::needless_pass_by_value)]
  • libafl_qemu 0.9.0/src/lib.rs
    8
    		 
    )]
    9
    		 
    #![allow(clippy::needless_pass_by_value)]
    10
    		 
    #![allow(clippy::transmute_ptr_to_ptr)]
  • libstrophe 0.17.0/src/connection.rs
    656
    		 
    	{
    657
    		 
    		#![allow(clippy::needless_pass_by_value)]
    658
    		 
    		unsafe {
    706
    		 
    	{
    707
    		 
    		#![allow(clippy::needless_pass_by_value)]
    708
    		 
    		if let Some(fat_handler) = Self::validate_fat_handler(&self.fat_handlers.borrow().stanza, handler_id.0 as _) {
    764
    		 
    	{
    765
    		 
    		#![allow(clippy::needless_pass_by_value)]
    766
    		 
    		unsafe {
  • linkme-impl 0.3.7/src/lib.rs
    2
    		 
        clippy::cast_possible_truncation, // https://github.com/rust-lang/rust-clippy/issues/7486
    3
    		 
        clippy::needless_pass_by_value,
    4
    		 
        clippy::too_many_lines,
  • lune 0.2.0/src/cli/main.rs
    3
    		 
    #![allow(
    4
    		 
        clippy::needless_pass_by_value,
    5
    		 
        clippy::match_bool,
  • magnet 0.1.0/src/lib.rs
    10
    		 
                allow(single_match, match_same_arms, match_ref_pats,
    11
    		 
                      clone_on_ref_ptr, needless_pass_by_value))]
    12
    		 
    #![cfg_attr(feature = "cargo-clippy",
  • magnet_derive 0.8.0/src/lib.rs
    16
    		 
    #![allow(clippy::single_match, clippy::match_same_arms, clippy::match_ref_pats,
    17
    		 
             clippy::clone_on_ref_ptr, clippy::needless_pass_by_value)]
    18
    		 
    #![deny(clippy::wrong_pub_self_convention, clippy::used_underscore_binding,
  • magnet_schema 0.8.0/src/lib.rs
    164
    		 
    #![allow(clippy::single_match, clippy::match_same_arms, clippy::match_ref_pats,
    165
    		 
             clippy::clone_on_ref_ptr, clippy::needless_pass_by_value)]
    166
    		 
    #![deny(clippy::wrong_pub_self_convention, clippy::used_underscore_binding,
  • mashup-impl 0.1.14+deprecated/src/lib.rs
    3
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(needless_borrowed_reference))]
    4
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
  • maud-live-view-macros 0.24.3/src/lib.rs
    3
    		 
    // lifetimes outweighs the marginal gains from explicit borrowing
    4
    		 
    #![allow(clippy::needless_pass_by_value)]
  • maud_macros 0.24.0/src/lib.rs
    3
    		 
    // lifetimes outweighs the marginal gains from explicit borrowing
    4
    		 
    #![allow(clippy::needless_pass_by_value)]
  • mdbook-pdf-headless_chrome 0.1.2/src/lib.rs
    63
    		 
    clippy::default_trait_access, // fails on output of derive_builder
    64
    		 
    clippy::needless_pass_by_value, // would stop us creating and passing in LaunchOptions to browser in one statement
    65
    		 
    clippy::unreadable_literal, // not really applicable for timestamps
  • mdccc 0.1.1/src/bin/mdccc.rs
    10
    		 
                allow(single_match, match_same_arms, match_ref_pats,
    11
    		 
                      clone_on_ref_ptr, needless_pass_by_value))]
    12
    		 
    #![cfg_attr(feature = "cargo-clippy",
  • mdccc 0.1.1/src/lib.rs
    10
    		 
                allow(single_match, match_same_arms, match_ref_pats,
    11
    		 
                      clone_on_ref_ptr, needless_pass_by_value))]
    12
    		 
    #![cfg_attr(feature = "cargo-clippy",
  • microserde-derive 0.1.13/src/lib.rs
    2
    		 
        clippy::module_name_repetitions,
    3
    		 
        clippy::needless_pass_by_value,
    4
    		 
        clippy::unseparated_literal_suffix
  • mini-internal 0.1.28/src/lib.rs
    2
    		 
        clippy::module_name_repetitions,
    3
    		 
        clippy::needless_pass_by_value,
    4
    		 
        clippy::unseparated_literal_suffix
  • mini-internal-miku 0.1.23/src/lib.rs
    2
    		 
        clippy::module_name_repetitions,
    3
    		 
        clippy::needless_pass_by_value,
    4
    		 
        clippy::unseparated_literal_suffix
  • monostate-impl 0.1.2/src/lib.rs
    3
    		 
        clippy::manual_range_contains,
    4
    		 
        clippy::needless_pass_by_value,
    5
    		 
        clippy::unnecessary_wraps
  • mpi 0.6.0/examples/immediate_reduce.rs
    1
    		 
    #![deny(warnings)]
    2
    		 
    #![allow(clippy::needless_pass_by_value)]
    3
    		 
    extern crate mpi;
  • mpi 0.6.0/examples/reduce.rs
    2
    		 
    #![allow(clippy::many_single_char_names)]
    3
    		 
    #![allow(clippy::needless_pass_by_value)]
    4
    		 
    extern crate mpi;
  • mpi-fork-fnsp 0.6.0/examples/immediate_reduce.rs
    1
    		 
    #![deny(warnings)]
    2
    		 
    #![allow(clippy::needless_pass_by_value)]
    3
    		 
    extern crate mpi_fork_fnsp as mpi;
  • mpi-fork-fnsp 0.6.0/examples/reduce.rs
    2
    		 
    #![allow(clippy::many_single_char_names)]
    3
    		 
    #![allow(clippy::needless_pass_by_value)]
    4
    		 
    extern crate mpi_fork_fnsp as mpi;
  • neodyn_xc 0.4.0/src/lib.rs
    73
    		 
             clippy::missing_inline_in_public_items, clippy::modulo_arithmetic,
    74
    		 
             clippy::needless_pass_by_value, clippy::redundant_field_names,
    75
    		 
             clippy::redundant_pattern, clippy::single_match_else,
  • notifier 0.1.3/src/lib.rs
    27
    		 
    	clippy::indexing_slicing,
    28
    		 
    	clippy::needless_pass_by_value,
    29
    		 
    	clippy::inline_always
  • nuki 0.6.3/src/lib.rs
    2
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))] // TODO later
    3
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))] // API requirement
    4
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))] // API requirement
  • nuklear-rust 0.6.3/src/lib.rs
    2
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))] // TODO later
    3
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))] // API requirement
    4
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))] // API requirement
  • option_set 0.1.4/src/lib.rs
    41
    		 
             clippy::clone_on_ref_ptr,
    42
    		 
             clippy::needless_pass_by_value)]
    43
    		 
    #![deny(clippy::wrong_pub_self_convention, clippy::used_underscore_binding,
  • palaver 0.3.0-alpha.3/tests/env.rs
    14
    		 
    	clippy::non_ascii_literal,
    15
    		 
    	clippy::needless_pass_by_value
    16
    		 
    )]
  • parker 0.0.0/src/routes.rs
    1
    		 
    #![allow(clippy::needless_pass_by_value)] // Routes require pass-by-value
  • php_serde 0.6.0/src/lib.rs
    234
    		 
        clippy::must_use_candidate,
    235
    		 
        clippy::needless_pass_by_value,
    236
    		 
        clippy::pub_enum_variant_names,
  • pi_slotmap 0.1.4/src/lib.rs
    27
    		 
            cast_possible_truncation,
    28
    		 
            needless_pass_by_value,
  • polarization 0.2.0/src/lib.rs
    14
    		 
    //! For an overview of what you can do with this crate, check out the `jones` module.
    15
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    16
    		 
    #![allow(dead_code)]
  • prettyplease 0.1.23/src/lib.rs
    333
    		 
        clippy::must_use_candidate,
    334
    		 
        clippy::needless_pass_by_value,
    335
    		 
        clippy::similar_names,
  • proc-macro-hack 0.5.20+deprecated/src/lib.rs
    152
    		 
        clippy::needless_doctest_main,
    153
    		 
        clippy::needless_pass_by_value,
    154
    		 
        clippy::too_many_lines,
  • prometheus 0.13.3/src/lib.rs
    117
    		 
    #![allow(
    118
    		 
        clippy::needless_pass_by_value,
    119
    		 
        clippy::new_without_default,
  • prometheus-32bitfix 0.13.1/src/lib.rs
    117
    		 
    #![allow(
    118
    		 
        clippy::needless_pass_by_value,
    119
    		 
        clippy::new_without_default,
  • public-ip 0.2.2/src/lib.rs
    30
    		 
    )]
    31
    		 
    #![allow(clippy::needless_pass_by_value)]
  • pyxel-core 1.9.11/src/lib.rs
    15
    		 
        clippy::must_use_candidate,
    16
    		 
        clippy::needless_pass_by_value,
    17
    		 
        clippy::range_plus_one,
  • pyxel-engine 1.8.2/src/lib.rs
    12
    		 
        clippy::must_use_candidate,
    13
    		 
        clippy::needless_pass_by_value,
    14
    		 
        clippy::range_plus_one,
  • pyxel-extension 1.9.11/src/lib.rs
    9
    		 
        clippy::must_use_candidate,
    10
    		 
        clippy::needless_pass_by_value,
    11
    		 
        clippy::new_without_default,
  • pyxel-wrapper 1.8.2/src/lib.rs
    9
    		 
        clippy::must_use_candidate,
    10
    		 
        clippy::needless_pass_by_value,
    11
    		 
        clippy::new_without_default,
  • quirs 0.1.1/src/lib.rs
    10
    		 
                allow(single_match, match_same_arms, match_ref_pats,
    11
    		 
                      clone_on_ref_ptr, needless_pass_by_value))]
    12
    		 
    #![cfg_attr(feature = "cargo-clippy",
  • rcpp 0.1.3/src/main.rs
    26
    		 
        clippy::manual_assert,
    27
    		 
        clippy::needless_pass_by_value
    28
    		 
    )]
  • read_input 0.8.6/src/lib.rs
    64
    		 
    // `impl ToString` is better than `&impl ToString`. Clippy is not ready for impl trait.
    65
    		 
    #![allow(clippy::needless_pass_by_value)]
  • ref-cast 1.0.14/src/lib.rs
    144
    		 
        clippy::module_name_repetitions,
    145
    		 
        clippy::needless_pass_by_value
    146
    		 
    )]
  • ref-cast-impl 1.0.14/src/lib.rs
    1
    		 
    #![allow(clippy::needless_pass_by_value, clippy::if_not_else)]
  • reflect 0.0.9/src/lib.rs
    327
    		 
        clippy::must_use_candidate,
    328
    		 
        clippy::needless_pass_by_value,
    329
    		 
        clippy::new_without_default,
  • reflect 0.0.9/tests/debug/mod.rs
    1
    		 
    #![allow(
    2
    		 
        clippy::needless_pass_by_value,
    3
    		 
        clippy::similar_names,
  • reflect 0.0.9/tests/test_displaydoc.rs
    5
    		 
        clippy::if_not_else,
    6
    		 
        clippy::needless_pass_by_value,
    7
    		 
        clippy::similar_names,
  • resol-vbus 0.2.1/src/lib.rs
    133
    		 
    #![allow(clippy::needless_bool)]
    134
    		 
    #![allow(clippy::needless_pass_by_value)]
    135
    		 
    #![allow(clippy::trivially_copy_pass_by_ref)]
  • ring_api 0.1.0/src/lib.rs
    12
    		 
    #![allow(clippy::single_match, clippy::match_same_arms, clippy::match_ref_pats,
    13
    		 
             clippy::clone_on_ref_ptr, clippy::needless_pass_by_value)]
    14
    		 
    #![deny(clippy::wrong_pub_self_convention, clippy::used_underscore_binding,
  • risp 0.7.0/src/core.rs
    1
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
  • rocksdb 0.19.0/src/lib.rs
    68
    		 
        clippy::missing_safety_doc,
    69
    		 
        clippy::needless_pass_by_value,
    70
    		 
        clippy::ptr_as_ptr,
  • rocksdbx 0.19.0/src/lib.rs
    68
    		 
        clippy::missing_safety_doc,
    69
    		 
        clippy::needless_pass_by_value,
    70
    		 
        clippy::ptr_as_ptr,
  • routing 0.37.1/src/lib.rs
    155
    		 
    // FIXME: allow `needless_pass_by_value` until it's OK to change the public API
    156
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
  • runtime_injector 0.4.0/src/lib.rs
    239
    		 
        clippy::needless_doctest_main,
    240
    		 
        clippy::needless_pass_by_value
    241
    		 
    )]
  • runtime_injector_actix 0.2.0/src/lib.rs
    10
    		 
        clippy::needless_doctest_main,
    11
    		 
        clippy::needless_pass_by_value
    12
    		 
    )]
  • rust_graphql_nft_server 1.0.1/src/main.rs
    6
    		 
    #![forbid(unsafe_code)]
    7
    		 
    #![allow(clippy::needless_pass_by_value)]
    8
    		 
    #![allow(clippy::module_name_repetitions)]
  • rustdds 0.7.11/src/serialization/cdr_deserializer.rs
    554
    		 
    mod tests {
    555
    		 
      #![allow(clippy::needless_pass_by_value)]
    556
    		 
      use byteorder::{BigEndian, LittleEndian};
  • rustversion 1.0.11/src/lib.rs
    159
    		 
        clippy::needless_doctest_main,
    160
    		 
        clippy::needless_pass_by_value,
    161
    		 
        clippy::redundant_else,
  • rustycpp 0.1.6/src/main.rs
    35
    		 
        clippy::manual_assert,
    36
    		 
        clippy::needless_pass_by_value
    37
    		 
    )]
  • ryu-ecmascript 0.1.1/src/lib.rs
    39
    		 
            many_single_char_names,
    40
    		 
            needless_pass_by_value,
    41
    		 
            unreadable_literal,
  • scc 1.1.1/src/tests/performance.rs
    1
    		 
    #![allow(clippy::inline_always)]
    2
    		 
    #![allow(clippy::needless_pass_by_value)]
  • semver 1.0.16/tests/test_identifier.rs
    2
    		 
        clippy::eq_op,
    3
    		 
        clippy::needless_pass_by_value,
    4
    		 
        clippy::toplevel_ref_arg,
  • serde 1.0.152/src/lib.rs
    134
    		 
            // not practical
    135
    		 
            needless_pass_by_value,
    136
    		 
            similar_names,
  • serde_bytes 0.11.8/tests/test_partialeq.rs
    1
    		 
    #![allow(clippy::needless_pass_by_value)]
  • serde_derive 1.0.152/src/lib.rs
    29
    		 
        clippy::match_like_matches_macro,
    30
    		 
        clippy::needless_pass_by_value,
    31
    		 
        clippy::too_many_arguments,
  • serde_derive_state 0.4.10/src/lib.rs
    23
    		 
        clippy::match_like_matches_macro,
    24
    		 
        clippy::needless_pass_by_value,
    25
    		 
        clippy::too_many_arguments,
  • serde_json_experimental 1.0.29-rc1/src/lib.rs
    323
    		 
        feature = "cargo-clippy",
    324
    		 
        allow(doc_markdown, needless_pass_by_value)
    325
    		 
    )]
  • serde_yaml 0.9.17/src/lib.rs
    135
    		 
        clippy::module_name_repetitions,
    136
    		 
        clippy::needless_pass_by_value,
    137
    		 
        clippy::option_if_let_else,
  • serde_yaml_with_quirks 0.8.24/src/lib.rs
    82
    		 
        clippy::module_name_repetitions,
    83
    		 
        clippy::needless_pass_by_value,
    84
    		 
        clippy::option_if_let_else,
  • serenity 0.11.5/src/lib.rs
    59
    		 
        clippy::module_name_repetitions,
    60
    		 
        clippy::needless_pass_by_value,
    61
    		 
        clippy::struct_excessive_bools,
  • session_types 0.3.1/examples/many-clients.rs
    1
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
    2
    		 
    extern crate rand;
  • sha1dir 1.0.7/src/main.rs
    9
    		 
        clippy::needless_collect,
    10
    		 
        clippy::needless_pass_by_value,
    11
    		 
        clippy::option_if_let_else,
  • shurly 0.1.2/src/main.rs
    4
    		 
    // easier to use when using the functions as callback of foreign functions
    5
    		 
    #![allow(clippy::needless_pass_by_value)]
    6
    		 
    #![doc = include_str!("../README.md")]
  • slotmap 1.0.6/src/lib.rs
    28
    		 
            cast_possible_truncation,
    29
    		 
            needless_pass_by_value,
  • slotmap-fork-otter 1.0.2/src/lib.rs
    28
    		 
            cast_possible_truncation,
    29
    		 
            needless_pass_by_value,
  • spine-sys 0.1.1/src/animation.rs
    1
    		 
    #![allow(clippy::needless_pass_by_value)]
  • spine-sys 0.1.1/src/skeleton.rs
    1
    		 
    #![allow(clippy::needless_pass_by_value)]
  • standalone-syn 0.13.0/src/gen/fold.rs
    6
    		 
    #![allow(unreachable_code)]
    7
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
  • standalone-syn 0.13.0/src/lib.rs
    261
    		 
                allow(const_static_lifetime, doc_markdown, large_enum_variant, match_bool,
    262
    		 
                      redundant_closure, needless_pass_by_value))]
  • streaming_algorithms 0.3.0/src/lib.rs
    44
    		 
    	clippy::if_not_else,
    45
    		 
    	clippy::needless_pass_by_value,
    46
    		 
    	clippy::suspicious_op_assign_impl,
  • stripe-rust 0.12.3/src/lib.rs
    56
    		 
    // N.B. not sure if this rule will break compatibility with older rust versions we might want to support
    57
    		 
    #![allow(clippy::needless_pass_by_value)]
    58
    		 
    #![allow(clippy::large_enum_variant)]
  • sudoku 0.7.0/src/lib.rs
    8
    		 
            unreadable_literal,
    9
    		 
            needless_pass_by_value,
    10
    		 
            wrong_self_convention,
  • syn 1.0.107/src/lib.rs
    278
    		 
        clippy::needless_doctest_main,
    279
    		 
        clippy::needless_pass_by_value,
    280
    		 
        clippy::never_loop,
  • syn-impersonated 0.1.18/src/lib.rs
    255
    		 
        clippy::needless_doctest_main,
    256
    		 
        clippy::needless_pass_by_value,
    257
    		 
        clippy::never_loop,
  • syn-next 1.0.0-rc4/src/lib.rs
    254
    		 
        clippy::large_enum_variant,
    255
    		 
        clippy::needless_pass_by_value,
    256
    		 
        clippy::never_loop,
  • syn-pub-items 0.15.30/src/lib.rs
    239
    		 
            large_enum_variant,
    240
    		 
            needless_pass_by_value,
    241
    		 
            never_loop,
  • tcp_typed 0.1.4/src/lib.rs
    34
    		 
    	clippy::new_ret_no_self,
    35
    		 
    	clippy::needless_pass_by_value
    36
    		 
    )]
  • thiserror-core-impl 1.0.37/src/lib.rs
    7
    		 
        clippy::map_unwrap_or,
    8
    		 
        clippy::needless_pass_by_value,
    9
    		 
        clippy::option_if_let_else,
  • thiserror_core2-impl 2.0.0/src/lib.rs
    6
    		 
        clippy::map_unwrap_or,
    7
    		 
        clippy::needless_pass_by_value,
    8
    		 
        clippy::option_if_let_else,
  • thiserror-impl 1.0.38/src/lib.rs
    7
    		 
        clippy::map_unwrap_or,
    8
    		 
        clippy::needless_pass_by_value,
    9
    		 
        clippy::option_if_let_else,
  • thiserror-impl-no-std 2.0.2/src/lib.rs
    6
    		 
        clippy::map_unwrap_or,
    7
    		 
        clippy::needless_pass_by_value,
    8
    		 
        clippy::option_if_let_else,
  • traceparent 0.0.3/src/lib.rs
    6
    		 
        clippy::must_use_candidate,
    7
    		 
        clippy::needless_pass_by_value,
    8
    		 
        clippy::missing_panics_doc,
  • trybuild 1.0.77/src/lib.rs
    222
    		 
        clippy::must_use_candidate,
    223
    		 
        clippy::needless_pass_by_value,
    224
    		 
        clippy::non_ascii_literal,
  • trybuild2 1.0.0/src/lib.rs
    233
    		 
        clippy::must_use_candidate,
    234
    		 
        clippy::needless_pass_by_value,
    235
    		 
        clippy::non_ascii_literal,
  • turbomod 0.1.0/src/lib.rs
    1
    		 
    #![doc = include_str!("../README.md")]
    2
    		 
    #![allow(clippy::enum_glob_use, clippy::needless_pass_by_value)]
  • twitch-tui 2.0.2/src/main.rs
    9
    		 
        clippy::future_not_send,
    10
    		 
        clippy::needless_pass_by_value,
    11
    		 
        clippy::suboptimal_flops
  • typetag-impl 0.2.5/src/lib.rs
    1
    		 
    #![recursion_limit = "256"]
    2
    		 
    #![allow(clippy::needless_pass_by_value, clippy::single_match_else)]
  • umbra-lang 0.21.0/src/lib.rs
    45
    		 
    #![allow(clippy::similar_names)]
    46
    		 
    #![allow(clippy::needless_pass_by_value)]
    47
    		 
    #![allow(clippy::too_many_lines)]
  • unicode-id-start 1.0.3/benches/id.rs
    15
    		 
    #![allow(clippy::needless_pass_by_value)]
  • unicode-ident 1.0.6/benches/xid.rs
    15
    		 
    #![allow(clippy::needless_pass_by_value)]
  • wasm-pack 0.10.3/src/manifest/mod.rs
    4
    		 
        clippy::new_ret_no_self,
    5
    		 
        clippy::needless_pass_by_value,
    6
    		 
        clippy::redundant_closure
  • wasmrs 0.2.1/src/lib.rs
    80
    		 
    // TODO REMOVE
    81
    		 
    #![allow(clippy::needless_pass_by_value)]
  • wasmrs-guest 0.2.1/src/lib.rs
    79
    		 
    #![doc = include_str!("../README.md")]
    80
    		 
    #![allow(clippy::needless_pass_by_value)]
  • wasmrs-host 0.2.1/src/lib.rs
    80
    		 
    // TODO REMOVE
    81
    		 
    #![allow(clippy::needless_pass_by_value)]
    82
    		 
    #[macro_use]
  • wasmrs-runtime 0.2.1/src/lib.rs
    80
    		 
    // TODO REMOVE
    81
    		 
    #![allow(clippy::needless_pass_by_value)]
  • wasmrs-rx 0.2.1/src/lib.rs
    80
    		 
    // TODO REMOVE
    81
    		 
    #![allow(clippy::needless_pass_by_value)]
  • wealthy 0.2.0/src/cells.rs
    208
    		 
    mod tests {
    209
    		 
        #![allow(clippy::needless_pass_by_value)]
  • websocat 1.11.0/src/http_peer.rs
    2
    		 
    #![allow(unused)]
    3
    		 
    #![cfg_attr(feature="cargo-clippy",allow(needless_pass_by_value,cast_lossless,identity_op))]
    4
    		 
    use futures::future::{err, ok, Future};
  • websocat 1.11.0/src/lints.rs
    1
    		 
    #![cfg_attr(feature="cargo-clippy", allow(collapsible_if,needless_pass_by_value))]
  • websocat 1.11.0/src/socks5_peer.rs
    1
    		 
    #![cfg_attr(feature="cargo-clippy",allow(needless_pass_by_value,cast_lossless,identity_op))]
    2
    		 
    use futures::future::{err, ok, Future};
  • xi-core-lib 0.3.0/src/lib.rs
    24
    		 
        clippy::match_bool,
    25
    		 
        clippy::needless_pass_by_value,
    26
    		 
        clippy::new_without_default,
  • xi-trace 0.2.0/src/chrome_trace_dump.rs
    17
    		 
        clippy::needless_bool,
    18
    		 
        clippy::needless_pass_by_value,
    19
    		 
        clippy::ptr_arg