Remove deprecated moves

src/mat2.rs

@@ -48,8 +48,8 @@ pub impl<T:Copy Float> Mat2<T> {
     #[inline(always)]
     static pure fn new(c0r0: T, c0r1: T,
                        c1r0: T, c1r1: T) -> Mat2<T> {
-        Mat2::from_cols(Vec2::new(move c0r0, move c0r1),
-                        Vec2::new(move c1r0, move c1r1))
+        Mat2::from_cols(Vec2::new(c0r0, c0r1),
+                        Vec2::new(c1r0, c1r1))
     }
     
     /**
@@ -72,8 +72,7 @@ pub impl<T:Copy Float> Mat2<T> {
     #[inline(always)]
     static pure fn from_cols(c0: Vec2<T>,
                              c1: Vec2<T>) -> Mat2<T> {
-        Mat2 { x: move c0,
-               y: move c1 }
+        Mat2 { x: c0, y: c1 }
     }
     
     /**

src/mat3.rs

@@ -53,9 +53,9 @@ pub impl<T:Copy Float> Mat3<T> {
     static pure fn new(c0r0:T, c0r1:T, c0r2:T,
                        c1r0:T, c1r1:T, c1r2:T,
                        c2r0:T, c2r1:T, c2r2:T) -> Mat3<T> {
-        Mat3::from_cols(Vec3::new(move c0r0, move c0r1, move c0r2),
-                        Vec3::new(move c1r0, move c1r1, move c1r2),
-                        Vec3::new(move c2r0, move c2r1, move c2r2))
+        Mat3::from_cols(Vec3::new(c0r0, c0r1, c0r2),
+                        Vec3::new(c1r0, c1r1, c1r2),
+                        Vec3::new(c2r0, c2r1, c2r2))
     }
     
     /**
@@ -82,9 +82,7 @@ pub impl<T:Copy Float> Mat3<T> {
     static pure fn from_cols(c0: Vec3<T>,
                              c1: Vec3<T>,
                              c2: Vec3<T>) -> Mat3<T> {
-        Mat3 { x: move c0,
-               y: move c1,
-               z: move c2 }
+        Mat3 { x: c0, y: c1, z: c2 }
     }
     
     /**

src/mat4.rs

@@ -57,10 +57,10 @@ pub impl<T:Copy Float> Mat4<T> {
                        c1r0: T, c1r1: T, c1r2: T, c1r3: T,
                        c2r0: T, c2r1: T, c2r2: T, c2r3: T,
                        c3r0: T, c3r1: T, c3r2: T, c3r3: T) -> Mat4<T>  {
-        Mat4::from_cols(Vec4::new(move c0r0, move c0r1, move c0r2, move c0r3),
-                        Vec4::new(move c1r0, move c1r1, move c1r2, move c1r3),
-                        Vec4::new(move c2r0, move c2r1, move c2r2, move c2r3),
-                        Vec4::new(move c3r0, move c3r1, move c3r2, move c3r3))
+        Mat4::from_cols(Vec4::new(c0r0, c0r1, c0r2, c0r3),
+                        Vec4::new(c1r0, c1r1, c1r2, c1r3),
+                        Vec4::new(c2r0, c2r1, c2r2, c2r3),
+                        Vec4::new(c3r0, c3r1, c3r2, c3r3))
     }
     
     /**
@@ -91,10 +91,7 @@ pub impl<T:Copy Float> Mat4<T> {
                              c1: Vec4<T>,
                              c2: Vec4<T>,
                              c3: Vec4<T>) -> Mat4<T> {
-        Mat4 { x: move c0,
-               y: move c1,
-               z: move c2,
-               w: move c3 }
+        Mat4 { x: c0, y: c1, z: c2, w: c3 }
     }
     
     /**

src/quat.rs

@@ -215,7 +215,7 @@ pub impl<T:Copy Float> Quat<T> {
      */
     #[inline(always)]
     static pure fn new(w: T, xi: T, yj: T, zk: T) -> Quat<T> {
-        Quat::from_sv(move w, move Vec3::new(move xi, move yj, move zk))
+        Quat::from_sv(w, Vec3::new(xi, yj, zk))
     }
     
     /**
@@ -228,7 +228,7 @@ pub impl<T:Copy Float> Quat<T> {
      */
     #[inline(always)]
     static pure fn from_sv(s: T, v: Vec3<T>) -> Quat<T> {
-        Quat { s: move s, v: move v }
+        Quat { s: s, v: v }
     }
     
     #[inline(always)]

src/vec2.rs

@@ -28,7 +28,7 @@ pub struct Vec2<T> { x: T, y: T }
 pub impl<T> Vec2<T>/*: Vector2<T>*/ {
     #[inline(always)]
     static pure fn new(x: T, y: T ) -> Vec2<T> {
-        Vec2 { x: move x, y: move y }
+        Vec2 { x: x, y: y }
     }
 }
 

src/vec3.rs

@@ -29,7 +29,7 @@ pub struct Vec3<T> { x: T, y: T, z: T }
 pub impl<T> Vec3<T>/*: Vector3<T>*/ {
     #[inline(always)]
     static pure fn new(x: T, y: T, z: T) -> Vec3<T> {
-        Vec3 { x: move x, y: move y, z: move z }
+        Vec3 { x: x, y: y, z: z }
     }
 }
 

src/vec4.rs

@@ -30,7 +30,7 @@ pub struct Vec4<T> { x: T, y: T, z: T, w: T }
 pub impl<T> Vec4<T>/*: Vector4<T>*/ {
     #[inline(always)]
     static pure fn new(x: T, y: T, z: T, w: T) -> Vec4<T> {
-        Vec4 { x: move x, y: move y, z: move z, w: move w }
+        Vec4 { x: x, y: y, z: z, w: w }
     }
 }