Repository: bitshifter/glam-rs
Pull request #355 (2022-10-24 09:30:09)

Prepare 0.22.0 release


Patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4f8585c..97e2544 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,7 +5,7 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog], and this project adheres to
 [Semantic Versioning].
 
-## [Unreleased]
+## [0.22.0] - 2022-10-24
 
 ### Breaking changes
 
@@ -15,6 +15,9 @@ The format is based on [Keep a Changelog], and this project adheres to
 * Removed `Add`, `Sub`, and scalar `Mul` implementations from affine types as
   they didn't make sense on these types.
 
+* Removed deprecated `const_*` macros. These have been replaced by `const fn`
+  methods.
+
 ### Fixed
 
 * Fixed `neg` and `signum` to consistently handle negative zero across multiple
@@ -886,7 +889,8 @@ The format is based on [Keep a Changelog], and this project adheres to
 
 [Keep a Changelog]: https://keepachangelog.com/
 [Semantic Versioning]: https://semver.org/spec/v2.0.0.html
-[Unreleased]: https://github.com/bitshifter/glam-rs/compare/0.21.3...HEAD
+[Unreleased]: https://github.com/bitshifter/glam-rs/compare/0.22.0...HEAD
+[0.22.0]: https://github.com/bitshifter/glam-rs/compare/0.21.3...0.22.0
 [0.21.3]: https://github.com/bitshifter/glam-rs/compare/0.21.2...0.21.3
 [0.21.2]: https://github.com/bitshifter/glam-rs/compare/0.21.1...0.21.2
 [0.21.1]: https://github.com/bitshifter/glam-rs/compare/0.21.0...0.21.1
diff --git a/Cargo.toml b/Cargo.toml
index eaf4bc7..f145c6e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "glam"
-version = "0.21.3" # remember to update html_root_url
+version = "0.22.0" # remember to update html_root_url
 edition = "2021"
 authors = ["Cameron Hart <cameron.hart@gmail.com>"]
 description = "A simple and fast 3D math library for games and graphics"
diff --git a/README.md b/README.md
index b32cdd8..3e13cf5 100644
--- a/README.md
+++ b/README.md
@@ -70,7 +70,7 @@ defined in `std`. For example:
 
 ```toml
 [dependencies]
-glam = { version = "0.21", default-features = false, features = ["libm"] }
+glam = { version = "0.22", default-features = false, features = ["libm"] }
 ```
 
 To support both `std` and `no_std` builds in project, you can use the following
@@ -84,7 +84,7 @@ std = ["glam/std"]
 libm = ["glam/libm"]
 
 [dependencies]
