Merge pull request #326 from remilauzier/master

Update cgf-if and a few fix

Cargo.toml

@@ -7,7 +7,7 @@ homepage = "https://github.com/rust-lang/packed_simd"
 repository = "https://github.com/rust-lang/packed_simd"
 keywords = ["simd", "vector", "portability"]
 categories = ["hardware-support", "concurrency", "no-std", "data-structures"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 build = "build.rs"
 edition = "2018"
 
@@ -20,7 +20,7 @@ is-it-maintained-open-issues = { repository = "rust-lang/packed_simd" }
 maintenance = { status = "experimental" }
 
 [dependencies]
-cfg-if = "0.1.10"
+cfg-if = "1.0.0"
 core_arch = { version = "0.1.5", optional = true }
 libm = "0.1.4"
 

contributing.md

@@ -35,7 +35,7 @@ If LLVM is indeed the cause, the issue will be reported upstream to the
 ## Submitting Pull Requests
 
 New code is submitted to the crate using GitHub's [pull request] mechanism.
-You should first fork this repository, make your changes (preferrably in a new
+You should first fork this repository, make your changes (preferably in a new
 branch), then use GitHub's web UI to create a new PR.
 
 [pull request]: https://help.github.com/articles/about-pull-requests/

src/api/into_bits/macros.rs

@@ -24,7 +24,7 @@ macro_rules! impl_from_bits_ {
  use crate::IntoBits;
  assert_eq!(size_of::<$id>(),
  size_of::<$from_ty>());
- // This is safe becasue we never create a reference to
+ // This is safe because we never create a reference to
  // uninitialized memory:
  let a: $from_ty = unsafe { zeroed() };
 

src/api/ptr/gather_scatter.rs

@@ -146,8 +146,8 @@ macro_rules! impl_ptr_write {
  use super::*;
  #[test]
  fn write() {
- // fourty_two = [42, 42, 42, ...]
- let fourty_two
+ // forty_two = [42, 42, 42, ...]
+ let forty_two
  = Simd::<[i32; $elem_count]>::splat(42_i32);
 
  // This test will write to this array
@@ -165,11 +165,11 @@ macro_rules! impl_ptr_write {
  }
  // ptr = [&arr[0], &arr[1], ...]
 
- // write `fourty_two` to all elements of `v`
+ // write `forty_two` to all elements of `v`
  {
  let backup = arr;
  unsafe {
- ptr.write($mask_ty::splat(true), fourty_two)
+ ptr.write($mask_ty::splat(true), forty_two)
  };
  assert_eq!(arr, [42_i32; $elem_count]);
  arr = backup; // arr = [0, 1, 2, ...]
@@ -195,7 +195,7 @@ macro_rules! impl_ptr_write {
  }
 
  let backup = arr;
- unsafe { ptr.write(mask, fourty_two) };
+ unsafe { ptr.write(mask, forty_two) };
  assert_eq!(arr, r);
  arr = backup; // arr = [0, 1, 2, 3, ...]
  }
@@ -204,7 +204,7 @@ macro_rules! impl_ptr_write {
  {
  let backup = arr;
  unsafe {
- ptr.write($mask_ty::splat(false), fourty_two)
+ ptr.write($mask_ty::splat(false), forty_two)
  };
  assert_eq!(arr, backup);
  }

src/codegen/reductions/mask.rs

@@ -1,6 +1,6 @@
 //! Code generation workaround for `all()` mask horizontal reduction.
 //!
-//! Works arround [LLVM bug 36702].
+//! Works around [LLVM bug 36702].
 //!
 //! [LLVM bug 36702]: https://bugs.llvm.org/show_bug.cgi?id=36702
 #![allow(unused_macros)]

src/lib.rs

@@ -49,7 +49,7 @@
 //! ```
 //! # use packed_simd_2::*;
 //! fn reduce(x: &[i32]) -> i32 {
-//! assert!(x.len() % 4 == 0);
+//! assert_eq!(x.len() % 4, 0);
 //! let mut sum = i32x4::splat(0); // [0, 0, 0, 0]
 //! for i in (0..x.len()).step_by(4) {
 //! sum += i32x4::from_slice_unaligned(&x[i..]);
@@ -134,7 +134,7 @@
 //! > of lanes as the mask. The example shows this by using [`m16x4`] instead
 //! > of [`m32x4`]. It is _typically_ more performant to use a mask element
 //! > width equal to the element width of the vectors being operated upon.
-//! > This is, however, not true for 512-bit wide vectors when targetting
+//! > This is, however, not true for 512-bit wide vectors when targeting
 //! > AVX-512, where the most efficient masks use only 1-bit per element.
 //!
 //! All vertical comparison operations returns masks:
@@ -168,11 +168,11 @@
 //! u8x8 = m8x8::splat(true).into_bits();` is provided because all `m8x8` bit
 //! patterns are valid `u8x8` bit patterns. However, the opposite is not
 //! true, not all `u8x8` bit patterns are valid `m8x8` bit-patterns, so this
-//! operation cannot be peformed safely using `x.into_bits()`; one needs to
+//! operation cannot be performed safely using `x.into_bits()`; one needs to
 //! use `unsafe { crate::mem::transmute(x) }` for that, making sure that the
 //! value in the `u8x8` is a valid bit-pattern of `m8x8`.
 //!
-//! * **numeric casts** (`as`): are peformed using [`FromCast`]/[`Cast`]
+//! * **numeric casts** (`as`): are performed using [`FromCast`]/[`Cast`]
 //! (`x.cast()`), just like `as`:
 //!
 //! * casting integer vectors whose lane types have the same size (e.g.

src/testing/utils.rs

@@ -15,7 +15,7 @@ where
  assert!(b > a, "{:?}, {:?}", a, b);
 
  assert!(!(a == b), "{:?}, {:?}", a, b);
- assert!(a != b, "{:?}, {:?}", a, b);
+ assert_ne!(a, b, "{:?}, {:?}", a, b);
 
  assert!(a <= b, "{:?}, {:?}", a, b);
  assert!(b >= a, "{:?}, {:?}", a, b);
@@ -52,7 +52,7 @@ where
 
  assert!(!(a != b), "{:?}, {:?}", a, b);
  } else {
- assert!(a != b, "{:?}, {:?}", a, b);
+ assert_ne!(a, b, "{:?}, {:?}", a, b);
  test_lt(a, b);
  }
 }