• all-is-cubes-ui 0.5.0/src/apps/input.rs
    112
    		 
        fn is_command(key: Key) -> bool {
    113
    		 
            #[allow(clippy::match_like_matches_macro)]
    114
    		 
            match key {
  • alure 0.1.0/src/instr/op_types.rs
    138
    		 
        pub fn is_float(self) -> bool {
    139
    		 
            #[allow(clippy::match_like_matches_macro)]
    140
    		 
            match self {
    147
    		 
        pub fn is_unsigned(self) -> bool {
    148
    		 
            #[allow(clippy::match_like_matches_macro)]
    149
    		 
            match self {
  • amplify_derive 4.0.0-alpha.3/src/display.rs
    543
    		 
        // Ancient rust versions do not known about `matches!` macro
    544
    		 
        #[allow(clippy::match_like_matches_macro)]
    545
    		 
        let mut use_global = match global {
  • amplify_syn 2.0.0-beta.1/src/req.rs
    146
    		 
            // Ancient rust versions do not known about `matches!` macro
    147
    		 
            #[allow(clippy::match_like_matches_macro)]
    148
    		 
            match self {
    237
    		 
            // Ancient rust versions do not known about `matches!` macro
    238
    		 
            #[allow(clippy::match_like_matches_macro)]
    239
    		 
            match self {
  • amplify_syn 2.0.0-beta.1/src/val.rs
    568
    		 
        pub fn is_none(&self) -> bool {
    569
    		 
            #[allow(clippy::match_like_matches_macro)]
    570
    		 
            // Ancient rust versions do not known about `matches!` macro
    580
    		 
            // Ancient rust versions do not known about `matches!` macro
    581
    		 
            #[allow(clippy::match_like_matches_macro)]
    582
    		 
            match self {
  • asn1-rs 0.5.1/src/asn1_types/oid.rs
    481
    		 
        const OID_EC_PUBLIC_KEY: &[u8] = &oid! {raw 1.2.840.10045.2.1};
    482
    		 
        #[allow(clippy::match_like_matches_macro)]
    483
    		 
        fn compare_oid(oid: &Oid) -> bool {
  • barter-data 0.6.7/src/error.rs
    23
    		 
        /// Determine if an error requires a [`MarketStream`](super::MarketStream) to re-initialise.
    24
    		 
        #[allow(clippy::match_like_matches_macro)]
    25
    		 
        pub fn is_terminal(&self) -> bool {
  • barter-data 0.6.7/src/exchange/mod.rs
    205
    		 
        /// ingestion of [`InstrumentKind::Spot`](barter_integration::model::InstrumentKind) market data.
    206
    		 
        #[allow(clippy::match_like_matches_macro)]
    207
    		 
        pub fn supports_spot(&self) -> bool {
    216
    		 
        /// market data.
    217
    		 
        #[allow(clippy::match_like_matches_macro)]
    218
    		 
        pub fn supports_futures(&self) -> bool {
  • bevy-egui-kbgp 0.10.0/src/lib.rs
    1000
    		 
            input.pointer = Default::default();
    1001
    		 
            #[allow(clippy::match_like_matches_macro)]
    1002
    		 
            input.events.retain(|event| match event {
  • bio-types 0.13.0/src/strand.rs
    57
    		 
    #[allow(clippy::match_like_matches_macro)]
    58
    		 
    impl PartialEq for Strand {
    80
    		 
    #[allow(clippy::match_like_matches_macro)]
    81
    		 
    impl Same for Strand {
  • blstrs 0.6.1/src/scalar.rs
    604
    		 
        #[allow(clippy::match_like_matches_macro)]
    605
    		 
        pub fn is_quad_res(&self) -> Choice {
  • bonsaimq 0.2.0/src/error.rs
    31
    		 
    	pub fn should_retry(&self) -> bool {
    32
    		 
    		#[allow(clippy::match_like_matches_macro)]
    33
    		 
    		match self {
  • boring 2.1.0/src/ssl/bio.rs
    148
    		 
    #[allow(clippy::match_like_matches_macro)] // matches macro requires rust 1.42.0
    149
    		 
    fn retriable_error(err: &io::Error) -> bool {
  • butane_core 0.5.1/src/db/pg.rs
    451
    		 
        #[allow(clippy::match_like_matches_macro)]
    452
    		 
        fn accepts(_ty: &postgres::types::Type) -> bool {
  • cargo-check-external-types 0.1.6/src/visitor.rs
    102
    		 
                // This code is much clearer with a match statement
    103
    		 
                #[allow(clippy::match_like_matches_macro)]
    104
    		 
                Visibility::Default => match (&item.inner, path.last_type()) {
  • cargo-geiger 0.11.5/src/graph/extra_deps.rs
    12
    		 
        // This clippy recommendation is valid, but makes this function much harder to read
    13
    		 
        #[allow(clippy::match_like_matches_macro)]
    14
    		 
        pub fn allows(&self, dependency_kind: DependencyKind) -> bool {
  • chashmap-async 0.1.0/src/lib.rs
    460
    		 
                    // shush clippy, the comments are important
    461
    		 
                    #[allow(clippy::match_like_matches_macro)]
    462
    		 
                    let bucket = self.scan_mut_no_lock(&key, |x| match *x {
  • ciboulette 0.1.4/src/id.rs
    104
    		 
        fn compatible(ty: &sqlx::postgres::PgTypeInfo) -> bool {
    105
    		 
            #[allow(clippy::match_like_matches_macro)]
    106
    		 
            match ty.name() {
  • console 0.15.5/src/ansi.rs
    31
    		 
        fn is_final(&self) -> bool {
    32
    		 
            #[allow(clippy::match_like_matches_macro)]
    33
    		 
            match self {
    39
    		 
        fn is_trapped(&self) -> bool {
    40
    		 
            #[allow(clippy::match_like_matches_macro)]
    41
    		 
            match self {
  • console 0.15.5/src/utils.rs
    108
    		 
        fn is_color256(self) -> bool {
    109
    		 
            #[allow(clippy::match_like_matches_macro)]
    110
    		 
            match self {
  • der-parser 8.1.0/tests/oid.rs
    8
    		 
    const OID_EC_PUBLIC_KEY: &[u8] = &oid!(raw 1.2.840.10045.2.1);
    9
    		 
    #[allow(clippy::match_like_matches_macro)]
    10
    		 
    fn compare_oid(oid: &Oid) -> bool {
  • derivative 2.2.0/src/bound.rs
    169
    		 
    #[allow(clippy::match_like_matches_macro)] // needs rustc 1.42
    170
    		 
    fn is_phantom_data(path: &syn::Path) -> bool {
  • emulsion 10.0.0/src/utils.rs
    3
    		 
    pub fn virtual_keycode_is_char(vk: VirtualKeyCode) -> bool {
    4
    		 
    	#[allow(clippy::match_like_matches_macro)]
    5
    		 
    	match vk {
  • enumflags2_derive 0.7.4/src/lib.rs
    28
    		 
        // matches! is beyond our MSRV
    29
    		 
        #[allow(clippy::match_like_matches_macro)]
    30
    		 
        fn is_inferred(&self) -> bool {
  • etwin_core 0.11.0/src/user.rs
    511
    		 
      fn eq(&self, other: &Self) -> bool {
    512
    		 
        #[allow(clippy::match_like_matches_macro)]
    513
    		 
        match (self, other) {
  • fitparser 0.5.1/src/profile/field_types.rs
    21653
    		 
    impl FieldDataType {
    21654
    		 
        #[allow(clippy::match_like_matches_macro)]
    21655
    		 
        pub fn is_enum_type(self) -> bool {
  • fs-mistrust 0.6.0/src/disable.rs
    57
    		 
    /// None.
    58
    		 
    #[allow(clippy::match_like_matches_macro)]
    59
    		 
    fn from_env_var_value(input: std::result::Result<String, VarError>) -> Option<Status> {
  • fuel-asm 0.25.2/src/opcode/consts.rs
    540
    		 
        /// <https://github.com/FuelLabs/fuel-specs/blob/master/src/vm/instruction_set.md#contract-instructions>
    541
    		 
        #[allow(clippy::match_like_matches_macro)]
    542
    		 
        // Not following clippy conventions because rustfmt formats macros into bloated code
    560
    		 
    #[test]
    561
    		 
    #[allow(clippy::match_like_matches_macro)]
    562
    		 
    fn check_predicate_allowed() {
  • gdbstub 0.6.3/src/protocol/common/hex.rs
    70
    		 
    pub fn is_hex(c: u8) -> bool {
    71
    		 
        #[allow(clippy::match_like_matches_macro)] // mirror ascii2byte
    72
    		 
        match c {
  • gemachain-runtime 1.8.2/src/hardened_unpack.rs
    463
    		 
        trace!("validating: {:?} {:?}", parts, kind);
    464
    		 
        #[allow(clippy::match_like_matches_macro)]
    465
    		 
        match (parts, kind) {
  • geph4-binder-transport 0.2.3/src/wiretypes.rs
    105
    		 
        /// Returns a boolean determining whether or not this request is idempotent.
    106
    		 
        #[allow(clippy::match_like_matches_macro)]
    107
    		 
        pub fn is_idempotent(&self) -> bool {
  • git-checks 4.2.1/src/binary_format.rs
    40
    		 
        #[allow(clippy::match_like_matches_macro)]
    41
    		 
        pub(crate) fn is_executable(&self) -> bool {
  • git-checks 4.2.1/src/changelog.rs
    123
    		 
        /// Whether the path with the given status change is OK.
    124
    		 
        #[allow(clippy::match_like_matches_macro)]
    125
    		 
        fn is_ok(&self, status: StatusChange) -> bool {
  • git-checks 4.2.1/src/third_party.rs
    144
    		 
        /// Whether the result is an import or not.
    145
    		 
        #[allow(clippy::match_like_matches_macro)]
    146
    		 
        fn is_import(&self) -> bool {
  • go-away 0.5.0/src/registry.rs
    131
    		 
        #[allow(clippy::match_like_matches_macro)]
    132
    		 
        fn same_kind(&self, other: &Type) -> bool {
  • heim-disk 0.1.0-rc.1/src/filesystem.rs
    76
    		 
        /// Checks if filesystem is used for a physical devices
    77
    		 
        #[allow(clippy::unknown_clippy_lints, clippy::match_like_matches_macro)]
    78
    		 
        pub fn is_physical(&self) -> bool {
  • heim-disk 0.1.0-rc.1/src/sys/linux/partitions.rs
    106
    		 
                #[allow(clippy::match_like_matches_macro)] // >= 1.42.0
    107
    		 
                let nodev = match parts.next() {
  • holochain 0.1.0/src/conductor/manager/error.rs
    55
    		 
            use ManagedTaskError::*;
    56
    		 
            #[allow(clippy::match_like_matches_macro)]
    57
    		 
            match self {
  • iced-x86 1.18.0/src/code.rs
    44695
    		 
    	#[inline]
    44696
    		 
    	#[allow(clippy::match_like_matches_macro)]
    44697
    		 
    	pub const fn is_string_instruction(self) -> bool {
    44925
    		 
    	#[must_use]
    44926
    		 
    	#[allow(clippy::match_like_matches_macro)]
    44927
    		 
    	pub(crate) const fn ignores_segment(self) -> bool {
    44950
    		 
    	#[inline]
    44951
    		 
    	#[allow(clippy::match_like_matches_macro)]
    44952
    		 
    	pub(crate) const fn ignores_index(self) -> bool {
  • infisearch_lang_ascii 0.10.0/src/utils.rs
    10
    		 
    #[allow(clippy::match_like_matches_macro)]
    11
    		 
    fn boundary_filter(c: char) -> bool {
  • interprocess 1.2.1/src/os/unix/udsocket/path.rs
    124
    		 
        // Cannot use `matches!` due to #[cfg(...)]
    125
    		 
        #[allow(clippy::match_like_matches_macro)]
    126
    		 
        pub const fn is_owned(&self) -> bool {
  • janetrs_macros 0.5.0/src/utils.rs
    133
    		 
        fn eq(&self, other: &Self) -> bool {
    134
    		 
            #[allow(clippy::match_like_matches_macro)]
    135
    		 
            match (self, other) {
  • kitsune_p2p_types 0.1.0/src/lib.rs
    242
    		 
        fn eq(&self, oth: &Self) -> bool {
    243
    		 
            #[allow(clippy::match_like_matches_macro)]
    244
    		 
            match (self, oth) {
  • lexical-parse-float 0.8.5/src/bigint.rs
    609
    		 
        #[inline]
    610
    		 
        #[allow(clippy::match_like_matches_macro)]
    611
    		 
        pub fn is_normalized(&self) -> bool {
  • linemux 0.3.0/src/reader.rs
    335
    		 
        #[allow(clippy::match_like_matches_macro)] // otherwise bumps MSRV
    336
    		 
        pub fn is_transient(&self) -> bool {
  • livestream-dl 0.5.7/src/mux/concat.rs
    173
    		 
    async fn should_use_ffmpeg_concat(segment: &Segment) -> Result<bool> {
    174
    		 
        #[allow(clippy::match_like_matches_macro)]
    175
    		 
        let use_ffmpeg = match segment.format {
  • log4rs 1.2.0/src/append/console.rs
    63
    		 
            // 1.40 compat
    64
    		 
            #[allow(clippy::match_like_matches_macro)]
    65
    		 
            match self {
  • lunatic-redis 0.1.3/src/types.rs
    744
    		 
                {
    745
    		 
                    #[allow(clippy::match_like_matches_macro)]
    746
    		 
                    match kind {
  • mco-redis-rs 0.21.6/src/types.rs
    422
    		 
                ErrorRepr::IoError(ref err) => {
    423
    		 
                    #[allow(clippy::match_like_matches_macro)]
    424
    		 
                    match err.kind() {
  • mcp794xx 0.3.0/src/common/datetime.rs
    161
    		 
        #[allow(clippy::match_like_matches_macro)] // not available on the MSRV
    162
    		 
        fn set_hours(&mut self, hours: Hours) -> Result<(), Self::Error> {
  • millennium-core 1.0.0-beta.3/src/platform_impl/macos/view.rs
    477
    		 
    fn is_corporate_character(c: char) -> bool {
    478
    		 
    	#[allow(clippy::match_like_matches_macro)]
    479
    		 
    	match c {
  • minimad 0.9.1/src/markdown/line.rs
    79
    		 
        #[inline(always)]
    80
    		 
        #[allow(clippy::match_like_matches_macro)]
    81
    		 
        pub fn is_table_part(&self) -> bool {
  • minimal-lexical 0.2.1/src/bigint.rs
    172
    		 
    #[inline]
    173
    		 
    #[allow(clippy::match_like_matches_macro)]
    174
    		 
    pub fn is_normalized(x: &[Limb]) -> bool {
  • monoio 0.0.9/src/net/unix/socket_addr.rs
    80
    		 
        // FIXME: The matches macro requires rust 1.42.0 and we still support 1.39.0
    81
    		 
        #[allow(clippy::match_like_matches_macro)]
    82
    		 
        pub fn is_unnamed(&self) -> bool {
  • morsels_lang_ascii 0.7.3/src/utils.rs
    10
    		 
    #[allow(clippy::match_like_matches_macro)]
    11
    		 
    fn boundary_filter(c: char) -> bool {
  • newline-converter 0.2.2/src/lib.rs
    79
    		 
    #[allow(clippy::match_like_matches_macro)] // MSRV 1.38, matches! macro available in 1.42
    80
    		 
    /// Converts UNIX-style line endings (`\n`) to DOS-style (`\r\n`).
  • nonogrid 0.7.3/src/solver/probing.rs
    261
    		 
        #[allow(clippy::missing_const_for_fn)]
    262
    		 
        #[allow(clippy::match_like_matches_macro)]
    263
    		 
        fn is_contradiction(&self) -> bool {
  • nvml-wrapper 0.9.0/src/device.rs
    3595
    		 
                #[allow(clippy::match_like_matches_macro)]
    3596
    		 
                Ok(match bool_int {
  • nvml-wrapper 0.9.0/src/nv_link.rs
    166
    		 
                #[allow(clippy::match_like_matches_macro)]
    167
    		 
                Ok(match capability {
  • nvml-wrapper 0.9.0/src/struct_wrappers/device.rs
    417
    		 
            #[allow(clippy::match_like_matches_macro)]
    418
    		 
            Self {
  • objpoke 0.3.0/src/elf/symtab.rs
    49
    		 
        {
    50
    		 
            #[allow(clippy::match_like_matches_macro)]
    51
    		 
            let is_code_or_data = match sym.st_type() {
  • openssl 0.10.45/src/ssl/bio.rs
    132
    		 
    #[allow(clippy::match_like_matches_macro)] // matches macro requires rust 1.42.0
    133
    		 
    fn retriable_error(err: &io::Error) -> bool {
  • openssl-sys 0.9.80/build/main.rs
    336
    		 
    #[allow(deprecated)] // trim_right_matches is now trim_end_matches
    337
    		 
    #[allow(clippy::match_like_matches_macro)] // matches macro requires rust 1.42.0
    338
    		 
    fn parse_version(version: &str) -> u64 {
  • pallas-localstate 0.4.0/src/lib.rs
    140
    		 
        #[allow(clippy::match_like_matches_macro)]
    141
    		 
        fn has_agency(&self) -> bool {
  • pallas-miniprotocols 0.17.0/src/localstate/client.rs
    64
    		 
        #[allow(clippy::match_like_matches_macro)]
    65
    		 
        fn has_agency(&self) -> bool {
  • pallas-traverse 0.17.0/src/era.rs
    5
    		 
    impl Era {
    6
    		 
        #[allow(clippy::match_like_matches_macro)]
    7
    		 
        pub fn has_feature(&self, feature: Feature) -> bool {
  • polars-core 0.26.1/src/datatypes/dtype.rs
    154
    		 
            // allow because it cannot be replaced when object feature is activated
    155
    		 
            #[allow(clippy::match_like_matches_macro)]
    156
    		 
            match self {
    185
    		 
            // allow because it cannot be replaced when object feature is activated
    186
    		 
            #[allow(clippy::match_like_matches_macro)]
    187
    		 
            match self {
  • pp-rs 0.2.1/src/lib.rs
    3
    		 
    #[allow(clippy::match_like_matches_macro)]
    4
    		 
    mod lexer;
  • psh 0.3.0/src/alias_data.rs
    78
    		 
        #[allow(clippy::match_like_matches_macro)]
    79
    		 
        fn extract_secret_flag(bit_flags: u8) -> bool {
  • readme-sync 0.2.1/src/cmark_data.rs
    184
    		 
        /// if the specified predicate returns true when passing image urls to it.
    185
    		 
        #[allow(clippy::match_like_matches_macro)] // requires minimum rustc version 1.42.0
    186
    		 
        pub fn remove_images_only_paragraph<P>(self, mut predicate: P) -> Self
    470
    		 
    #[allow(clippy::match_like_matches_macro)] // requires minimum rustc version 1.42.0
    471
    		 
    fn is_url_with_scheme(url: &str) -> bool {
  • redis 0.22.3/src/types.rs
    471
    		 
                ErrorRepr::IoError(ref err) => {
    472
    		 
                    #[allow(clippy::match_like_matches_macro)]
    473
    		 
                    match err.kind() {
  • result-like-derive 0.4.5/src/lib.rs
    44
    		 
        fn matches(self, fields: &syn::Fields) -> bool {
    45
    		 
            #[allow(clippy::match_like_matches_macro)]
    46
    		 
            match (self, fields) {
  • rline 0.3.1/src/lib.rs
    144
    		 
    impl<T> Locked for Mutex<T> {
    145
    		 
      #[allow(clippy::match_like_matches_macro)]
    146
    		 
      fn is_locked(&self) -> bool {
  • rp2040-hal 0.7.0/src/gpio/dynpin.rs
    166
    		 
                    },
    167
    		 
                    #[allow(clippy::match_like_matches_macro)]
    168
    		 
                    Qspi => match alt {
  • rrdb 0.0.1/src/lib/ast/types/expression.rs
    30
    		 
        pub fn is_unary(&self) -> bool {
    31
    		 
            #[allow(clippy::match_like_matches_macro)]
    32
    		 
            match self.clone() {
  • rrdb 0.0.1/src/lib/lexer/tokens.rs
    105
    		 
        pub fn is_eof(&self) -> bool {
    106
    		 
            #[allow(clippy::match_like_matches_macro)]
    107
    		 
            match self {
    122
    		 
        pub fn can_be_multi_token_operator(&self) -> bool {
    123
    		 
            #[allow(clippy::match_like_matches_macro)]
    124
    		 
            match self {
  • rtrtr 0.2.2/src/metrics.rs
    373
    		 
        /// Returns whether the format supports non-numerical metrics.
    374
    		 
        #[allow(clippy::match_like_matches_macro)]
    375
    		 
        pub fn allows_text(self) -> bool {
    382
    		 
        /// Returns whether this output format supports this metric type.
    383
    		 
        #[allow(clippy::match_like_matches_macro)]
    384
    		 
        pub fn supports_type(self, metric: MetricType) -> bool {
  • rust-mqtt 0.1.5/src/packet/v5/property.rs
    64
    		 
            // not possible to use with associated values with different types
    65
    		 
            #[allow(clippy::match_like_matches_macro)]
    66
    		 
            match self {
    81
    		 
            // not possible to use with associated values with different types
    82
    		 
            #[allow(clippy::match_like_matches_macro)]
    83
    		 
            match self {
    105
    		 
            // not possible to use with associated values with different types
    106
    		 
            #[allow(clippy::match_like_matches_macro)]
    107
    		 
            match self {
    121
    		 
            // not possible to use with associated values with different types
    122
    		 
            #[allow(clippy::match_like_matches_macro)]
    123
    		 
            match self {
    131
    		 
            // not possible to use with associated values with different types
    132
    		 
            #[allow(clippy::match_like_matches_macro)]
    133
    		 
            match self {
  • rustc_codegen_spirv 0.4.0/src/abi.rs
    154
    		 
            #[allow(clippy::match_like_matches_macro)]
    155
    		 
            let hide_niche = match ty.kind() {
  • safecoin-runtime 1.14.3/src/hardened_unpack.rs
    521
    		 
        trace!("validating: {:?} {:?}", parts, kind);
    522
    		 
        #[allow(clippy::match_like_matches_macro)]
    523
    		 
        match (parts, kind) {
  • sfz 0.7.1/src/extensions.rs
    110
    		 
            let subtype = self.subtype();
    111
    		 
            #[allow(clippy::match_like_matches_macro)]
    112
    		 
            match (self.type_(), subtype, subtype.as_str()) {
  • shadowsocks-crypto 0.5.1/src/kind.rs
    280
    		 
        #[cfg(feature = "v1-stream")]
    281
    		 
        #[allow(clippy::match_like_matches_macro)]
    282
    		 
        pub fn is_stream(&self) -> bool {
  • solana-runtime 1.14.13/src/hardened_unpack.rs
    521
    		 
        trace!("validating: {:?} {:?}", parts, kind);
    522
    		 
        #[allow(clippy::match_like_matches_macro)]
    523
    		 
        match (parts, kind) {
  • sql_lexer 0.9.3/src/lexer.rs
    92
    		 
        #[allow(clippy::match_like_matches_macro)]
    93
    		 
        pub fn lex(mut self) -> Sql {
  • sqlxmq 0.4.1/src/lib.rs
    243
    		 
            // It's more readable as a match
    244
    		 
            #[allow(clippy::match_like_matches_macro)]
    245
    		 
            match (db_error.code().as_deref(), db_error.constraint()) {
  • staticvec 0.11.9/src/string/string_errors.rs
    24
    		 
    #[allow(clippy::match_like_matches_macro)]
    25
    		 
    impl StringError {
  • tao 0.17.0/src/platform_impl/macos/view.rs
    635
    		 
    fn is_corporate_character(c: char) -> bool {
    636
    		 
      #[allow(clippy::match_like_matches_macro)]
    637
    		 
      match c {
  • tendermint-p2p 0.28.0/src/secret_connection/protocol.rs
    219
    		 
    /// <https://eprint.iacr.org/2017/806.pdf>
    220
    		 
    #[allow(clippy::match_same_arms, clippy::match_like_matches_macro)]
    221
    		 
    fn is_low_order_point(point: &EphemeralPublic) -> bool {
  • textwrap 0.16.0/src/word_separators.rs
    276
    		 
            .filter(|(idx, _)| {
    277
    		 
                #[allow(clippy::match_like_matches_macro)]
    278
    		 
                match &stripped[..*idx].chars().next_back() {
  • tophat 0.3.0/src/chunked/decoder.rs
    217
    		 
            let buffer = std::mem::replace(&mut this.buffer, POOL.alloc(INITIAL_CAPACITY));
    218
    		 
            #[allow(clippy::match_like_matches_macro)]
    219
    		 
            let mut needs_read = if let State::Chunk(_, _) = this.state {
  • tulip-derivative 2.2.1/src/bound.rs
    169
    		 
    #[allow(clippy::match_like_matches_macro)] // needs rustc 1.42
    170
    		 
    fn is_phantom_data(path: &syn::Path) -> bool {
  • uniswap-rs 0.4.0/src/v3/library/command.rs
    158
    		 
        /// Returns whether this command is valid.
    159
    		 
        #[allow(clippy::match_like_matches_macro)]
    160
    		 
        pub const fn is_valid(&self) -> bool {
    167
    		 
        /// Returns whether this command is invalid.
    168
    		 
        #[allow(clippy::match_like_matches_macro)]
    169
    		 
        pub const fn is_invalid(&self) -> bool {
  • voikko-rs 1.1.0/src/libvoikko.rs
    466
    		 
    #[allow(clippy::match_like_matches_macro)]
    467
    		 
    pub fn set_bool_option(handle: *mut VoikkoHandle, option: i32, value: bool) -> bool {
    475
    		 
    #[allow(clippy::match_like_matches_macro)]
    476
    		 
    pub fn set_int_option(handle: *mut VoikkoHandle, option: i32, value: i32) -> bool {
  • vulkano 0.32.3/autogen/extensions.rs
    18
    		 
    fn required_if_supported(name: &str) -> bool {
    19
    		 
        #[allow(clippy::match_like_matches_macro)]
    20
    		 
        match name {
  • w5500-ll 0.10.4/src/net.rs
    222
    		 
        /// ```
    223
    		 
        #[allow(clippy::match_like_matches_macro)]
    224
    		 
        pub const fn is_documentation(&self) -> bool {
  • waffles-solana-runtime 1.15.0/src/hardened_unpack.rs
    515
    		 
        trace!("validating: {:?} {:?}", parts, kind);
    516
    		 
        #[allow(clippy::match_like_matches_macro)]
    517
    		 
        match (parts, kind) {
  • adventjson 0.1.1/src/lib.rs
    37
    		 
        clippy::suspicious_else_formatting,
    38
    		 
        clippy::match_like_matches_macro
    39
    		 
    )]
  • alt_serde_derive 1.0.119/src/lib.rs
    22
    		 
        clippy::enum_variant_names,
    23
    		 
        clippy::match_like_matches_macro,
    24
    		 
        clippy::needless_pass_by_value,
  • alt_serde_json 1.0.61/src/lib.rs
    312
    		 
        clippy::manual_range_contains,
    313
    		 
        clippy::match_like_matches_macro,
    314
    		 
        clippy::match_single_binding,
  • arti 1.1.0/src/socks.rs
    389
    		 
    fn accept_err_is_fatal(err: &IoError) -> bool {
    390
    		 
        #![allow(clippy::match_like_matches_macro)]
  • baryon-core 0.1.0/src/lib.rs
    4
    		 
        // We don't use syntax sugar where it's not necessary.
    5
    		 
        clippy::match_like_matches_macro,
    6
    		 
        // Redundant matching is more explicit.
  • basic-toml 0.1.1/src/lib.rs
    120
    		 
        clippy::manual_range_contains,
    121
    		 
        clippy::match_like_matches_macro,
    122
    		 
        clippy::missing_errors_doc,
  • basic-toml 0.1.1/tests/valid.rs
    1
    		 
    #![allow(
    2
    		 
        clippy::match_like_matches_macro,
    3
    		 
        clippy::needless_pass_by_value,
  • bevy_vulkano 0.10.0/src/lib.rs
    6
    		 
        clippy::single_match,
    7
    		 
        clippy::match_like_matches_macro
    8
    		 
    )]
  • blade-graphics 0.1.1/src/lib.rs
    2
    		 
        // We don't use syntax sugar where it's not necessary.
    3
    		 
        clippy::match_like_matches_macro,
    4
    		 
        // Redundant matching is more explicit.
  • bpaf 0.7.7/src/meta_help.rs
    1
    		 
    #![allow(clippy::write_with_newline)]
    2
    		 
    #![allow(clippy::match_like_matches_macro)]
    3
    		 
    use std::collections::BTreeSet;
  • bytemuck 1.13.0/src/lib.rs
    2
    		 
    #![warn(missing_docs)]
    3
    		 
    #![allow(clippy::match_like_matches_macro)]
    4
    		 
    #![cfg_attr(feature = "nightly_portable_simd", feature(portable_simd))]
  • cargo-expand 1.0.40/src/main.rs
    6
    		 
        clippy::manual_strip,
    7
    		 
        clippy::match_like_matches_macro,
    8
    		 
        clippy::needless_borrow, // https://github.com/rust-lang/rust-clippy/issues/9710
  • choir 0.5.0/src/lib.rs
    18
    		 
        clippy::unneeded_field_pattern,
    19
    		 
        clippy::match_like_matches_macro,
    20
    		 
        clippy::manual_strip,
  • cidr 0.2.1/src/lib.rs
    4
    		 
    #![doc(html_root_url = "https://docs.rs/cidr/0.2.1")]
    5
    		 
    #![allow(clippy::match_like_matches_macro)]
  • ckb-sentry-core 0.21.0/src/session.rs
    283
    		 
        fn test_session_batching() {
    284
    		 
            #![allow(clippy::match_like_matches_macro)]
    285
    		 
            let envelopes = capture_envelopes(|| {
  • clang-ast 0.1.13/src/lib.rs
    391
    		 
        clippy::blocks_in_if_conditions,
    392
    		 
        clippy::match_like_matches_macro,
    393
    		 
        clippy::must_use_candidate,
  • color-operators 0.0.3/src/lib.rs
    2
    		 
    #![deny(clippy::all, missing_docs, unsafe_code)]
    3
    		 
    #![allow(clippy::upper_case_acronyms, clippy::from_over_into, clippy::match_like_matches_macro)]
  • combine 4.6.6/src/lib.rs
    192
    		 
        clippy::too_many_arguments,
    193
    		 
        clippy::match_like_matches_macro
    194
    		 
    )]
  • conjure-codegen 3.5.0/src/context.rs
    13
    		 
    // limitations under the License.
    14
    		 
    #![allow(clippy::match_like_matches_macro)]
  • cpython 0.7.1/src/lib.rs
    26
    		 
        clippy::manual_strip,
    27
    		 
        clippy::match_like_matches_macro
    28
    		 
    )]
  • dtool 0.11.0/src/modules.rs
    5
    		 
    #![allow(clippy::unnecessary_wraps)]
    6
    		 
    #![allow(clippy::match_like_matches_macro)]
    7
    		 
    #![allow(clippy::needless_range_loop)]
  • ensc-testsuite 0.1.6/src/lib.rs
    1
    		 
    #![allow(clippy::redundant_field_names)]
    2
    		 
    #![allow(clippy::match_like_matches_macro)]
  • evilaes 0.1.0/src/lib.rs
    37
    		 
        clippy::suspicious_else_formatting,
    38
    		 
        clippy::match_like_matches_macro,
    39
    		 
        unstable_features
  • evilrng 0.1.0/src/lib.rs
    35
    		 
    )]
    36
    		 
    #![allow(clippy::suspicious_else_formatting, clippy::match_like_matches_macro)]
  • evilsha 0.1.0/src/lib.rs
    37
    		 
        clippy::suspicious_else_formatting,
    38
    		 
        clippy::match_like_matches_macro,
    39
    		 
        // (Hopefully) always manual checked
  • exocore-store 0.1.24/src/error.rs
    79
    		 
        pub fn is_fatal(&self) -> bool {
    80
    		 
            #![allow(clippy::match_like_matches_macro)]
    81
    		 
            match self {
  • flexbuffers 2.0.0/src/lib.rs
    32
    		 
    #![allow(clippy::unknown_clippy_lints)]
    33
    		 
    #![allow(clippy::match_like_matches_macro)]
  • img-parts 0.3.0/src/lib.rs
    68
    		 
    // requires Rust >=1.42
    69
    		 
    #![allow(clippy::match_like_matches_macro)]
  • indigo-structopt-derive 0.4.14/src/lib.rs
    14
    		 
    // FIXME: remove when and if our MSRV hits 1.42
    15
    		 
    #![allow(clippy::match_like_matches_macro)]
    16
    		 
    #![forbid(unsafe_code)]
  • isahc 1.7.2/src/lib.rs
    237
    		 
    // These lints suggest to use features not available in our MSRV.
    238
    		 
    #![allow(clippy::manual_strip, clippy::match_like_matches_macro)]
  • isahc-opendal-workaround 2.0.0-opendal.1/src/lib.rs
    241
    		 
    // These lints suggest to use features not available in our MSRV.
    242
    		 
    #![allow(clippy::manual_strip, clippy::match_like_matches_macro)]
  • kanata-evsieve 1.3.1/src/bin.rs
    10
    		 
    // Allowed because the matches! macro is not supported in Rust 1.41.1, under which evsieve must compile.
    11
    		 
    #![allow(clippy::match_like_matches_macro)]
    12
    		 
    // Disallowed for code uniformity.
  • kanata-evsieve 1.3.1/src/lib.rs
    10
    		 
    // Allowed because the matches! macro is not supported in Rust 1.41.1, under which evsieve must compile.
    11
    		 
    #![allow(clippy::match_like_matches_macro)]
    12
    		 
    // Disallowed for code uniformity.
  • lexpr 0.2.6/src/lib.rs
    4
    		 
    // currently support 1.32+.
    5
    		 
    #![allow(clippy::match_like_matches_macro)]
    6
    		 
    // The `contains` method on ranges was stabilized in 1.35.
  • lyon_path 1.0.3/src/lib.rs
    3
    		 
    #![deny(unconditional_recursion)]
    4
    		 
    #![allow(clippy::match_like_matches_macro)]
    5
    		 
    #![no_std]
  • modalkit 0.0.10/src/lib.rs
    84
    		 
    #![allow(clippy::manual_range_contains)]
    85
    		 
    #![allow(clippy::match_like_matches_macro)]
    86
    		 
    #![allow(clippy::needless_return)]
  • naga 0.11.0/src/lib.rs
    190
    		 
        clippy::unneeded_field_pattern,
    191
    		 
        clippy::match_like_matches_macro,
    192
    		 
        clippy::if_same_then_else,
  • nats 0.23.1/src/lib.rs
    183
    		 
    #![allow(
    184
    		 
        clippy::match_like_matches_macro,
    185
    		 
        clippy::await_holding_lock,
  • nats-aflowt 0.16.105/src/lib.rs
    185
    		 
    #![allow(
    186
    		 
        clippy::match_like_matches_macro,
    187
    		 
        clippy::await_holding_lock,
  • object 0.30.3/src/lib.rs
    60
    		 
    #![allow(clippy::comparison_chain)]
    61
    		 
    #![allow(clippy::match_like_matches_macro)]
    62
    		 
    #![allow(clippy::single_match)]
  • pilka_ash 0.7.11/src/lib.rs
    5
    		 
        // We don't use syntax sugar where it's not necessary.
    6
    		 
        clippy::match_like_matches_macro,
    7
    		 
        // Redundant matching is more explicit.
  • pilka_wgpu 0.7.11/src/lib.rs
    6
    		 
        // We don't use syntax sugar where it's not necessary.
    7
    		 
        clippy::match_like_matches_macro,
    8
    		 
        // Redundant matching is more explicit.
  • prettyplease 0.1.23/src/lib.rs
    329
    		 
        clippy::items_after_statements,
    330
    		 
        clippy::match_like_matches_macro,
    331
    		 
        clippy::match_same_arms,
  • proxide 0.2.3/src/main.rs
    1
    		 
    #![allow(clippy::match_bool)]
    2
    		 
    #![allow(clippy::match_like_matches_macro)]
  • qr_code 1.1.0/src/lib.rs
    11
    		 
        clippy::use_self, // Rust 1.33 doesn't support Self::EnumVariant, let's try again in 1.37.
    12
    		 
        clippy::match_like_matches_macro, // MSRV is lower than what's needed for matches!
    13
    		 
    )]
  • ratmom 0.1.0/src/lib.rs
    241
    		 
        clippy::manual_strip,
    242
    		 
        clippy::match_like_matches_macro,
    243
    		 
        clippy::needless_borrow
  • regress 0.4.1/src/lib.rs
    112
    		 
    #![warn(clippy::all)]
    113
    		 
    #![allow(clippy::upper_case_acronyms, clippy::match_like_matches_macro)]
    114
    		 
    // Clippy's manual_range_contains suggestion produces worse codegen.
  • repc-impl 0.1.1/src/builder/common.rs
    1
    		 
    // SPDX-License-Identifier: MIT OR Apache-2.0
    2
    		 
    #![allow(clippy::match_like_matches_macro)]
  • repr-c-impl 0.1.0/src/builder/common.rs
    1
    		 
    // SPDX-License-Identifier: MIT OR Apache-2.0
    2
    		 
    #![allow(clippy::match_like_matches_macro)]
  • rink-core 0.6.2/src/lib.rs
    33
    		 
    #![allow(clippy::cognitive_complexity)]
    34
    		 
    #![allow(clippy::match_like_matches_macro)]
    35
    		 
    #![allow(clippy::from_str_radix_10)]
  • roxmltree 0.17.0/src/lib.rs
    21
    		 
    // `matches!` available since 1.42, but we target 1.36 for now.
    22
    		 
    #![allow(clippy::match_like_matches_macro)]
  • rseip 0.3.1/src/lib.rs
    223
    		 
    #![allow(clippy::match_like_matches_macro)]
  • rseip-cip 0.2.0/src/lib.rs
    19
    		 
    //#![warn(missing_docs)]
    20
    		 
    #![allow(clippy::match_like_matches_macro)]
  • rseip-core 0.1.3/src/lib.rs
    16
    		 
    //#![warn(missing_docs)]
    17
    		 
    #![allow(clippy::match_like_matches_macro)]
  • rseip-eip 0.2.0/src/lib.rs
    7
    		 
    //#![warn(missing_docs)]
    8
    		 
    #![allow(clippy::match_like_matches_macro)]
  • rune 0.12.0/src/lib.rs
    167
    		 
    #![allow(clippy::branches_sharing_code)]
    168
    		 
    #![allow(clippy::match_like_matches_macro)]
    169
    		 
    #![allow(clippy::type_complexity)]
  • rustc_version 0.4.0/tests/all.rs
    1
    		 
    #![allow(clippy::match_like_matches_macro)]
  • rustler_codegen 0.27.0/src/context.rs
    1
    		 
    // TODO When we settle for a minimum version of Rust >= 1.42, remove this.
    2
    		 
    #![allow(clippy::match_like_matches_macro)]
  • saphir 3.1.0/src/lib.rs
    71
    		 
    //! *_More feature will be added in the future_*
    72
    		 
    #![allow(clippy::match_like_matches_macro)]
    73
    		 
    #![cfg_attr(docsrs, feature(doc_cfg))]
  • saphir-cli 0.5.1/src/main.rs
    1
    		 
    #![allow(clippy::match_like_matches_macro)]
    2
    		 
    use clap::{Parser, Subcommand};
  • saphir_macro 2.2.0/src/lib.rs
    2
    		 
    #![recursion_limit = "512"]
    3
    		 
    #![allow(clippy::match_like_matches_macro)]
  • scutiger-lfs 0.3.0/src/bin/git-lfs-transfer.rs
    3
    		 
    #![allow(clippy::unnecessary_wraps)]
    4
    		 
    #![allow(clippy::match_like_matches_macro)]
    5
    		 
    #![allow(clippy::mutable_key_type)]
  • scutiger-lfs 0.3.0/src/processor.rs
    1
    		 
    #![allow(clippy::mutable_key_type)]
    2
    		 
    #![allow(clippy::match_like_matches_macro)]
  • seaslug 0.0.0/src/ebr/mod.rs
    1
    		 
    #![allow(unsafe_code)]
    2
    		 
    #![allow(clippy::match_like_matches_macro)]
  • serde_derive 1.0.152/src/lib.rs
    28
    		 
        clippy::manual_map,
    29
    		 
        clippy::match_like_matches_macro,
    30
    		 
        clippy::needless_pass_by_value,
  • serde_derive_state 0.4.10/src/lib.rs
    22
    		 
        clippy::enum_variant_names,
    23
    		 
        clippy::match_like_matches_macro,
    24
    		 
        clippy::needless_pass_by_value,
  • serde_json 1.0.91/src/lib.rs
    313
    		 
        clippy::manual_range_contains,
    314
    		 
        clippy::match_like_matches_macro,
    315
    		 
        clippy::match_single_binding,
  • serde_json_lenient 0.1.4/src/lib.rs
    320
    		 
        clippy::manual_range_contains,
    321
    		 
        clippy::match_like_matches_macro,
    322
    		 
        clippy::match_single_binding,
  • serde_partiql 1.1.65/src/lib.rs
    312
    		 
        clippy::manual_range_contains,
    313
    		 
        clippy::match_like_matches_macro,
    314
    		 
        clippy::match_single_binding,
  • serde_yaml 0.9.17/src/lib.rs
    132
    		 
        clippy::manual_assert,
    133
    		 
        clippy::match_like_matches_macro,
    134
    		 
        clippy::match_same_arms,
  • sled 0.34.7/src/lib.rs
    158
    		 
    #![allow(clippy::mem_replace_with_default)] // Not using std::mem::take() due to MSRV of 1.37 (intro'd in 1.40)
    159
    		 
    #![allow(clippy::match_like_matches_macro)] // Not using std::matches! due to MSRV of 1.37 (intro'd in 1.42)
  • smoltcp 0.8.2/src/lib.rs
    91
    		 
    #![allow(clippy::match_like_matches_macro)]
    92
    		 
    #![allow(clippy::redundant_field_names)]
  • starlark 0.8.0/src/lib.rs
    381
    		 
    #![allow(clippy::len_without_is_empty)]
    382
    		 
    #![allow(clippy::match_like_matches_macro)]
    383
    		 
    #![allow(clippy::new_without_default)]
  • structopt-derive 0.4.18/src/lib.rs
    14
    		 
    // FIXME: remove when and if our MSRV hits 1.42
    15
    		 
    #![allow(clippy::match_like_matches_macro)]
    16
    		 
    #![forbid(unsafe_code)]
  • swc_css_minifier 0.109.2/src/lib.rs
    2
    		 
    #![deny(clippy::all)]
    3
    		 
    #![allow(clippy::match_like_matches_macro)]
    4
    		 
    #![allow(clippy::needless_update)]
  • swc_css_prefixer 0.146.2/src/prefixer.rs
    1
    		 
    #![allow(clippy::match_like_matches_macro)]
  • swc_ecma_codegen 0.129.8/src/lib.rs
    3
    		 
    #![deny(unused)]
    4
    		 
    #![allow(clippy::match_like_matches_macro)]
    5
    		 
    #![allow(clippy::nonminimal_bool)]
  • swc_ecma_minifier 0.166.10/src/lib.rs
    37
    		 
    #![allow(unstable_name_collisions)]
    38
    		 
    #![allow(clippy::match_like_matches_macro)]
  • swc_ecma_parser 0.124.5/src/lib.rs
    125
    		 
    #![allow(clippy::wrong_self_convention)]
    126
    		 
    #![allow(clippy::match_like_matches_macro)]
  • swc_ecma_transforms_compat 0.141.6/src/lib.rs
    4
    		 
    #![allow(clippy::boxed_local)]
    5
    		 
    #![allow(clippy::match_like_matches_macro)]
  • swc_ecma_transforms_optimization 0.172.9/src/lib.rs
    2
    		 
    #![deny(unused)]
    3
    		 
    #![allow(clippy::match_like_matches_macro)]
  • swc_ecma_utils 0.107.5/src/lib.rs
    2
    		 
    #![allow(clippy::boxed_local)]
    3
    		 
    #![allow(clippy::match_like_matches_macro)]
    4
    		 
    #![allow(clippy::vec_box)]
  • swc_html_codegen 0.37.33/src/lib.rs
    2
    		 
    #![allow(clippy::needless_update)]
    3
    		 
    #![allow(clippy::match_like_matches_macro)]
  • swc_html_parser 0.34.32/src/lib.rs
    6
    		 
    #![allow(clippy::wrong_self_convention)]
    7
    		 
    #![allow(clippy::match_like_matches_macro)]
  • target-tuples 0.5.11/src/pieces.rs
    3
    		 
        clippy::manual_non_exhaustive,
    4
    		 
        clippy::match_like_matches_macro
    5
    		 
    )] // Kill clippy for MSRV
  • tiny_http 0.12.0/src/lib.rs
    91
    		 
    #![deny(rust_2018_idioms)]
    92
    		 
    #![allow(clippy::match_like_matches_macro)]
  • tinyjson 2.5.1/src/lib.rs
    81
    		 
    // introduced in recent Rust 1.42. This library should support older Rust.
    82
    		 
    #![allow(clippy::match_like_matches_macro)]
  • tower-http 0.3.5/src/lib.rs
    218
    		 
        // TODO: Remove this once the MSRV bumps to 1.42.0 or above.
    219
    		 
        clippy::match_like_matches_macro,
    220
    		 
        clippy::type_complexity
  • trybuild 1.0.77/src/lib.rs
    219
    		 
        clippy::manual_range_contains,
    220
    		 
        clippy::match_like_matches_macro,
    221
    		 
        clippy::module_name_repetitions,
  • typeracer 2.1.2/src/main.rs
    1
    		 
    #![cfg_attr(test, allow(dead_code, unused_imports))]
    2
    		 
    #![allow(clippy::match_like_matches_macro)]
    3
    		 
    use clap::{Arg, Command};
  • typescript-type-def-derive 0.5.5/src/lib.rs
    6
    		 
    #![deny(clippy::correctness)]
    7
    		 
    #![allow(clippy::match_like_matches_macro)]
  • ureq 2.6.2/src/lib.rs
    5
    		 
    // the matches! macro is obscure and not widely known.
    6
    		 
    #![allow(clippy::match_like_matches_macro)]
    7
    		 
    // we're not changing public api due to a lint.
  • ux-dx 0.2.1/src/lib.rs
    39
    		 
        clippy::useless_format,
    40
    		 
        clippy::match_like_matches_macro,
    41
    		 
        clippy::needless_update,
  • venial 0.5.0/src/lib.rs
    4
    		 
    #![warn(clippy::cargo)]
    5
    		 
    #![allow(clippy::match_like_matches_macro)]
    6
    		 
    #![allow(clippy::needless_late_init)]
  • vsdbsled 0.34.7-patched/src/lib.rs
    158
    		 
    #![allow(clippy::mem_replace_with_default)] // Not using std::mem::take() due to MSRV of 1.37 (intro'd in 1.40)
    159
    		 
    #![allow(clippy::match_like_matches_macro)] // Not using std::matches! due to MSRV of 1.37 (intro'd in 1.42)
  • wgpu-core 0.15.0/src/lib.rs
    12
    		 
        // We don't use syntax sugar where it's not necessary.
    13
    		 
        clippy::match_like_matches_macro,
    14
    		 
        // Redundant matching is more explicit.
  • wgpu-hal 0.15.1/src/lib.rs
    23
    		 
        // We don't use syntax sugar where it's not necessary.
    24
    		 
        clippy::match_like_matches_macro,
    25
    		 
        // Redundant matching is more explicit.
  • wgpu-types 0.15.0/src/lib.rs
    7
    		 
        // We don't use syntax sugar where it's not necessary.
    8
    		 
        clippy::match_like_matches_macro,
    9
    		 
    )]
  • ya-smoltcp 0.1.0/src/lib.rs
    91
    		 
    #![allow(clippy::match_like_matches_macro)]
    92
    		 
    #![allow(clippy::redundant_field_names)]
  • yarte_html 0.15.2/src/lib.rs
    5
    		 
        clippy::match_on_vec_items,
    6
    		 
        clippy::match_like_matches_macro,
    7
    		 
        clippy::collapsible_match,