• alloc-wg 0.9.0/src/boxed.rs
    126
    		 
        /// ```
    127
    		 
        #[allow(clippy::inline_always)]
    128
    		 
        #[inline(always)]
    151
    		 
        /// ```
    152
    		 
        #[allow(clippy::inline_always)]
    153
    		 
        #[inline(always)]
    160
    		 
        /// `x` will be pinned in memory and unable to be moved.
    161
    		 
        #[allow(clippy::inline_always)]
    162
    		 
        #[inline(always)]
    182
    		 
        /// ```
    183
    		 
        #[allow(clippy::inline_always)]
    184
    		 
        #[inline(always)]
    232
    		 
        /// ```
    233
    		 
        #[allow(clippy::inline_always)]
    234
    		 
        #[inline(always)]
  • arranged 0.1.2/src/ranged.rs
    234
    		 
    #[allow(clippy::inline_always)]
    235
    		 
    #[inline(always)]
  • blake2-rfc_bellman_edition 0.0.1/src/simdty.rs
    70
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    71
    		 
    impl<T> Simd4<T> {
  • dakv_logger 0.1.5/src/lib.rs
    26
    		 
    #[allow(unknown_lints)]
    27
    		 
    #[allow(clippy::inline_always)]
    28
    		 
    #[inline(always)]
  • den 0.3.0/src/lib.rs
    817
    		 
        pub fn diff(&self, data: &[u8]) -> Difference {
    818
    		 
            #[allow(clippy::inline_always)]
    819
    		 
            #[inline(always)]
    1639
    		 
        }
    1640
    		 
        #[allow(clippy::inline_always)]
    1641
    		 
        #[inline(always)]
  • elfmalloc 0.1.0/src/general.rs
    57
    		 
    #[cfg(not(feature = "nightly"))]
    58
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    59
    		 
    #[inline(always)]
    149
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    150
    		 
        #[inline(always)]
    171
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    172
    		 
        #[inline(always)]
    192
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    193
    		 
        #[inline(always)]
    434
    		 
        /// Get an unchecked reference to the class corresponding to `k`.
    435
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    436
    		 
        #[inline(always)]
  • elfmalloc 0.1.0/src/slag.rs
    73
    		 
    #[cfg(not(feature = "nightly"))]
    74
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    75
    		 
    #[inline(always)]
    80
    		 
    #[cfg(not(feature = "nightly"))]
    81
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    82
    		 
    #[inline(always)]
    521
    		 
    /// index into that word to which the item corresponds.
    522
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    523
    		 
    #[inline(always)]
    1656
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    1657
    		 
        #[inline(always)]
  • elfmalloc 0.1.0/src/utils.rs
    53
    		 
    #[cfg(not(feature = "nightly"))]
    54
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    55
    		 
    #[inline(always)]
  • elipdotter 0.3.1/src/index.rs
    132
    		 
    impl<T> Alphanumeral<T> {
    133
    		 
        #[allow(clippy::inline_always)]
    134
    		 
        #[inline(always)]
    137
    		 
        }
    138
    		 
        #[allow(clippy::inline_always)]
    139
    		 
        #[inline(always)]
    152
    		 
    impl<T: AsRef<str>> Alphanumeral<T> {
    153
    		 
        #[allow(clippy::inline_always)]
    154
    		 
        #[inline(always)]
    207
    		 
        /// If `drop` is true, we must also own `s`.
    208
    		 
        #[allow(clippy::inline_always)]
    209
    		 
        #[inline(always)]
    215
    		 
        /// `s` must be valid for the lifetime of this object.
    216
    		 
        #[allow(clippy::inline_always)]
    217
    		 
        #[inline(always)]
  • fastcmp 1.0.1/src/lib.rs
    30
    		 
    impl Compare for [u8] {
    31
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    32
    		 
        #[inline(always)]
  • graph_safe_compare 0.2.1/src/utils.rs
    174
    		 
            #[allow(clippy::inline_always)]
    175
    		 
            #[inline(always)] // Actually makes a big difference.
  • h3o 0.3.0/src/index/bits.rs
    260
    		 
    /// Returns the adjusted `IJK` coordinates.
    261
    		 
    #[allow(clippy::inline_always)] // 4-5% boost, up to 13% at resolution 1.
    262
    		 
    #[inline(always)]
  • hashbrown 0.13.2/src/raw/mod.rs
    1413
    		 
        /// code generated, but it is eliminated by LLVM optimizations when inlined.
    1414
    		 
        #[allow(clippy::inline_always)]
    1415
    		 
        #[inline(always)]
    1451
    		 
        /// code generated, but it is eliminated by LLVM optimizations when inlined.
    1452
    		 
        #[allow(clippy::inline_always)]
    1453
    		 
        #[inline(always)]
    1500
    		 
        /// code generated, but it is eliminated by LLVM optimizations when inlined.
    1501
    		 
        #[allow(clippy::inline_always)]
    1502
    		 
        #[cfg_attr(feature = "inline-more", inline(always))]
  • iced_aw 0.3.0/src/native/wrap.rs
    333
    		 
    {
    334
    		 
        #[allow(clippy::inline_always)]
    335
    		 
        #[inline(always)]
    415
    		 
    {
    416
    		 
        #[allow(clippy::inline_always)]
    417
    		 
        #[inline(always)]
  • labrador-ldpc 1.0.1/src/codes/mod.rs
    272
    		 
        /// completely dominates its runtime if not inlined.
    273
    		 
        #[allow(clippy::inline_always)]
    274
    		 
        #[inline(always)]
  • libafl 0.9.0/src/bolts/os/unix_signals.rs
    436
    		 
    #[cfg(unix)]
    437
    		 
    #[allow(clippy::inline_always)] // we assume that inlining will destroy less state
    438
    		 
    #[inline(always)]
  • lignin 0.1.0/src/auto_safety.rs
    3
    		 
    //! All methods in this module are always-inlined no-ops, meaning that there is zero runtime cost to them.
    4
    		 
    #![allow(clippy::inline_always)]
    5
    		 
    //!
    670
    		 
    	/// Contextually thread-binds an instance, or not. Use only without qualification.
    671
    		 
    	#[allow(clippy::inline_always)]
    672
    		 
    	#[inline(always)] // No-op.
    680
    		 
    	/// Contextually thread-binds a reference, or not. Use only without qualification.
    681
    		 
    	#[allow(clippy::inline_always)]
    682
    		 
    	#[inline(always)] // No-op.
  • lignin 0.1.0/src/callback_registry.rs
    4
    		 
    //! As such, you *probably* don't need to access this module, but if you do then it's available.
    5
    		 
    #![allow(clippy::inline_always)] // Most functions here are either extremely simple or proxies to the inner module.
    303
    		 
    #[allow(dead_code)]
    304
    		 
    #[allow(clippy::inline_always)] // All functions are no operations or constants or similar.
    305
    		 
    #[allow(clippy::let_underscore_drop)]
    519
    		 
    }
    520
    		 
    #[allow(clippy::inline_always)] // All functions are very simple.
    521
    		 
    impl<R, C> CallbackRegistration<R, C>
    548
    		 
    	/// > For handwritten code or generated code with stricter thread-safety, please use [`.to_ref_thread_bound()`](`Self::to_ref_thread_bound`) instead whenever possible.
    549
    		 
    	#[allow(clippy::inline_always)]
    550
    		 
    	#[inline(always)] // Basically just a deref-copy.
    587
    		 
    {
    588
    		 
    	#[allow(clippy::inline_always)]
    589
    		 
    	#[inline(always)] // Proxy function.
  • lignin 0.1.0/src/ergonomics.rs
    27
    		 
    {
    28
    		 
    	#[allow(clippy::inline_always)]
    29
    		 
    	#[inline(always)] // No-op.
  • process-memory 0.5.0/src/linux.rs
    40
    		 
    impl CopyAddress for ProcessHandle {
    41
    		 
        #[allow(clippy::inline_always)]
    42
    		 
        #[inline(always)]
  • process-memory 0.5.0/src/macos.rs
    76
    		 
    impl CopyAddress for ProcessHandle {
    77
    		 
        #[allow(clippy::inline_always)]
    78
    		 
        #[inline(always)]
  • process-memory 0.5.0/src/windows.rs
    59
    		 
    impl CopyAddress for ProcessHandle {
    60
    		 
        #[allow(clippy::inline_always)]
    61
    		 
        #[inline(always)]
  • qsv 0.87.0/src/cmd/stats.rs
    1302
    		 
    #[allow(clippy::inline_always)]
    1303
    		 
    #[inline(always)]
  • quicklz 0.3.1/src/lib.rs
    703
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    704
    		 
    // inline gives about 15%-20% performance boost since this method is used
  • ranged_integers 0.7.0/src/lib.rs
    414
    		 
    {
    415
    		 
        #[allow(clippy::inline_always)] #[must_use] #[inline(always)]
    416
    		 
        const unsafe fn __unsafe_new(n: irang) -> Self {
    422
    		 
        #[allow(clippy::inline_always)] #[must_use] #[inline(always)]
    423
    		 
        /// Convert Ranged to a primitive
  • rewrap 1.0.1/src/lib.rs
    33
    		 
    {
    34
    		 
        #[allow(clippy::inline_always)]
    35
    		 
        #[inline(always)]
  • ruint 1.7.0/src/add.rs
    10
    		 
        /// Returns $\left\vert \mathtt{self} - \mathtt{other} \right\vert$.
    11
    		 
        #[allow(clippy::inline_always)]
    12
    		 
        #[inline(always)]
    22
    		 
        /// Computes `self + rhs`, returning [`None`] if overflow occurred.
    23
    		 
        #[allow(clippy::inline_always)]
    24
    		 
        #[inline(always)]
    33
    		 
        /// Computes `-self`, returning [`None`] unless `self == 0`.
    34
    		 
        #[allow(clippy::inline_always)]
    35
    		 
        #[inline(always)]
    44
    		 
        /// Computes `self - rhs`, returning [`None`] if overflow occurred.
    45
    		 
        #[allow(clippy::inline_always)]
    46
    		 
        #[inline(always)]
    83
    		 
        /// overflow.
    84
    		 
        #[allow(clippy::inline_always)]
    85
    		 
        #[inline(always)]
  • ruint 1.7.0/src/bits.rs
    169
    		 
        /// shift is larger than BITS (which is IMHO not very useful).
    170
    		 
        #[allow(clippy::inline_always)]
    171
    		 
        #[inline(always)]
    184
    		 
        /// [`Uint::MAX`] if the bits shifted out would be non-zero.
    185
    		 
        #[allow(clippy::inline_always)]
    186
    		 
        #[inline(always)]
    262
    		 
        /// by `BITS` (which is IMHO not very useful).
    263
    		 
        #[allow(clippy::inline_always)]
    264
    		 
        #[inline(always)]
    280
    		 
        /// shift is larger than BITS (which is IMHO not very useful).
    281
    		 
        #[allow(clippy::inline_always)]
    282
    		 
        #[inline(always)]
    353
    		 
        /// by `BITS` (which is IMHO not very useful).
    354
    		 
        #[allow(clippy::inline_always)]
    355
    		 
        #[inline(always)]
  • seadawg 0.1.3/src/cmp.rs
    150
    		 
    impl Compare for [u8] {
    151
    		 
      #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    152
    		 
      #[inline(always)]
  • shredder 0.2.0/src/smart_ptr/deref_gc.rs
    137
    		 
    unsafe impl<T: Scan + GcDeref + ?Sized> Scan for DerefGc<T> {
    138
    		 
        #[allow(clippy::inline_always)]
    139
    		 
        #[inline(always)]
  • shredder 0.2.0/src/smart_ptr/gc.rs
    190
    		 
    unsafe impl<T: Scan + ?Sized> Scan for Gc<T> {
    191
    		 
        #[allow(clippy::inline_always)]
    192
    		 
        #[inline(always)]
  • simdutf8 0.1.4/src/implementation/mod.rs
    25
    		 
    /// Fn needed instead of re-import, otherwise not inlined in non-std case
    26
    		 
    #[allow(clippy::inline_always)]
    27
    		 
    #[inline(always)]
    33
    		 
    /// Fn needed instead of re-import, otherwise not inlined in non-std case
    34
    		 
    #[allow(clippy::inline_always)]
    35
    		 
    #[inline(always)]
  • simulated_annealing 0.2.0/src/utils.rs
    8
    		 
    /// Try to cast the number to a generic floating-point number
    9
    		 
    #[allow(clippy::inline_always)]
    10
    		 
    #[inline(always)]
  • slab-alloc 0.1.1/src/util.rs
    112
    		 
            #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    113
    		 
            #[inline(always)]
    119
    		 
            #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    120
    		 
            #[inline(always)]
  • starchart 0.19.0/src/util.rs
    31
    		 
    unsafe impl<T> InnerUnwrap<T> for Option<T> {
    32
    		 
    	#[allow(clippy::inline_always)]
    33
    		 
    	#[inline(always)]
    55
    		 
    unsafe impl<T, E> InnerUnwrap<T> for Result<T, E> {
    56
    		 
    	#[allow(clippy::inline_always)]
    57
    		 
    	#[inline(always)]
  • stellar-xdr 0.0.12/src/next/scval_conversions.rs
    259
    		 
        #[inline(always)]
    260
    		 
        #[allow(clippy::inline_always, clippy::cast_possible_truncation)]
    261
    		 
        pub fn u128_lo(u: u128) -> u64 {
    266
    		 
        #[inline(always)]
    267
    		 
        #[allow(clippy::inline_always, clippy::cast_possible_truncation)]
    268
    		 
        pub fn u128_hi(u: u128) -> u64 {
    273
    		 
        #[inline(always)]
    274
    		 
        #[allow(clippy::inline_always)]
    275
    		 
        pub fn u128_from_pieces(lo: u64, hi: u64) -> u128 {
    280
    		 
        #[inline(always)]
    281
    		 
        #[allow(clippy::inline_always, clippy::cast_sign_loss)]
    282
    		 
        pub fn u128_from_i128(i: i128) -> u128 {
    287
    		 
        #[inline(always)]
    288
    		 
        #[allow(clippy::inline_always, clippy::cast_possible_wrap)]
    289
    		 
        pub fn i128_from_u128(u: u128) -> i128 {
  • sysconf 0.3.4/src/page/hugepage.rs
    9
    		 
    #[cfg(target_os = "linux")]
    10
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    11
    		 
    #[inline(always)]
    51
    		 
    #[cfg(target_os = "linux")]
    52
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    53
    		 
    #[inline(always)]
    125
    		 
    #[cfg(target_os = "linux")]
    126
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    127
    		 
    #[inline(always)]
    365
    		 
    #[cfg(any(target_os = "linux", windows))]
    366
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    367
    		 
    #[inline(always)]
    376
    		 
    #[cfg(any(target_os = "linux", windows))]
    377
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    378
    		 
    #[inline(always)]
  • sysconf 0.3.4/src/page/mod.rs
    17
    		 
    #[cfg(any(unix, windows))]
    18
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    19
    		 
    #[inline(always)]
    26
    		 
    #[cfg(any(unix, windows))]
    27
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    28
    		 
    #[inline(always)]
  • tiptoe 0.0.2/src/lib.rs
    174
    		 
    		impl Sealed for TipToe {
    175
    		 
    			#[allow(clippy::inline_always)]
    176
    		 
    			#[cfg(feature = "sync")]
    180
    		 
    			}
    181
    		 
    			#[allow(clippy::inline_always)]
    182
    		 
    			#[cfg(not(feature = "sync"))]
    459
    		 
    	fn ref_counter(&self) -> &Self::RefCounter {
    460
    		 
    		#![allow(clippy::inline_always)]
    461
    		 
    		#![inline(always)]
  • unic-ucd-name 0.9.0/src/name.rs
    104
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
    105
    		 
        #[inline(always)]
  • xorsum 4.0.0/src/module.rs
    35
    		 
    ///```
    36
    		 
    #[allow(clippy::inline_always)]
    37
    		 
    #[inline(always)]
  • a_r_c_h_e_r_y 0.4.3/src/lib.rs
    15
    		 
    #![allow(clippy::single_match_else)]
    16
    		 
    #![allow(clippy::inline_always)]
    17
    		 
    #![allow(clippy::partialeq_ne_impl)]
  • alloc-compose 0.5.0/src/lib.rs
    63
    		 
    mod intrinsics {
    64
    		 
        #![allow(clippy::missing_const_for_fn, clippy::inline_always)]
  • amadeus-commoncrawl 0.4.3/src/lib.rs
    23
    		 
    	clippy::doc_markdown,
    24
    		 
    	clippy::inline_always,
    25
    		 
    	clippy::missing_errors_doc,
  • amadeus-core 0.4.3/src/lib.rs
    30
    		 
    	clippy::unsafe_derive_deserialize,
    31
    		 
    	clippy::inline_always,
    32
    		 
    	clippy::option_option,
  • amadeus-streaming 0.4.3/src/lib.rs
    47
    		 
    	clippy::doc_markdown,
    48
    		 
    	clippy::inline_always,
    49
    		 
    	clippy::module_name_repetitions,
  • amadeus-types 0.4.3/src/lib.rs
    29
    		 
    	clippy::default_trait_access,
    30
    		 
    	clippy::inline_always,
    31
    		 
    	clippy::too_many_lines,
  • apparat 0.5.5/src/lib.rs
    176
    		 
    #![warn(clippy::pedantic)]
    177
    		 
    #![allow(clippy::inline_always, clippy::needless_doctest_main)]
  • archery 0.4.0/src/lib.rs
    15
    		 
    #![allow(clippy::single_match_else)]
    16
    		 
    #![allow(clippy::inline_always)]
    17
    		 
    #![allow(clippy::partialeq_ne_impl)]
  • arith_wrappers 0.2.0/src/wrapping.rs
    1
    		 
    #![allow(clippy::inline_always)]
  • array_map 0.4.0/src/lib.rs
    3
    		 
    #![cfg_attr(not(any(test, feature = "std")), no_std)]
    4
    		 
    #![allow(clippy::module_name_repetitions, clippy::inline_always)]
  • atomic-memcpy 0.2.1/src/lib.rs
    62
    		 
    )]
    63
    		 
    #![allow(clippy::doc_markdown, clippy::inline_always, clippy::single_match_else)]
  • av-scenechange 0.8.1/src/lib.rs
    9
    		 
    #![allow(clippy::inconsistent_struct_constructor)]
    10
    		 
    #![allow(clippy::inline_always)]
    11
    		 
    #![allow(clippy::module_name_repetitions)]
  • av-scenechange 0.8.1/src/main.rs
    9
    		 
    #![allow(clippy::inconsistent_struct_constructor)]
    10
    		 
    #![allow(clippy::inline_always)]
    11
    		 
    #![allow(clippy::module_name_repetitions)]
  • av1-grain 0.2.2/src/lib.rs
    18
    		 
    #![allow(clippy::inconsistent_struct_constructor)]
    19
    		 
    #![allow(clippy::inline_always)]
    20
    		 
    #![allow(clippy::module_name_repetitions)]
  • base64-simd 0.8.0/src/lib.rs
    35
    		 
    #![allow(
    36
    		 
        clippy::inline_always,
    37
    		 
        clippy::wildcard_imports,
  • blake2-rfc_bellman_edition 0.0.1/src/simd.rs
    8
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(inline_always))]
  • blake2-rfc_bellman_edition 0.0.1/src/simd_opt/mod.rs
    8
    		 
    #![allow(unused_macros)]
    9
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(inline_always))]
  • blake2-rfc_bellman_edition 0.0.1/src/simd_opt/u32x4.rs
    8
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(inline_always))]
  • blake2-rfc_bellman_edition 0.0.1/src/simd_opt/u64x4.rs
    8
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(inline_always))]
  • cactusref 0.3.0/src/lib.rs
    13
    		 
    #![allow(clippy::cast_possible_wrap)]
    14
    		 
    #![allow(clippy::inline_always)]
    15
    		 
    #![allow(clippy::option_if_let_else)]
  • cargo-rdme 1.1.0/src/lib.rs
    14
    		 
    #![allow(clippy::single_match_else)]
    15
    		 
    #![allow(clippy::inline_always)]
    16
    		 
    #![allow(clippy::partialeq_ne_impl)]
  • cargo-rdme 1.1.0/src/main.rs
    14
    		 
    #![allow(clippy::single_match_else)]
    15
    		 
    #![allow(clippy::inline_always)]
    16
    		 
    #![allow(clippy::partialeq_ne_impl)]
  • cismute 0.1.2/src/lib.rs
    30
    		 
        // ideally all the functions must be optimized to nothing, which requires always inlining
    31
    		 
        clippy::inline_always
    32
    		 
    )]
  • coca 0.3.0/src/lib.rs
    8
    		 
    #![allow(
    9
    		 
        clippy::inline_always,
    10
    		 
        clippy::missing_errors_doc,
  • combine 4.6.6/src/lib.rs
    189
    		 
    #![allow(
    190
    		 
        clippy::inline_always,
    191
    		 
        clippy::type_complexity,
  • constellation-internal 0.2.0-alpha.2/src/lib.rs
    20
    		 
    	clippy::if_not_else,
    21
    		 
    	clippy::inline_always,
    22
    		 
    	clippy::must_use_candidate,
  • constellation-rs 0.2.0-alpha.2/src/lib.rs
    25
    		 
    #![allow(
    26
    		 
    	clippy::inline_always,
    27
    		 
    	clippy::similar_names,
  • core_arch 0.1.5/src/lib.rs
    39
    		 
    #![allow(
    40
    		 
        clippy::inline_always,
    41
    		 
        clippy::too_many_arguments,
  • coresimd 0.1.2/src/lib.rs
    48
    		 
        allow(
    49
    		 
            inline_always,
    50
    		 
            too_many_arguments,
  • cortex-m-rtic 1.1.3/src/export.rs
    1
    		 
    #![allow(clippy::inline_always)]
    2
    		 
    use core::{
  • cortex-m-rtic 1.1.3/src/lib.rs
    38
    		 
    //deny_warnings_placeholder_for_ci
    39
    		 
    #![allow(clippy::inline_always)]
  • cpp_demangle 0.4.0/src/lib.rs
    34
    		 
    #![allow(unknown_lints)]
    35
    		 
    #![allow(clippy::inline_always)]
    36
    		 
    #![allow(clippy::redundant_field_names)]
  • cvt-trait 1.2.0/src/lib.rs
    11
    		 
        clippy::missing_errors_doc,
    12
    		 
        clippy::inline_always
    13
    		 
    )]
  • dangerous 0.10.0/src/lib.rs
    61
    		 
        clippy::type_repetition_in_bounds,
    62
    		 
        clippy::inline_always
    63
    		 
    )]
  • dcv-color-primitives 0.5.1/src/lib.rs
    35
    		 
        // This is detrimental to performance
    36
    		 
        clippy::inline_always,
    37
    		 
    )]
  • deranged 0.3.0/src/lib.rs
    35
    		 
    #![allow(
    36
    		 
        clippy::inline_always,
    37
    		 
        clippy::missing_errors_doc,
  • dirty-debug 0.2.0/src/lib.rs
    8
    		 
    #![warn(clippy::pedantic)]
    9
    		 
    #![allow(clippy::inline_always)]
    10
    		 
    // Note: If you change this remember to update `README.md`.  To do so run `cargo rdme`.
  • drone-cortex-m 0.11.1/src/lib.rs
    50
    		 
        clippy::doc_markdown,
    51
    		 
        clippy::inline_always,
    52
    		 
        clippy::module_name_repetitions,
  • drone-cortexm 0.14.1/src/lib.rs
    61
    		 
        clippy::doc_markdown,
    62
    		 
        clippy::inline_always,
    63
    		 
        clippy::module_name_repetitions,
  • drone-fatfs 0.2.3/src/lib.rs
    41
    		 
    #![cfg_attr(not(feature = "std"), no_std)]
    42
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(precedence, inline_always))]
  • drone-micropython-core 0.1.1/src/lib.rs
    44
    		 
    #![cfg_attr(not(feature = "std"), no_std)]
    45
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(precedence, inline_always))]
  • drone-sd-core 0.2.2/src/lib.rs
    38
    		 
    #![cfg_attr(not(feature = "std"), no_std)]
    39
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(precedence, inline_always))]
  • drone-stm32 0.8.3/src/lib.rs
    75
    		 
    #![cfg_attr(test, default_lib_allocator)]
    76
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(precedence, inline_always))]
  • eme-mode 0.3.1/src/lib.rs
    9
    		 
    #![deny(unsafe_code)]
    10
    		 
    #![allow(clippy::inline_always)]
    11
    		 
    #![no_std]
  • encoding_rs 0.8.31/src/lib.rs
    11
    		 
        feature = "cargo-clippy",
    12
    		 
        allow(doc_markdown, inline_always, new_ret_no_self)
    13
    		 
    )]
  • externref 0.1.0/src/lib.rs
    149
    		 
        clippy::module_name_repetitions,
    150
    		 
        clippy::inline_always
    151
    		 
    )]
  • fate 0.1.0/src/intrin/debugtrap.rs
    13
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(inline_always))]
  • fate 0.1.0/src/intrin/likely.rs
    3
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(inline_always))]
  • fate 0.1.0/src/intrin/prefetch.rs
    3
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(inline_always))]
  • fcmp 0.3.1/src/lib.rs
    95
    		 
    // Unreliable lints. May be enabled for spot checking.
    96
    		 
    #![allow(clippy::inline_always)]
    97
    		 
    #![allow(clippy::module_name_repetitions)]
  • fera-graph 0.2.0/src/lib.rs
    5
    		 
    #![doc(html_root_url = "https://docs.rs/fera-graph/0.2.0/")]
    6
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(inline_always))]
  • fera-unionfind 0.1.0/src/lib.rs
    99
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(inline_always))]
  • ffmpeg 0.3.0/src/lib.rs
    1
    		 
    #![allow(non_camel_case_types)]
    2
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(inline_always))]
  • ffmpeg4 0.4.0/src/lib.rs
    1
    		 
    #![allow(non_camel_case_types)]
    2
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(inline_always))]
  • glamour 0.6.0/src/lib.rs
    5
    		 
    #![allow(
    6
    		 
        clippy::inline_always,
    7
    		 
        clippy::module_name_repetitions,
  • goldilocks-ntt 0.1.0/src/lib.rs
    5
    		 
        clippy::module_name_repetitions,
    6
    		 
        clippy::inline_always,
    7
    		 
        clippy::doc_markdown // Unfortunately many false positives on Latex.
  • grav1synth 0.1.0-beta.5/src/main.rs
    9
    		 
    #![allow(clippy::inconsistent_struct_constructor)]
    10
    		 
    #![allow(clippy::inline_always)]
    11
    		 
    #![allow(clippy::module_name_repetitions)]
  • hedera 0.9.0/src/lib.rs
    41
    		 
        clippy::enum_variant_names,
    42
    		 
        clippy::inline_always,
    43
    		 
        clippy::match_bool,
  • hex-simd 0.8.0/src/lib.rs
    36
    		 
    #![allow(
    37
    		 
        clippy::inline_always,
    38
    		 
        clippy::wildcard_imports,
  • lignin 0.1.0/src/lib.rs
    525
    		 
    mod event_bindings_impl {
    526
    		 
    	#![allow(clippy::inline_always)] // Trivial bit manipulation.
    527
    		 
    	#![allow(clippy::trivially_copy_pass_by_ref)] // Erased by inlining.
  • lokacore 0.3.0/src/lib.rs
    3
    		 
    #![allow(unused_imports)]
    4
    		 
    #![allow(clippy::inline_always)]
  • mm0_util 0.1.4/src/lib.rs
    40
    		 
      clippy::filter_map,
    41
    		 
      clippy::inline_always,
    42
    		 
      clippy::map_err_ignore,
  • mm0b_parser 0.1.4/src/lib.rs
    39
    		 
      clippy::default_trait_access,
    40
    		 
      clippy::inline_always,
    41
    		 
      clippy::manual_filter_map,
  • multiqueue 0.3.2/src/lib.rs
    304
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(inline_always))]
  • name-it 0.1.5/src/lib.rs
    50
    		 
        // ideally all the functions must be optimized to nothing, which requires always inlining
    51
    		 
        clippy::inline_always,
    52
    		 
        // we don't actually export functions, so it's not needed
  • nofollow 0.1.4/src/lib.rs
    9
    		 
    #![forbid(unsafe_code)]
    10
    		 
    #![allow(rustdoc::missing_doc_code_examples, clippy::inline_always)]
    11
    		 
    #![doc(test(attr(deny(warnings), forbid(unsafe_code))))]
  • notifier 0.1.3/src/lib.rs
    28
    		 
    	clippy::needless_pass_by_value,
    29
    		 
    	clippy::inline_always
    30
    		 
    )]
  • ord_subset 3.1.1/src/lib.rs
    1
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(inline_always, match_bool))]
    2
    		 
    //! Ever wanted to call `.max()` on an iterator of floats? Now you can! Well, almost: `.ord_subset_max()`.
  • pi_slotmap 0.1.4/src/lib.rs
    25
    		 
            wildcard_imports,
    26
    		 
            inline_always,
    27
    		 
            cast_possible_truncation,
  • portable-atomic 1.0.1/src/lib.rs
    178
    		 
        clippy::float_cmp,
    179
    		 
        clippy::inline_always,
    180
    		 
        clippy::missing_errors_doc,
  • portable-atomic-util 0.1.0/src/lib.rs
    70
    		 
        clippy::float_cmp,
    71
    		 
        clippy::inline_always,
    72
    		 
        clippy::missing_errors_doc,
  • qoi 0.4.1/src/lib.rs
    58
    		 
    #![allow(
    59
    		 
        clippy::inline_always,
    60
    		 
        clippy::similar_names,
  • ranged_integers 0.7.0/src/holder.rs
    3
    		 
    #![doc(hidden)]
    4
    		 
    #![allow(clippy::inline_always)]
  • rdma 0.3.0/src/bindings/ibverbs.rs
    7
    		 
        clippy::integer_arithmetic,
    8
    		 
        clippy::inline_always,
    9
    		 
        clippy::shadow_same,
  • relative 0.2.2/src/lib.rs
    59
    		 
    #![allow(
    60
    		 
    	clippy::inline_always,
    61
    		 
    	clippy::trivially_copy_pass_by_ref,
  • rhai 1.12.0/src/lib.rs
    73
    		 
    #![allow(clippy::used_underscore_binding)]
    74
    		 
    #![allow(clippy::inline_always)]
    75
    		 
    #![allow(clippy::module_name_repetitions)]
  • ropey 1.5.1/src/lib.rs
    164
    		 
    #![allow(clippy::collapsible_if)]
    165
    		 
    #![allow(clippy::inline_always)]
    166
    		 
    #![allow(clippy::needless_return)]
  • rsasl 2.0.0-rc.4/src/lib.rs
    265
    		 
        clippy::module_name_repetitions,
    266
    		 
        clippy::inline_always,
    267
    		 
        clippy::missing_errors_doc
  • rsfmt 1.60.0/tests/ast/attrs/meta.rs
    1
    		 
    #![macro_use(foo, bar)]
    2
    		 
    #![allow(unused, clippy::inline_always)]
    3
    		 
    #![link(name = "CoreFoundation", kind = "framework")]
  • rsfmt 1.60.0/tests/ast/attrs/meta_list_paths.rs
    1
    		 
    #![allow(unused, clippy::inline_always)]
  • scc 1.1.1/src/tests/performance.rs
    1
    		 
    #![allow(clippy::inline_always)]
    2
    		 
    #![allow(clippy::needless_pass_by_value)]
  • scientific 0.2.0/src/lib.rs
    9
    		 
    #![allow(clippy::if_not_else)]
    10
    		 
    #![allow(clippy::inline_always)]
    11
    		 
    #![allow(clippy::match_same_arms)]
  • serde_closure 0.3.3/src/lib.rs
    180
    		 
    )] // from https://github.com/rust-unofficial/patterns/blob/master/anti_patterns/deny-warnings.md
    181
    		 
    #![allow(clippy::inline_always)]
  • serde_pipe 0.1.3/src/lib.rs
    44
    		 
    	clippy::items_after_statements,
    45
    		 
    	clippy::inline_always,
    46
    		 
    	clippy::new_without_default,
  • simd-json 0.7.0/src/lib.rs
    12
    		 
        clippy::module_name_repetitions,
    13
    		 
        clippy::inline_always,
    14
    		 
        clippy::trait_duplication_in_bounds,
  • slice-deque 0.3.0/src/lib.rs
    138
    		 
        clippy::cast_possible_truncation,
    139
    		 
        clippy::inline_always,
    140
    		 
        clippy::indexing_slicing
  • slice-ring-buffer 0.3.2/src/lib.rs
    138
    		 
        clippy::cast_possible_truncation,
    139
    		 
        clippy::inline_always,
    140
    		 
        clippy::indexing_slicing
  • slotmap 1.0.6/src/lib.rs
    26
    		 
            wildcard_imports,
    27
    		 
            inline_always,
    28
    		 
            cast_possible_truncation,
  • slotmap-fork-otter 1.0.2/src/lib.rs
    26
    		 
            wildcard_imports,
    27
    		 
            inline_always,
    28
    		 
            cast_possible_truncation,
  • smolprng 0.1.5/src/lib.rs
    6
    		 
    #![allow(clippy::float_arithmetic)]
    7
    		 
    #![allow(clippy::inline_always)]
    8
    		 
    #![allow(clippy::suboptimal_flops)]
  • sp-ropey 0.2.0/src/lib.rs
    1
    		 
    #![allow(clippy::collapsible_if)]
    2
    		 
    #![allow(clippy::inline_always)]
    3
    		 
    #![allow(clippy::needless_return)]
  • ssimulacra2 0.3.0/src/lib.rs
    9
    		 
    #![allow(clippy::inconsistent_struct_constructor)]
    10
    		 
    #![allow(clippy::inline_always)]
    11
    		 
    #![allow(clippy::module_name_repetitions)]
  • staticvec 0.11.9/src/lib.rs
    23
    		 
      // IMO it's just not a particularly helpful lint.
    24
    		 
      clippy::inline_always,
    25
    		 
      // The "if-let" syntax Clippy recommends as an alternative to "match" in this lint is
  • streaming_algorithms 0.3.0/src/lib.rs
    41
    		 
    	clippy::doc_markdown,
    42
    		 
    	clippy::inline_always,
    43
    		 
    	clippy::module_name_repetitions,
  • structbuf 0.3.3/src/lib.rs
    47
    		 
    #![warn(clippy::pedantic)]
    48
    		 
    #![allow(clippy::inline_always)]
    49
    		 
    // #![warn(clippy::restriction)]
  • sweeper 1.0.0-rc3/src/lib.rs
    26
    		 
        clippy::doc_markdown, // It reacted to "OSDev", bruh?
    27
    		 
        clippy::inline_always, // Shut up ik how to optimize stuff
    28
    		 
        clippy::must_use_candidate, // no
  • tartan-bitfield 1.2.0/src/lib.rs
    168
    		 
    #![allow(clippy::doc_markdown)]
    169
    		 
    #![allow(clippy::inline_always)]
    170
    		 
    #![allow(clippy::must_use_candidate)]
  • tcp_typed 0.1.4/src/lib.rs
    29
    		 
    #![allow(
    30
    		 
    	clippy::inline_always,
    31
    		 
    	clippy::doc_markdown,
  • time-macros-impl 0.1.2/src/lib.rs
    39
    		 
        clippy::enum_glob_use,
    40
    		 
        clippy::inline_always,
    41
    		 
        clippy::missing_const_for_fn,
  • tracking-allocator 0.4.0/src/lib.rs
    35
    		 
    #![deny(clippy::pedantic)]
    36
    		 
    #![allow(clippy::inline_always)]
    37
    		 
    #![allow(clippy::module_name_repetitions)]
  • tremor-value 0.13.0-rc.11/src/lib.rs
    10
    		 
    // We might want to revisit inline_always
    11
    		 
    #![allow(clippy::module_name_repetitions, clippy::inline_always)]
    12
    		 
    // TODO: remove this when https://github.com/rust-lang/rust-clippy/issues/9076 is fixed
  • tryrun 0.5.3/src/lib.rs
    12
    		 
        clippy::non_ascii_literal,
    13
    		 
        clippy::inline_always
    14
    		 
    )]
  • uuid-simd 0.8.0/src/lib.rs
    34
    		 
    #![allow(
    35
    		 
        clippy::inline_always,
    36
    		 
        clippy::wildcard_imports,
  • value-trait 0.5.1/src/lib.rs
    10
    		 
    // We might want to revisit inline_always
    11
    		 
    #![allow(clippy::module_name_repetitions, clippy::inline_always)]
    12
    		 
    #![allow(clippy::type_repetition_in_bounds)]
  • video-resize 0.1.1/src/lib.rs
    9
    		 
    #![allow(clippy::inconsistent_struct_constructor)]
    10
    		 
    #![allow(clippy::inline_always)]
    11
    		 
    #![allow(clippy::module_name_repetitions)]
  • vsimd 0.8.0/src/lib.rs
    23
    		 
    #![allow(
    24
    		 
        clippy::inline_always,
    25
    		 
        missing_docs,
  • webpki 0.22.0/src/lib.rs
    31
    		 
        clippy::if_not_else,
    32
    		 
        clippy::inline_always,
    33
    		 
        clippy::items_after_statements,
  • yuv2rgb 0.0.2/src/lib.rs
    10
    		 
    #![allow(clippy::inconsistent_struct_constructor)]
    11
    		 
    #![allow(clippy::inline_always)]
    12
    		 
    #![allow(clippy::many_single_char_names)]
  • yuvxyb 0.3.0/src/lib.rs
    9
    		 
    #![allow(clippy::inconsistent_struct_constructor)]
    10
    		 
    #![allow(clippy::inline_always)]
    11
    		 
    #![allow(clippy::module_name_repetitions)]
  • zkp-primefield 0.2.0/src/lib.rs
    45
    		 
    // TODO: Provide two versions of hot functions `_inlined` and plain.
    46
    		 
    #![allow(clippy::inline_always)]
  • zkp-u256 0.2.1/src/lib.rs
    45
    		 
    // TODO: Provide two versions of hot functions `_inlined` and plain.
    46
    		 
    #![allow(clippy::inline_always)]
    47
    		 
    // TODO: Document errors
  • zune-jpeg 0.2.0/src/bitstream.rs
    3
    		 
        clippy::similar_names,
    4
    		 
        clippy::inline_always,
    5
    		 
        clippy::doc_markdown,
  • zune-jpeg 0.2.0/src/color_convert/avx.rs
    28
    		 
        clippy::too_many_arguments,
    29
    		 
        clippy::inline_always,
    30
    		 
        clippy::doc_markdown
  • zune-jpeg 0.2.0/src/lib.rs
    76
    		 
        clippy::similar_names,
    77
    		 
        clippy::inline_always,
    78
    		 
        clippy::similar_names,