[clippy] fix clippy issues

Author: gnzlbg

.appveyor.yml

@@ -15,7 +15,6 @@ install:
   - if NOT "%TARGET%" == "x86_64-pc-windows-msvc" rustup target add %TARGET%
   - rustc -vV
   - cargo -vV
-  - cargo install clippy
 
 build: false
 

examples/play.rs

@@ -1,6 +1,13 @@
 #![cfg_attr(feature = "strict", deny(warnings))]
 #![feature(target_feature)]
 
+#![cfg_attr(feature = "cargo-clippy",
+            allow(similar_names, missing_docs_in_private_items, cast_sign_loss,
+                  cast_possible_truncation, cast_possible_wrap, option_unwrap_used,
+                  use_debug, print_stdout,
+            )
+)]
+
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 mod example {
 

examples/types.rs

@@ -1,6 +1,12 @@
 #![cfg_attr(feature = "strict", deny(warnings))]
 #![feature(target_feature)]
 
+#![cfg_attr(feature = "cargo-clippy",
+            allow(missing_docs_in_private_items, result_unwrap_used,
+                  option_unwrap_used, print_stdout, use_debug
+            )
+)]
+
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 mod example {
     extern crate stdsimd;

examples/wat.rs

@@ -1,6 +1,12 @@
 #![cfg_attr(feature = "strict", deny(warnings))]
 #![feature(target_feature)]
 
+#![cfg_attr(feature = "cargo-clippy",
+            allow(missing_docs_in_private_items, result_unwrap_used,
+                  option_unwrap_used, print_stdout, use_debug
+            )
+)]
+
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 mod example {
     extern crate stdsimd;

src/lib.rs

@@ -26,7 +26,7 @@
 //! others at:
 //!
 //! * [i686](https://rust-lang-nursery.github.io/stdsimd/i686/stdsimd/)
-//! * [x86_64](https://rust-lang-nursery.github.io/stdsimd/x86_64/stdsimd/)
+//! * [`x86_64`](https://rust-lang-nursery.github.io/stdsimd/x86_64/stdsimd/)
 //! * [arm](https://rust-lang-nursery.github.io/stdsimd/arm/stdsimd/)
 //! * [aarch64](https://rust-lang-nursery.github.io/stdsimd/aarch64/stdsimd/)
 //!
@@ -123,6 +123,13 @@
            const_atomic_usize_new, stmt_expr_attributes)]
 #![cfg_attr(test, feature(proc_macro, test))]
 
+#![cfg_attr(feature = "cargo-clippy",
+            allow(inline_always, too_many_arguments, missing_docs_in_private_items,
+                  cast_sign_loss, cast_lossless, cast_possible_wrap,
+                  cast_possible_truncation, cast_precision_loss, shadow_reuse,
+                  cyclomatic_complexity, similar_names
+            ))]
+
 #[cfg(test)]
 extern crate stdsimd_test;
 

src/x86/avx.rs

@@ -113,7 +113,7 @@ pub unsafe fn _mm256_shuffle_pd(a: f64x4, b: f64x4, imm8: i32) -> f64x4 {
             }
         }
     }
-    match (imm8 >> 0) & 0x1 {
+    match imm8 & 0x1 {
         0 => shuffle1!(0),
         _ => shuffle1!(1),
     }
@@ -860,7 +860,7 @@ pub unsafe fn _mm256_permute_ps(a: f32x8, imm8: i32) -> f32x8 {
             }
         }
     }
-    match (imm8 >> 0) & 0b11 {
+    match imm8 & 0b11 {
         0b00 => shuffle1!(0),
         0b01 => shuffle1!(1),
         0b10 => shuffle1!(2),
@@ -914,7 +914,7 @@ pub unsafe fn _mm_permute_ps(a: f32x4, imm8: i32) -> f32x4 {
             }
         }
     }
-    match (imm8 >> 0) & 0b11 {
+    match imm8 & 0b11 {
         0b00 => shuffle1!(0),
         0b01 => shuffle1!(1),
         0b10 => shuffle1!(2),
@@ -974,7 +974,7 @@ pub unsafe fn _mm256_permute_pd(a: f64x4, imm8: i32) -> f64x4 {
             }
         }
     }
