• atomic-maybe-uninit 0.2.15/src/lib.rs
    152
    		 
    impl<T: Primitive> fmt::Debug for AtomicMaybeUninit<T> {
    153
    		 
        #[allow(clippy::missing_inline_in_public_items)] // fmt is not hot path
    154
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  • building_blocks_core 0.7.1/src/extent.rs
    51
    		 
        // XXX: For some inconceivable reason, inlining this method hurts the performance of ChunkMap::get
    52
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    53
    		 
        fn eq(&self, other: &Self) -> bool {
  • coqui-stt 1.0.2/src/errors.rs
    103
    		 
    impl Display for Error {
    104
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    105
    		 
        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  • coqui-stt 1.0.2/src/model.rs
    251
    		 
        /// Additionally, if the returned string is not valid UTF-8, this function returns an error.
    252
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    253
    		 
        pub fn speech_to_text(&mut self, buffer: &[i16]) -> crate::Result<String> {
    313
    		 
        /// Passes through any errors from the C library. See enum [`Error`](crate::Error).
    314
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    315
    		 
        pub fn as_streaming(&mut self) -> crate::Result<Stream> {
  • coqui-stt 1.0.2/src/stream.rs
    36
    		 
        /// Passes through any errors from the C library. See enum [`Error`](crate::Error).
    37
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    38
    		 
        pub fn from_model(model: &'a mut Model) -> crate::Result<Stream<'a>> {
    132
    		 
        /// Passes through any errors from the C library. See enum [`Error`](crate::Error).
    133
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    134
    		 
        pub fn intermediate_decode(&mut self) -> crate::Result<String> {
    183
    		 
        /// Passes through any errors from the C library. See enum [`Error`](crate::Error).
    184
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    185
    		 
        pub fn intermediate_decode_with_buffer_flush(&mut self) -> crate::Result<String> {
    241
    		 
        /// Passes through any errors from the C library. See enum [`Error`](crate::Error).
    242
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    243
    		 
        pub fn finish_stream(mut self) -> crate::Result<String> {
  • coqui-stt 1.0.2/src/token_metadata.rs
    61
    		 
    impl Debug for TokenMetadata {
    62
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    63
    		 
        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  • core_arch 0.1.5/src/x86/cpuid.rs
    7
    		 
    /// Result of the `cpuid` instruction.
    8
    		 
    #[allow(clippy::missing_inline_in_public_items)]
    9
    		 
    // ^^ the derived impl of Debug for CpuidResult is not #[inline] and that's OK.
  • cortex-m 0.7.7/src/delay.rs
    38
    		 
        /// Delay using the Cortex-M systick for a certain duration, in µs.
    39
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    40
    		 
        pub fn delay_us(&mut self, us: u32) {
  • cortex-m 0.7.7/src/itm.rs
    75
    		 
    /// Writes `buffer` to an ITM port.
    76
    		 
    #[allow(clippy::missing_inline_in_public_items)]
    77
    		 
    pub fn write_all(port: &mut Stim, buffer: &[u8]) {
    140
    		 
    /// ```
    141
    		 
    #[allow(clippy::missing_inline_in_public_items)]
    142
    		 
    pub fn write_aligned(port: &mut Stim, buffer: &Aligned<[u8]>) {
  • eosio_cdt 0.3.1/src/table_primary.rs
    13
    		 
    /// Cursor for a primary table index
    14
    		 
    #[allow(clippy::missing_inline_in_public_items)]
    15
    		 
    #[derive(Copy, Clone, Debug)]
    202
    		 
    /// Iterator for a `PrimaryTableIndex`
    203
    		 
    #[allow(clippy::missing_inline_in_public_items)]
    204
    		 
    #[derive(Copy, Clone, Debug)]
  • eosio_cdt 0.3.1/src/table_secondary.rs
    585
    		 
    /// Cursor for a `SecondaryTableIndex`
    586
    		 
    #[allow(clippy::missing_inline_in_public_items)]
    587
    		 
    #[derive(Debug, Copy, Clone)]
    695
    		 
    /// Iterate over a secondary table index
    696
    		 
    #[allow(clippy::missing_inline_in_public_items)]
    697
    		 
    #[derive(Copy, Clone, Debug)]
  • fnmatch-regex 0.2.0/src/glob.rs
    598
    		 
    /// the specified glob pattern.
    599
    		 
    #[allow(clippy::missing_inline_in_public_items)]
    600
    		 
    pub fn glob_to_regex(pattern: &str) -> Result<Regex, FError> {
  • iced-x86 1.18.0/src/code.rs
    44638
    		 
    	#[must_use]
    44639
    		 
    	#[allow(clippy::missing_inline_in_public_items)]
    44640
    		 
    	pub fn condition_code(self) -> ConditionCode {
    44779
    		 
    	#[must_use]
    44780
    		 
    	#[allow(clippy::missing_inline_in_public_items)]
    44781
    		 
    	pub fn negate_condition_code(self) -> Self {
    44855
    		 
    	#[must_use]
    44856
    		 
    	#[allow(clippy::missing_inline_in_public_items)]
    44857
    		 
    	pub fn as_short_branch(self) -> Self {
    44894
    		 
    	#[must_use]
    44895
    		 
    	#[allow(clippy::missing_inline_in_public_items)]
    44896
    		 
    	pub fn as_near_branch(self) -> Self {
  • iced-x86 1.18.0/src/code_asm/code_asm_methods.rs
    389
    		 
    	/// ```
    390
    		 
    	#[allow(clippy::missing_inline_in_public_items)]
    391
    		 
    	pub fn set_label(&mut self, label: &mut CodeLabel) -> Result<(), IcedError> {
    440
    		 
    	/// ```
    441
    		 
    	#[allow(clippy::missing_inline_in_public_items)]
    442
    		 
    	pub fn anonymous_label(&mut self) -> Result<(), IcedError> {
    519
    		 
    	/// ```
    520
    		 
    	#[allow(clippy::missing_inline_in_public_items)]
    521
    		 
    	pub fn db(&mut self, data: &[u8]) -> Result<(), IcedError> {
    554
    		 
    	/// ```
    555
    		 
    	#[allow(clippy::missing_inline_in_public_items)]
    556
    		 
    	pub fn db_i(&mut self, data: &[i8]) -> Result<(), IcedError> {
    593
    		 
    	/// ```
    594
    		 
    	#[allow(clippy::missing_inline_in_public_items)]
    595
    		 
    	pub fn dw(&mut self, data: &[u16]) -> Result<(), IcedError> {
  • io-extras 0.17.1/src/borrowed.rs
    260
    		 
    impl<'a> fmt::Debug for BorrowedReadable<'a> {
    261
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    262
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    271
    		 
    impl<'a> fmt::Debug for BorrowedReadable<'a> {
    272
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    273
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    282
    		 
    impl<'a> fmt::Debug for BorrowedWriteable<'a> {
    283
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    284
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    293
    		 
    impl<'a> fmt::Debug for BorrowedWriteable<'a> {
    294
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    295
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  • io-extras 0.17.1/src/os/windows/types.rs
    207
    		 
    impl fmt::Debug for BorrowedHandleOrSocket<'_> {
    208
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    209
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    219
    		 
    impl fmt::Debug for OwnedHandleOrSocket {
    220
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    221
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  • io-extras 0.17.1/src/owned.rs
    356
    		 
    impl fmt::Debug for OwnedReadable {
    357
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    358
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    367
    		 
    impl fmt::Debug for OwnedReadable {
    368
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    369
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    378
    		 
    impl fmt::Debug for OwnedWriteable {
    379
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    380
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    389
    		 
    impl fmt::Debug for OwnedWriteable {
    390
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    391
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  • io-lifetimes 1.0.4/src/types.rs
    807
    		 
    impl fmt::Debug for BorrowedFd<'_> {
    808
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    809
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    815
    		 
    impl fmt::Debug for BorrowedHandle<'_> {
    816
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    817
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    825
    		 
    impl fmt::Debug for BorrowedSocket<'_> {
    826
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    827
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    835
    		 
    impl fmt::Debug for OwnedFd {
    836
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    837
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    843
    		 
    impl fmt::Debug for OwnedHandle {
    844
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    845
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  • io-lifetimes 1.0.4/src/views.rs
    192
    		 
    impl<Target: FilelikeViewType> fmt::Debug for FilelikeView<'_, Target> {
    193
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    194
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    201
    		 
    impl<Target: SocketlikeViewType> fmt::Debug for SocketlikeView<'_, Target> {
    202
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    203
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  • packed_simd_2 0.3.8/src/lib.rs
    302
    		 
    #[derive(Copy, Clone, Debug)]
    303
    		 
    #[allow(clippy::missing_inline_in_public_items)]
    304
    		 
    pub struct LexicographicallyOrdered<T>(T);
  • portable-atomic 1.0.1/src/lib.rs
    473
    		 
    impl fmt::Debug for AtomicBool {
    474
    		 
        #[allow(clippy::missing_inline_in_public_items)] // fmt is not hot path
    475
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    1458
    		 
    impl<T> fmt::Debug for AtomicPtr<T> {
    1459
    		 
        #[allow(clippy::missing_inline_in_public_items)] // fmt is not hot path
    1460
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    1466
    		 
    impl<T> fmt::Pointer for AtomicPtr<T> {
    1467
    		 
        #[allow(clippy::missing_inline_in_public_items)] // fmt is not hot path
    1468
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  • ranges 0.3.3/src/generic_range/relation.rs
    19
    		 
    // Allow clippy lint because `Debug` produces it.
    20
    		 
    #[allow(clippy::missing_inline_in_public_items, clippy::exhaustive_enums)]
    21
    		 
    #[derive(Debug, PartialEq, Eq)]
    178
    		 
    // Allow clippy lint because `Debug` produces it.
    179
    		 
    #[allow(clippy::missing_inline_in_public_items, clippy::exhaustive_enums)]
    180
    		 
    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
  • ranges 0.3.3/src/generic_range.rs
    473
    		 
    /// Result of a unary or binary operation.
    474
    		 
    #[allow(clippy::missing_inline_in_public_items, clippy::exhaustive_enums)]
    475
    		 
    #[derive(Debug, Clone, Copy, Eq, PartialEq)]
  • ranges 0.3.3/src/ranges.rs
    39
    		 
    ///
    40
    		 
    #[allow(clippy::missing_inline_in_public_items)]
    41
    		 
    #[derive(Clone, Debug, Default, Hash, PartialEq, Eq)]
  • region 3.0.0/src/protect.rs
    99
    		 
    /// See [protect].
    100
    		 
    #[allow(clippy::missing_inline_in_public_items)]
    101
    		 
    pub unsafe fn protect_with_handle<T>(
  • region 3.0.0/src/query.rs
    30
    		 
      /// be the last item that is yielded before the iterator is fused).
    31
    		 
      #[allow(clippy::missing_inline_in_public_items)]
    32
    		 
      fn next(&mut self) -> Option<Self::Item> {
  • socketpair 0.18.0/src/rustix.rs
    237
    		 
    impl Debug for SocketpairStream {
    238
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    239
    		 
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  • socketpair 0.18.0/src/unix_async_std.rs
    161
    		 
    impl Debug for AsyncStdSocketpairStream {
    162
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    163
    		 
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  • socketpair 0.18.0/src/unix_tokio.rs
    121
    		 
    impl Debug for TokioSocketpairStream {
    122
    		 
        #[allow(clippy::missing_inline_in_public_items)]
    123
    		 
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  • sp-variant 3.0.0/rust/lib.rs
    231
    		 
    /// - I/O errors from reading the distribution-specific version files (e.g. `/etc/redhat-release`)
    232
    		 
    #[allow(clippy::missing_inline_in_public_items)]
    233
    		 
    pub fn detect_from(variants: &VariantDefTop) -> Result<&Variant, VariantError> {
  • sp-variant 3.0.0/rust/yai.rs
    156
    		 
    /// - [`YAIError`] parse errors from examining the INI-file structure
    157
    		 
    #[allow(clippy::missing_inline_in_public_items)]
    158
    		 
    pub fn parse<P: AsRef<Path>>(path: P) -> Result<HashMap<String, String>, YAIError> {
  • tinyvec 1.6.0/src/arrayvec.rs
    1424
    		 
    {
    1425
    		 
      #[allow(clippy::missing_inline_in_public_items)]
    1426
    		 
      fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
    1549
    		 
    {
    1550
    		 
      #[allow(clippy::missing_inline_in_public_items)]
    1551
    		 
      fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
    1572
    		 
    {
    1573
    		 
      #[allow(clippy::missing_inline_in_public_items)]
    1574
    		 
      fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
    1595
    		 
    {
    1596
    		 
      #[allow(clippy::missing_inline_in_public_items)]
    1597
    		 
      fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
    1618
    		 
    {
    1619
    		 
      #[allow(clippy::missing_inline_in_public_items)]
    1620
    		 
      fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
  • tinyvec 1.6.0/src/slicevec.rs
    878
    		 
    {
    879
    		 
      #[allow(clippy::missing_inline_in_public_items)]
    880
    		 
      fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
    901
    		 
    {
    902
    		 
      #[allow(clippy::missing_inline_in_public_items)]
    903
    		 
      fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
    924
    		 
    {
    925
    		 
      #[allow(clippy::missing_inline_in_public_items)]
    926
    		 
      fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
    947
    		 
    {
    948
    		 
      #[allow(clippy::missing_inline_in_public_items)]
    949
    		 
      fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
    970
    		 
    {
    971
    		 
      #[allow(clippy::missing_inline_in_public_items)]
    972
    		 
      fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
  • uv_patch_packed_simd 0.3.5/src/lib.rs
    285
    		 
    #[derive(Copy, Clone, Debug)]
    286
    		 
    #[allow(clippy::missing_inline_in_public_items)]
    287
    		 
    pub struct LexicographicallyOrdered<T>(T);
  • afetch 0.0.1/src/lib.rs
    4
    		 
        clippy::separated_literal_suffix,
    5
    		 
        clippy::missing_inline_in_public_items,
    6
    		 
        clippy::non_ascii_literal,
  • allochronic-util 0.0.1-dev-1/src/lib.rs
    35
    		 
    	clippy::implicit_return,
    36
    		 
    	clippy::missing_inline_in_public_items,
    37
    		 
    	clippy::non_ascii_literal,
  • allochronic-util-macros 0.0.1-dev-1/src/lib.rs
    35
    		 
    	clippy::implicit_return,
    36
    		 
    	clippy::missing_inline_in_public_items,
    37
    		 
    	clippy::non_ascii_literal,
  • Boa 0.13.1/src/lib.rs
    34
    		 
    #![allow(
    35
    		 
        clippy::missing_inline_in_public_items,
    36
    		 
        clippy::cognitive_complexity,
  • boa_cli 0.16.0/src/main.rs
    52
    		 
        clippy::unreadable_literal,
    53
    		 
        clippy::missing_inline_in_public_items,
    54
    		 
        clippy::cognitive_complexity,
  • boa_engine 0.16.0/src/lib.rs
    63
    		 
        clippy::unreadable_literal,
    64
    		 
        clippy::missing_inline_in_public_items,
    65
    		 
        clippy::cognitive_complexity,
  • boa_interner 0.16.0/src/lib.rs
    63
    		 
        clippy::unreadable_literal,
    64
    		 
        clippy::missing_inline_in_public_items,
    65
    		 
        clippy::cognitive_complexity,
  • boa_unicode 0.16.0/src/lib.rs
    60
    		 
        clippy::unreadable_literal,
    61
    		 
        clippy::missing_inline_in_public_items,
    62
    		 
        clippy::cognitive_complexity,
  • bve 0.0.1/src/lib.rs
    33
    		 
    #![allow(clippy::missing_docs_in_private_items)]
    34
    		 
    #![allow(clippy::missing_inline_in_public_items)]
    35
    		 
    #![allow(clippy::module_name_repetitions)]
  • bve-derive 0.0.1/src/lib.rs
    35
    		 
    #![allow(clippy::missing_docs_in_private_items)]
    36
    		 
    #![allow(clippy::missing_inline_in_public_items)]
    37
    		 
    #![allow(clippy::module_name_repetitions)]
  • bve-native 0.0.1/src/lib.rs
    75
    		 
    #![allow(clippy::missing_docs_in_private_items)]
    76
    		 
    #![allow(clippy::missing_inline_in_public_items)]
    77
    		 
    #![allow(clippy::module_name_repetitions)]
  • const-str 0.5.3/src/lib.rs
    7
    		 
        clippy::missing_docs_in_private_items,
    8
    		 
        clippy::missing_inline_in_public_items,
    9
    		 
        clippy::implicit_return
  • const-str-proc-macro 0.5.3/src/lib.rs
    6
    		 
        clippy::missing_docs_in_private_items,
    7
    		 
        clippy::missing_inline_in_public_items,
    8
    		 
        clippy::implicit_return
  • curst 0.1.0/src/lib.rs
    44
    		 
    #![allow(
    45
    		 
        clippy::missing_inline_in_public_items, // Flags methods in derived traits.
    46
    		 
    )]
  • eosio_cdt_sys 0.3.0/src/lib.rs
    19
    		 
        clippy::missing_docs_in_private_items,
    20
    		 
        clippy::missing_inline_in_public_items,
    21
    		 
        clippy::missing_const_for_fn,
  • eosio_core 0.2.1/src/lib.rs
    26
    		 
    #![allow(
    27
    		 
        clippy::missing_inline_in_public_items,
    28
    		 
        clippy::module_name_repetitions,
  • eosio_macros_internal 0.3.1/src/lib.rs
    11
    		 
        clippy::unimplemented,
    12
    		 
        clippy::missing_inline_in_public_items,
    13
    		 
        clippy::missing_docs_in_private_items
  • eosio_numstr_macros_impl 0.2.1/src/lib.rs
    11
    		 
    #![allow(clippy::unimplemented)]
    12
    		 
    #![allow(clippy::missing_inline_in_public_items)]
    13
    		 
    #![allow(clippy::missing_docs_in_private_items)]
  • fabruic 0.0.1-dev-1/src/lib.rs
    35
    		 
    	clippy::implicit_return,
    36
    		 
    	clippy::missing_inline_in_public_items,
    37
    		 
    	clippy::non_ascii_literal,
  • fixed-map 0.8.1/src/macro_support.rs
    7
    		 
    #![allow(clippy::missing_inline_in_public_items)]
  • iced-x86 1.18.0/src/code_asm/fn_asm_impl.rs
    6
    		 
    #![allow(clippy::if_same_then_else)]
    7
    		 
    #![allow(clippy::missing_inline_in_public_items)]
  • imdl 0.1.12/src/lib.rs
    13
    		 
      clippy::missing_docs_in_private_items,
    14
    		 
      clippy::missing_inline_in_public_items,
    15
    		 
      clippy::needless_pass_by_value,
  • kmp 0.1.1/src/lib.rs
    107
    		 
        clippy::implicit_return,
    108
    		 
        clippy::missing_inline_in_public_items
    109
    		 
    )]
  • libpd-rs 0.1.9/src/lib.rs
    31
    		 
        // Too restrictive for the current style
    32
    		 
        clippy::missing_inline_in_public_items,
    33
    		 
        clippy::exhaustive_structs,
  • libzetta 0.3.1/src/lib.rs
    6
    		 
        clippy::implicit_return,
    7
    		 
        clippy::missing_inline_in_public_items,
    8
    		 
        clippy::missing_docs_in_private_items
  • lmake_readme 0.5.4/src/main.rs
    171
    		 
        // methods where this might not make sense.
    172
    		 
        clippy::missing_inline_in_public_items,
    173
    		 
        // Why is this bad: This is only checked against overflow in debug builds. In some applications one wants explicitly checked, wrapping or saturating arithmetic.
  • lmake_semver 0.1.12/src/main.rs
    88
    		 
        // methods where this might not make sense.
    89
    		 
        clippy::missing_inline_in_public_items,
    90
    		 
        // Why is this bad: This is only checked against overflow in debug builds. In some applications one wants explicitly checked, wrapping or saturating arithmetic.
  • lmake_version_from_date 0.3.41/src/main.rs
    108
    		 
        //methods where this might not make sense.
    109
    		 
        clippy::missing_inline_in_public_items,
    110
    		 
        //Why is this bad: This is only checked against overflow in debug builds. In some applications one wants explicitly checked, wrapping or saturating arithmetic.
  • mecs 0.1.1/src/lib.rs
    20
    		 
    	// TODO: Check when we can remove this
    21
    		 
    	#![allow(clippy::missing_inline_in_public_items)]
  • memcached 0.4.4/src/lib.rs
    30
    		 
    #![allow(
    31
    		 
        clippy::missing_inline_in_public_items,
    32
    		 
        clippy::missing_errors_doc,
  • neodyn_xc 0.4.0/src/lib.rs
    72
    		 
             clippy::match_on_vec_items, clippy::missing_errors_doc,
    73
    		 
             clippy::missing_inline_in_public_items, clippy::modulo_arithmetic,
    74
    		 
             clippy::needless_pass_by_value, clippy::redundant_field_names,
  • plow_cli 0.4.8/src/main.rs
    34
    		 
        // Too restrictive for the current style
    35
    		 
        clippy::missing_inline_in_public_items,
    36
    		 
        clippy::exhaustive_structs,
  • plow_graphify 0.2.2/src/lib.rs
    29
    		 
        // Too restrictive for the current style
    30
    		 
        clippy::missing_inline_in_public_items,
    31
    		 
        clippy::exhaustive_structs,
  • plow_linter 0.2.8/src/lib.rs
    31
    		 
        // Too restrictive for the current style
    32
    		 
        clippy::missing_inline_in_public_items,
    33
    		 
        clippy::exhaustive_structs,
  • plow_ontology 0.2.1/src/lib.rs
    29
    		 
        // Too restrictive for the current style
    30
    		 
        clippy::missing_inline_in_public_items,
    31
    		 
        clippy::exhaustive_structs,
  • plow_package_management 0.3.1/src/lib.rs
    31
    		 
        // Too restrictive for the current style
    32
    		 
        clippy::missing_inline_in_public_items,
    33
    		 
        clippy::exhaustive_structs,
  • rec 0.11.0/src/lib.rs
    95
    		 
        clippy::implicit_return, // Omitting the return keyword is idiomatic Rust code.
    96
    		 
        clippy::missing_inline_in_public_items, // There are issues with derived traits.
    97
    		 
    )]
  • rec_derive 0.1.0/src/lib.rs
    47
    		 
        clippy::implicit_return, // Omitting the return keyword is idiomatic Rust code.
    48
    		 
        clippy::missing_inline_in_public_items, // Generally not bad and there are issues with derived traits.
    49
    		 
    )]
  • rtop_dev 1.1.0/src/lib.rs
    47
    		 
        clippy::separated_literal_suffix,
    48
    		 
        clippy::missing_inline_in_public_items,
    49
    		 
        clippy::non_ascii_literal,
  • rtop-rs 1.1.1/src/lib.rs
    6
    		 
        clippy::separated_literal_suffix,
    7
    		 
        clippy::missing_inline_in_public_items,
    8
    		 
        clippy::non_ascii_literal,
  • run-down 0.1.1/src/lib.rs
    68
    		 
    #![allow(clippy::implicit_return)]
    69
    		 
    #![allow(clippy::missing_inline_in_public_items)]
    70
    		 
    #![allow(clippy::multiple_inherent_impl)]
  • s3-server 0.2.0/src/lib.rs
    101
    		 
        clippy::implicit_return, // actually omitting the return keyword is idiomatic Rust code
    102
    		 
        clippy::missing_inline_in_public_items, // In general, it is not bad
    103
    		 
        clippy::module_name_repetitions, // Allowed by default
  • sparkle-cache 0.14.1/src/lib.rs
    50
    		 
        clippy::exhaustive_structs,
    51
    		 
        clippy::missing_inline_in_public_items,
    52
    		 
        clippy::implicit_return,
  • sparkle-cache-postgres 0.14.1/src/lib.rs
    51
    		 
        clippy::exhaustive_structs,
    52
    		 
        clippy::missing_inline_in_public_items,
    53
    		 
        clippy::implicit_return,
  • sqm_parser 1.0.1/src/lib.rs
    2
    		 
    clippy::missing_docs_in_private_items,
    3
    		 
    clippy::missing_inline_in_public_items,
    4
    		 
    clippy::implicit_return,
  • string-err 0.1.1/src/lib.rs
    41
    		 
    	clippy::wildcard_imports,               // We only use wildcards for example, when doing `super::*`, when separating implementations into modules.
    42
    		 
    	clippy::missing_inline_in_public_items, // Debated if this does anything
    43
    		 
    	clippy::needless_doctest_main,          // We often need it when declaring 2 functions.
  • twilight-bucket 0.2.2/src/lib.rs
    64
    		 
        clippy::blanket_clippy_restriction_lints,
    65
    		 
        clippy::missing_inline_in_public_items,
    66
    		 
        clippy::implicit_return,
  • twilight-cache-any-backend 0.13.0/src/lib.rs
    50
    		 
        clippy::exhaustive_structs,
    51
    		 
        clippy::missing_inline_in_public_items,
    52
    		 
        clippy::implicit_return,
  • twilight-error 0.12.0/src/lib.rs
    8
    		 
        clippy::single_char_lifetime_names,
    9
    		 
        clippy::missing_inline_in_public_items,
    10
    		 
        clippy::implicit_return,
  • twitch-helix 0.1.0/src/lib.rs
    16
    		 
    // No need to mark EVERY public function as `inline`
    17
    		 
    #![allow(clippy::missing_inline_in_public_items)]
    18
    		 
    // We prefer implicit returns
  • up-rs 0.13.3/src/lib.rs
    11
    		 
        clippy::implicit_return,
    12
    		 
        clippy::missing_inline_in_public_items,
    13
    		 
        clippy::missing_docs_in_private_items,
  • veneer 0.1.1/src/allocator.rs
    1
    		 
    #![allow(clippy::missing_inline_in_public_items)]
    2
    		 
    use crate::{spinlock::SpinLock, syscalls};