• au 0.10.0/src/polynomial/arithmetic.rs
    908
    		 
        #[test]
    909
    		 
        #[allow(clippy::op_ref)]
    910
    		 
        fn poly_mul_real_number_ref() {
    957
    		 
        #[allow(clippy::op_ref)]
    958
    		 
        #[test]
  • au 0.10.0/src/rational_function/arithmetic.rs
    341
    		 
        #[test]
    342
    		 
        #[allow(clippy::op_ref)]
    343
    		 
        fn add_scalar_reference() {
  • au 0.10.0/src/transfer_function/mod.rs
    684
    		 
        #[test]
    685
    		 
        #[allow(clippy::op_ref)]
    686
    		 
        fn add_scalar_reference() {
  • automatica 1.0.0/src/rational_function/arithmetic.rs
    402
    		 
        #[test]
    403
    		 
        #[allow(clippy::op_ref)]
    404
    		 
        fn add_scalar_reference() {
  • automatica 1.0.0/src/transfer_function/mod.rs
    851
    		 
        #[test]
    852
    		 
        #[allow(clippy::op_ref)]
    853
    		 
        fn add_scalar_reference() {
  • bellman 0.13.1/src/groth16/tests/dummy_engine.rs
    90
    		 
        #[allow(clippy::op_ref)]
    91
    		 
        fn add(self, other: Self) -> Self {
    121
    		 
        #[allow(clippy::op_ref)]
    122
    		 
        fn sub(self, other: Self) -> Self {
    152
    		 
        #[allow(clippy::op_ref)]
    153
    		 
        fn mul(self, other: Self) -> Self {
  • bitsvec 0.1.1/tests/it/main.rs
    204
    		 
    #[test]
    205
    		 
    #[allow(clippy::op_ref)]
    206
    		 
    fn test_bitvec_eq() {
  • blstrs 0.6.1/src/pairing.rs
    198
    		 
        #[inline]
    199
    		 
        #[allow(clippy::op_ref)]
    200
    		 
        fn add_assign(&mut self, rhs: &'b MillerLoopResult) {
  • ckb-chain-spec 0.107.0/src/consensus.rs
    571
    		 
    #[allow(clippy::op_ref)]
    572
    		 
    impl Consensus {
  • com-croftsoft-core 0.9.0/src/math/quat/test.rs
    160
    		 
    #[allow(clippy::op_ref)]
    161
    		 
    #[test]
  • concatsql 0.4.0/src/wrapstring.rs
    564
    		 
        #[allow(
    565
    		 
            clippy::op_ref,
    566
    		 
            clippy::deref_addrof,
    643
    		 
        #[test]
    644
    		 
        #[allow(clippy::op_ref)]
    645
    		 
        fn uuid() {
  • cosmwasm-std 1.2.1/src/math/decimal.rs
    1157
    		 
        #[test]
    1158
    		 
        #[allow(clippy::op_ref)]
    1159
    		 
        fn decimal_add_works() {
    1203
    		 
        #[test]
    1204
    		 
        #[allow(clippy::op_ref)]
    1205
    		 
        fn decimal_sub_works() {
    1247
    		 
        #[test]
    1248
    		 
        #[allow(clippy::op_ref)]
    1249
    		 
        fn decimal_implements_mul() {
    1450
    		 
        #[test]
    1451
    		 
        #[allow(clippy::op_ref)]
    1452
    		 
        fn decimal_implements_div() {
    1870
    		 
        #[test]
    1871
    		 
        #[allow(clippy::op_ref)]
    1872
    		 
        fn decimal_rem_works() {
  • cosmwasm-std 1.2.1/src/math/decimal256.rs
    1264
    		 
        #[test]
    1265
    		 
        #[allow(clippy::op_ref)]
    1266
    		 
        fn decimal256_add_works() {
    1313
    		 
        #[test]
    1314
    		 
        #[allow(clippy::op_ref)]
    1315
    		 
        fn decimal256_sub_works() {
    1363
    		 
        #[test]
    1364
    		 
        #[allow(clippy::op_ref)]
    1365
    		 
        fn decimal256_implements_mul() {
    1569
    		 
        #[test]
    1570
    		 
        #[allow(clippy::op_ref)]
    1571
    		 
        fn decimal256_implements_div() {
    2017
    		 
        #[test]
    2018
    		 
        #[allow(clippy::op_ref)]
    2019
    		 
        fn decimal256_rem_works() {
  • crypto-bigint 0.5.0-pre.3/src/uint/modular/constant_mod/const_add.rs
    33
    		 
        type Output = Residue<MOD, LIMBS>;
    34
    		 
        #[allow(clippy::op_ref)]
    35
    		 
        fn add(self, rhs: Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS> {
    43
    		 
        type Output = Residue<MOD, LIMBS>;
    44
    		 
        #[allow(clippy::op_ref)]
    45
    		 
        fn add(self, rhs: &Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS> {
  • crypto-bigint 0.5.0-pre.3/src/uint/modular/constant_mod/const_mul.rs
    52
    		 
        type Output = Residue<MOD, LIMBS>;
    53
    		 
        #[allow(clippy::op_ref)]
    54
    		 
        fn mul(self, rhs: Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS> {
    62
    		 
        type Output = Residue<MOD, LIMBS>;
    63
    		 
        #[allow(clippy::op_ref)]
    64
    		 
        fn mul(self, rhs: &Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS> {
  • crypto-bigint 0.5.0-pre.3/src/uint/modular/constant_mod/const_sub.rs
    33
    		 
        type Output = Residue<MOD, LIMBS>;
    34
    		 
        #[allow(clippy::op_ref)]
    35
    		 
        fn sub(self, rhs: Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS> {
    43
    		 
        type Output = Residue<MOD, LIMBS>;
    44
    		 
        #[allow(clippy::op_ref)]
    45
    		 
        fn sub(self, rhs: &Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS> {
  • crypto-bigint 0.5.0-pre.3/src/uint/modular/runtime_mod/runtime_add.rs
    30
    		 
        type Output = DynResidue<LIMBS>;
    31
    		 
        #[allow(clippy::op_ref)]
    32
    		 
        fn add(self, rhs: DynResidue<LIMBS>) -> DynResidue<LIMBS> {
    38
    		 
        type Output = DynResidue<LIMBS>;
    39
    		 
        #[allow(clippy::op_ref)]
    40
    		 
        fn add(self, rhs: &DynResidue<LIMBS>) -> DynResidue<LIMBS> {
  • crypto-bigint 0.5.0-pre.3/src/uint/modular/runtime_mod/runtime_mul.rs
    46
    		 
        type Output = DynResidue<LIMBS>;
    47
    		 
        #[allow(clippy::op_ref)]
    48
    		 
        fn mul(self, rhs: DynResidue<LIMBS>) -> DynResidue<LIMBS> {
    54
    		 
        type Output = DynResidue<LIMBS>;
    55
    		 
        #[allow(clippy::op_ref)]
    56
    		 
        fn mul(self, rhs: &DynResidue<LIMBS>) -> DynResidue<LIMBS> {
  • dashu-int 0.3.1/tests/add.rs
    135
    		 
    #[test]
    136
    		 
    #[allow(clippy::op_ref)]
    137
    		 
    fn test_add_sub_ubig_primitive() {
    167
    		 
    #[test]
    168
    		 
    #[allow(clippy::op_ref)]
    169
    		 
    fn test_add_sub_ibig_primitive() {
  • dashu-int 0.3.1/tests/bits.rs
    419
    		 
    #[test]
    420
    		 
    #[allow(clippy::identity_op, clippy::op_ref)]
    421
    		 
    fn test_bit_ops_ubig_unsigned() {
    477
    		 
    #[test]
    478
    		 
    #[allow(clippy::identity_op, clippy::op_ref)]
    479
    		 
    fn test_bit_ops_ibig_primitive() {
  • dashu-int 0.3.1/tests/div.rs
    287
    		 
    #[test]
    288
    		 
    #[allow(clippy::op_ref)]
    289
    		 
    fn test_div_rem_ubig_unsigned() {
    319
    		 
    #[test]
    320
    		 
    #[allow(clippy::op_ref)]
    321
    		 
    fn test_div_rem_ibig_signed() {
  • dashu-int 0.3.1/tests/mul.rs
    89
    		 
    #[test]
    90
    		 
    #[allow(clippy::op_ref, clippy::erasing_op)]
    91
    		 
    fn test_mul_ubig_primitive() {
    106
    		 
    #[test]
    107
    		 
    #[allow(clippy::op_ref)]
    108
    		 
    fn test_mul_ibig_primitive() {
  • dashu-int 0.3.1/tests/shift.rs
    3
    		 
    #[test]
    4
    		 
    #[allow(clippy::identity_op, clippy::op_ref)]
    5
    		 
    fn test_ubig_shl() {
    75
    		 
    #[test]
    76
    		 
    #[allow(clippy::op_ref)]
    77
    		 
    fn test_ibig_shl() {
  • elrond-wasm 0.38.0/src/types/managed/basic/managed_buffer.rs
    283
    		 
    impl<M: ManagedTypeApi, const N: usize> PartialEq<&[u8; N]> for ManagedBuffer<M> {
    284
    		 
        #[allow(clippy::op_ref)] // clippy is wrong here, it is not needless
    285
    		 
        fn eq(&self, other: &&[u8; N]) -> bool {
  • forward_ref_generic 0.2.1/tests/binary.rs
    1
    		 
    #[allow(clippy::op_ref)]
    2
    		 
    use forward_ref_generic::{commutative_binop, forward_ref_binop, forward_ref_commutative_binop};
  • gstreamer 0.19.7/src/format/clock_time.rs
    616
    		 
        #[test]
    617
    		 
        #[allow(clippy::eq_op, clippy::op_ref)]
    618
    		 
        fn ops() {
  • gstreamer 0.19.7/src/format/generic.rs
    429
    		 
        #[test]
    430
    		 
        #[allow(clippy::eq_op, clippy::op_ref)]
    431
    		 
        fn other() {
    452
    		 
        #[test]
    453
    		 
        #[allow(clippy::eq_op, clippy::op_ref)]
    454
    		 
        fn generic_other() {
    477
    		 
        #[test]
    478
    		 
        #[allow(clippy::eq_op, clippy::op_ref)]
    479
    		 
        fn generic_signed_other() {
  • halo2_gadgets 0.2.0/src/ecc/chip/mul_fixed/base_field_elem.rs
    412
    		 
        #[allow(clippy::op_ref)]
    413
    		 
        fn test_single_base(
  • halo2_gadgets 0.2.0/src/ecc/chip/mul_fixed/full_width.rs
    211
    		 
        #[allow(clippy::op_ref)]
    212
    		 
        fn test_single_base(
  • halo2_gadgets 0.2.0/src/ecc/chip/mul_fixed/short.rs
    268
    		 
        #[allow(clippy::op_ref)]
    269
    		 
        pub(crate) fn test_mul_fixed_short(
  • halo2_gadgets 0.2.0/src/ecc/chip/mul_fixed.rs
    134
    		 
        /// [Specification](https://p.z.cash/halo2-0.1:ecc-fixed-mul-coordinates).
    135
    		 
        #[allow(clippy::op_ref)]
    136
    		 
        fn coords_check(
  • ibig 0.3.6/tests/add.rs
    146
    		 
    #[test]
    147
    		 
    #[allow(clippy::op_ref)]
    148
    		 
    fn test_add_sub_ubig_primitive() {
    206
    		 
    #[test]
    207
    		 
    #[allow(clippy::op_ref)]
    208
    		 
    fn test_add_sub_ibig_primitive() {
  • ibig 0.3.6/tests/bits.rs
    417
    		 
    #[test]
    418
    		 
    #[allow(clippy::identity_op, clippy::op_ref)]
    419
    		 
    fn test_bit_ops_ubig_unsigned() {
    480
    		 
    #[test]
    481
    		 
    #[allow(clippy::identity_op, clippy::op_ref)]
    482
    		 
    fn test_bit_ops_ubig_signed() {
    565
    		 
    #[test]
    566
    		 
    #[allow(clippy::identity_op, clippy::op_ref)]
    567
    		 
    fn test_bit_ops_ibig_primitive() {
  • ibig 0.3.6/tests/div.rs
    236
    		 
    #[test]
    237
    		 
    #[allow(clippy::op_ref)]
    238
    		 
    fn test_div_rem_ubig_unsigned() {
    285
    		 
    #[test]
    286
    		 
    #[allow(clippy::op_ref)]
    287
    		 
    fn test_div_rem_ubig_signed() {
    366
    		 
    #[test]
    367
    		 
    #[allow(clippy::op_ref)]
    368
    		 
    fn test_div_rem_ibig_unsigned() {
    415
    		 
    #[test]
    416
    		 
    #[allow(clippy::op_ref)]
    417
    		 
    fn test_div_rem_ibig_signed() {
  • ibig 0.3.6/tests/mul.rs
    82
    		 
    #[test]
    83
    		 
    #[allow(clippy::op_ref, clippy::erasing_op)]
    84
    		 
    fn test_mul_ubig_primitive() {
  • inari 1.0.0/src/arith.rs
    437
    		 
        #[allow(clippy::op_ref)]
    438
    		 
        #[test]
  • inari_wasm 0.1.1/src/arith.rs
    254
    		 
        #[allow(clippy::op_ref)]
    255
    		 
        #[test]
  • jk-cosmwasm-std 0.16.2/src/math/uint128.rs
    554
    		 
        #[test]
    555
    		 
        #[allow(clippy::op_ref)]
    556
    		 
        fn uint128_math() {
  • jk-cosmwasm-std 0.16.2/src/math/uint256.rs
    976
    		 
        #[test]
    977
    		 
        #[allow(clippy::op_ref)]
    978
    		 
        fn uint256_math() {
  • jk-cosmwasm-std 0.16.2/src/math/uint512.rs
    591
    		 
        #[test]
    592
    		 
        #[allow(clippy::op_ref)]
    593
    		 
        fn uint512_math() {
  • jk-cosmwasm-std 0.16.2/src/math/uint64.rs
    442
    		 
        #[test]
    443
    		 
        #[allow(clippy::op_ref)]
    444
    		 
        fn uint64_math() {
  • lattice-qcd-rs 0.2.1/src/field.rs
    1483
    		 
        #[allow(clippy::eq_op)]
    1484
    		 
        #[allow(clippy::op_ref)]
    1485
    		 
        fn test_su3_adj() {
  • ledb 0.4.0/src/index.rs
    282
    		 
                                let key = KeyData::from_raw(end_key.get_type(), key)?;
    283
    		 
                                #[allow(clippy::op_ref)]
    284
    		 
                                {
    331
    		 
                                let key = KeyData::from_raw(end_key.get_type(), key)?;
    332
    		 
                                #[allow(clippy::op_ref)]
    333
    		 
                                {
  • lexical-parse-float 0.8.5/src/bigint.rs
    647
    		 
        #[inline]
    648
    		 
        #[allow(clippy::op_ref)]
    649
    		 
        fn eq(&self, other: &Self) -> bool {
  • magnesia 0.9.2/src/algebra/complex.rs
    315
    		 
    #[test]
    316
    		 
    #[allow(clippy::op_ref)]
    317
    		 
    fn test_mul_for_ref_complex_int() {
    341
    		 
    #[test]
    342
    		 
    #[allow(clippy::op_ref)]
    343
    		 
    fn test_div_for_ref_complex_f32() {
  • malachite-nz 0.3.2/tests/integer/comparison/partial_eq_primitive_int.rs
    113
    		 
    // Extra refs necessary for type inference
    114
    		 
    #[allow(clippy::cmp_owned, clippy::op_ref, clippy::trait_duplication_in_bounds)]
    115
    		 
    fn partial_eq_primitive_int_properties_helper_unsigned<
    140
    		 
    // Extra refs necessary for type inference
    141
    		 
    #[allow(clippy::cmp_owned, clippy::op_ref, clippy::trait_duplication_in_bounds)]
    142
    		 
    fn partial_eq_primitive_int_properties_helper_signed<
  • malachite-nz 0.3.2/tests/natural/comparison/partial_eq_primitive_int.rs
    90
    		 
    // Extra refs necessary for type inference
    91
    		 
    #[allow(clippy::cmp_owned, clippy::op_ref, clippy::trait_duplication_in_bounds)]
    92
    		 
    fn partial_eq_primitive_int_properties_helper_unsigned<
    118
    		 
    // Extra refs necessary for type inference
    119
    		 
    #[allow(clippy::cmp_owned, clippy::op_ref, clippy::trait_duplication_in_bounds)]
    120
    		 
    fn partial_eq_primitive_int_properties_helper_signed<
  • malachite-q 0.3.2/tests/comparison/partial_eq_primitive_int.rs
    115
    		 
    // Extra refs necessary for type inference
    116
    		 
    #[allow(clippy::cmp_owned, clippy::op_ref, clippy::trait_duplication_in_bounds)]
    117
    		 
    fn partial_eq_primitive_int_properties_helper_unsigned<
    140
    		 
    // Extra refs necessary for type inference
    141
    		 
    #[allow(clippy::cmp_owned, clippy::op_ref, clippy::trait_duplication_in_bounds)]
    142
    		 
    fn partial_eq_primitive_int_properties_helper_signed<
  • minimal-lexical 0.2.1/src/heapvec.rs
    145
    		 
        #[inline]
    146
    		 
        #[allow(clippy::op_ref)]
    147
    		 
        fn eq(&self, other: &Self) -> bool {
  • minimal-lexical 0.2.1/src/stackvec.rs
    253
    		 
        #[inline]
    254
    		 
        #[allow(clippy::op_ref)]
    255
    		 
        fn eq(&self, other: &Self) -> bool {
  • multiversx-sc 0.39.4/src/types/managed/basic/managed_buffer.rs
    316
    		 
    impl<M: ManagedTypeApi, const N: usize> PartialEq<&[u8; N]> for ManagedBuffer<M> {
    317
    		 
        #[allow(clippy::op_ref)] // clippy is wrong here, it is not needless
    318
    		 
        fn eq(&self, other: &&[u8; N]) -> bool {
  • noria-dataflow 0.6.0/src/state/persistent_state.rs
    1144
    		 
        #[test]
    1145
    		 
        #[allow(clippy::op_ref)]
    1146
    		 
        fn persistent_state_prefix_transform() {
  • polynomen 1.0.0/src/arithmetic.rs
    932
    		 
        #[test]
    933
    		 
        #[allow(clippy::op_ref)]
    934
    		 
        fn poly_mul_real_number_ref() {
    984
    		 
        #[allow(clippy::op_ref)]
    985
    		 
        #[test]
  • prov-cosmwasm-std 1.0.0-provbeta3/src/math/uint128.rs
    615
    		 
        #[test]
    616
    		 
        #[allow(clippy::op_ref)]
    617
    		 
        fn uint128_math() {
  • prov-cosmwasm-std 1.0.0-provbeta3/src/math/uint256.rs
    1165
    		 
        #[test]
    1166
    		 
        #[allow(clippy::op_ref)]
    1167
    		 
        fn uint256_math() {
  • prov-cosmwasm-std 1.0.0-provbeta3/src/math/uint512.rs
    937
    		 
        #[test]
    938
    		 
        #[allow(clippy::op_ref)]
    939
    		 
        fn uint512_math() {
  • prov-cosmwasm-std 1.0.0-provbeta3/src/math/uint64.rs
    478
    		 
        #[test]
    479
    		 
        #[allow(clippy::op_ref)]
    480
    		 
        fn uint64_math() {
  • qt_ritual_build 0.5.0/src/lib.rs
    25
    		 
    #[allow(clippy::op_ref)] // false positive
    26
    		 
    fn detect_closest_version(known: &[&str], current: &str) -> Result<Option<String>> {
  • ropey 1.5.1/src/slice.rs
    1932
    		 
    impl<'a> std::cmp::Ord for RopeSlice<'a> {
    1933
    		 
        #[allow(clippy::op_ref)] // Erroneously thinks with can directly use a slice.
    1934
    		 
        fn cmp(&self, other: &RopeSlice<'a>) -> std::cmp::Ordering {
  • scicrypt-he 0.7.1/src/threshold_cryptosystems/curve_el_gamal.rs
    75
    		 
    impl DecryptionShare<CurveElGamalPK> for NOfNCurveElGamalShare {
    76
    		 
        #[allow(clippy::op_ref)]
    77
    		 
        fn combine(
  • secret-cosmwasm-std 1.0.0/src/math/decimal.rs
    964
    		 
        #[test]
    965
    		 
        #[allow(clippy::op_ref)]
    966
    		 
        fn decimal_add_works() {
    1010
    		 
        #[test]
    1011
    		 
        #[allow(clippy::op_ref)]
    1012
    		 
        fn decimal_sub_works() {
    1054
    		 
        #[test]
    1055
    		 
        #[allow(clippy::op_ref)]
    1056
    		 
        fn decimal_implements_mul() {
    1257
    		 
        #[test]
    1258
    		 
        #[allow(clippy::op_ref)]
    1259
    		 
        fn decimal_implements_div() {
  • secret-cosmwasm-std 1.0.0/src/math/decimal256.rs
    1043
    		 
        #[test]
    1044
    		 
        #[allow(clippy::op_ref)]
    1045
    		 
        fn decimal256_add_works() {
    1092
    		 
        #[test]
    1093
    		 
        #[allow(clippy::op_ref)]
    1094
    		 
        fn decimal256_sub_works() {
    1142
    		 
        #[test]
    1143
    		 
        #[allow(clippy::op_ref)]
    1144
    		 
        fn decimal256_implements_mul() {
    1348
    		 
        #[test]
    1349
    		 
        #[allow(clippy::op_ref)]
    1350
    		 
        fn decimal256_implements_div() {
  • secret-cosmwasm-std 1.0.0/src/math/uint128.rs
    657
    		 
        #[test]
    658
    		 
        #[allow(clippy::op_ref)]
    659
    		 
        fn uint128_math() {
    703
    		 
        #[test]
    704
    		 
        #[allow(clippy::op_ref)]
    705
    		 
        fn uint128_sub_works() {
  • shipyard 0.6.2/src/scheduler/label.rs
    130
    		 
        #[allow(clippy::op_ref)]
    131
    		 
        fn dyn_eq(&self, other: &dyn Label) -> bool {
    163
    		 
        #[allow(clippy::op_ref)]
    164
    		 
        fn dyn_eq(&self, other: &dyn Label) -> bool {
    196
    		 
        #[allow(clippy::op_ref)]
    197
    		 
        fn dyn_eq(&self, other: &dyn Label) -> bool {
  • snarkvm-circuit-environment 0.9.11/src/helpers/linear_combination.rs
    230
    		 
        #[allow(clippy::op_ref)]
    231
    		 
        fn add(self, other: Variable<F>) -> Self::Output {
    247
    		 
        #[allow(clippy::op_ref)]
    248
    		 
        fn add(self, other: Variable<F>) -> Self::Output {
    348
    		 
        #[allow(clippy::op_ref)]
    349
    		 
        fn sub(self, other: Variable<F>) -> Self::Output {
    365
    		 
        #[allow(clippy::op_ref)]
    366
    		 
        fn sub(self, other: Variable<F>) -> Self::Output {
    406
    		 
        #[allow(clippy::op_ref)]
    407
    		 
        fn mul(self, coefficient: F) -> Self::Output {
  • snarkvm-circuit-environment 0.9.11/src/helpers/variable.rs
    114
    		 
    #[allow(clippy::op_ref)]
    115
    		 
    impl<F: PrimeField> Add<Variable<F>> for Variable<F> {
    123
    		 
    #[allow(clippy::op_ref)]
    124
    		 
    impl<F: PrimeField> Add<Variable<F>> for &Variable<F> {
    132
    		 
    #[allow(clippy::op_ref)]
    133
    		 
    impl<F: PrimeField> Add<&Variable<F>> for Variable<F> {
    152
    		 
    #[allow(clippy::op_ref)]
    153
    		 
    impl<F: PrimeField> Add<LinearCombination<F>> for Variable<F> {
    161
    		 
    #[allow(clippy::op_ref)]
    162
    		 
    impl<F: PrimeField> Add<LinearCombination<F>> for &Variable<F> {
  • sp-ropey 0.2.0/src/slice.rs
    1513
    		 
    impl<'a> core::cmp::Ord for RopeSlice<'a> {
    1514
    		 
        #[allow(clippy::op_ref)] // Erroneously thinks with can directly use a slice.
    1515
    		 
        fn cmp(&self, other: &RopeSlice<'a>) -> core::cmp::Ordering {
  • tari_core 0.8.1/src/transactions/mod.rs
    5
    		 
    pub mod transaction;
    6
    		 
    #[allow(clippy::op_ref)]
    7
    		 
    pub mod transaction_protocol;
  • tari_crypto 0.11.2/src/lib.rs
    16
    		 
    // Implementations
    17
    		 
    #[allow(clippy::op_ref)]
    18
    		 
    pub mod ristretto;
  • tari_transactions 0.0.7/src/lib.rs
    9
    		 
    pub mod transaction;
    10
    		 
    #[allow(clippy::op_ref)]
    11
    		 
    pub mod transaction_protocol;
  • tinyid 1.0.3/src/lib.rs
    591
    		 
        #[cfg_attr(coverage, no_coverage)]
    592
    		 
        #[allow(clippy::op_ref)]
    593
    		 
        fn eqs() {
  • vek2d 1.0.1/src/lib.rs
    403
    		 
        #[allow(clippy::op_ref)]
    404
    		 
        #[test]
    415
    		 
        #[allow(clippy::op_ref)]
    416
    		 
        #[test]
    427
    		 
        #[allow(clippy::op_ref)]
    428
    		 
        #[test]
    439
    		 
        #[allow(clippy::op_ref)]
    440
    		 
        #[test]
  • acir 0.3.1/src/native_types/linear.rs
    2
    		 
    // file contains /implementations/)
    3
    		 
    #![allow(clippy::op_ref)]
  • ark-ec 0.4.0/src/lib.rs
    10
    		 
    #![allow(
    11
    		 
        clippy::op_ref,
    12
    		 
        clippy::suspicious_op_assign_impl,
  • ark-ff 0.4.0/src/lib.rs
    8
    		 
    )]
    9
    		 
    #![allow(clippy::op_ref, clippy::suspicious_op_assign_impl)]
    10
    		 
    #![deny(unsafe_code)]
  • ark-gm17 0.3.0/src/lib.rs
    12
    		 
    )]
    13
    		 
    #![allow(clippy::many_single_char_names, clippy::op_ref)]
    14
    		 
    #![forbid(unsafe_code)]
  • ark-groth16 0.3.0/src/lib.rs
    11
    		 
    )]
    12
    		 
    #![allow(clippy::many_single_char_names, clippy::op_ref)]
    13
    		 
    #![forbid(unsafe_code)]
  • ark-r1cs-std 0.4.0/src/lib.rs
    10
    		 
    )]
    11
    		 
    #![allow(clippy::op_ref)]
  • assert2ify 0.1.0-alpha1/tests/logic/mod.rs
    5
    		 
    #![allow(clippy::eq_op)]
    6
    		 
    #![allow(clippy::op_ref)]
    7
    		 
    #![allow(clippy::assertions_on_constants)]
  • bandersnatch 0.1.1/src/lib.rs
    1
    		 
    #![cfg_attr(not(feature = "std"), no_std)]
    2
    		 
    #![allow(clippy::op_ref)]
    3
    		 
    // #![no_std]
  • bellperson 0.24.1/src/groth16/tests/dummy_engine.rs
    1
    		 
    #![allow(clippy::op_ref)]
  • classygroup 0.0.5/src/uint.rs
    468
    		 
        fn rem(self, x: U256) -> U256 {
    469
    		 
            #![allow(clippy::op_ref)]
    470
    		 
            self % &x
    502
    		 
        fn mul(self, x: Self) -> U512 {
    503
    		 
            #![allow(clippy::op_ref)]
    504
    		 
            self * &x
  • crystal_packing 0.6.0/src/shape/components/atom2_ops.rs
    7
    		 
    #![allow(clippy::op_ref)]
  • crystal_packing 0.6.0/src/shape/components/line2_ops.rs
    7
    		 
    #![allow(clippy::op_ref)]
    8
    		 
    use std::ops::Mul;
  • crystal_packing 0.6.0/src/shape/components/lj2_ops.rs
    7
    		 
    #![allow(clippy::op_ref)]
    8
    		 
    use std::ops::Mul;
  • elliptic-curve 0.13.0-pre.3/src/weierstrass.rs
    6
    		 
    #![allow(clippy::op_ref)]
  • eosio_cdt_sys 0.3.0/src/lib.rs
    21
    		 
        clippy::missing_const_for_fn,
    22
    		 
        clippy::op_ref,
    23
    		 
        clippy::use_self,
  • fil_pasta_curves 0.5.2/src/lib.rs
    5
    		 
    #![allow(unknown_lints)]
    6
    		 
    #![allow(clippy::op_ref, clippy::same_item_push, clippy::upper_case_acronyms)]
    7
    		 
    #![deny(rustdoc::broken_intra_doc_links)]
  • halo2-core 0.1.0-beta.2/src/lib.rs
    11
    		 
    #![allow(
    12
    		 
        clippy::op_ref,
    13
    		 
        clippy::assign_op_pattern,
  • halo2-core 0.1.0-beta.2/tests/plonk_api.rs
    1
    		 
    #![allow(clippy::many_single_char_names)]
    2
    		 
    #![allow(clippy::op_ref)]
  • halo2_proofs 0.2.0/src/lib.rs
    11
    		 
    #![allow(
    12
    		 
        clippy::op_ref,
    13
    		 
        clippy::assign_op_pattern,
  • halo2_proofs 0.2.0/tests/plonk_api.rs
    1
    		 
    #![allow(clippy::many_single_char_names)]
    2
    		 
    #![allow(clippy::op_ref)]
  • hifb-sys 0.1.11/src/lib.rs
    3
    		 
    #![allow(non_snake_case)]
    4
    		 
    #![allow(clippy::op_ref)]
  • himpi-sys 0.1.21/src/lib.rs
    9
    		 
    #![allow(clippy::missing_safety_doc)]
    10
    		 
    #![allow(clippy::op_ref)]
    11
    		 
    #![allow(clippy::redundant_static_lifetimes)]
  • in-toto 0.3.0/src/lib.rs
    7
    		 
        clippy::new_ret_no_self,
    8
    		 
        clippy::op_ref,
    9
    		 
        clippy::too_many_arguments
  • k256 0.12.0/src/arithmetic/affine.rs
    3
    		 
    #![allow(clippy::op_ref)]
  • k256 0.12.0/src/arithmetic/field.rs
    3
    		 
    #![allow(clippy::assign_op_pattern, clippy::op_ref)]
  • k256 0.12.0/src/arithmetic/projective.rs
    3
    		 
    #![allow(clippy::op_ref)]
  • legogroth16 0.3.0/src/lib.rs
    7
    		 
    #![warn(unused, future_incompatible, nonstandard_style)]
    8
    		 
    #![allow(clippy::many_single_char_names, clippy::op_ref)]
    9
    		 
    #![forbid(unsafe_code)]
  • minivec 0.4.0/tests/vec.rs
    4
    		 
      clippy::unnecessary_operation,
    5
    		 
      clippy::op_ref,
    6
    		 
      clippy::verbose_bit_mask,
  • nalgebra 0.32.1/src/geometry/dual_quaternion.rs
    1
    		 
    // The macros break if the references are taken out, for some reason.
    2
    		 
    #![allow(clippy::op_ref)]
  • nalgebra 0.32.1/src/geometry/dual_quaternion_ops.rs
    1
    		 
    // The macros break if the references are taken out, for some reason.
    2
    		 
    #![allow(clippy::op_ref)]
  • nalgebra 0.32.1/src/geometry/isometry_ops.rs
    1
    		 
    // The macros break if the references are taken out, for some reason.
    2
    		 
    #![allow(clippy::op_ref)]
  • nalgebra 0.32.1/src/geometry/quaternion_ops.rs
    1
    		 
    // The macros break if the references are taken out, for some reason.
    2
    		 
    #![allow(clippy::op_ref)]
  • nalgebra 0.32.1/src/geometry/similarity_ops.rs
    1
    		 
    // The macros break if the references are taken out, for some reason.
    2
    		 
    #![allow(clippy::op_ref)]
  • nalgebra 0.32.1/src/geometry/transform_ops.rs
    1
    		 
    // The macros break if the references are taken out, for some reason.
    2
    		 
    #![allow(clippy::op_ref)]
  • nalgebra 0.32.1/src/geometry/unit_complex_ops.rs
    1
    		 
    // The macros break if the references are taken out, for some reason.
    2
    		 
    #![allow(clippy::op_ref)]
  • newtype-derive-2018 0.1.0/tests/arith.rs
    10
    		 
    #![deny(warnings)]
    11
    		 
    #![allow(clippy::op_ref)]
    12
    		 
    #![recursion_limit = "128"]
  • newtype-derive-2018 0.1.0/tests/arith_generic.rs
    10
    		 
    #![deny(warnings)]
    11
    		 
    #![allow(clippy::op_ref)]
    12
    		 
    #![recursion_limit = "128"]
  • newtype-derive-2018 0.1.0/tests/star_forms.rs
    10
    		 
    #![deny(warnings)]
    11
    		 
    #![allow(clippy::op_ref)]
  • noah-algebra 0.4.0/src/lib.rs
    19
    		 
    #![allow(
    20
    		 
        clippy::op_ref,
    21
    		 
        clippy::suspicious_op_assign_impl,
  • noah-api 0.4.0/src/lib.rs
    20
    		 
    #![allow(
    21
    		 
        clippy::op_ref,
    22
    		 
        clippy::suspicious_op_assign_impl,
  • noah-plonk 0.4.0/src/lib.rs
    18
    		 
    #![allow(
    19
    		 
        clippy::op_ref,
    20
    		 
        clippy::suspicious_op_assign_impl,
  • ordered-float 3.4.0/tests/test.rs
    1
    		 
    #![allow(clippy::float_cmp, clippy::eq_op, clippy::op_ref)]
  • p256 0.12.0/src/arithmetic/field.rs
    3
    		 
    #![allow(clippy::assign_op_pattern, clippy::op_ref)]
  • p384_rs 0.1.10/src/arithmetic/affine.rs
    3
    		 
    #![allow(clippy::op_ref)]
  • p384_rs 0.1.10/src/arithmetic/projective.rs
    3
    		 
    #![allow(clippy::needless_range_loop, clippy::op_ref)]
  • pasta_curves 0.5.0/src/lib.rs
    5
    		 
    #![allow(unknown_lints)]
    6
    		 
    #![allow(clippy::op_ref, clippy::same_item_push, clippy::upper_case_acronyms)]
    7
    		 
    #![deny(rustdoc::broken_intra_doc_links)]
  • primeorder 0.12.1/src/affine.rs
    3
    		 
    #![allow(clippy::op_ref)]
  • primeorder 0.12.1/src/projective.rs
    3
    		 
    #![allow(clippy::needless_range_loop, clippy::op_ref)]
  • rand_hc 0.3.1/src/hc128.rs
    12
    		 
    // Disable a lint that cannot be fixed without increasing the MSRV
    13
    		 
    #![allow(clippy::op_ref)]
  • rta-for-fps-lib 0.2.0/src/window/window_end.rs
    44
    		 
        fn add(self, rhs: Self) -> Self::Output {
    45
    		 
            #![allow(clippy::op_ref)]
    46
    		 
            &self + &rhs
    75
    		 
        fn add(self, rhs: Self) -> Self::Output {
    76
    		 
            #![allow(clippy::op_ref)]
    77
    		 
            &*self + &*rhs
  • safe-zk-token-sdk 1.14.3/src/lib.rs
    1
    		 
    #![allow(clippy::integer_arithmetic, clippy::op_ref)]
  • smallbigint 1.1.0/src/lib.rs
    1606
    		 
    mod test {
    1607
    		 
        #![allow(clippy::redundant_clone, clippy::cognitive_complexity, clippy::op_ref)]
  • solana-zk-token-sdk 1.14.13/src/lib.rs
    1
    		 
    #![allow(clippy::integer_arithmetic, clippy::op_ref)]
  • suzy 0.2.0/src/platform/opengl/matrix.rs
    151
    		 
        fn mul(self, rhs: Mat4) -> Mat4 {
    152
    		 
            #![allow(clippy::op_ref)]
    153
    		 
            (&self) * (&rhs)
    160
    		 
        fn mul(self, rhs: &Mat4) -> Mat4 {
    161
    		 
            #![allow(clippy::op_ref)]
    162
    		 
            (&self) * rhs
    169
    		 
        fn mul(self, rhs: Mat4) -> Mat4 {
    170
    		 
            #![allow(clippy::op_ref)]
    171
    		 
            self * (&rhs)
    176
    		 
        fn mul_assign(&mut self, rhs: Mat4) {
    177
    		 
            #![allow(clippy::op_ref)]
    178
    		 
            *self = &*self * rhs
    183
    		 
        fn mul_assign(&mut self, rhs: &Mat4) {
    184
    		 
            #![allow(clippy::op_ref)]
    185
    		 
            *self = &*self * rhs
  • threshold_crypto 0.4.0/src/mock/ms8.rs
    426
    		 
        #![allow(clippy::unreadable_literal)]
    427
    		 
        #![allow(clippy::op_ref)]
    428
    		 
        // We test a few mathematical identities, including `c - c = 0`. Clippy complains about these
  • tophat 0.3.0/src/client/decode.rs
    1
    		 
    #![allow(clippy::nonminimal_bool)]
    2
    		 
    #![allow(clippy::op_ref)]
  • tuf 0.3.0-beta9/src/lib.rs
    109
    		 
        clippy::new_ret_no_self,
    110
    		 
        clippy::op_ref,
    111
    		 
        clippy::too_many_arguments
  • vulkano 0.32.3/src/lib.rs
    76
    		 
        clippy::nonminimal_bool,
    77
    		 
        clippy::op_ref, // Seems to be bugged, the fixed code triggers a compile error
    78
    		 
        clippy::too_many_arguments,
  • waffles-solana-zk-token-sdk 1.15.0/src/lib.rs
    1
    		 
    #![allow(clippy::integer_arithmetic, clippy::op_ref)]