-    match (imm8 >> 0) & 0x1 {
+    match imm8 & 0x1 {
         0 => shuffle1!(0),
         _ => shuffle1!(1),
     }
@@ -1002,7 +1002,7 @@ pub unsafe fn _mm_permute_pd(a: f64x2, imm8: i32) -> f64x2 {
             }
         }
     }
-    match (imm8 >> 0) & 0x1 {
+    match imm8 & 0x1 {
         0 => shuffle1!(0),
         _ => shuffle1!(1),
     }

src/x86/bmi.rs

@@ -21,7 +21,7 @@ use stdsimd_test::assert_instr;
 #[target_feature = "+bmi"]
 #[cfg_attr(test, assert_instr(bextr))]
 pub unsafe fn _bextr_u32(a: u32, start: u32, len: u32) -> u32 {
-    _bextr2_u32(a, (start & 0xffu32) | ((len & 0xffu32) << 8u32))
+    _bextr2_u32(a, (start & 0xff_u32) | ((len & 0xff_u32) << 8_u32))
 }
 
 /// Extracts bits in range [`start`, `start` + `length`) from `a` into
@@ -31,7 +31,7 @@ pub unsafe fn _bextr_u32(a: u32, start: u32, len: u32) -> u32 {
 #[cfg_attr(test, assert_instr(bextr))]
 #[cfg(not(target_arch = "x86"))]
 pub unsafe fn _bextr_u64(a: u64, start: u64, len: u64) -> u64 {
-    _bextr2_u64(a, (start & 0xffu64) | ((len & 0xffu64) << 8u64))
+    _bextr2_u64(a, (start & 0xff_u64) | ((len & 0xff_u64) << 8_u64))
 }
 
 /// Extracts bits of `a` specified by `control` into
@@ -97,7 +97,7 @@ pub unsafe fn _blsi_u64(x: u64) -> u64 {
 #[target_feature = "+bmi"]
 #[cfg_attr(test, assert_instr(blsmsk))]
 pub unsafe fn _blsmsk_u32(x: u32) -> u32 {
-    x ^ (x.wrapping_sub(1u32))
+    x ^ (x.wrapping_sub(1_u32))
 }
 
 /// Get mask up to lowest set bit.
@@ -106,7 +106,7 @@ pub unsafe fn _blsmsk_u32(x: u32) -> u32 {
 #[cfg_attr(test, assert_instr(blsmsk))]
 #[cfg(not(target_arch = "x86"))] // generates lots of instructions
 pub unsafe fn _blsmsk_u64(x: u64) -> u64 {
-    x ^ (x.wrapping_sub(1u64))
+    x ^ (x.wrapping_sub(1_u64))
 }
 
 /// Resets the lowest set bit of `x`.

src/x86/runtime.rs

@@ -131,21 +131,18 @@ pub enum __Feature {
     #[doc(hidden)] __NonExhaustive,
 }
 
+/// Sets the `bit`-th bit of `x`.
 fn set_bit(x: usize, bit: u32) -> usize {
     debug_assert!(32 > bit);
     x | 1 << bit
 }
 
+/// Tests the `bit`-th bit of `x`.
 fn test_bit(x: usize, bit: u32) -> bool {
     debug_assert!(32 > bit);
     x & (1 << bit) != 0
 }
 
-fn inv_test_bit(v: usize, idx: u32) -> bool {
-    debug_assert!(32 > idx);
-    ((v >> idx) & 1) != 0
-}
-
 /// Run-time feature detection on x86 works by using the CPUID instruction.
 ///
 /// The [CPUID Wikipedia page][wiki_cpuid] contains
@@ -174,20 +171,21 @@ fn detect_features() -> usize {
         /// below),
         asm!("cpuid"
              : "={ecx}"(ecx), "={edx}"(edx)
-             : "{eax}"(0x00000001u32), "{ecx}"(0 as u32)
+             : "{eax}"(0x0000_0001_u32), "{ecx}"(0 as u32)
              : :);
 
         /// 2. EAX=7, ECX=0: Queries "Extended Features"
         /// This gives us information about bmi,bmi2, and avx2 support
         /// (see below).
         asm!("cpuid"
              : "={ebx}"(ebx)
-             : "{eax}"(0x00000007u32), "{ecx}"(0 as u32)
+             : "{eax}"(0x0000_0007_u32), "{ecx}"(0 as u32)
              : :);
     }
 
     let mut value: usize = 0;
 
+<<<<<<< HEAD
     // CPUID call with EAX=7, ECX=0 => Extended Features in EBX and ECX
     // (the result in ECX is not currently needed):
     if inv_test_bit(ebx, 3) {
@@ -235,6 +233,26 @@ fn detect_features() -> usize {
     if inv_test_bit(edx, 26) {
         value = set_bit(value, __Feature::sse2 as u32);
     }
+=======
+    // CPUID call with EAX=7, ECX=0 => Extended Features in EBX and ECX (unneeded):
+    if test_bit(ebx, 3) { value = set_bit(value, __Feature::bmi as u32); }
+    if test_bit(ebx, 5) { value = set_bit(value, __Feature::avx2 as u32); }
+    if test_bit(ebx, 8) { value = set_bit(value, __Feature::bmi2 as u32); }
+
+    // CPUID call with EAX=1 => feature bits in ECX and EDX:
+    if test_bit(ecx, 0) { value = set_bit(value, __Feature::sse3 as u32); }
+    if test_bit(ecx, 5) { value = set_bit(value, __Feature::abm as u32); }
+    if test_bit(ecx, 9) { value = set_bit(value, __Feature::ssse3 as u32); }
+    if test_bit(ecx, 12) { value = set_bit(value, __Feature::fma as u32); }
+    if test_bit(ecx, 19) { value = set_bit(value, __Feature::sse4_1 as u32); }
+    if test_bit(ecx, 20) { value = set_bit(value, __Feature::sse4_2 as u32); }
+    if test_bit(ecx, 21) { value = set_bit(value, __Feature::tbm as u32); }
+    if test_bit(ecx, 23) { value = set_bit(value, __Feature::popcnt as u32); }
+    if test_bit(ecx, 28) { value = set_bit(value, __Feature::avx as u32); }
+
+    if test_bit(edx, 25) { value = set_bit(value, __Feature::sse as u32); }
+    if test_bit(edx, 26) { value = set_bit(value, __Feature::sse2 as u32); }
+>>>>>>> [clippy] fix clippy issues
 
     value
 }

src/x86/sse2.rs

@@ -1105,7 +1105,6 @@ pub unsafe fn _mm_shufflehi_epi16(a: i16x8, imm8: i32) -> i16x8 {
     const fn add4(x: u32) -> u32 {
         x + 4
     }
-
     macro_rules! shuffle_done {
         ($x01:expr, $x23:expr, $x45:expr, $x67:expr) => {
             simd_shuffle8(a, a, [

src/x86/sse42.rs

@@ -5,42 +5,42 @@ use v128::*;
 use x86::__m128i;
 
 /// String contains unsigned 8-bit characters *(Default)*
-pub const _SIDD_UBYTE_OPS: i8 = 0b00000000;
+pub const _SIDD_UBYTE_OPS: i8 = 0b0000_0000;
 /// String contains unsigned 16-bit characters
-pub const _SIDD_UWORD_OPS: i8 = 0b00000001;
+pub const _SIDD_UWORD_OPS: i8 = 0b0000_0001;
 /// String contains signed 8-bit characters
-pub const _SIDD_SBYTE_OPS: i8 = 0b00000010;
+pub const _SIDD_SBYTE_OPS: i8 = 0b0000_0010;
 /// String contains unsigned 16-bit characters
-pub const _SIDD_SWORD_OPS: i8 = 0b00000011;
+pub const _SIDD_SWORD_OPS: i8 = 0b0000_0011;
 
 /// For each character in `a`, find if it is in `b` *(Default)*
-pub const _SIDD_CMP_EQUAL_ANY: i8 = 0b00000000;
-/// For each character in `a`, determine if `b[0] <= c <= b[1] or b[1] <= c <=
-/// b[2]...`
-pub const _SIDD_CMP_RANGES: i8 = 0b00000100;
+pub const _SIDD_CMP_EQUAL_ANY: i8 = 0b0000_0000;
+/// For each character in `a`, determine if
+/// `b[0] <= c <= b[1] or b[1] <= c <= b[2]...`
+pub const _SIDD_CMP_RANGES: i8 = 0b0000_0100;
 /// The strings defined by `a` and `b` are equal
-pub const _SIDD_CMP_EQUAL_EACH: i8 = 0b00001000;
+pub const _SIDD_CMP_EQUAL_EACH: i8 = 0b0000_1000;
 /// Search for the defined substring in the target
-pub const _SIDD_CMP_EQUAL_ORDERED: i8 = 0b00001100;
+pub const _SIDD_CMP_EQUAL_ORDERED: i8 = 0b0000_1100;
 
 /// Do not negate results *(Default)*
-pub const _SIDD_POSITIVE_POLARITY: i8 = 0b00000000;
+pub const _SIDD_POSITIVE_POLARITY: i8 = 0b0000_0000;
 /// Negate results
-pub const _SIDD_NEGATIVE_POLARITY: i8 = 0b00010000;
+pub const _SIDD_NEGATIVE_POLARITY: i8 = 0b0001_0000;
 /// Do not negate results before the end of the string
-pub const _SIDD_MASKED_POSITIVE_POLARITY: i8 = 0b00100000;
+pub const _SIDD_MASKED_POSITIVE_POLARITY: i8 = 0b0010_0000;
 /// Negate results only before the end of the string
-pub const _SIDD_MASKED_NEGATIVE_POLARITY: i8 = 0b00110000;
+pub const _SIDD_MASKED_NEGATIVE_POLARITY: i8 = 0b0011_0000;
 
 /// **Index only**: return the least significant bit *(Default)*
-pub const _SIDD_LEAST_SIGNIFICANT: i8 = 0b00000000;
+pub const _SIDD_LEAST_SIGNIFICANT: i8 = 0b0000_0000;
 /// **Index only**: return the most significant bit
-pub const _SIDD_MOST_SIGNIFICANT: i8 = 0b01000000;
+pub const _SIDD_MOST_SIGNIFICANT: i8 = 0b0100_0000;
 
 /// **Mask only**: return the bit mask
-pub const _SIDD_BIT_MASK: i8 = 0b00000000;
+pub const _SIDD_BIT_MASK: i8 = 0b0000_0000;
 /// **Mask only**: return the byte mask
-pub const _SIDD_UNIT_MASK: i8 = 0b01000000;
+pub const _SIDD_UNIT_MASK: i8 = 0b0100_0000;
 
 /// Compare packed strings with implicit lengths in `a` and `b` using the
 /// control in `imm8`, and return the generated mask.

src/x86/ssse3.rs

@@ -70,6 +70,8 @@ pub unsafe fn _mm_shuffle_epi8(a: u8x16, b: u8x16) -> u8x16 {
 #[target_feature = "+ssse3"]
 #[cfg_attr(test, assert_instr(palignr, n = 15))]
 pub unsafe fn _mm_alignr_epi8(a: i8x16, b: i8x16, n: i32) -> i8x16 {
+    const fn add(a: u32, b: u32) -> u32 { a + b }
+
     let n = n as u32;
     // If palignr is shifting the pair of vectors more than the size of two
     // lanes, emit zero.

tests/cpu-detection.rs

@@ -1,7 +1,9 @@
-#![cfg_attr(feature = "strict", deny(warnings))]
 #![feature(cfg_target_feature)]
+#![cfg_attr(feature = "strict", deny(warnings))]
+#![cfg_attr(feature = "cargo-clippy", allow(option_unwrap_used))]
 
 extern crate cupid;
+
 #[macro_use]
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 extern crate stdsimd;