• adder-codec-rs 0.2.7/src/raw/stream.rs
    98
    		 
        #[allow(clippy::match_same_arms)]
    99
    		 
        fn get_source_type(&self) -> SourceType {
  • ansirs 0.1.7/src/color/color.rs
    110
    		 
        /// Converts an ANSI-256 color number to an rgb [`Color`].
    111
    		 
        #[allow(clippy::match_same_arms, clippy::too_many_lines)]
    112
    		 
        #[must_use]
  • ansirs 0.1.7/src/color/colors.rs
    919
    		 
        /// Get the RGB values of this named color.
    920
    		 
        #[allow(clippy::match_same_arms)]
    921
    		 
        #[must_use]
  • asn1rs 0.2.2/src/io/async_psql/mod.rs
    439
    		 
        fn source(&self) -> Option<&(dyn error::Error + 'static)> {
    440
    		 
            #[allow(clippy::match_same_arms)]
    441
    		 
            match self {
  • asn1rs-model 0.2.2/src/model/protobuf/mod.rs
    35
    		 
        pub fn to_rust(&self) -> RustType {
    36
    		 
            #[allow(clippy::match_same_arms)] // to have the same order as the original enum
    37
    		 
            match self {
    56
    		 
        pub fn is_primitive(&self) -> bool {
    57
    		 
            #[allow(clippy::match_same_arms)] // to have the same order as the original enum
    58
    		 
            match self {
    176
    		 
        pub fn definition_type_to_protobuf_type(rust_type: &RustType) -> ProtobufType {
    177
    		 
            #[allow(clippy::match_same_arms)] // to have the same order as the original enum
    178
    		 
            match rust_type {
  • asn1rs-model 0.2.2/src/model/rust/mod.rs
    128
    		 
        pub fn integer_range_str(&self) -> Option<Range<String>> {
    129
    		 
            #[allow(clippy::match_same_arms)] // to have the same order as the original enum
    130
    		 
            match self {
  • asn1rs-model 0.2.2/src/model/sql/mod.rs
    68
    		 
        pub fn to_rust(&self) -> RustType {
    69
    		 
            #[allow(clippy::match_same_arms)] // to have the same order as the original enum
    70
    		 
            RustType::Option(Box::new(match self {
    474
    		 
        pub fn is_primitive(rust: &RustType) -> bool {
    475
    		 
            #[allow(clippy::match_same_arms)] // to have the same order as the original enum
    476
    		 
            match rust.as_inner_type() {
  • babycat 0.0.14/src/backend/decoder/mod.rs
    172
    		 
    ) -> DecoderResult {
    173
    		 
        #[allow(clippy::match_same_arms)]
    174
    		 
        match decoding_backend {
  • beatrice 0.3.2/src/request.rs
    231
    		 
        };
    232
    		 
        #[allow(clippy::match_same_arms)]
    233
    		 
        // https://datatracker.ietf.org/doc/html/rfc7230#section-3.3
  • beatrice 0.3.2/src/request_body.rs
    55
    		 
        #[allow(clippy::missing_panics_doc)]
    56
    		 
        #[allow(clippy::match_same_arms)]
    57
    		 
        pub fn len(&self) -> u64 {
  • beatrice 0.3.2/src/response_body.rs
    27
    		 
        pub fn is_empty(&self) -> bool {
    28
    		 
            #[allow(clippy::match_same_arms)]
    29
    		 
            match self.len() {
    146
    		 
        fn eq(&self, other: &Self) -> bool {
    147
    		 
            #[allow(clippy::match_same_arms)]
    148
    		 
            match (self, other) {
  • beatrice 0.3.2/src/time.rs
    23
    		 
    #[allow(clippy::missing_panics_doc)]
    24
    		 
    #[allow(clippy::match_same_arms)]
    25
    		 
    #[must_use]
  • bendy 0.4.0-beta.2/src/state_tracker/state.rs
    63
    		 
        #[allow(clippy::match_same_arms)]
    64
    		 
        pub fn observe_token<'a>(&mut self, token: &Token<'a>) -> Result<(), E>
  • bevy_render 0.9.1/src/mesh/mesh/mod.rs
    288
    		 
        /// Does nothing if no [Indices] are set.
    289
    		 
        #[allow(clippy::match_same_arms)]
    290
    		 
        pub fn duplicate_vertices(&mut self) {
    537
    		 
    impl VertexFormatSize for wgpu::VertexFormat {
    538
    		 
        #[allow(clippy::match_same_arms)]
    539
    		 
        fn get_size(self) -> u64 {
    615
    		 
        /// mesh, all of the [`VertexAttributeValues`] must have the same length.
    616
    		 
        #[allow(clippy::match_same_arms)]
    617
    		 
        pub fn len(&self) -> usize {
    665
    		 
        /// useful for serialization and sending to the GPU.
    666
    		 
        #[allow(clippy::match_same_arms)]
    667
    		 
        pub fn get_bytes(&self) -> &[u8] {
  • bevy_render 0.9.1/src/texture/image.rs
    489
    		 
    impl TextureFormatPixelInfo for TextureFormat {
    490
    		 
        #[allow(clippy::match_same_arms)]
    491
    		 
        fn pixel_info(&self) -> PixelInfo {
  • bfbb 0.3.0-beta.1/src/spatula.rs
    229
    		 
        pub fn get_offset(&self) -> Option<usize> {
    230
    		 
            #[allow(clippy::match_same_arms)]
    231
    		 
            match *self {
    328
    		 
        pub fn get_level(&self) -> crate::Level {
    329
    		 
            #[allow(clippy::match_same_arms)]
    330
    		 
            match *self {
  • bpaf 0.7.7/src/info.rs
    31
    		 
        pub(crate) fn combine_with(self, other: Self) -> Self {
    32
    		 
            #[allow(clippy::match_same_arms)]
    33
    		 
            match (self, other) {
  • bvh-arena 1.1.3/src/bvh.rs
    260
    		 
        }
    261
    		 
        #[allow(clippy::match_same_arms)]
    262
    		 
        match (&left_node.content, &right_node.content) {
  • cargo-public-api 0.27.1/src/plain.rs
    119
    		 
        };
    120
    		 
        #[allow(clippy::match_same_arms)]
    121
    		 
        match token {
  • cetkaik_calculate_hand 1.0.0/src/lib.rs
    112
    		 
    impl PositiveHand {
    113
    		 
        #[allow(clippy::match_same_arms)]
    114
    		 
        #[must_use]
  • cfg-expr 0.14.0/src/expr.rs
    95
    		 
        #[allow(clippy::cognitive_complexity)]
    96
    		 
        #[allow(clippy::match_same_arms)]
    97
    		 
        fn matches(&self, tp: &TargetPredicate) -> bool {
  • cpclib 0.6.0/src/asm.rs
    57
    		 
        #[allow(clippy::match_same_arms)]
    58
    		 
        pub fn start_address(self) -> u16 {
  • cpclib-asm 0.6.0/src/implementation/tokens.rs
    58
    		 
        /// Assemble the symbol taking into account some context, but never modify this context
    59
    		 
        #[allow(clippy::match_same_arms)]
    60
    		 
        fn to_bytes_with_context(
    193
    		 
        /// This estimation may be wrong for instruction having several states.
    194
    		 
        #[allow(clippy::match_same_arms)]
    195
    		 
        fn estimated_duration(&self) -> Result<usize, AssemblerError> {
  • cpclib-sna 0.6.0/src/flags.rs
    269
    		 
        /// Return the size of one unique element
    270
    		 
        #[allow(clippy::match_same_arms, clippy::match_ref_pats)]
    271
    		 
        pub fn elem_size(&self) -> usize {
  • crash-handler 0.5.1/src/mac/state.rs
    595
    		 
        // the same result
    596
    		 
        #[allow(clippy::match_same_arms)]
    597
    		 
        match exc_info.resource_exception() {
  • daml-codegen 0.2.2/src/renderer/type_renderer.rs
    9
    		 
    #[allow(clippy::match_same_arms)]
    10
    		 
    pub fn quote_type(daml_type: &DamlType<'_>) -> TokenStream {
  • daml-lf 0.2.2/src/convert/archive_converter.rs
    344
    		 
    /// Convert from `DamlTypeWrapper` to `DamlType`.
    345
    		 
    #[allow(clippy::match_same_arms)]
    346
    		 
    impl<'a> TryFrom<&DamlTypeWrapper<'a>> for DamlType<'a> {
  • datetime 0.5.2/src/cal/datetime.rs
    1025
    		 
    #[allow(clippy::match_same_arms)]
    1026
    		 
    impl Month {
  • dbgen 0.8.0/src/schemagen_cli.rs
    101
    		 
        let unsigned = rng.gen::<bool>();
    102
    		 
        #[allow(clippy::match_same_arms)]
    103
    		 
        let ty = match (dialect, unsigned, bytes) {
  • derive-error-chain 0.11.2/src/lib.rs
    1351
    		 
    		#[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    1352
    		 
    		match (self.custom_cause.as_ref(), &self.link_type) {
  • domain 0.7.1/src/resolv/stub/conf.rs
    468
    		 
        #[allow(clippy::match_same_arms)]
    469
    		 
        fn parse_options(&mut self, words: SplitWhitespace) -> Result<(), Error> {
  • domain-resolv 0.5.1/src/stub/conf.rs
    459
    		 
        #[allow(clippy::match_same_arms)]
    460
    		 
        fn parse_options(&mut self, words: SplitWhitespace) -> Result<(), Error> {
  • egui_demo_lib 0.20.0/src/demo/font_book.rs
    124
    		 
    fn special_char_name(chr: char) -> Option<&'static str> {
    125
    		 
        #[allow(clippy::match_same_arms)] // many "flag"
    126
    		 
        match chr {
  • entab 0.3.1/src/parsers/tsv_inference.rs
    330
    		 
        /// Coerce a string into a Value
    331
    		 
        #[allow(clippy::match_same_arms)] // TODO: remove when dates are supported
    332
    		 
        #[must_use]
  • error-stack 0.2.4/src/fmt/mod.rs
    441
    		 
        //  emits which and also keeps it nicely formatted.
    442
    		 
        #[allow(clippy::match_same_arms)]
    443
    		 
        fn prepare(&self) -> PreparedInstruction {
  • ferrous-actions 0.1.0-beta.1/src/cargo_hooks/annotation.rs
    64
    		 
        fn annotation_level(level: DiagnosticLevel) -> AnnotationLevel {
    65
    		 
            #[allow(clippy::match_same_arms)]
    66
    		 
            match level {
  • fetcher-core 0.10.0/src/error.rs
    57
    		 
    	/// Check if the current error is somehow related to network connection and return it if it is
    58
    		 
    	#[allow(clippy::match_same_arms)]
    59
    		 
    	#[must_use]
  • file-expert 1.1.0/src/linguist_heuristics.rs
    227
    		 
    #[allow(clippy::too_many_lines)]
    228
    		 
    #[allow(clippy::match_same_arms)]
    229
    		 
    #[allow(clippy::if_same_then_else)]
  • flacenc 0.1.0/src/component.rs
    469
    		 
        pub const fn bits_per_sample_offset(&self, ch: usize) -> usize {
    470
    		 
            #[allow(clippy::match_same_arms)]
    471
    		 
            match *self {
  • focaccia 1.3.1/src/exhaustive/full.rs
    13
    		 
    #[must_use]
    14
    		 
    #[allow(clippy::match_same_arms)]
    15
    		 
    #[allow(clippy::too_many_lines)]
  • focaccia 1.3.1/src/exhaustive/turkic.rs
    13
    		 
    #[must_use]
    14
    		 
    #[allow(clippy::match_same_arms)]
    15
    		 
    #[allow(clippy::too_many_lines)]
  • focaccia 1.3.1/src/folding/mapping/lookup.rs
    15
    		 
    #[must_use]
    16
    		 
    #[allow(clippy::match_same_arms)]
    17
    		 
    #[allow(clippy::too_many_lines)]
  • formula 0.1.0/src/lib.rs
    146
    		 
        fn parse_pair(pair: Pair<Rule>) -> Result<Expr> {
    147
    		 
            #[allow(clippy::match_same_arms)]
    148
    		 
            let res = match pair.as_rule() {
  • grass_compiler 0.12.2/src/builtin/functions/meta.rs
    41
    		 
        #[allow(clippy::match_same_arms)]
    42
    		 
        Ok(match feature.as_str() {
  • gstreamer 0.19.7/src/lib.rs
    38
    		 
    #[allow(clippy::too_many_arguments)]
    39
    		 
    #[allow(clippy::match_same_arms)]
    40
    		 
    #[allow(clippy::type_complexity)]
  • gstreamer-allocators 0.19.2/src/lib.rs
    30
    		 
    #[allow(clippy::too_many_arguments)]
    31
    		 
    #[allow(clippy::match_same_arms)]
    32
    		 
    #[allow(clippy::type_complexity)]
  • gstreamer-app 0.19.6/src/lib.rs
    31
    		 
    #[allow(clippy::too_many_arguments)]
    32
    		 
    #[allow(clippy::match_same_arms)]
    33
    		 
    #[allow(clippy::use_self)]
  • gstreamer-audio 0.19.4/src/lib.rs
    31
    		 
    #[allow(clippy::too_many_arguments)]
    32
    		 
    #[allow(clippy::match_same_arms)]
    33
    		 
    #[allow(clippy::use_self)]
  • gstreamer-base 0.19.3/src/lib.rs
    30
    		 
    #[allow(clippy::too_many_arguments)]
    31
    		 
    #[allow(clippy::match_same_arms)]
    32
    		 
    #[allow(clippy::type_complexity)]
  • gstreamer-check 0.19.2/src/lib.rs
    26
    		 
    #[allow(clippy::too_many_arguments)]
    27
    		 
    #[allow(clippy::match_same_arms)]
    28
    		 
    #[allow(clippy::type_complexity)]
  • gstreamer-controller 0.19.2/src/lib.rs
    30
    		 
    #[allow(clippy::too_many_arguments)]
    31
    		 
    #[allow(clippy::match_same_arms)]
    32
    		 
    #[allow(clippy::use_self)]
  • gstreamer-editing-services 0.19.4/src/lib.rs
    61
    		 
    #[allow(clippy::too_many_arguments)]
    62
    		 
    #[allow(clippy::match_same_arms)]
    63
    		 
    #[allow(clippy::use_self)]
  • gstreamer-gl 0.19.5/src/lib.rs
    32
    		 
    #[allow(clippy::too_many_arguments)]
    33
    		 
    #[allow(clippy::match_same_arms)]
    34
    		 
    #[allow(clippy::use_self)]
  • gstreamer-net 0.19.4/src/lib.rs
    30
    		 
    #[allow(clippy::too_many_arguments)]
    31
    		 
    #[allow(clippy::match_same_arms)]
    32
    		 
    #[allow(clippy::use_self)]
  • gstreamer-pbutils 0.19.2/src/lib.rs
    37
    		 
    #[allow(clippy::too_many_arguments)]
    38
    		 
    #[allow(clippy::match_same_arms)]
    39
    		 
    #[allow(clippy::type_complexity)]
  • gstreamer-player 0.19.4/src/lib.rs
    30
    		 
    #[allow(clippy::too_many_arguments)]
    31
    		 
    #[allow(clippy::match_same_arms)]
    32
    		 
    #[allow(clippy::type_complexity)]
  • gstreamer-rtp 0.19.4/src/lib.rs
    31
    		 
    #[allow(clippy::too_many_arguments)]
    32
    		 
    #[allow(clippy::match_same_arms)]
    33
    		 
    #[allow(non_snake_case)]
  • gstreamer-rtsp 0.19.2/src/lib.rs
    31
    		 
    #[allow(clippy::too_many_arguments)]
    32
    		 
    #[allow(clippy::match_same_arms)]
    33
    		 
    #[allow(clippy::use_self)]
  • gstreamer-rtsp-server 0.19.2/src/lib.rs
    34
    		 
    #[allow(clippy::too_many_arguments)]
    35
    		 
    #[allow(clippy::match_same_arms)]
    36
    		 
    #[allow(clippy::type_complexity)]
  • gstreamer-sdp 0.19.4/src/lib.rs
    30
    		 
    #[allow(clippy::too_many_arguments)]
    31
    		 
    #[allow(clippy::match_same_arms)]
    32
    		 
    #[allow(non_snake_case)]
  • gstreamer-validate 0.19.0/src/lib.rs
    39
    		 
    #[allow(clippy::too_many_arguments)]
    40
    		 
    #[allow(clippy::match_same_arms)]
    41
    		 
    #[allow(non_snake_case)]
  • gstreamer-video 0.19.5/src/lib.rs
    31
    		 
    #[allow(clippy::too_many_arguments)]
    32
    		 
    #[allow(clippy::match_same_arms)]
    33
    		 
    #[allow(clippy::use_self)]
  • gstreamer-webrtc 0.19.3/src/lib.rs
    31
    		 
    #[allow(clippy::too_many_arguments)]
    32
    		 
    #[allow(clippy::match_same_arms)]
    33
    		 
    #[allow(clippy::use_self)]
  • hdbconnect 0.24.0/src/protocol/parts/type_id.rs
    179
    		 
            // From To Conversions
    180
    		 
            #[allow(clippy::match_same_arms)]
    181
    		 
            match (value_type, self) {
  • hdd 0.10.3/src/drivedb/drivedb.rs
    122
    		 
    	#[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    123
    		 
    	preset.into_iter().filter(|attr| match (&attr.drivetype, &drivetype) {
  • hebo_codec 0.2.3/src/v5/property.rs
    661
    		 
        /// Get byte length used in packets.
    662
    		 
        #[allow(clippy::match_same_arms)]
    663
    		 
        #[must_use]
    867
    		 
    impl EncodePacket for Property {
    868
    		 
        #[allow(clippy::match_same_arms)]
    869
    		 
        fn encode(&self, buf: &mut Vec<u8>) -> Result<usize, EncodeError> {
  • hedera 0.9.0/src/schedule/schedule_create_transaction.rs
    207
    		 
                #[allow(clippy::match_same_arms)]
    208
    		 
                let data = match data {
  • hoard 0.5.1/src/command/status.rs
    19
    		 
                .try_filter_map(|hoard_diff| async move {
    20
    		 
                    #[allow(clippy::match_same_arms)]
    21
    		 
                    let source = match hoard_diff {
  • hoard 0.5.1/src/hoard/iter/diff_files.rs
    249
    		 
            #[allow(clippy::match_same_arms)]
    250
    		 
            let diff = match (
  • hoard 0.5.1/src/hoard/iter/operation.rs
    28
    		 
                    tracing::trace!("found diff: {:?}", diff);
    29
    		 
                    #[allow(clippy::match_same_arms)]
    30
    		 
                    let op = match diff {
  • iban_validate 4.0.1/src/lib.rs
    129
    		 
        pub fn bank_identifier(&self) -> Option<&str> {
    130
    		 
            #[allow(clippy::match_same_arms)] // For clarity, identical arms are not combined.
    131
    		 
            match self.country_code() {
    232
    		 
        pub fn branch_identifier(&self) -> Option<&str> {
    233
    		 
            #[allow(clippy::match_same_arms)] // For clarity, identical arms are not combined.
    234
    		 
            match self.country_code() {
    476
    		 
            };
    477
    		 
            #[allow(clippy::match_same_arms)] // For clarity, identical arms are not combined.
    478
    		 
            (match base_iban.country_code() {
  • inside-baseball 0.1.0/src/script/decode.rs
    394
    		 
        let opcode = read_u8(code)?;
    395
    		 
        #[allow(clippy::match_same_arms)]
    396
    		 
        match opcode {
  • inside-baseball 0.1.0/src/script/visit.rs
    41
    		 
    pub fn default_visit_stmt(script: &mut Scripto, stmt: &mut Stmt, visit: &mut dyn Visitor) {
    42
    		 
        #[allow(clippy::match_same_arms)]
    43
    		 
        match *stmt {
  • iso_11649 0.1.2/src/lib.rs
    556
    		 
            for ir in INVALID_REFS {
    557
    		 
                #[allow(clippy::match_same_arms)]
    558
    		 
                match RfCreditorReference::from_str(ir) {
  • jsonschema 0.16.1/src/schemas.rs
    49
    		 
    impl Draft {
    50
    		 
        #[allow(clippy::match_same_arms)]
    51
    		 
        pub(crate) fn get_validator(self, keyword: &str) -> Option<CompileFunc> {
  • k8s-openapi-codegen-common 0.17.0/src/lib.rs
    1089
    		 
    	#[allow(clippy::match_same_arms)]
    1090
    		 
    	let is_default = evaluate_trait_bound(kind, false, definitions, map_namespace, |kind, required| match kind {
    1177
    		 
    ) -> Result<bool, Error> {
    1178
    		 
    	#[allow(clippy::match_same_arms)]
    1179
    		 
    	evaluate_trait_bound(kind, false, definitions, map_namespace, |kind, required| match kind {
    1459
    		 
    	#[allow(clippy::match_same_arms)]
    1460
    		 
    	match schema_kind {
  • kul_core 0.1.2/src/datum.rs
    53
    		 
    /// deep tree shapes, but those are rare).
    54
    		 
    #[allow(clippy::match_same_arms)]
    55
    		 
    impl<TT1, TT2, ET1, ET2, DR1, DR2>
  • kul_core 0.1.2/src/error.rs
    30
    		 
    /// types](enum.Error.html#variant.FailedCombiner) can be.
    31
    		 
    #[allow(clippy::match_same_arms)]
    32
    		 
    impl<P1, P2, CE1, CE2> PartialEq<Error<P2, CE2>> for Error<P1, CE1>
  • kvarn 0.5.0/src/application.rs
    200
    		 
        pub async fn new(stream: Encryption, version: Version) -> Result<Self, Error> {
    201
    		 
            #[allow(clippy::match_same_arms)] // When http2 isn't enabled
    202
    		 
            match version {
  • kvarn 0.5.0/src/comprash.rs
    446
    		 
                    {
    447
    		 
                        #[allow(clippy::match_same_arms)] // we have comments
    448
    		 
                        match mime_type.get_param("charset") {
  • kvarn-auth 0.1.0/src/lib.rs
    903
    		 
        }
    904
    		 
        #[allow(clippy::match_same_arms)] // cfg
    905
    		 
        fn decrypt<'a>(&self, b: &'a mut [u8]) -> Option<Cow<'a, [u8]>> {
  • lettre-openssl111 0.9.0/src/smtp/client/net.rs
    120
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    121
    		 
        fn upgrade_tls(&mut self, tls_parameters: &ClientTlsParameters) -> io::Result<()> {
    137
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    138
    		 
        fn is_encrypted(&self) -> bool {
  • lettre-openssl111 0.9.0/src/smtp/error.rs
    49
    		 
    impl StdError for Error {
    50
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    51
    		 
        fn description(&self) -> &str {
  • lettre-openssl111 0.9.0/src/smtp/mod.rs
    278
    		 
        /// Sends an email
    279
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms, cyclomatic_complexity))]
    280
    		 
        fn send(&mut self, email: SendableEmail) -> SmtpResult {
  • libafl_cc 0.9.0/src/clang.rs
    88
    		 
    #[allow(clippy::match_same_arms)] // for the linking = false wip for "shared"
    89
    		 
    impl CompilerWrapper for ClangWrapper {
  • librespot-core 0.4.2/src/session.rs
    182
    		 
        #[allow(clippy::match_same_arms)]
    183
    		 
        fn dispatch(&self, cmd: u8, data: Bytes) {
  • light-curve-feature 0.5.2/src/features/periodogram.rs
    11
    		 
    fn number_ending(i: usize) -> &'static str {
    12
    		 
        #[allow(clippy::match_same_arms)]
    13
    		 
        match (i % 10, i % 100) {
  • lychee-lib 0.10.3/src/extract/html5ever.rs
    20
    		 
        #[allow(clippy::match_same_arms)]
    21
    		 
        fn process_token(&mut self, token: Token, _line_number: u64) -> TokenSinkResult<()> {
  • lychee-lib 0.10.3/src/types/error.rs
    131
    		 
    #[allow(clippy::match_same_arms)]
    132
    		 
    impl PartialEq for ErrorKind {
    168
    		 
    #[allow(clippy::match_same_arms)]
    169
    		 
    impl Hash for ErrorKind {
  • lychee-lib 0.10.3/src/types/status.rs
    94
    		 
        #[must_use]
    95
    		 
        #[allow(clippy::match_same_arms)]
    96
    		 
        pub fn details(&self) -> Option<String> {
  • madsim-rdkafka 0.2.14-alpha/src/std/error.rs
    310
    		 
        /// Returns the [`RDKafkaErrorCode`] underlying this error, if any.
    311
    		 
        #[allow(clippy::match_same_arms)]
    312
    		 
        pub fn rdkafka_error_code(&self) -> Option<RDKafkaErrorCode> {
  • malachite-nz 0.3.2/src/natural/arithmetic/mod_pow.rs
    689
    		 
        /// ```
    690
    		 
        #[allow(clippy::match_same_arms)] // matches are order-dependent
    691
    		 
        fn mod_pow(self, mut exp: Natural, mut m: Natural) -> Natural {
    743
    		 
        /// ```
    744
    		 
        #[allow(clippy::match_same_arms)] // matches are order-dependent
    745
    		 
        fn mod_pow(self, mut exp: Natural, m: &'b Natural) -> Natural {
    797
    		 
        /// ```
    798
    		 
        #[allow(clippy::match_same_arms)] // matches are order-dependent
    799
    		 
        fn mod_pow(self, exp: &'b Natural, mut m: Natural) -> Natural {
    850
    		 
        /// ```
    851
    		 
        #[allow(clippy::match_same_arms)] // matches are order-dependent
    852
    		 
        fn mod_pow(self, exp: &'b Natural, m: &'c Natural) -> Natural {
    901
    		 
        /// ```
    902
    		 
        #[allow(clippy::match_same_arms)] // matches are order-dependent
    903
    		 
        fn mod_pow_assign(&mut self, mut exp: Natural, mut m: Natural) {
  • minus 5.1.0/src/core/init.rs
    187
    		 
        let run_mode = *RUNMODE.lock();
    188
    		 
        #[allow(clippy::match_same_arms)]
    189
    		 
        match run_mode {
  • moneta 0.3.2/src/iso_4217.rs
    718
    		 
        ///
    719
    		 
        #[allow(clippy::match_same_arms)]
    720
    		 
        #[must_use]
  • nng 1.0.1/src/error.rs
    190
    		 
    			#[rustfmt::skip]
    191
    		 
    			#[allow(clippy::match_same_arms)]
    192
    		 
    			let new_kind = match e {
  • owo-colors 3.6.0/src/colors/dynamic.rs
    79
    		 
        fn from(color: &'a str) -> Self {
    80
    		 
            #[allow(clippy::match_same_arms)] // defaults to white color
    81
    		 
            match color {
  • printenv2 0.1.0/build.rs
    22
    		 
        #[allow(clippy::match_same_arms)]
    23
    		 
        match (unix.as_deref(), os.as_deref()) {
  • printpdf 0.5.3/src/pdf_conformance.rs
    233
    		 
        /// if it has to conform to the given PDF Standard
    234
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    235
    		 
        pub fn must_have_xmp_metadata(&self)
    265
    		 
        /// but the conformance to the given PDF standard does not allow it.
    266
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    267
    		 
        pub fn is_layering_allowed(&self)
  • pty_closure 0.1.2/src/lib.rs
    123
    		 
                    let result = waitpid(child, None).map_err(Error::Wait)?;
    124
    		 
                    #[allow(clippy::match_same_arms)]
    125
    		 
                    match result {
  • qr_code 1.1.0/src/bits.rs
    200
    		 
        pub fn push_mode_indicator(&mut self, mode: ExtendedMode) -> QrResult<()> {
    201
    		 
            #[allow(clippy::match_same_arms)]
    202
    		 
            let number = match (self.version, mode) {
  • qr_code 1.1.0/src/canvas.rs
    228
    		 
                        y + j,
    229
    		 
                        #[allow(clippy::match_same_arms)]
    230
    		 
                        match (i, j) {
  • qrcode 0.12.0/src/bits.rs
    192
    		 
        pub fn push_mode_indicator(&mut self, mode: ExtendedMode) -> QrResult<()> {
    193
    		 
            #[allow(clippy::match_same_arms)]
    194
    		 
            let number = match (self.version, mode) {
  • qrcode 0.12.0/src/canvas.rs
    223
    		 
                        y + j,
    224
    		 
                        #[allow(clippy::match_same_arms)]
    225
    		 
                        match (i, j) {
  • qsv 0.87.0/src/cmd/apply.rs
    1248
    		 
                search_result.map(|locdetails| {
    1249
    		 
                    #[allow(clippy::match_same_arms)]
    1250
    		 
                    // match arms are evaluated in order,
  • qsv 0.87.0/src/cmd/stats.rs
    1045
    		 
        #[inline]
    1046
    		 
        #[allow(clippy::match_same_arms)]
    1047
    		 
        // we allow match_same_arms because we want are optimizing for
  • rdkafka 0.29.0/src/error.rs
    310
    		 
        /// Returns the [`RDKafkaErrorCode`] underlying this error, if any.
    311
    		 
        #[allow(clippy::match_same_arms)]
    312
    		 
        pub fn rdkafka_error_code(&self) -> Option<RDKafkaErrorCode> {
  • reaclib 0.1.3/src/lib.rs
    318
    		 
        pub const fn num_reactants(&self) -> usize {
    319
    		 
            #[allow(clippy::match_same_arms)]
    320
    		 
            match self {
    336
    		 
        pub const fn num_products(&self) -> usize {
    337
    		 
            #[allow(clippy::match_same_arms)]
    338
    		 
            match self {
  • reserde 0.0.4/src/main.rs
    270
    		 
    fn convert_bool_variants(object: &mut Object) {
    271
    		 
    	#[allow(clippy::match_same_arms)]
    272
    		 
    	match object {
    368
    		 
    fn stringify(object: &mut Object, encoding: Encoding) {
    369
    		 
    	#[allow(clippy::match_same_arms)]
    370
    		 
    	match object {
    451
    		 
    	*object = Object::String(
    452
    		 
    		#[allow(clippy::match_same_arms)]
    453
    		 
    		match object {
  • rhymuweb 1.2.1/src/chunked_body.rs
    393
    		 
                // if the arms are left in chronological order.
    394
    		 
                #[allow(clippy::match_same_arms)]
    395
    		 
                match i {
    514
    		 
                // if the arms are left in chronological order.
    515
    		 
                #[allow(clippy::match_same_arms)]
    516
    		 
                match i {
  • romy-sdl2 0.32.2/src/sdl2/event.rs
    405
    		 
    impl WindowEvent {
    406
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    407
    		 
        fn from_ll(id: u8, data1: i32, data2: i32) -> WindowEvent {
  • romy-sdl2 0.32.2/src/sdl2/pixels.rs
    309
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    310
    		 
        pub fn byte_size_of_pixels(&self, num_of_pixels: usize) -> usize {
    347
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    348
    		 
        pub fn byte_size_per_pixel(&self) -> usize {
  • rsmorphy 0.4.0/src/container/decode/mod.rs
    51
    		 
                // FIXME a bug in clippy; https://github.com/rust-lang-nursery/rust-clippy/issues/860
    52
    		 
                #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    53
    		 
                match (esc, c1, c2) {
  • rucline 0.4.0/src/prompt/context.rs
    171
    		 
        // Allowed because it is more readable
    172
    		 
        #[allow(clippy::match_same_arms)]
    173
    		 
        fn cycle(&mut self, direction: Direction) {
  • rustc_codegen_spirv 0.4.0/src/builder_spirv.rs
    532
    		 
            };
    533
    		 
            #[allow(clippy::match_same_arms)]
    534
    		 
            let legal = match val {
  • rustc_codegen_spirv 0.4.0/src/codegen_cx/entry.rs
    626
    		 
            }
    627
    		 
            #[allow(clippy::match_same_arms)]
    628
    		 
            let flat_forced = match (execution_model, storage_class) {
  • rustc_codegen_spirv 0.4.0/src/linker/specializer.rs
    1620
    		 
            #[allow(clippy::match_same_arms)]
    1621
    		 
            Ok(match (a.clone(), b.clone()) {
  • rustc_codegen_spirv 0.4.0/src/spirv_type_constraints.rs
    241
    		 
        #[allow(clippy::match_same_arms)]
    242
    		 
        match op {
  • rustc_codegen_spirv 0.4.0/src/target.rs
    45
    		 
        pub fn spirv_version(&self) -> (u8, u8) {
    46
    		 
            #[allow(clippy::match_same_arms)]
    47
    		 
            match self.env {
  • rustyline 10.1.1/src/keymap.rs
    131
    		 
        pub const fn should_reset_kill_ring(&self) -> bool {
    132
    		 
            #[allow(clippy::match_same_arms)]
    133
    		 
            match *self {
  • rustyline 10.1.1/src/keys.rs
    26
    		 
            }
    27
    		 
            #[allow(clippy::match_same_arms)]
    28
    		 
            match c {
  • rustyline-with-hint-fix 10.0.4/src/keymap.rs
    131
    		 
        pub const fn should_reset_kill_ring(&self) -> bool {
    132
    		 
            #[allow(clippy::match_same_arms)]
    133
    		 
            match *self {
  • rustyline-with-hint-fix 10.0.4/src/keys.rs
    26
    		 
            }
    27
    		 
            #[allow(clippy::match_same_arms)]
    28
    		 
            match c {
  • s3-server 0.2.0/src/errors.rs
    508
    		 
        /// Returns a corresponding status code of the error code
    509
    		 
        #[allow(clippy::match_same_arms)] // keep alphabet order for human readability
    510
    		 
        #[must_use]
  • safe-regex-compiler 0.2.5/src/parser.rs
    570
    		 
        };
    571
    		 
        #[allow(clippy::match_same_arms, clippy::unnested_or_patterns)]
    572
    		 
        match (&mut prev, &mut last, byte.map(|b| b)) {
  • saft 0.32.0/src/graph.rs
    434
    		 
            #[allow(clippy::match_same_arms)] // nicer to have the cases separately here, for now?
    435
    		 
            match node {
  • sdl2 0.35.2/src/sdl2/event.rs
    413
    		 
    impl DisplayEvent {
    414
    		 
        #[allow(clippy::match_same_arms)]
    415
    		 
        fn from_ll(id: u8, data1: i32) -> DisplayEvent {
    486
    		 
    impl WindowEvent {
    487
    		 
        #[allow(clippy::match_same_arms)]
    488
    		 
        fn from_ll(id: u8, data1: i32, data2: i32) -> WindowEvent {
  • sdl2 0.35.2/src/sdl2/pixels.rs
    325
    		 
        #[allow(clippy::match_same_arms)]
    326
    		 
        pub fn byte_size_of_pixels(self, num_of_pixels: usize) -> usize {
    368
    		 
        #[allow(clippy::match_same_arms)]
    369
    		 
        pub fn byte_size_per_pixel(self) -> usize {
  • seed 0.9.2/src/browser/dom/virtual_dom_bridge.rs
    306
    		 
    /// See the [example](https://github.com/seed-rs/seed/issues/335) of such element.
    307
    		 
    #[allow(clippy::match_same_arms)]
    308
    		 
    fn fix_attrs_order(attrs: &mut Attrs) {
  • semverver 0.1.51/src/traverse.rs
    1111
    		 
    #[allow(clippy::let_and_return)]
    1112
    		 
    #[allow(clippy::match_same_arms)]
    1113
    		 
    fn is_impl_trait_public<'tcx>(tcx: TyCtxt<'tcx>, impl_def_id: DefId) -> bool {
  • semververfork 0.1.64/src/traverse.rs
    1095
    		 
    #[allow(clippy::let_and_return)]
    1096
    		 
    #[allow(clippy::match_same_arms)]
    1097
    		 
    fn is_impl_trait_public<'tcx>(tcx: TyCtxt<'tcx>, impl_def_id: DefId) -> bool {
  • serde_json_merge 0.0.4/src/merge/union.rs
    180
    		 
                |_idx: &IndexPath, this: &mut Value, other: Option<&Value>| -> bool {
    181
    		 
                    #[allow(clippy::match_same_arms)]
    182
    		 
                    match (this, other) {
  • serde_taml 0.0.3/src/de/type_overrides.rs
    274
    		 
    		#[allow(
    275
    		 
    			clippy::match_same_arms,
    276
    		 
    			clippy::non_ascii_literal,
  • servlin 0.1.1/src/request.rs
    231
    		 
        };
    232
    		 
        #[allow(clippy::match_same_arms)]
    233
    		 
        // https://datatracker.ietf.org/doc/html/rfc7230#section-3.3
  • servlin 0.1.1/src/request_body.rs
    55
    		 
        #[allow(clippy::missing_panics_doc)]
    56
    		 
        #[allow(clippy::match_same_arms)]
    57
    		 
        pub fn len(&self) -> u64 {
  • servlin 0.1.1/src/response_body.rs
    27
    		 
        pub fn is_empty(&self) -> bool {
    28
    		 
            #[allow(clippy::match_same_arms)]
    29
    		 
            match self.len() {
    146
    		 
        fn eq(&self, other: &Self) -> bool {
    147
    		 
            #[allow(clippy::match_same_arms)]
    148
    		 
            match (self, other) {
  • servlin 0.1.1/src/time.rs
    23
    		 
    #[allow(clippy::missing_panics_doc)]
    24
    		 
    #[allow(clippy::match_same_arms)]
    25
    		 
    #[must_use]
  • signalo_filters 0.6.0/src/classify/slopes.rs
    138
    		 
                Some(ref state) => {
    139
    		 
                    #[allow(clippy::match_same_arms)]
    140
    		 
                    match state.partial_cmp(&input) {
  • soroban-cli 0.4.0/src/strval.rs
    240
    		 
    pub fn to_string(v: &ScVal) -> Result<String, Error> {
    241
    		 
        #[allow(clippy::match_same_arms)]
    242
    		 
        Ok(match v {
    252
    		 
    pub fn to_json(v: &ScVal) -> Result<Value, Error> {
    253
    		 
        #[allow(clippy::match_same_arms)]
    254
    		 
        let val: Value = match v {
  • spirt 0.1.0/src/context.rs
    372
    		 
        fn get(&self, k: K) -> Option<&V> {
    373
    		 
            #[allow(clippy::match_same_arms)]
    374
    		 
            match self {
    382
    		 
        fn get_mut(&mut self, k: K) -> Option<&mut V> {
    383
    		 
            #[allow(clippy::match_same_arms)]
    384
    		 
            match self {
  • spirt 0.1.0/src/print/pretty.rs
    471
    		 
            #[allow(clippy::match_same_arms)]
    472
    		 
            match self {
  • spirt 0.1.0/src/spv/lift.rs
    211
    		 
        fn visit_data_inst_def(&mut self, data_inst_def: &DataInstDef) {
    212
    		 
            #[allow(clippy::match_same_arms)]
    213
    		 
            match data_inst_def.kind {
    1082
    		 
            #[allow(clippy::match_same_arms)]
    1083
    		 
            match self {
  • standalone-syn 0.13.0/src/path.rs
    449
    		 
        impl ToTokens for GenericArgument {
    450
    		 
            #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    451
    		 
            fn to_tokens(&self, tokens: &mut Tokens) {
  • stellar-xdr 0.0.12/src/curr/generated.rs
    2530
    		 
        pub const fn discriminant(&self) -> ScpStatementType {
    2531
    		 
            #[allow(clippy::match_same_arms)]
    2532
    		 
            match self {
    2571
    		 
            let dv: ScpStatementType = <ScpStatementType as ReadXdr>::read_xdr(r)?;
    2572
    		 
            #[allow(clippy::match_same_arms, clippy::match_wildcard_for_single_variants)]
    2573
    		 
            let v = match dv {
    2590
    		 
            self.discriminant().write_xdr(w)?;
    2591
    		 
            #[allow(clippy::match_same_arms)]
    2592
    		 
            match self {
    2796
    		 
        pub const fn discriminant(&self) -> i32 {
    2797
    		 
            #[allow(clippy::match_same_arms)]
    2798
    		 
            match self {
    2835
    		 
            let dv: i32 = <i32 as ReadXdr>::read_xdr(r)?;
    2836
    		 
            #[allow(clippy::match_same_arms, clippy::match_wildcard_for_single_variants)]
    2837
    		 
            let v = match dv {
  • stellar-xdr 0.0.12/src/next/generated.rs
    2545
    		 
        pub const fn discriminant(&self) -> ScpStatementType {
    2546
    		 
            #[allow(clippy::match_same_arms)]
    2547
    		 
            match self {
    2586
    		 
            let dv: ScpStatementType = <ScpStatementType as ReadXdr>::read_xdr(r)?;
    2587
    		 
            #[allow(clippy::match_same_arms, clippy::match_wildcard_for_single_variants)]
    2588
    		 
            let v = match dv {
    2605
    		 
            self.discriminant().write_xdr(w)?;
    2606
    		 
            #[allow(clippy::match_same_arms)]
    2607
    		 
            match self {
    2902
    		 
        pub const fn discriminant(&self) -> ScEnvMetaKind {
    2903
    		 
            #[allow(clippy::match_same_arms)]
    2904
    		 
            match self {
    2940
    		 
            let dv: ScEnvMetaKind = <ScEnvMetaKind as ReadXdr>::read_xdr(r)?;
    2941
    		 
            #[allow(clippy::match_same_arms, clippy::match_wildcard_for_single_variants)]
    2942
    		 
            let v = match dv {
  • subcomponent 0.1.0/src/cmd/mod.rs
    92
    		 
            */
    93
    		 
           #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    94
    		 
            match *self {
  • swarm-bot 0.3.4/src/client/physics/tools.rs
    140
    		 
            #[allow(clippy::match_same_arms)]
    141
    		 
            let best_tool = match (block.material, self.kind) {
  • syn 1.0.107/src/path.rs
    725
    		 
        impl ToTokens for GenericArgument {
    726
    		 
            #[allow(clippy::match_same_arms)]
    727
    		 
            fn to_tokens(&self, tokens: &mut TokenStream) {
  • syn-impersonated 0.1.18/src/path.rs
    597
    		 
        impl ToTokens for GenericArgument {
    598
    		 
            #[allow(clippy::match_same_arms)]
    599
    		 
            fn to_tokens(&self, tokens: &mut TokenStream) {
  • syn-next 1.0.0-rc4/src/path.rs
    557
    		 
        impl ToTokens for GenericArgument {
    558
    		 
            #[allow(clippy::match_same_arms)]
    559
    		 
            fn to_tokens(&self, tokens: &mut TokenStream) {
  • syn-pub-items 0.15.30/src/path.rs
    557
    		 
        impl ToTokens for GenericArgument {
    558
    		 
            #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    559
    		 
            fn to_tokens(&self, tokens: &mut TokenStream) {
  • tame-gcs 0.12.0/src/types.rs
    148
    		 
            #[allow(clippy::match_same_arms)]
    149
    		 
            for (i, c) in name.chars().enumerate() {
  • taml 0.0.11/src/formatting.rs
    51
    		 
    	pub fn next<Position>(&mut self, token: &Token<Position>) -> Recommendation {
    52
    		 
    		#[allow(clippy::match_same_arms)]
    53
    		 
    		let recommendation = match (&self.state, token) {
  • taurus 0.1.1/src/player.rs
    79
    		 
                if flags.contains(input::KEY_PRESS) {
    80
    		 
                    #[allow(clippy::match_same_arms)]
    81
    		 
                    match key.code {
  • 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 {
  • textmode 0.3.0/src/private.rs
    74
    		 
        fn try_read_bytes(&mut self) -> Option<crate::Key> {
    75
    		 
            #[allow(clippy::match_same_arms)]
    76
    		 
            let prefix: Vec<_> = self
    336
    		 
        #[allow(clippy::match_same_arms)]
    337
    		 
        fn expected_leading_utf8_bytes(&self, c: u8) -> usize {
  • tremor-script 0.13.0-rc.11/src/ast/visitors/impls/const_folder.rs
    56
    		 
    impl<'run, 'script: 'run> ImutExprVisitor<'script> for ConstFolder<'run, 'script> {
    57
    		 
        #[allow(clippy::too_many_lines, clippy::match_same_arms)]
    58
    		 
        fn leave_expr(&mut self, e: &mut ImutExpr<'script>) -> Result<()> {
  • trippy 0.6.0/src/dns.rs
    33
    		 
        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
    34
    		 
            #[allow(clippy::match_same_arms)]
    35
    		 
            match self {
  • unic-segment 0.9.0/src/grapheme.rs
    276
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    277
    		 
        match (before, after) {
  • unic-segment 0.9.0/src/word.rs
    170
    		 
        #[inline]
    171
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    172
    		 
        fn next(&mut self) -> Option<&'a str> {
  • unic-ucd 0.9.0/tests/bidi_class_consistency_tests.rs
    25
    		 
    #[test]
    26
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    27
    		 
    fn test_from_bidi_class() {
  • wotw_seedgen 0.2.1/src/item/mod.rs
    181
    		 
        pub fn cost(&self) -> u32 {
    182
    		 
            #[allow(clippy::match_same_arms)]
    183
    		 
            match self {
    206
    		 
        pub fn shop_price(&self) -> u32 {
    207
    		 
            #[allow(clippy::match_same_arms)]
    208
    		 
            match self {
  • yata 0.6.1/src/methods/renko.rs
    400
    		 
    	#[test]
    401
    		 
    	#[allow(clippy::match_same_arms)]
    402
    		 
    	#[allow(clippy::clone_on_copy)]
  • yatima-rustyline 0.2.0/src/keymap.rs
    131
    		 
        pub const fn should_reset_kill_ring(&self) -> bool {
    132
    		 
            #[allow(clippy::match_same_arms)]
    133
    		 
            match *self {
  • yatima-rustyline 0.2.0/src/keys.rs
    26
    		 
            }
    27
    		 
            #[allow(clippy::match_same_arms)]
    28
    		 
            match c {
  • aa_similarity 0.1.0/src/lib.rs
    28
    		 
    // #![warn(clippy::all, clippy::pedantic, clippy::nursery, clippy::cargo)]
    29
    		 
    #![allow(clippy::match_same_arms, clippy::too_many_lines)]
  • advent-of-code 2022.0.46/src/year2016/day02.rs
    3
    		 
    pub fn solve(input: &Input) -> Result<String, String> {
    4
    		 
        #![allow(clippy::match_same_arms)]
    5
    		 
        let mut code = String::new();
  • alt_serde_derive 1.0.119/src/lib.rs
    41
    		 
        clippy::map_err_ignore,
    42
    		 
        clippy::match_same_arms,
    43
    		 
        clippy::module_name_repetitions,
  • alt_serde_json 1.0.61/src/lib.rs
    334
    		 
        clippy::map_err_ignore,
    335
    		 
        clippy::match_same_arms,
    336
    		 
        clippy::similar_names,
  • arn-language 1.2.1/src/main.rs
    8
    		 
        // I have a lot of TODOs, so this is reduntant
    9
    		 
        clippy::match_same_arms,
    10
    		 
        // I don't care about this
  • artillery-core 0.1.2/src/epidemic/member.rs
    180
    		 
        // It's important bit otherwise we won't understand.
    181
    		 
        #![allow(clippy::match_same_arms)]
  • asuran-core 0.1.6/src/repository/encryption.rs
    6
    		 
    // In this case, this lint results in harder to read code for security critical portions
    7
    		 
    #![allow(clippy::match_same_arms)]
  • async-graphql 5.0.5/src/lib.rs
    157
    		 
    #![allow(clippy::option_if_let_else)]
    158
    		 
    #![allow(clippy::match_same_arms)]
    159
    		 
    #![allow(clippy::default_trait_access)]
  • avocado 0.6.0/src/lib.rs
    674
    		 
            unused_import_braces, unused_qualifications, missing_docs)]
    675
    		 
    #![allow(clippy::single_match, clippy::match_same_arms, clippy::match_ref_pats,
    676
    		 
             clippy::clone_on_ref_ptr, clippy::needless_pass_by_value)]
  • avocado_derive 0.6.0/src/lib.rs
    16
    		 
            /* missing_docs (https://github.com/rust-lang/rust/issues/42008) */)]
    17
    		 
    #![allow(clippy::single_match, clippy::match_same_arms, clippy::match_ref_pats,
    18
    		 
             clippy::clone_on_ref_ptr, clippy::needless_pass_by_value)]
  • base64-simd 0.8.0/src/lib.rs
    43
    		 
        clippy::items_after_statements,
    44
    		 
        clippy::match_same_arms,
    45
    		 
        clippy::verbose_bit_mask
  • bevy 0.9.1/examples/reflection/reflection_types.rs
    1
    		 
    #![allow(clippy::match_same_arms)]
    2
    		 
    //! This example illustrates how reflection works for simple data structures, like
  • bevy_mikktspace 0.9.1/src/generated.rs
    33
    		 
        clippy::redundant_else,
    34
    		 
        clippy::match_same_arms,
    35
    		 
        clippy::semicolon_if_nothing_returned,
  • bevy_mikktspace 0.9.1/tests/regression_test.rs
    4
    		 
        clippy::redundant_else,
    5
    		 
        clippy::match_same_arms,
    6
    		 
        clippy::semicolon_if_nothing_returned,
  • boreal 0.1.0/src/lib.rs
    58
    		 
    #![allow(clippy::unnested_or_patterns)]
    59
    		 
    #![allow(clippy::match_same_arms)]
    60
    		 
    #![allow(clippy::too_many_lines)]
  • break-time 0.1.2/src/lib.rs
    7
    		 
        clippy::single_match_else,
    8
    		 
        clippy::match_same_arms
    9
    		 
    )]
  • bvm_filter 1.0.0/src/lib.rs
    24
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(redundant_field_names, single_match, cast_lossless, doc_markdown, match_same_arms, unreadable_literal, new_ret_no_self))]
  • camelpaste 0.1.0/src/lib.rs
    142
    		 
        clippy::doc_markdown,
    143
    		 
        clippy::match_same_arms,
    144
    		 
        clippy::module_name_repetitions,
  • cargo-llvm-cov 0.5.9/src/main.rs
    4
    		 
    #![allow(
    5
    		 
        clippy::match_same_arms,
    6
    		 
        clippy::similar_names,
  • cretonne-codegen 0.13.2/src/lib.rs
    25
    		 
    // Code generator doesn't have a way to collapse identical arms:
    26
    		 
                    match_same_arms,
    27
    		 
    // These are relatively minor style issues, but would be easy to fix:
  • cxx-build 1.0.88/src/lib.rs
    60
    		 
        clippy::match_on_vec_items,
    61
    		 
        clippy::match_same_arms,
    62
    		 
        clippy::module_name_repetitions,
  • cxx-gen 0.7.88/src/lib.rs
    21
    		 
        clippy::match_on_vec_items,
    22
    		 
        clippy::match_same_arms,
    23
    		 
        clippy::missing_errors_doc,
  • cxxbridge-cmd 1.0.88/src/main.rs
    12
    		 
        clippy::match_on_vec_items,
    13
    		 
        clippy::match_same_arms,
    14
    		 
        clippy::module_name_repetitions,
  • cxxbridge-macro 1.0.88/src/lib.rs
    11
    		 
        clippy::match_bool,
    12
    		 
        clippy::match_same_arms,
    13
    		 
        clippy::module_name_repetitions,
  • deca 0.0.10/src/lib.rs
    111
    		 
            match (op_1, op_2, op_3, op_4) {
    112
    		 
                #![allow(clippy::match_same_arms, clippy::cast_possible_truncation)]
    113
    		 
                // from chip8run:
  • diesel 2.0.3/src/lib.rs
    181
    		 
    #![allow(
    182
    		 
        clippy::match_same_arms,
    183
    		 
        clippy::needless_doctest_main,
  • dissimilar 1.0.6/src/lib.rs
    48
    		 
        clippy::comparison_chain,
    49
    		 
        clippy::match_same_arms,
    50
    		 
        clippy::module_name_repetitions,
  • epaint 0.20.0/src/shape_transform.rs
    3
    		 
    pub fn adjust_colors(shape: &mut Shape, adjust_color: &impl Fn(&mut Color32)) {
    4
    		 
        #![allow(clippy::match_same_arms)]
    5
    		 
        match shape {
  • exa 0.10.1/src/main.rs
    12
    		 
    #![allow(clippy::map_unwrap_or)]
    13
    		 
    #![allow(clippy::match_same_arms)]
    14
    		 
    #![allow(clippy::missing_const_for_fn)]
  • fancy-prompt 0.2.1/src/main.rs
    7
    		 
    // match_same_arms is buggy, doesn't notice differences due to match arm order
    8
    		 
    #![allow(clippy::match_same_arms)]
    9
    		 
    #![allow(clippy::module_name_repetitions)]
  • io-extras 0.17.1/src/os/windows/stdio.rs
    15
    		 
        clippy::let_underscore_drop,
    16
    		 
        clippy::match_same_arms
    17
    		 
    )]
  • lalrproc 0.0.8/src/lib.rs
    10
    		 
        clippy::from_iter_instead_of_collect,
    11
    		 
        clippy::match_same_arms,
    12
    		 
        clippy::module_name_repetitions,
  • libasuran 0.0.3/src/repository/encryption.rs
    1
    		 
    // In this case, this lint results in harder to read code for security critical portions
    2
    		 
    #![allow(clippy::match_same_arms)]
  • lignin 0.1.0/src/ergonomics.rs
    1
    		 
    //! This module is private but contains various convenience implementations not used by the rest of the library that may be useful to consumers of this crate.
    2
    		 
    #![allow(clippy::match_same_arms)]
  • lsd 0.23.1/src/main.rs
    3
    		 
        clippy::cast_sign_loss,
    4
    		 
        clippy::match_same_arms,
    5
    		 
        clippy::cast_possible_wrap
  • magnet 0.1.0/src/lib.rs
    9
    		 
    #![cfg_attr(feature = "cargo-clippy",
    10
    		 
                allow(single_match, match_same_arms, match_ref_pats,
    11
    		 
                      clone_on_ref_ptr, needless_pass_by_value))]
  • magnet_derive 0.8.0/src/lib.rs
    15
    		 
            /* missing_docs (https://github.com/rust-lang/rust/issues/42008) */)]
    16
    		 
    #![allow(clippy::single_match, clippy::match_same_arms, clippy::match_ref_pats,
    17
    		 
             clippy::clone_on_ref_ptr, clippy::needless_pass_by_value)]
  • magnet_schema 0.8.0/src/lib.rs
    163
    		 
            unused_import_braces, unused_qualifications, missing_docs)]
    164
    		 
    #![allow(clippy::single_match, clippy::match_same_arms, clippy::match_ref_pats,
    165
    		 
             clippy::clone_on_ref_ptr, clippy::needless_pass_by_value)]
  • mdccc 0.1.1/src/bin/mdccc.rs
    9
    		 
    #![cfg_attr(feature = "cargo-clippy",
    10
    		 
                allow(single_match, match_same_arms, match_ref_pats,
    11
    		 
                      clone_on_ref_ptr, needless_pass_by_value))]
  • mdccc 0.1.1/src/lib.rs
    9
    		 
    #![cfg_attr(feature = "cargo-clippy",
    10
    		 
                allow(single_match, match_same_arms, match_ref_pats,
    11
    		 
                      clone_on_ref_ptr, needless_pass_by_value))]
  • memegeom 0.1.0/src/lib.rs
    38
    		 
    )]
    39
    		 
    #![allow(clippy::match_same_arms)]
    40
    		 
    #![feature(array_chunks, array_windows, drain_filter)]
  • migrations_internals 2.0.0/src/lib.rs
    4
    		 
        clippy::map_unwrap_or,
    5
    		 
        clippy::match_same_arms,
    6
    		 
        clippy::type_complexity
  • migrations_macros 2.0.0/src/lib.rs
    4
    		 
        clippy::map_unwrap_or,
    5
    		 
        clippy::match_same_arms,
    6
    		 
        clippy::type_complexity,
  • nc 0.8.13/src/platform/darwin-x86_64/errno.rs
    3
    		 
    #![allow(clippy::match_same_arms)]
  • option_set 0.1.4/src/lib.rs
    39
    		 
            unused_import_braces, unused_qualifications, missing_docs)]
    40
    		 
    #![allow(clippy::match_same_arms,
    41
    		 
             clippy::clone_on_ref_ptr,
  • paste 1.0.11/src/lib.rs
    142
    		 
        clippy::doc_markdown,
    143
    		 
        clippy::match_same_arms,
    144
    		 
        clippy::module_name_repetitions,
  • phile 0.1.4/src/lib.rs
    48
    		 
    #![cfg_attr(feature = "cargo-clippy",
    49
    		 
                allow(match_same_arms, clone_on_ref_ptr))]
    50
    		 
    #![cfg_attr(feature = "cargo-clippy",
  • phile 0.1.4/tests/lexer.rs
    15
    		 
    #![cfg_attr(feature = "cargo-clippy",
    16
    		 
                allow(match_same_arms, clone_on_ref_ptr))]
    17
    		 
    #![cfg_attr(feature = "cargo-clippy",
  • phile 0.1.4/tests/parser.rs
    15
    		 
    #![cfg_attr(feature = "cargo-clippy",
    16
    		 
                allow(match_same_arms, clone_on_ref_ptr))]
    17
    		 
    #![cfg_attr(feature = "cargo-clippy",
  • philec 0.1.4/src/main.rs
    113
    		 
    #![cfg_attr(feature = "cargo-clippy",
    114
    		 
                allow(match_same_arms, clone_on_ref_ptr))]
    115
    		 
    #![cfg_attr(feature = "cargo-clippy",
  • polywrap_paste 1.0.0/src/lib.rs
    142
    		 
        clippy::doc_markdown,
    143
    		 
        clippy::match_same_arms,
    144
    		 
        clippy::module_name_repetitions,
  • prettyplease 0.1.23/src/lib.rs
    330
    		 
        clippy::match_like_matches_macro,
    331
    		 
        clippy::match_same_arms,
    332
    		 
        clippy::module_name_repetitions,
  • pyxel-core 1.9.11/src/lib.rs
    10
    		 
        clippy::items_after_statements,
    11
    		 
        clippy::match_same_arms,
    12
    		 
        clippy::missing_const_for_fn,
  • pyxel-engine 1.8.2/src/lib.rs
    8
    		 
        clippy::fn_params_excessive_bools,
    9
    		 
        clippy::match_same_arms,
    10
    		 
        clippy::missing_panics_doc,
  • quirs 0.1.1/src/lib.rs
    9
    		 
    #![cfg_attr(feature = "cargo-clippy",
    10
    		 
                allow(single_match, match_same_arms, match_ref_pats,
    11
    		 
                      clone_on_ref_ptr, needless_pass_by_value))]
  • range_ranger 0.1.1/src/lib.rs
    2
    		 
        clippy::bool_assert_comparison,
    3
    		 
        clippy::match_same_arms,
    4
    		 
        clippy::module_name_repetitions
  • rbpf 0.1.0/src/lib.rs
    22
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(redundant_field_names, single_match, cast_lossless, doc_markdown, match_same_arms, unreadable_literal))]
  • reflect 0.0.9/src/lib.rs
    323
    		 
        clippy::manual_assert,
    324
    		 
        clippy::match_same_arms,
    325
    		 
        clippy::missing_panics_doc,
  • remain 0.2.6/src/lib.rs
    149
    		 
        clippy::manual_find,
    150
    		 
        clippy::match_same_arms,
    151
    		 
        clippy::module_name_repetitions,
  • remain 0.2.6/tests/stable.rs
    4
    		 
        clippy::let_unit_value,
    5
    		 
        clippy::match_same_arms
    6
    		 
    )]
  • remain 0.2.6/tests/unstable.rs
    3
    		 
    #![feature(proc_macro_hygiene, stmt_expr_attributes)]
    4
    		 
    #![allow(clippy::derive_partial_eq_without_eq, clippy::match_same_arms)]
  • rhai 1.12.0/src/lib.rs
    80
    		 
    #![allow(clippy::upper_case_acronyms)]
    81
    		 
    #![allow(clippy::match_same_arms)]
    82
    		 
    // The lints below can be turned off to reduce signal/noise ratio
  • ring_api 0.1.0/src/lib.rs
    11
    		 
            unused_import_braces, unused_qualifications, missing_docs)]
    12
    		 
    #![allow(clippy::single_match, clippy::match_same_arms, clippy::match_ref_pats,
    13
    		 
             clippy::clone_on_ref_ptr, clippy::needless_pass_by_value)]
  • rpds 0.12.0/src/lib.rs
    17
    		 
    #![allow(clippy::wildcard_imports)]
    18
    		 
    #![allow(clippy::match_same_arms)]
    19
    		 
    #![allow(clippy::missing_panics_doc)]
  • scientific 0.2.0/src/lib.rs
    10
    		 
    #![allow(clippy::inline_always)]
    11
    		 
    #![allow(clippy::match_same_arms)]
    12
    		 
    #![allow(clippy::missing_errors_doc)]
  • serde_derive 1.0.152/src/lib.rs
    47
    		 
        clippy::map_err_ignore,
    48
    		 
        clippy::match_same_arms,
    49
    		 
        // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984
  • serde_derive_internals 0.26.0/lib.rs
    23
    		 
        clippy::let_underscore_drop,
    24
    		 
        clippy::match_same_arms,
    25
    		 
        // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984
  • serde_derive_state 0.4.10/src/lib.rs
    41
    		 
        clippy::map_err_ignore,
    42
    		 
        clippy::match_same_arms,
    43
    		 
        clippy::module_name_repetitions,
  • serde_json 1.0.91/src/lib.rs
    341
    		 
        clippy::map_err_ignore,
    342
    		 
        clippy::match_same_arms,
    343
    		 
        clippy::similar_names,
  • serde_json_lenient 0.1.4/src/lib.rs
    342
    		 
        clippy::map_err_ignore,
    343
    		 
        clippy::match_same_arms,
    344
    		 
        clippy::similar_names,
  • serde_partiql 1.1.65/src/lib.rs
    334
    		 
        clippy::map_err_ignore,
    335
    		 
        clippy::match_same_arms,
    336
    		 
        clippy::similar_names,
  • serde_yaml 0.9.17/src/lib.rs
    133
    		 
        clippy::match_like_matches_macro,
    134
    		 
        clippy::match_same_arms,
    135
    		 
        clippy::module_name_repetitions,
  • serde_yaml_with_quirks 0.8.24/src/lib.rs
    80
    		 
        clippy::manual_assert,
    81
    		 
        clippy::match_same_arms,
    82
    		 
        clippy::module_name_repetitions,
  • standalone-syn 0.13.0/src/gen/visit.rs
    5
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
  • standalone-syn 0.13.0/src/gen/visit_mut.rs
    5
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
  • stijl 0.5.2/src/lib.rs
    113
    		 
    #![allow(non_upper_case_globals)]
    114
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
    115
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(match_bool))]
  • strict-yaml-rust 0.1.2/src/lib.rs
    42
    		 
        feature = "cargo-clippy",
    43
    		 
        allow(match_same_arms, should_implement_trait)
    44
    		 
    )]
  • strip_markdown 0.2.0/src/lib.rs
    1
    		 
    #![warn(clippy::all, clippy::pedantic)]
    2
    		 
    #![allow(clippy::match_same_arms)]
  • syn 1.0.107/src/lib.rs
    271
    		 
        clippy::match_on_vec_items,
    272
    		 
        clippy::match_same_arms,
    273
    		 
        clippy::match_wildcard_for_single_variants, // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984
  • syn-impersonated 0.1.18/src/lib.rs
    267
    		 
        clippy::items_after_statements,
    268
    		 
        clippy::match_same_arms,
    269
    		 
        clippy::missing_errors_doc,
  • teleterm 0.2.0/src/main.rs
    4
    		 
    #![warn(clippy::nursery)]
    5
    		 
    #![allow(clippy::match_same_arms)]
    6
    		 
    #![allow(clippy::missing_const_for_fn)]
  • unity-yaml-rust 0.1.1/src/lib.rs
    39
    		 
        feature = "cargo-clippy",
    40
    		 
        allow(match_same_arms, should_implement_trait)
    41
    		 
    )]
  • vsimd 0.8.0/src/lib.rs
    36
    		 
        clippy::items_after_statements,
    37
    		 
        clippy::match_same_arms,
    38
    		 
        clippy::many_single_char_names
  • yaml-rust 0.4.5/src/lib.rs
    43
    		 
        feature = "cargo-clippy",
    44
    		 
        allow(match_same_arms, should_implement_trait)
    45
    		 
    )]
  • yaml-rust-davvid 0.5.1/src/lib.rs
    50
    		 
        feature = "cargo-clippy",
    51
    		 
        allow(match_same_arms, should_implement_trait)
    52
    		 
    )]
  • zspell 0.3.3/src/lib.rs
    91
    		 
    #![allow(clippy::use_self)] // disabled because strum doesn't enforce it
    92
    		 
    #![allow(clippy::match_same_arms)]
    93
    		 
    #![allow(clippy::struct_excessive_bools)]