Update soa-derive to use edition 2018

Author: Guillaume Fraux

Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "soa_derive"
-version = "0.7.0"
+version = "0.8.0"
+edition = "2018"
 authors = ["Guillaume Fraux <guillaume.fraux@chimie-paristech.fr>"]
 license = "MIT/Apache-2.0"
 readme = "README.md"
@@ -18,7 +19,7 @@ members = [
 ]
 
 [dependencies]
-soa_derive_internal = {path = "soa-derive-internal", version = "0.6"}
+soa_derive_internal = {path = "soa-derive-internal", version = "0.8"}
 
 [dev-dependencies]
 bencher = "0.1"

src/lib.rs

@@ -158,11 +158,7 @@
 // The proc macro is implemented in soa_derive_internal, and re-exported by this
 // crate. This is because a single crate can not define both a proc macro and a
 // macro_rules macro.
-#[allow(unused_imports)]
-#[macro_use]
-extern crate soa_derive_internal;
-#[doc(hidden)]
-pub use soa_derive_internal::*;
+pub use soa_derive_internal::StructOfArray;
 
 /// Create an iterator over multiple fields in a Struct of array style vector.
 ///
@@ -225,7 +221,7 @@ pub use soa_derive_internal::*;
 macro_rules! soa_zip {
     ($self: expr, [$($fields: tt)*] $(, $external: expr)* $(,)*) => {{
         let this = $self;
-        soa_zip_impl!(@munch this, {$($fields)*} -> [] $($external ,)*)
+        $crate::soa_zip_impl!(@munch this, {$($fields)*} -> [] $($external ,)*)
     }};
 }
 
@@ -239,36 +235,36 @@ macro_rules! soa_zip_impl {
     };
     // Eat an element ($_iter) and add it to the current closure. Then recurse
     (@flatten $p:pat => ( $($tup:tt)* ) , $_iter:expr $( , $tail:expr )* ) => {
-        soa_zip_impl!(@flatten ($p, a) => ( $($tup)*, a ) $( , $tail )*)
+        $crate::soa_zip_impl!(@flatten ($p, a) => ( $($tup)*, a ) $( , $tail )*)
     };
 
     // The main code is emmited here: we create an iterator, zip it and then
     // map the zipped iterator to flatten it
-    (@final , $first: expr, $($tail: expr,)*) => {
+    (@last , $first: expr, $($tail: expr,)*) => {
         ::std::iter::IntoIterator::into_iter($first)
             $(
                 .zip($tail)
             )*
             .map(
-                soa_zip_impl!(@flatten a => (a) $( , $tail )*)
+                $crate::soa_zip_impl!(@flatten a => (a) $( , $tail )*)
             )
     };
 
     // Eat the last `mut $field` and then emit code
     (@munch $self: expr, {mut $field: ident} -> [$($output: tt)*] $($ext: expr ,)*) => {
-        soa_zip_impl!(@final $($output)*, $self.$field.iter_mut(), $($ext, )*)
+        $crate::soa_zip_impl!(@last $($output)*, $self.$field.iter_mut(), $($ext, )*)
     };
     // Eat the last `$field` and then emit code
     (@munch $self: expr, {$field: ident} -> [$($output: tt)*] $($ext: expr ,)*) => {
-        soa_zip_impl!(@final $($output)*, $self.$field.iter(), $($ext, )*)
+        $crate::soa_zip_impl!(@last $($output)*, $self.$field.iter(), $($ext, )*)
     };
 
     // Eat the next `mut $field` and then recurse
     (@munch $self: expr, {mut $field: ident, $($tail: tt)*} -> [$($output: tt)*] $($ext: expr ,)*) => {
-        soa_zip_impl!(@munch $self, {$($tail)*} -> [$($output)*, $self.$field.iter_mut()] $($ext, )*)
+        $crate::soa_zip_impl!(@munch $self, {$($tail)*} -> [$($output)*, $self.$field.iter_mut()] $($ext, )*)
     };
     // Eat the next `$field` and then recurse
     (@munch $self: expr, {$field: ident, $($tail: tt)*} -> [$($output: tt)*] $($ext: expr ,)*) => {
-        soa_zip_impl!(@munch $self, {$($tail)*} -> [$($output)*, $self.$field.iter()] $($ext, )*)
+        $crate::soa_zip_impl!(@munch $self, {$($tail)*} -> [$($output)*, $self.$field.iter()] $($ext, )*)
     };
 }

tests/extreme.rs

@@ -1,7 +1,6 @@
 #![deny(warnings)]
 
-#[macro_use]
-extern crate soa_derive;
+use soa_derive::StructOfArray;
 
 // This test checks that the derive code works even in some extreme cases
 

tests/iter.rs

@@ -1,8 +1,6 @@
-#[macro_use]
-extern crate soa_derive;
 mod particles;
 
-use particles::{Particle, ParticleVec};
+use self::particles::{Particle, ParticleVec};
 
 #[test]
 fn iter() {

tests/particles/mod.rs

@@ -1,5 +1,7 @@
 #![forbid(warnings)]
 
+use soa_derive::StructOfArray;
+
 #[derive(Debug, Clone, PartialEq, StructOfArray)]
 #[soa_derive = "Debug, Clone, PartialEq"]
 pub struct Particle {

tests/ptr.rs

@@ -1,8 +1,5 @@
-#[macro_use]
-extern crate soa_derive;
 mod particles;
-
-use particles::{Particle, ParticleVec, ParticleSlice, ParticleSliceMut};
+use self::particles::{Particle, ParticleVec, ParticleSlice, ParticleSliceMut};
 
 #[test]
 fn const_ref() {

tests/slice.rs

@@ -1,8 +1,5 @@
-#[macro_use]
-extern crate soa_derive;
 mod particles;
-
-use particles::{Particle, ParticleVec};
+use self::particles::{Particle, ParticleVec};
 
 #[test]
 fn len() {

tests/slice_mut.rs

@@ -1,8 +1,5 @@
-#[macro_use]
-extern crate soa_derive;
 mod particles;
-
-use particles::{Particle, ParticleVec};
+use self::particles::{Particle, ParticleVec};
 
 #[test]
 fn len() {

tests/vec.rs

@@ -1,8 +1,5 @@
-#[macro_use]
-extern crate soa_derive;
 mod particles;
-
-use particles::{Particle, ParticleVec};
+use self::particles::{Particle, ParticleVec};
 
 #[test]
 fn push() {

tests/zip.rs

@@ -1,8 +1,6 @@
-#[macro_use]
-extern crate soa_derive;
+use soa_derive::soa_zip;
 mod particles;
-
-use particles::{Particle, ParticleVec, ParticleSlice, ParticleSliceMut};
+use self::particles::{Particle, ParticleVec, ParticleSlice, ParticleSliceMut};
 
 #[test]
 fn vec() {