-glam = { version = "0.21", default-features = false }
+glam = { version = "0.22", default-features = false }
 ```
 
 ### Optional features
diff --git a/codegen/templates/vec.rs.tera b/codegen/templates/vec.rs.tera
index 25e4386..7a00ba3 100644
--- a/codegen/templates/vec.rs.tera
+++ b/codegen/templates/vec.rs.tera
@@ -51,8 +51,6 @@
     {% set vec4_t = "UVec4" %}
 {% endif %}
 
-{% set const_new = "const_" ~ self_t | lower %}
-
 {% if scalar_t == "f64" or dim == 4 %}
     {% set cuda_align = 16 %}
 {% elif dim == 2 %}
diff --git a/src/euler.rs b/src/euler.rs
index 5ee5ed6..c97a962 100644
--- a/src/euler.rs
+++ b/src/euler.rs
@@ -123,7 +123,6 @@ macro_rules! impl_from_quat {
 
             fn third(self, q: $quat) -> $t {
                 use EulerRot::*;
-                #[allow(deprecated)]
                 match self {
                     ZYX => (2.0 * (q.y * q.z + q.w * q.x))
                         .atan2(q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z),
diff --git a/src/lib.rs b/src/lib.rs
index bfb7a5e..b26016c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -245,7 +245,7 @@ and benchmarks.
 The minimum supported Rust version is `1.58.1`.
 
 */
-#![doc(html_root_url = "https://docs.rs/glam/0.21.3")]
+#![doc(html_root_url = "https://docs.rs/glam/0.22.0")]
 #![cfg_attr(not(feature = "std"), no_std)]
 #![cfg_attr(target_arch = "spirv", feature(repr_simd))]
 #![deny(
diff --git a/src/macros.rs b/src/macros.rs
index f2074c3..579a7a9 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -25,236 +25,3 @@ macro_rules! const_assert_eq {
         const_assert!($x == $y);
     };
 }
-
-#[deprecated(since = "0.21.0", note = "use sse2::m128_from_f32x4() instead.")]
-#[macro_export]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-macro_rules! const_m128 {
-    ($fx4:expr) => {{
-        $crate::sse2::m128_from_f32x4($fx4)
-    }};
-}
-
-#[deprecated(since = "0.21.0", note = "use Vec2::from_array() instead.")]
-#[macro_export]
-macro_rules! const_vec2 {
-    ($fx2:expr) => {{
-        $crate::Vec2::from_array($fx2)
-    }};
-}
-
-#[deprecated(since = "0.21.0", note = "use Vec3::from_array() instead.")]
-#[macro_export]
-macro_rules! const_vec3 {
-    ($fx3:expr) => {{
-        $crate::Vec3::from_array($fx3)
-    }};
-}
-
-#[deprecated(since = "0.21.0", note = "use Vec3A::from_array() instead.")]
-#[macro_export]
-macro_rules! const_vec3a {
-    ($fx3:expr) => {{
-        $crate::Vec3A::from_array($fx3)
-    }};
-}
-
-#[deprecated(since = "0.21.0", note = "use Vec4::from_array() instead.")]
-#[macro_export]
-macro_rules! const_vec4 {
-    ($fx4:expr) => {{
-        $crate::Vec4::from_array($fx4)
-    }};
-}
-
-#[deprecated(
-    since = "0.21.0",
-    note = "use Mat2::from_cols(), Mat2::from_cols_array() or Mat2::from_cols_array_2d() instead."
-)]
-#[macro_export]
-macro_rules! const_mat2 {
-    ($col0:expr, $col1:expr) => {{
-        $crate::Mat2::from_cols_array_2d(&[$col0, $col1])
-    }};
-    ($fx4:expr) => {{
-        $crate::Mat2::from_cols_array(&$fx4)
-    }};
-}
-
-#[deprecated(
-    since = "0.21.0",
-    note = "use Mat3::from_cols(), Mat3::from_cols_array() or Mat3::from_cols_array_2d() instead."
-)]
-#[macro_export]
-macro_rules! const_mat3 {
-    ($col0:expr, $col1:expr, $col2:expr) => {{
-        $crate::Mat3::from_cols_array_2d(&[$col0, $col1, $col2])
-    }};
-    ($fx9:expr) => {{
-        $crate::Mat3::from_cols_array(&$fx9)
-    }};
-}
-
-#[deprecated(
-    since = "0.21.0",
-    note = "use Mat3A::from_cols(), Mat3A::from_cols_array() or Mat3A::from_cols_array_2d() instead."
-)]
-#[macro_export]
-macro_rules! const_mat3a {
-    ($col0:expr, $col1:expr, $col2:expr) => {{
-        $crate::Mat3A::from_cols_array_2d(&[$col0, $col1, $col2])
-    }};
-    ($fx9:expr) => {{
-        $crate::Mat3A::from_cols_array(&$fx9)
-    }};
-}
-
-#[deprecated(
-    since = "0.21.0",
-    note = "use Mat4::from_cols(), Mat4::from_cols_array() or Mat4::from_cols_array_2d() instead."
-)]
-#[macro_export]
-macro_rules! const_mat4 {
-    ($col0:expr, $col1:expr, $col2:expr, $col3:expr) => {{
-        $crate::Mat4::from_cols_array_2d(&[$col0, $col1, $col2, $col3])
-    }};
-    ($fx16:expr) => {{
-        $crate::Mat4::from_cols_array(&$fx16)
-    }};
-}
-
-#[deprecated(
-    since = "0.21.0",
-    note = "use Quat::from_xyzw() or Quat::from_array() instead."
-)]
-#[macro_export]
-macro_rules! const_quat {
-    ($fx4:expr) => {{
-        $crate::Quat::from_array($fx4)
-    }};
-}
-
-#[deprecated(since = "0.21.0", note = "use DVec2::from_array() instead.")]
-#[macro_export]
-macro_rules! const_dvec2 {
-    ($fx2:expr) => {{
-        $crate::DVec2::from_array($fx2)
-    }};
-}
-
-#[deprecated(since = "0.21.0", note = "use DVec3::from_array() instead.")]
-#[macro_export]
-macro_rules! const_dvec3 {
-    ($fx3:expr) => {{
-        $crate::DVec3::from_array($fx3)
-    }};
-}
-
-#[deprecated(since = "0.21.0", note = "use DVec4::from_array() instead.")]
-#[macro_export]
-macro_rules! const_dvec4 {
-    ($fx4:expr) => {{
-        $crate::DVec4::from_array($fx4)
-    }};
-}
-
-#[deprecated(
-    since = "0.21.0",
-    note = "use DMat2::from_cols(), DMat2::from_cols_array() or DMat2::from_cols_array_2d() instead."
-)]
-#[macro_export]
-macro_rules! const_dmat2 {
-    ($col0:expr, $col1:expr) => {{
-        $crate::DMat2::from_cols_array_2d(&[$col0, $col1])
-    }};
-    ($fx4:expr) => {{
-        $crate::DMat2::from_cols_array(&$fx4)
-    }};
-}
-
-#[deprecated(
-    since = "0.21.0",
-    note = "use DMat3::from_cols(), DMat3::from_cols_array() or DMat3::from_cols_array_2d() instead."
-)]
-#[macro_export]
-macro_rules! const_dmat3 {
-    ($col0:expr, $col1:expr, $col2:expr) => {{
-        $crate::DMat3::from_cols_array_2d(&[$col0, $col1, $col2])
-    }};
-    ($fx9:expr) => {{
-        $crate::DMat3::from_cols_array(&$fx9)
-    }};
-}
-
-#[deprecated(
-    since = "0.21.0",
-    note = "use DMat4::from_cols(), DMat4::from_cols_array() or DMat4::from_cols_array_2d() instead."
-)]
-#[macro_export]
-macro_rules! const_dmat4 {
-    ($col0:expr, $col1:expr, $col2:expr, $col3:expr) => {{
-        $crate::DMat4::from_cols_array_2d(&[$col0, $col1, $col2, $col3])
-    }};
-    ($fx16:expr) => {{
-        $crate::DMat4::from_cols_array(&$fx16)
-    }};
-}
-
-#[deprecated(
-    since = "0.21.0",
-    note = "use DQuat::from_xyzw() or DQuat::from_array() instead."
-)]
-#[macro_export]
-macro_rules! const_dquat {
-    ($fx4:expr) => {{
-        $crate::DQuat::from_array($fx4)
-    }};
-}
-
-#[deprecated(since = "0.21.0", note = "use IVec2::from_array() instead.")]
-#[macro_export]
-macro_rules! const_ivec2 {
-    ($ix2:expr) => {{
-        $crate::IVec2::from_array($ix2)
-    }};
-}
-
-#[deprecated(since = "0.21.0", note = "use IVec3::from_array() instead.")]
-#[macro_export]
-macro_rules! const_ivec3 {
-    ($ix3:expr) => {{
-        $crate::IVec3::from_array($ix3)
-    }};
-}
-
-#[deprecated(since = "0.21.0", note = "use IVec4::from_array() instead.")]
-#[macro_export]
-macro_rules! const_ivec4 {
-    ($ix4:expr) => {{
-        $crate::IVec4::from_array($ix4)
-    }};
-}
-
-#[deprecated(since = "0.21.0", note = "use UVec2::from_array() instead.")]
-#[macro_export]
-macro_rules! const_uvec2 {
-    ($ux2:expr) => {{
-        $crate::UVec2::from_array($ux2)
-    }};
-}
-
-#[deprecated(since = "0.21.0", note = "use UVec3::from_array() instead.")]
-#[macro_export]
-macro_rules! const_uvec3 {
-    ($ux3:expr) => {{
-        $crate::UVec3::from_array($ux3)
-    }};
-}
-
-#[deprecated(since = "0.21.0", note = "use UVec4::from_array() instead.")]
-#[macro_export]
-macro_rules! const_uvec4 {
-    ($ux4:expr) => {{
-        $crate::UVec4::from_array($ux4)
-    }};
-}


Test patch:
diff --git a/tests/mat2.rs b/tests/mat2.rs
index c53c669..a19eb7d 100644
--- a/tests/mat2.rs
+++ b/tests/mat2.rs
@@ -2,7 +2,7 @@
 mod support;
 
 macro_rules! impl_mat2_tests {
-    ($t:ident, $const_new:ident, $newmat2:ident, $mat2:ident, $mat3:ident, $newvec2:ident, $vec2:ident) => {
+    ($t:ident, $newmat2:ident, $mat2:ident, $mat3:ident, $newvec2:ident, $vec2:ident) => {
         const IDENTITY: [[$t; 2]; 2] = [[1.0, 0.0], [0.0, 1.0]];
 
         const MATRIX: [[$t; 2]; 2] = [[1.0, 2.0], [3.0, 4.0]];
@@ -19,18 +19,6 @@ macro_rules! impl_mat2_tests {
             assert_eq!(MATRIX1D, M2.to_cols_array());
         });
 
-        glam_test!(test_const_macros, {
-            #[allow(deprecated)]
-            const M0: $mat2 = $const_new!([0.0; 4]);
-            #[allow(deprecated)]
-            const M1: $mat2 = $const_new!([1.0, 2.0, 3.0, 4.0]);
-            #[allow(deprecated)]
-            const M2: $mat2 = $const_new!([1.0, 2.0], [3.0, 4.0]);
-            assert_eq!($mat2::ZERO, M0);
-            assert_eq!($mat2::from_cols_array(&[1.0, 2.0, 3.0, 4.0]), M1);
-            assert_eq!($mat2::from_cols_array(&[1.0, 2.0, 3.0, 4.0]), M2);
-        });
-
         glam_test!(test_mat2_identity, {
             assert_eq!($mat2::IDENTITY, $mat2::from_cols_array(&[1., 0., 0., 1.]));
             let identity = $mat2::IDENTITY;
@@ -252,8 +240,7 @@ macro_rules! impl_as_ref_tests {
 
 mod mat2 {
     use super::support::deg;
-    #[allow(deprecated)]
-    use glam::{const_mat2, mat2, swizzles::*, vec2, Mat2, Mat3, Vec2};
+    use glam::{mat2, swizzles::*, vec2, Mat2, Mat3, Vec2};
 
     glam_test!(test_align, {
         use std::mem;
@@ -284,14 +271,13 @@ mod mat2 {
         );
     });
 
-    impl_mat2_tests!(f32, const_mat2, mat2, Mat2, Mat3, vec2, Vec2);
+    impl_mat2_tests!(f32, mat2, Mat2, Mat3, vec2, Vec2);
     impl_as_ref_tests!(Mat2);
 }
 
 mod dmat2 {
     use super::support::deg;
-    #[allow(deprecated)]
-    use glam::{const_dmat2, dmat2, dvec2, swizzles::*, DMat2, DMat3, DVec2};
+    use glam::{dmat2, dvec2, swizzles::*, DMat2, DMat3, DVec2};
 
     glam_test!(test_align, {
         use std::mem;
@@ -299,6 +285,6 @@ mod dmat2 {
         assert_eq!(mem::align_of::<DVec2>(), mem::align_of::<DMat2>());
     });
 
-    impl_mat2_tests!(f64, const_dmat2, dmat2, DMat2, DMat3, dvec2, DVec2);
+    impl_mat2_tests!(f64, dmat2, DMat2, DMat3, dvec2, DVec2);
     impl_as_ref_tests!(DMat2);
 }
diff --git a/tests/mat3.rs b/tests/mat3.rs
index fbd280f..baf1e42 100644
--- a/tests/mat3.rs
+++ b/tests/mat3.rs
@@ -2,7 +2,7 @@
 mod support;
 
 macro_rules! impl_mat3_tests {
-    ($t:ident, $const_new:ident, $newmat3:ident, $mat3:ident, $mat2:ident, $mat4:ident, $quat:ident, $newvec3:ident, $vec3:ident, $vec2:ident) => {
+    ($t:ident, $newmat3:ident, $mat3:ident, $mat2:ident, $mat4:ident, $quat:ident, $newvec3:ident, $vec3:ident, $vec2:ident) => {
         use core::$t::INFINITY;
         use core::$t::NAN;
         use core::$t::NEG_INFINITY;
@@ -27,24 +27,6 @@ macro_rules! impl_mat3_tests {
             assert_eq!(MATRIX1D, M2.to_cols_array());
         });
 
-        glam_test!(test_const_macros, {
-            #[allow(deprecated)]
-            const M0: $mat3 = $const_new!([0.0; 9]);
-            #[allow(deprecated)]
-            const M1: $mat3 = $const_new!([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]);
-            #[allow(deprecated)]
-            const M2: $mat3 = $const_new!([1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]);
-            assert_eq!($mat3::ZERO, M0);
-            assert_eq!(
-                $mat3::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]),
-                M1
-            );
-            assert_eq!(
-                $mat3::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]),
-                M2
-            );
-        });
-
         glam_test!(test_mat3_identity, {
             assert_eq!(
                 $mat3::IDENTITY,
@@ -394,10 +376,7 @@ macro_rules! impl_as_ref_tests {
 
 mod mat3 {
     use super::support::deg;
-    #[allow(deprecated)]
-    use glam::{
-        const_mat3, mat3, swizzles::*, vec3, vec3a, Mat2, Mat3, Mat4, Quat, Vec2, Vec3, Vec3A,
-    };
+    use glam::{mat3, swizzles::*, vec3, vec3a, Mat2, Mat3, Mat4, Quat, Vec2, Vec3, Vec3A};
 
     glam_test!(test_align, {
         use std::mem;
@@ -423,16 +402,13 @@ mod mat3 {
         );
     });
 
-    impl_mat3_tests!(f32, const_mat3, mat3, Mat3, Mat2, Mat4, Quat, vec3, Vec3, Vec2);
+    impl_mat3_tests!(f32, mat3, Mat3, Mat2, Mat4, Quat, vec3, Vec3, Vec2);
     impl_as_ref_tests!(Mat3);
 }
 
 mod mat3a {
     use super::support::deg;
-    #[allow(deprecated)]
-    use glam::{
-        const_mat3a, mat3a, swizzles::*, vec3a, Mat2, Mat3A, Mat4, Quat, Vec2, Vec3, Vec3A,
-    };
+    use glam::{mat3a, swizzles::*, vec3a, Mat2, Mat3A, Mat4, Quat, Vec2, Vec3, Vec3A};
 
     glam_test!(test_align, {
         use std::mem;
@@ -454,24 +430,12 @@ mod mat3a {
         );
     });
 
-    impl_mat3_tests!(
-        f32,
-        const_mat3a,
-        mat3a,
-        Mat3A,
-        Mat2,
-        Mat4,
-        Quat,
-        vec3a,
-        Vec3,
-        Vec2
-    );
+    impl_mat3_tests!(f32, mat3a, Mat3A, Mat2, Mat4, Quat, vec3a, Vec3, Vec2);
 }
 
 mod dmat3 {
     use super::support::deg;
-    #[allow(deprecated)]
-    use glam::{const_dmat3, dmat3, dvec3, swizzles::*, DMat2, DMat3, DMat4, DQuat, DVec2, DVec3};
+    use glam::{dmat3, dvec3, swizzles::*, DMat2, DMat3, DMat4, DQuat, DVec2, DVec3};
 
     glam_test!(test_align, {
         use std::mem;
@@ -479,17 +443,6 @@ mod dmat3 {
         assert_eq!(mem::align_of::<DVec3>(), mem::align_of::<DMat3>());
     });
 
-    impl_mat3_tests!(
-        f64,
-        const_dmat3,
-        dmat3,
-        DMat3,
-        DMat2,
-        DMat4,
-        DQuat,
-        dvec3,
-        DVec3,
-        DVec2
-    );
+    impl_mat3_tests!(f64, dmat3, DMat3, DMat2, DMat4, DQuat, dvec3, DVec3, DVec2);
     impl_as_ref_tests!(DMat3);
 }
diff --git a/tests/mat4.rs b/tests/mat4.rs
index 7c35e82..164bdd6 100644
--- a/tests/mat4.rs
+++ b/tests/mat4.rs
@@ -2,7 +2,7 @@
 mod support;
 
 macro_rules! impl_mat4_tests {
-    ($t:ident, $const_new:ident, $newmat4:ident, $newvec4:ident, $newvec3:ident, $mat4:ident, $mat3:ident, $quat:ident, $vec4:ident, $vec3:ident) => {
+    ($t:ident, $newmat4:ident, $newvec4:ident, $newvec3:ident, $mat4:ident, $mat3:ident, $quat:ident, $vec4:ident, $vec3:ident) => {
         use core::$t::INFINITY;
         use core::$t::NAN;
         use core::$t::NEG_INFINITY;
@@ -39,42 +39,6 @@ macro_rules! impl_mat4_tests {
             assert_eq!(MATRIX1D, M2.to_cols_array());
         });
 
-        glam_test!(test_const_macros, {
-            #[allow(deprecated)]
-            const M0: $mat4 = $const_new!([0.0; 16]);
-            #[allow(deprecated)]
-            const M1: $mat4 = $const_new!([
-                1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0,
-                16.0
-            ]);
-            #[allow(deprecated)]
-            const M2: $mat4 = $const_new!(
-                [1.0, 2.0, 3.0, 4.0],
-                [5.0, 6.0, 7.0, 8.0],
-                [9.0, 10.0, 11.0, 12.0],
-                [13.0, 14.0, 15.0, 16.0]
-            );
-            assert_eq!($mat4::ZERO, M0);
-            assert_eq!(
-                $mat4::from_cols_array_2d(&[
-                    [1.0, 2.0, 3.0, 4.0],
-                    [5.0, 6.0, 7.0, 8.0],
-                    [9.0, 10.0, 11.0, 12.0],
-                    [13.0, 14.0, 15.0, 16.0]
-                ]),
-                M1
-            );
-            assert_eq!(
-                $mat4::from_cols_array_2d(&[
-                    [1.0, 2.0, 3.0, 4.0],
-                    [5.0, 6.0, 7.0, 8.0],
-                    [9.0, 10.0, 11.0, 12.0],
-                    [13.0, 14.0, 15.0, 16.0]
-                ]),
-                M2
-            );
-        });
-
         glam_test!(test_mat4_identity, {
             assert_eq!(
                 $mat4::IDENTITY,
@@ -718,8 +682,7 @@ macro_rules! impl_as_ref_tests {
 
 mod mat4 {
     use super::support::deg;
-    #[allow(deprecated)]
-    use glam::{const_mat4, mat4, swizzles::*, vec3, vec4, Mat3, Mat4, Quat, Vec3, Vec4};
+    use glam::{mat4, swizzles::*, vec3, vec4, Mat3, Mat4, Quat, Vec3, Vec4};
 
     glam_test!(test_align, {
         use std::mem;
@@ -776,14 +739,13 @@ mod mat4 {
         );
     });
 
-    impl_mat4_tests!(f32, const_mat4, mat4, vec4, vec3, Mat4, Mat3, Quat, Vec4, Vec3);
+    impl_mat4_tests!(f32, mat4, vec4, vec3, Mat4, Mat3, Quat, Vec4, Vec3);
     impl_as_ref_tests!(Mat4);
 }
 
 mod dmat4 {
     use super::support::deg;
-    #[allow(deprecated)]
-    use glam::{const_dmat4, dmat4, dvec3, dvec4, swizzles::*, DMat3, DMat4, DQuat, DVec3, DVec4};
+    use glam::{dmat4, dvec3, dvec4, swizzles::*, DMat3, DMat4, DQuat, DVec3, DVec4};
 
     glam_test!(test_align, {
         use std::mem;
@@ -791,17 +753,6 @@ mod dmat4 {
         assert_eq!(128, mem::size_of::<DMat4>());
     });
 
-    impl_mat4_tests!(
-        f64,
-        const_dmat4,
-        dmat4,
-        dvec4,
-        dvec3,
-        DMat4,
-        DMat3,
-        DQuat,
-        DVec4,
-        DVec3
-    );
+    impl_mat4_tests!(f64, dmat4, dvec4, dvec3, DMat4, DMat3, DQuat, DVec4, DVec3);
     impl_as_ref_tests!(DMat4);
 }
diff --git a/tests/quat.rs b/tests/quat.rs
index 4c92ba1..1a6f6e3 100644
--- a/tests/quat.rs
+++ b/tests/quat.rs
@@ -4,7 +4,7 @@
 mod support;
 
 macro_rules! impl_quat_tests {
-    ($t:ident, $const_new:ident, $new:ident, $mat3:ident, $mat4:ident, $quat:ident, $vec2:ident, $vec3:ident, $vec4:ident) => {
+    ($t:ident, $new:ident, $mat3:ident, $mat4:ident, $quat:ident, $vec2:ident, $vec3:ident, $vec4:ident) => {
         use core::$t::INFINITY;
         use core::$t::NAN;
         use core::$t::NEG_INFINITY;
@@ -12,11 +12,8 @@ macro_rules! impl_quat_tests {
         glam_test!(test_const, {
             const Q0: $quat = $quat::from_xyzw(1.0, 2.0, 3.0, 4.0);
             const Q1: $quat = $quat::from_array([1.0, 2.0, 3.0, 4.0]);
-            #[allow(deprecated)]
-            const Q2: $quat = $const_new!([1.0, 2.0, 3.0, 4.0]);
             assert_eq!([1.0, 2.0, 3.0, 4.0], *Q0.as_ref());
             assert_eq!([1.0, 2.0, 3.0, 4.0], *Q1.as_ref());
-            assert_eq!([1.0, 2.0, 3.0, 4.0], *Q2.as_ref());
         });
 
         glam_test!(test_nan, {
@@ -516,8 +513,7 @@ macro_rules! impl_quat_tests {
 mod quat {
     use crate::support::{deg, rad};
     use core::ops::Neg;
-    #[allow(deprecated)]
-    use glam::{const_quat, quat, EulerRot, Mat3, Mat4, Quat, Vec2, Vec3, Vec3A, Vec4};
+    use glam::{quat, EulerRot, Mat3, Mat4, Quat, Vec2, Vec3, Vec3A, Vec4};
 
     glam_test!(test_align, {
         use std::mem;
@@ -612,14 +608,13 @@ mod quat {
         );
     });
 
-    impl_quat_tests!(f32, const_quat, quat, Mat3, Mat4, Quat, Vec2, Vec3, Vec4);
+    impl_quat_tests!(f32, quat, Mat3, Mat4, Quat, Vec2, Vec3, Vec4);
 }
 
 mod dquat {
     use crate::support::{deg, rad};
     use core::ops::Neg;
-    #[allow(deprecated)]
-    use glam::{const_dquat, dquat, DMat3, DMat4, DQuat, DVec2, DVec3, DVec4, EulerRot};
+    use glam::{dquat, DMat3, DMat4, DQuat, DVec2, DVec3, DVec4, EulerRot};
 
     glam_test!(test_align, {
         use std::mem;
@@ -627,15 +622,5 @@ mod dquat {
         assert_eq!(mem::align_of::<f64>(), mem::align_of::<DQuat>());
     });
 
-    impl_quat_tests!(
-        f64,
-        const_dquat,
-        dquat,
-        DMat3,
-        DMat4,
-        DQuat,
-        DVec2,
-        DVec3,
-        DVec4
-    );
+    impl_quat_tests!(f64, dquat, DMat3, DMat4, DQuat, DVec2, DVec3, DVec4);
 }
diff --git a/tests/vec2.rs b/tests/vec2.rs
index 3ca9acc..8ebdd62 100644
--- a/tests/vec2.rs
+++ b/tests/vec2.rs
@@ -4,17 +4,14 @@
 mod support;
 
 macro_rules! impl_vec2_tests {
-    ($t:ty, $const_new:ident, $new:ident, $vec2:ident, $vec3:ident, $mask:ident) => {
+    ($t:ty, $new:ident, $vec2:ident, $vec3:ident, $mask:ident) => {
         glam_test!(test_const, {
             const V0: $vec2 = $vec2::splat(1 as $t);
             const V1: $vec2 = $vec2::new(1 as $t, 2 as $t);
             const V2: $vec2 = $vec2::from_array([1 as $t, 2 as $t]);
-            #[allow(deprecated)]
-            const V3: $vec2 = $const_new!([1 as $t, 2 as $t]);
             assert_eq!([1 as $t, 1 as $t], *V0.as_ref());
             assert_eq!([1 as $t, 2 as $t], *V1.as_ref());
             assert_eq!([1 as $t, 2 as $t], *V2.as_ref());
-            assert_eq!([1 as $t, 2 as $t], *V3.as_ref());
         });
 
         glam_test!(test_vec2_consts, {
@@ -464,8 +461,8 @@ macro_rules! impl_vec2_tests {
 }
 
 macro_rules! impl_vec2_signed_tests {
-    ($t:ident, $const_new:ident, $new:ident, $vec2:ident, $vec3:ident, $mask:ident) => {
-        impl_vec2_tests!($t, $const_new, $new, $vec2, $vec3, $mask);
+    ($t:ident, $new:ident, $vec2:ident, $vec3:ident, $mask:ident) => {
+        impl_vec2_tests!($t, $new, $vec2, $vec3, $mask);
 
         glam_test!(test_dot_signed, {
             let x = $new(1 as $t, 0 as $t);
@@ -534,8 +531,8 @@ macro_rules! impl_vec2_eq_hash_tests {
 }
 
 macro_rules! impl_vec2_float_tests {
-    ($t:ident, $const_new:ident, $new:ident, $vec2:ident, $vec3:ident, $mask:ident) => {
-        impl_vec2_signed_tests!($t, $const_new, $new, $vec2, $vec3, $mask);
+    ($t:ident, $new:ident, $vec2:ident, $vec3:ident, $mask:ident) => {
+        impl_vec2_signed_tests!($t, $new, $vec2, $vec3, $mask);
         impl_vec_float_normalize_tests!($t, $vec2);
 
         use core::$t::INFINITY;
@@ -915,8 +912,7 @@ macro_rules! impl_vec2_bit_op_tests {
 }
 
 mod vec2 {
-    #[allow(deprecated)]
-    use glam::{const_vec2, vec2, BVec2, Vec2, Vec3};
+    use glam::{vec2, BVec2, Vec2, Vec3};
 
     glam_test!(test_align, {
         use core::mem;
@@ -948,12 +944,11 @@ mod vec2 {
         assert_eq!(Vec2::new(1.0, 2.0), UVec2::new(1, 2).as_vec2());
     });
 
-    impl_vec2_float_tests!(f32, const_vec2, vec2, Vec2, Vec3, BVec2);
+    impl_vec2_float_tests!(f32, vec2, Vec2, Vec3, BVec2);
 }
 
 mod dvec2 {
-    #[allow(deprecated)]
-    use glam::{const_dvec2, dvec2, BVec2, DVec2, DVec3};
+    use glam::{dvec2, BVec2, DVec2, DVec3};
 
     glam_test!(test_align, {
         use core::mem;
@@ -966,12 +961,11 @@ mod dvec2 {
         assert_eq!(1, mem::align_of::<BVec2>());
     });
 
-    impl_vec2_float_tests!(f64, const_dvec2, dvec2, DVec2, DVec3, BVec2);
+    impl_vec2_float_tests!(f64, dvec2, DVec2, DVec3, BVec2);
 }
 
 mod ivec2 {
-    #[allow(deprecated)]
-    use glam::{const_ivec2, ivec2, BVec2, IVec2, IVec3, UVec2};
+    use glam::{ivec2, BVec2, IVec2, IVec3, UVec2};
 
     glam_test!(test_align, {
         use core::mem;
@@ -984,7 +978,7 @@ mod ivec2 {
         assert_eq!(1, mem::align_of::<BVec2>());
     });
 
-    impl_vec2_signed_tests!(i32, const_ivec2, ivec2, IVec2, IVec3, BVec2);
+    impl_vec2_signed_tests!(i32, ivec2, IVec2, IVec3, BVec2);
     impl_vec2_eq_hash_tests!(i32, ivec2);
 
     impl_vec2_scalar_shift_op_tests!(IVec2, -2, 2);
@@ -995,8 +989,7 @@ mod ivec2 {
 }
 
 mod uvec2 {
-    #[allow(deprecated)]
-    use glam::{const_uvec2, uvec2, BVec2, IVec2, UVec2, UVec3};
+    use glam::{uvec2, BVec2, IVec2, UVec2, UVec3};
 
     glam_test!(test_align, {
         use core::mem;
@@ -1009,7 +1002,7 @@ mod uvec2 {
         assert_eq!(1, mem::align_of::<BVec2>());
     });
 
-    impl_vec2_tests!(u32, const_uvec2, uvec2, UVec2, UVec3, BVec2);
+    impl_vec2_tests!(u32, uvec2, UVec2, UVec3, BVec2);
     impl_vec2_eq_hash_tests!(u32, uvec2);
 
     impl_vec2_scalar_shift_op_tests!(UVec2, 0, 2);
diff --git a/tests/vec3.rs b/tests/vec3.rs
index 92af042..fae8858 100644
--- a/tests/vec3.rs
+++ b/tests/vec3.rs
@@ -4,17 +4,14 @@
 mod support;
 
 macro_rules! impl_vec3_tests {
-    ($t:ident, $const_new:ident, $new:ident, $vec3:ident, $mask:ident) => {
+    ($t:ident, $new:ident, $vec3:ident, $mask:ident) => {
         glam_test!(test_const, {
             const V0: $vec3 = $vec3::splat(1 as $t);
             const V1: $vec3 = $vec3::new(1 as $t, 2 as $t, 3 as $t);
             const V2: $vec3 = $vec3::from_array([1 as $t, 2 as $t, 3 as $t]);
-            #[allow(deprecated)]
-            const V3: $vec3 = $const_new!([1 as $t, 2 as $t, 3 as $t]);
             assert_eq!([1 as $t, 1 as $t, 1 as $t], *V0.as_ref());
             assert_eq!([1 as $t, 2 as $t, 3 as $t], *V1.as_ref());
             assert_eq!([1 as $t, 2 as $t, 3 as $t], *V2.as_ref());
-            assert_eq!([1 as $t, 2 as $t, 3 as $t], *V3.as_ref());
         });
 
         glam_test!(test_vec3_consts, {
@@ -517,8 +514,8 @@ macro_rules! impl_vec3_tests {
 }
 
 macro_rules! impl_vec3_signed_tests {
-    ($t:ident, $const_new:ident, $new:ident, $vec3:ident, $mask:ident) => {
-        impl_vec3_tests!($t, $const_new, $new, $vec3, $mask);
+    ($t:ident, $new:ident, $vec3:ident, $mask:ident) => {
+        impl_vec3_tests!($t, $new, $vec3, $mask);
 
         glam_test!(test_neg, {
             let a = $new(1 as $t, 2 as $t, 3 as $t);
@@ -576,8 +573,8 @@ macro_rules! impl_vec3_eq_hash_tests {
 }
 
 macro_rules! impl_vec3_float_tests {
-    ($t:ident, $const_new:ident, $new:ident, $vec3:ident, $mask:ident) => {
-        impl_vec3_signed_tests!($t, $const_new, $new, $vec3, $mask);
+    ($t:ident, $new:ident, $vec3:ident, $mask:ident) => {
+        impl_vec3_signed_tests!($t, $new, $vec3, $mask);
         impl_vec_float_normalize_tests!($t, $vec3);
 
         use core::$t::INFINITY;
@@ -1015,8 +1012,7 @@ macro_rules! impl_vec3_bit_op_tests {
 }
 
 mod vec3 {
-    #[allow(deprecated)]
-    use glam::{const_vec3, vec3, BVec3, Vec3};
+    use glam::{vec3, BVec3, Vec3};
 
     glam_test!(test_align, {
         use std::mem;
@@ -1082,7 +1078,7 @@ mod vec3 {
         assert_eq!(Vec3A::new(1.0, 2.0, 3.0), UVec3::new(1, 2, 3).as_vec3a());
     });
 
-    impl_vec3_float_tests!(f32, const_vec3, vec3, Vec3, BVec3);
+    impl_vec3_float_tests!(f32, vec3, Vec3, BVec3);
 }
 
 mod vec3a {
@@ -1093,8 +1089,7 @@ mod vec3a {
     use glam::BVec3;
     #[cfg(not(feature = "scalar-math"))]
     use glam::BVec3A;
-    #[allow(deprecated)]
-    use glam::{const_vec3a, vec3a, Vec3A, Vec4};
+    use glam::{vec3a, Vec3A, Vec4};
 
     glam_test!(test_align, {
         use std::mem;
@@ -1171,18 +1166,17 @@ mod vec3a {
         any(target_feature = "sse2", target_feature = "simd128"),
         not(feature = "scalar-math")
     ))]
-    impl_vec3_float_tests!(f32, const_vec3a, vec3a, Vec3A, BVec3A);
+    impl_vec3_float_tests!(f32, vec3a, Vec3A, BVec3A);
 
     #[cfg(any(
         not(any(target_feature = "sse2", target_feature = "simd128")),
         feature = "scalar-math"
     ))]
-    impl_vec3_float_tests!(f32, const_vec3a, vec3a, Vec3A, BVec3);
+    impl_vec3_float_tests!(f32, vec3a, Vec3A, BVec3);
 }
 
 mod dvec3 {
-    #[allow(deprecated)]
-    use glam::{const_dvec3, dvec3, BVec3, DVec3};
+    use glam::{dvec3, BVec3, DVec3};
 
     glam_test!(test_align, {
         use std::mem;
@@ -1192,12 +1186,11 @@ mod dvec3 {
         assert_eq!(1, mem::align_of::<BVec3>());
     });
 
-    impl_vec3_float_tests!(f64, const_dvec3, dvec3, DVec3, BVec3);
+    impl_vec3_float_tests!(f64, dvec3, DVec3, BVec3);
 }
 
 mod ivec3 {
-    #[allow(deprecated)]
-    use glam::{const_ivec3, ivec3, BVec3, IVec3, UVec3};
+    use glam::{ivec3, BVec3, IVec3, UVec3};
 
     glam_test!(test_align, {
         use std::mem;
@@ -1207,7 +1200,7 @@ mod ivec3 {
         assert_eq!(1, mem::align_of::<BVec3>());
     });
 
-    impl_vec3_signed_tests!(i32, const_ivec3, ivec3, IVec3, BVec3);
+    impl_vec3_signed_tests!(i32, ivec3, IVec3, BVec3);
     impl_vec3_eq_hash_tests!(i32, ivec3);
 
     impl_vec3_scalar_shift_op_tests!(IVec3, -2, 2);
@@ -1218,8 +1211,7 @@ mod ivec3 {
 }
 
 mod uvec3 {
-    #[allow(deprecated)]
-    use glam::{const_uvec3, uvec3, BVec3, IVec3, UVec3};
+    use glam::{uvec3, BVec3, IVec3, UVec3};
 
     glam_test!(test_align, {
         use std::mem;
@@ -1229,7 +1221,7 @@ mod uvec3 {
         assert_eq!(1, mem::align_of::<BVec3>());
     });
 
-    impl_vec3_tests!(u32, const_uvec3, uvec3, UVec3, BVec3);
+    impl_vec3_tests!(u32, uvec3, UVec3, BVec3);
     impl_vec3_eq_hash_tests!(u32, uvec3);
 
     impl_vec3_scalar_shift_op_tests!(UVec3, 0, 2);
diff --git a/tests/vec4.rs b/tests/vec4.rs
index 9d06371..47f4fa8 100644
--- a/tests/vec4.rs
+++ b/tests/vec4.rs
@@ -4,17 +4,14 @@
 mod support;
 
 macro_rules! impl_vec4_tests {
-    ($t:ident, $const_new:ident, $new:ident, $vec4:ident, $vec3:ident, $vec2:ident, $mask:ident) => {
+    ($t:ident, $new:ident, $vec4:ident, $vec3:ident, $vec2:ident, $mask:ident) => {
         glam_test!(test_const, {
             const V0: $vec4 = $vec4::splat(1 as $t);
             const V1: $vec4 = $vec4::new(1 as $t, 2 as $t, 3 as $t, 4 as $t);
             const V2: $vec4 = $vec4::from_array([1 as $t, 2 as $t, 3 as $t, 4 as $t]);
-            #[allow(deprecated)]
-            const V3: $vec4 = $const_new!([1 as $t, 2 as $t, 3 as $t, 4 as $t]);
             assert_eq!([1 as $t, 1 as $t, 1 as $t, 1 as $t], *V0.as_ref());
             assert_eq!([1 as $t, 2 as $t, 3 as $t, 4 as $t], *V1.as_ref());
             assert_eq!([1 as $t, 2 as $t, 3 as $t, 4 as $t], *V2.as_ref());
-            assert_eq!([1 as $t, 2 as $t, 3 as $t, 4 as $t], *V3.as_ref());
         });
 
         glam_test!(test_vec4_consts, {
@@ -592,8 +589,8 @@ macro_rules! impl_vec4_tests {
 }
 
 macro_rules! impl_vec4_signed_tests {
-    ($t:ident, $const_new:ident, $new:ident, $vec4:ident, $vec3:ident, $vec2:ident, $mask:ident) => {
-        impl_vec4_tests!($t, $const_new, $new, $vec4, $vec3, $vec2, $mask);
+    ($t:ident, $new:ident, $vec4:ident, $vec3:ident, $vec2:ident, $mask:ident) => {
+        impl_vec4_tests!($t, $new, $vec4, $vec3, $vec2, $mask);
 
         glam_test!(test_neg, {
             let a = $new(1 as $t, 2 as $t, 3 as $t, 4 as $t);
@@ -653,8 +650,8 @@ macro_rules! impl_vec4_eq_hash_tests {
 }
 
 macro_rules! impl_vec4_float_tests {
-    ($t:ident, $const_new:ident, $new:ident, $vec4:ident, $vec3:ident, $vec2:ident, $mask:ident) => {
-        impl_vec4_signed_tests!($t, $const_new, $new, $vec4, $vec3, $vec2, $mask);
+    ($t:ident, $new:ident, $vec4:ident, $vec3:ident, $vec2:ident, $mask:ident) => {
+        impl_vec4_signed_tests!($t, $new, $vec4, $vec3, $vec2, $mask);
         impl_vec_float_normalize_tests!($t, $vec4);
 
         use core::$t::INFINITY;
@@ -1112,8 +1109,7 @@ mod vec4 {
     use glam::BVec4;
     #[cfg(not(feature = "scalar-math"))]
     use glam::BVec4A;
-    #[allow(deprecated)]
-    use glam::{const_vec4, vec4, Vec2, Vec3, Vec4};
+    use glam::{vec4, Vec2, Vec3, Vec4};
 
     glam_test!(test_align, {
         use std::mem;
@@ -1236,18 +1232,17 @@ mod vec4 {
         any(target_feature = "sse2", target_feature = "simd128"),
         not(feature = "scalar-math")
     ))]
-    impl_vec4_float_tests!(f32, const_vec4, vec4, Vec4, Vec3, Vec2, BVec4A);
+    impl_vec4_float_tests!(f32, vec4, Vec4, Vec3, Vec2, BVec4A);
 
     #[cfg(any(
         not(any(target_feature = "sse2", target_feature = "simd128")),
         feature = "scalar-math"
     ))]
-    impl_vec4_float_tests!(f32, const_vec4, vec4, Vec4, Vec3, Vec2, BVec4);
+    impl_vec4_float_tests!(f32, vec4, Vec4, Vec3, Vec2, BVec4);
 }
 
 mod dvec4 {
-    #[allow(deprecated)]
-    use glam::{const_dvec4, dvec4, BVec4, DVec2, DVec3, DVec4};
+    use glam::{dvec4, BVec4, DVec2, DVec3, DVec4};
 
     glam_test!(test_align, {
         use std::mem;
@@ -1260,12 +1255,11 @@ mod dvec4 {
         assert_eq!(1, mem::align_of::<BVec4>());
     });
 
-    impl_vec4_float_tests!(f64, const_dvec4, dvec4, DVec4, DVec3, DVec2, BVec4);
+    impl_vec4_float_tests!(f64, dvec4, DVec4, DVec3, DVec2, BVec4);
 }
 
 mod ivec4 {
-    #[allow(deprecated)]
-    use glam::{const_ivec4, ivec4, BVec4, IVec2, IVec3, IVec4, UVec4};
+    use glam::{ivec4, BVec4, IVec2, IVec3, IVec4, UVec4};
 
     glam_test!(test_align, {
         use std::mem;
@@ -1278,7 +1272,7 @@ mod ivec4 {
         assert_eq!(1, mem::align_of::<BVec4>());
     });
 
-    impl_vec4_signed_tests!(i32, const_ivec4, ivec4, IVec4, IVec3, IVec2, BVec4);
+    impl_vec4_signed_tests!(i32, ivec4, IVec4, IVec3, IVec2, BVec4);
     impl_vec4_eq_hash_tests!(i32, ivec4);
 
     impl_vec4_scalar_shift_op_tests!(IVec4, -2, 2);
@@ -1289,8 +1283,7 @@ mod ivec4 {
 }
 
 mod uvec4 {
-    #[allow(deprecated)]
-    use glam::{const_uvec4, uvec4, BVec4, IVec4, UVec2, UVec3, UVec4};
+    use glam::{uvec4, BVec4, IVec4, UVec2, UVec3, UVec4};
 
     glam_test!(test_align, {
         use std::mem;
@@ -1303,7 +1296,7 @@ mod uvec4 {
         assert_eq!(1, mem::align_of::<BVec4>());
     });
 
-    impl_vec4_tests!(u32, const_uvec4, uvec4, UVec4, UVec3, UVec2, BVec4);
+    impl_vec4_tests!(u32, uvec4, UVec4, UVec3, UVec2, BVec4);
     impl_vec4_eq_hash_tests!(u32, uvec4);
 
     impl_vec4_scalar_shift_op_tests!(UVec4, 0, 2);