Moved the NoInit tag from Math to the root namespace.

The old one is deprecated, and will be removed in a future release. Unfortunately, to avoid deprecation warnings, all use of NoInit in the Math library temporarily have to be Magnum::NoInit This will be cleaned up when the deprecated alias is removed.
6 years ago · 1026aee80e
55 changed files with 216 additions and 185 deletions
--- a/doc/changelog.dox
+++ b/doc/changelog.dox
@ -693,6 +693,9 @@ See also:
    was a rarely (if ever) used feature.
 -   @cpp DebugTools::Profiler @ce is obsolete, replaced with a much more
    flexible and extensible @ref DebugTools::FrameProfiler
+-   @cpp Math::NoInitT @ce and @cpp Math::NoInit @ce constructor tags are
+    deprecated in favor of @ref NoInitT and @ref NoInit directly in the
+    @ref Magnum namespace

@subsection changelog-latest-compatibility Potential compatibility breakages, removed APIs

--- a/doc/snippets/MagnumMath.cpp
+++ b/doc/snippets/MagnumMath.cpp
@ -601,7 +601,7 @@ Quaternion q1;
 Quaternion q2{Math::IdentityInit};

 /* Avoid unnecessary initialization if is overwritten anyway */
-Matrix4 projection{Math::NoInit};
+Matrix4 projection{NoInit};
 if(orthographic)
    projection = Matrix4::orthographicProjection({4.0f, 3.0f}, 0.1f, 100.0f);
 else
--- a/src/Magnum/GL/AbstractTexture.cpp
+++ b/src/Magnum/GL/AbstractTexture.cpp
@ -2061,7 +2061,7 @@ Math::Vector<1, GLint> AbstractTexture::DataHelper<1>::compressedBlockSize(const
 }

 Vector2i AbstractTexture::DataHelper<2>::compressedBlockSize(const GLenum target, const TextureFormat format) {
-    Vector2i value{Math::NoInit};
+    Vector2i value{NoInit};
    glGetInternalformativ(target, GLenum(format), GL_TEXTURE_COMPRESSED_BLOCK_WIDTH, 1, &value.x());
    glGetInternalformativ(target, GLenum(format), GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT, 1, &value.y());
    return value;
--- a/src/Magnum/Math/Algorithms/Test/SvdTest.cpp
+++ b/src/Magnum/Math/Algorithms/Test/SvdTest.cpp
@ -60,9 +60,9 @@ template<class T> void SvdTest::test() {
        Vector8<T>{T{ 7}, T{ 8}, T{  3}, T{ 4}, T{ 4}, T{-1}, T{ 1}, T{ 2}}};
    const Vector5<T> expected(std::sqrt(T{1248}), T{0}, T{20}, std::sqrt(T{384}), T{0});

-    Matrix5x8<T> u{NoInit};
-    Vector5<T> w{NoInit};
-    Matrix5<T> v{NoInit};
+    Matrix5x8<T> u{Magnum::NoInit};
+    Vector5<T> w{Magnum::NoInit};
+    Matrix5<T> v{Magnum::NoInit};
    std::tie(u, w, v) = Algorithms::svd(a);

    /* Test composition */
@ -103,9 +103,9 @@ void SvdTest::decomposeRotationShear() {

    Matrix4 a = Matrix4::scaling({1.5f, 2.0f, 1.0f})*Matrix4::rotationZ(35.0_degf);

-    Matrix3x3 u{NoInit};
-    Vector3 w{NoInit};
-    Matrix3x3 v{NoInit};
+    Matrix3x3 u{Magnum::NoInit};
+    Vector3 w{Magnum::NoInit};
+    Matrix3x3 v{Magnum::NoInit};
    std::tie(u, w, v) = Algorithms::svd(a.rotationScaling());

    CORRADE_COMPARE(u*Matrix3x3::fromDiagonal(w)*v.transposed(), a.rotationScaling());
--- a/src/Magnum/Math/Angle.h
+++ b/src/Magnum/Math/Angle.h
@ -112,7 +112,7 @@ template<class T> class Deg: public Unit<Deg, T> {
        constexpr explicit Deg(ZeroInitT) noexcept: Unit<Math::Deg, T>{ZeroInit} {}

        /** @brief Construct without initializing the contents */
-        explicit Deg(NoInitT) noexcept: Unit<Math::Deg, T>{NoInit} {}
+        explicit Deg(Magnum::NoInitT) noexcept: Unit<Math::Deg, T>{Magnum::NoInit} {}

        /** @brief Explicit constructor from unitless type */
        constexpr explicit Deg(T value) noexcept: Unit<Math::Deg, T>(value) {}
@ -181,7 +181,7 @@ template<class T> class Rad: public Unit<Rad, T> {
        constexpr explicit Rad(ZeroInitT) noexcept: Unit<Math::Rad, T>{ZeroInit} {}

        /** @brief Construct without initializing the contents */
-        explicit Rad(NoInitT) noexcept: Unit<Math::Rad, T>{NoInit} {}
+        explicit Rad(Magnum::NoInitT) noexcept: Unit<Math::Rad, T>{Magnum::NoInit} {}

        /** @brief Construct from unitless type */
        constexpr explicit Rad(T value) noexcept: Unit<Math::Rad, T>(value) {}
--- a/src/Magnum/Math/Bezier.h
+++ b/src/Magnum/Math/Bezier.h
@ -112,7 +112,7 @@ template<UnsignedInt order, UnsignedInt dimensions, class T> class Bezier {
        constexpr explicit Bezier(ZeroInitT) noexcept: Bezier<order, dimensions, T>{typename Implementation::GenerateSequence<order + 1>::Type{}, ZeroInit} {}

        /** @brief Construct Bézier without initializing the contents */
-        explicit Bezier(NoInitT) noexcept: Bezier<order, dimensions, T>{typename Implementation::GenerateSequence<order + 1>::Type{}, NoInit} {}
+        explicit Bezier(Magnum::NoInitT) noexcept: Bezier<order, dimensions, T>{typename Implementation::GenerateSequence<order + 1>::Type{}, Magnum::NoInit} {}

        /** @brief Construct Bézier curve with given array of control points */
        template<typename... U> constexpr /*implicit*/ Bezier(const Vector<dimensions, T>& first, U... next) noexcept: _data{first, next...} {
--- a/src/Magnum/Math/BoolVector.h
+++ b/src/Magnum/Math/BoolVector.h
@ -112,7 +112,7 @@ template<std::size_t size> class BoolVector {
        constexpr explicit BoolVector(ZeroInitT) noexcept: _data{} {}

        /** @brief Construct without initializing the contents */
-        explicit BoolVector(NoInitT) noexcept {}
+        explicit BoolVector(Magnum::NoInitT) noexcept {}

        /**
         * @brief Construct a boolean vector from segment values
@ -389,7 +389,7 @@ template<std::size_t size> inline bool BoolVector<size>::none() const {
 }

 template<std::size_t size> inline BoolVector<size> BoolVector<size>::operator~() const {
-    BoolVector<size> out{NoInit};
+    BoolVector<size> out{Magnum::NoInit};

    for(std::size_t i = 0; i != DataSize; ++i)
        out._data[i] = ~_data[i];
--- a/src/Magnum/Math/Color.h
+++ b/src/Magnum/Math/Color.h
@ -462,8 +462,8 @@ template<class T> class Color3: public Vector3<T> {
         */
        constexpr explicit Color3(ZeroInitT) noexcept: Vector3<T>{ZeroInit} {}

-        /** @copydoc Vector::Vector(NoInitT) */
-        explicit Color3(NoInitT) noexcept: Vector3<T>{NoInit} {}
+        /** @copydoc Vector::Vector(Magnum::NoInitT) */
+        explicit Color3(Magnum::NoInitT) noexcept: Vector3<T>{Magnum::NoInit} {}

        /**
         * @brief Gray constructor
@ -875,7 +875,7 @@ class Color4: public Vector4<T> {
        constexpr explicit Color4(ZeroInitT) noexcept: Vector4<T>{ZeroInit} {}

        /** @copydoc Vector::Vector(NoInitT) */
-        explicit Color4(NoInitT) noexcept: Vector4<T>{NoInit} {}
+        explicit Color4(Magnum::NoInitT) noexcept: Vector4<T>{Magnum::NoInit} {}

        /**
         * @copydoc Color3::Color3(T)
@ -1087,7 +1087,7 @@ template<class T> struct ColorHsv {
    constexpr explicit ColorHsv(ZeroInitT) noexcept: hue{}, saturation{}, value{} {}

    /** @brief Construct without initializing the contents */
-    explicit ColorHsv(NoInitT) noexcept: hue{NoInit} /* and the others not */ {}
+    explicit ColorHsv(Magnum::NoInitT) noexcept: hue{Magnum::NoInit} /* and the others not */ {}

    /** @brief Constructor */
    constexpr /*implicit*/ ColorHsv(Deg<T> hue, T saturation, T value) noexcept: hue{hue}, saturation{saturation}, value{value} {}
--- a/src/Magnum/Math/Complex.h
+++ b/src/Magnum/Math/Complex.h
@ -145,7 +145,7 @@ template<class T> class Complex {
        constexpr explicit Complex(ZeroInitT) noexcept: _real{}, _imaginary{} {}

        /** @brief Construct without initializing the contents */
-        explicit Complex(NoInitT) noexcept {}
+        explicit Complex(Magnum::NoInitT) noexcept {}

        /**
         * @brief Construct a complex number from real and imaginary part
--- a/src/Magnum/Math/CubicHermite.h
+++ b/src/Magnum/Math/CubicHermite.h
@ -126,7 +126,7 @@ template<class T> class CubicHermite {
        template<class U = T, class = typename std::enable_if<std::is_constructible<U, IdentityInitT>::value>::type> constexpr explicit CubicHermite(IdentityInitT) noexcept: _inTangent{ZeroInit}, _point{IdentityInit}, _outTangent{ZeroInit} {}

        /** @brief Construct cubic Hermite spline point without initializing its contents */
-        explicit CubicHermite(NoInitT) noexcept: CubicHermite{NoInit, typename std::conditional<std::is_constructible<T, NoInitT>::value, NoInitT*, void*>::type{}} {}
+        explicit CubicHermite(Magnum::NoInitT) noexcept: CubicHermite{Magnum::NoInit, typename std::conditional<std::is_constructible<T, Magnum::NoInitT>::value, Magnum::NoInitT*, void*>::type{}} {}

        /**
         * @brief Construct cubic Hermite spline point with given control points
@ -187,8 +187,8 @@ template<class T> class CubicHermite {

        /* Called from CubicHermite(NoInit), either using the NoInit
           constructor (if available) or not doing anything */
-        explicit CubicHermite(NoInitT, NoInitT*) noexcept: _inTangent{NoInit}, _point{NoInit}, _outTangent{NoInit} {}
-        explicit CubicHermite(NoInitT, void*) noexcept {}
+        explicit CubicHermite(Magnum::NoInitT, Magnum::NoInitT*) noexcept: _inTangent{Magnum::NoInit}, _point{Magnum::NoInit}, _outTangent{Magnum::NoInit} {}
+        explicit CubicHermite(Magnum::NoInitT, void*) noexcept {}

        T _inTangent;
        T _point;
--- a/src/Magnum/Math/Dual.h
+++ b/src/Magnum/Math/Dual.h
@ -81,8 +81,8 @@ template<class T> class Dual {
        explicit Dual(NoInitT) noexcept;
        #else
        /* MSVC 2015 can't handle {} instead of ::value */
-        template<class U = T, class = typename std::enable_if<std::is_standard_layout<U>::value && std::is_trivial<U>::value>::type> explicit Dual(NoInitT) noexcept {}
-        template<class U = T, class V = T, class = typename std::enable_if<std::is_constructible<U, NoInitT>::value>::type> explicit Dual(NoInitT) noexcept: _real{NoInit}, _dual{NoInit} {}
+        template<class U = T, class = typename std::enable_if<std::is_standard_layout<U>::value && std::is_trivial<U>::value>::type> explicit Dual(Magnum::NoInitT) noexcept {}
+        template<class U = T, class V = T, class = typename std::enable_if<std::is_constructible<U, Magnum::NoInitT>::value>::type> explicit Dual(Magnum::NoInitT) noexcept: _real{Magnum::NoInit}, _dual{Magnum::NoInit} {}
        #endif

        /**
--- a/src/Magnum/Math/DualComplex.h
+++ b/src/Magnum/Math/DualComplex.h
@ -126,7 +126,7 @@ template<class T> class DualComplex: public Dual<Complex<T>> {
        constexpr explicit DualComplex(ZeroInitT) noexcept: Dual<Complex<T>>{Complex<T>{ZeroInit}, Complex<T>{ZeroInit}} {}

        /** @brief Construct without initializing the contents */
-        explicit DualComplex(NoInitT) noexcept: Dual<Complex<T>>{NoInit} {}
+        explicit DualComplex(Magnum::NoInitT) noexcept: Dual<Complex<T>>{Magnum::NoInit} {}

        /**
         * @brief Construct dual complex number from real and dual part
--- a/src/Magnum/Math/DualQuaternion.h
+++ b/src/Magnum/Math/DualQuaternion.h
@ -266,7 +266,7 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
        constexpr explicit DualQuaternion(ZeroInitT) noexcept: Dual<Quaternion<T>>{Quaternion<T>{ZeroInit}, Quaternion<T>{ZeroInit}} {}

        /** @brief Construct without initializing the contents */
-        explicit DualQuaternion(NoInitT) noexcept: Dual<Quaternion<T>>{NoInit} {}
+        explicit DualQuaternion(Magnum::NoInitT) noexcept: Dual<Quaternion<T>>{Magnum::NoInit} {}

        /**
         * @brief Construct dual quaternion from real and dual part
--- a/src/Magnum/Math/Frustum.h
+++ b/src/Magnum/Math/Frustum.h
@ -85,7 +85,7 @@ template<class T> class Frustum {
        constexpr explicit Frustum(IdentityInitT) noexcept;

        /** @brief Construct a frustum without initializing the contents */
-        explicit Frustum(NoInitT) noexcept: _data{Vector4<T>{NoInit}, Vector4<T>{NoInit}, Vector4<T>{NoInit}, Vector4<T>{NoInit}, Vector4<T>{NoInit}, Vector4<T>{NoInit}} {}
+        explicit Frustum(Magnum::NoInitT) noexcept: _data{Vector4<T>{Magnum::NoInit}, Vector4<T>{Magnum::NoInit}, Vector4<T>{Magnum::NoInit}, Vector4<T>{Magnum::NoInit}, Vector4<T>{Magnum::NoInit}, Vector4<T>{Magnum::NoInit}} {}

        /**
         * @brief Construct a frustum from plane equations
--- a/src/Magnum/Math/Functions.h
+++ b/src/Magnum/Math/Functions.h
@ -245,7 +245,7 @@ template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type

 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> min(const Vector<size, T>& value, const Vector<size, T>& min) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = Math::min(value[i], min[i]);
    return out;
@ -253,7 +253,7 @@ template<std::size_t size, class T> inline Vector<size, T> min(const Vector<size

 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> min(const Vector<size, T>& value, T min) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = Math::min(value[i], min);
    return out;
@ -272,7 +272,7 @@ template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type

 /** @overload */
 template<std::size_t size, class T> Vector<size, T> max(const Vector<size, T>& value, const Vector<size, T>& max) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = Math::max(value[i], max[i]);
    return out;
@ -280,7 +280,7 @@ template<std::size_t size, class T> Vector<size, T> max(const Vector<size, T>& v

 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> max(const Vector<size, T>& value, T max) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = Math::max(value[i], max);
    return out;
@ -323,7 +323,7 @@ template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type

 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> clamp(const Vector<size, T>& value, const Vector<size, T>& min, const Vector<size, T>& max) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = Math::clamp(value[i], min[i], max[i]);
    return out;
@ -331,7 +331,7 @@ template<std::size_t size, class T> inline Vector<size, T> clamp(const Vector<si

 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> clamp(const Vector<size, T>& value, T min, T max) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = Math::clamp(value[i], min, max);
    return out;
@ -350,7 +350,7 @@ template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type si

 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> sign(const Vector<size, T>& a) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = Math::sign(a[i]);
    return out;
@ -363,7 +363,7 @@ template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type ab

 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> abs(const Vector<size, T>& a) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = Math::abs(a[i]);
    return out;
@ -376,7 +376,7 @@ template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type fl

 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> floor(const Vector<size, T>& a) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = Math::floor(a[i]);
    return out;
@ -389,7 +389,7 @@ template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type ro

 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> round(const Vector<size, T>& a) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = Math::round(a[i]);
    return out;
@ -402,7 +402,7 @@ template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type ce

 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> ceil(const Vector<size, T>& a) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = Math::ceil(a[i]);
    return out;
@ -450,7 +450,7 @@ component-wise selection from either @p a or @p b based on values in @p t.
@m_keyword{mix(),GLSL mix(),}
 */
 template<std::size_t size, class T> inline Vector<size, T> lerp(const Vector<size, T>& a, const Vector<size, T>& b, const BoolVector<size>& t) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = t[i] ? b[i] : a[i];
    return out;
@ -599,7 +599,7 @@ template<UnsignedInt exponent, class T> constexpr typename std::enable_if<IsScal

 /** @overload */
 template<UnsignedInt exponent, std::size_t size, class T> inline Vector<size, T> pow(const Vector<size, T>& base) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = Math::pow<exponent>(base[i]);
    return out;
@ -619,7 +619,7 @@ template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type po

 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> pow(const Vector<size, T>& base, T exponent) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = Math::pow(base[i], exponent);
    return out;
@ -638,7 +638,7 @@ template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type sq

 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> sqrt(const Vector<size, T>& a) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = Math::sqrt(a[i]);
    return out;
--- a/src/Magnum/Math/Half.h
+++ b/src/Magnum/Math/Half.h
@ -102,7 +102,7 @@ class Half {
        explicit Half(Double value) noexcept: _data{packHalf(Float(value))} {}

        /** @brief Construct without initializing the contents */
-        explicit Half(NoInitT) noexcept {}
+        explicit Half(Magnum::NoInitT) noexcept {}

        /**
         * @brief Equality comparison
--- a/src/Magnum/Math/Matrix.h
+++ b/src/Magnum/Math/Matrix.h
@ -85,8 +85,8 @@ template<std::size_t size, class T> class Matrix: public RectangularMatrix<size,
        /** @copydoc RectangularMatrix::RectangularMatrix(ZeroInitT) */
        constexpr explicit Matrix(ZeroInitT) noexcept: RectangularMatrix<size, size, T>{ZeroInit} {}

-        /** @copydoc RectangularMatrix::RectangularMatrix(NoInitT) */
-        constexpr explicit Matrix(NoInitT) noexcept: RectangularMatrix<size, size, T>{NoInit} {}
+        /** @copydoc RectangularMatrix::RectangularMatrix(Magnum::NoInitT) */
+        constexpr explicit Matrix(Magnum::NoInitT) noexcept: RectangularMatrix<size, size, T>{Magnum::NoInit} {}

        /** @brief Construct from column vectors */
        template<class ...U> constexpr /*implicit*/ Matrix(const Vector<size, T>& first, const U&... next) noexcept: RectangularMatrix<size, size, T>(first, next...) {}
@ -475,7 +475,7 @@ template<std::size_t size, class T> bool Matrix<size, T>::isOrthogonal() const {
 }

 template<std::size_t size, class T> Matrix<size-1, T> Matrix<size, T>::ij(const std::size_t skipCol, const std::size_t skipRow) const {
-    Matrix<size-1, T> out{NoInit};
+    Matrix<size-1, T> out{Magnum::NoInit};

    /* Using ._data[] instead of [] to avoid function call indirection on debug
       builds (saves a lot, yet doesn't obfuscate too much) */
@ -493,7 +493,7 @@ template<std::size_t size, class T> T Matrix<size, T>::cofactor(std::size_t col,
 }

 template<std::size_t size, class T> Matrix<size, T> Matrix<size, T>::comatrix() const {
-    Matrix<size, T> out{NoInit};
+    Matrix<size, T> out{Magnum::NoInit};

    /* Using ._data[] instead of [] to avoid function call indirection on debug
       builds (saves a lot, yet doesn't obfuscate too much) */
@ -505,7 +505,7 @@ template<std::size_t size, class T> Matrix<size, T> Matrix<size, T>::comatrix()
 }

 template<std::size_t size, class T> Matrix<size, T> Matrix<size, T>::adjugate() const {
-    Matrix<size, T> out{NoInit};
+    Matrix<size, T> out{Magnum::NoInit};

    /* Same as comatrix(), except using cofactor(row, col) instead of
       cofactor(col, row). Could also be just comatrix().transpose() but since
--- a/src/Magnum/Math/Matrix3.h
+++ b/src/Magnum/Math/Matrix3.h
@ -213,8 +213,8 @@ template<class T> class Matrix3: public Matrix3x3<T> {
        /** @copydoc Matrix::Matrix(ZeroInitT) */
        constexpr explicit Matrix3(ZeroInitT) noexcept: Matrix3x3<T>{ZeroInit} {}

-        /** @copydoc Matrix::Matrix(NoInitT) */
-        constexpr explicit Matrix3(NoInitT) noexcept: Matrix3x3<T>{NoInit} {}
+        /** @copydoc Matrix::Matrix(Magnum::NoInitT) */
+        constexpr explicit Matrix3(Magnum::NoInitT) noexcept: Matrix3x3<T>{Magnum::NoInit} {}

        /** @brief Construct from column vectors */
        constexpr /*implicit*/ Matrix3(const Vector3<T>& first, const Vector3<T>& second, const Vector3<T>& third) noexcept: Matrix3x3<T>(first, second, third) {}
--- a/src/Magnum/Math/Matrix4.h
+++ b/src/Magnum/Math/Matrix4.h
@ -447,8 +447,8 @@ template<class T> class Matrix4: public Matrix4x4<T> {
        /** @copydoc Matrix::Matrix(ZeroInitT) */
        constexpr explicit Matrix4(ZeroInitT) noexcept: Matrix4x4<T>{ZeroInit} {}

-        /** @copydoc Matrix::Matrix(NoInitT) */
-        constexpr explicit Matrix4(NoInitT) noexcept: Matrix4x4<T>{NoInit} {}
+        /** @copydoc Matrix::Matrix(Magnum::NoInitT) */
+        constexpr explicit Matrix4(Magnum::NoInitT) noexcept: Matrix4x4<T>{Magnum::NoInit} {}

        /** @brief Construct from column vectors */
        constexpr /*implicit*/ Matrix4(const Vector4<T>& first, const Vector4<T>& second, const Vector4<T>& third, const Vector4<T>& fourth) noexcept: Matrix4x4<T>(first, second, third, fourth) {}
--- a/src/Magnum/Math/Packing.h
+++ b/src/Magnum/Math/Packing.h
@ -99,7 +99,7 @@ template<class FloatingPoint, class Integral, UnsignedInt bits = sizeof(Integral
 template<class FloatingPoint, std::size_t size, class Integral, UnsignedInt bits = sizeof(Integral)*8> FloatingPoint unpack(const Vector<size, Integral>& value) {
    static_assert(FloatingPoint::Size == size,
        "return vector type should have the same size as input vector type");
-    FloatingPoint out{NoInit};
+    FloatingPoint out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = unpack<typename FloatingPoint::Type, Integral, bits>(value[i]);
    return out;
@ -148,7 +148,7 @@ template<class Integral, class FloatingPoint, UnsignedInt bits = sizeof(Integral
 template<class Integral, std::size_t size, class FloatingPoint, UnsignedInt bits = sizeof(typename Integral::Type)*8> Integral pack(const Vector<size, FloatingPoint>& value) {
    static_assert(Integral::Size == size,
        "return vector type should have the same size as input vector type");
-    Integral out{NoInit};
+    Integral out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = pack<typename Integral::Type, FloatingPoint, bits>(value[i]);
    return out;
@ -190,7 +190,7 @@ MAGNUM_EXPORT UnsignedShort packHalf(Float value);

 /** @overload */
 template<std::size_t size> Vector<size, UnsignedShort> packHalf(const Vector<size, Float>& value) {
-    Vector<size, UnsignedShort> out{NoInit};
+    Vector<size, UnsignedShort> out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = packHalf(value[i]);
    return out;
@ -211,7 +211,7 @@ MAGNUM_EXPORT Float unpackHalf(UnsignedShort value);

 /** @overload */
 template<std::size_t size> Vector<size, Float> unpackHalf(const Vector<size, UnsignedShort>& value) {
-    Vector<size, Float> out{NoInit};
+    Vector<size, Float> out{Magnum::NoInit};
    for(std::size_t i = 0; i != size; ++i)
        out[i] = unpackHalf(value[i]);
    return out;
--- a/src/Magnum/Math/Quaternion.h
+++ b/src/Magnum/Math/Quaternion.h
@ -318,7 +318,7 @@ template<class T> class Quaternion {
        constexpr explicit Quaternion(ZeroInitT) noexcept: _vector{ZeroInit}, _scalar{T{0}} {}

        /** @brief Construct without initializing the contents */
-        explicit Quaternion(NoInitT) noexcept: _vector{NoInit} {}
+        explicit Quaternion(Magnum::NoInitT) noexcept: _vector{Magnum::NoInit} {}

        /**
         * @brief Construct from a vector and a scalar
@ -783,7 +783,7 @@ template<class T> Vector3<Rad<T>> Quaternion<T>::toEuler() const {
    CORRADE_ASSERT(isNormalized(),
        "Math::Quaternion::toEuler():" << *this << "is not normalized", {});

-    Vector3<Rad<T>> euler{NoInit};
+    Vector3<Rad<T>> euler{Magnum::NoInit};

    Matrix3x3<T> rotMatrix = toMatrix();

--- a/src/Magnum/Math/Range.h
+++ b/src/Magnum/Math/Range.h
@ -111,7 +111,7 @@ template<UnsignedInt dimensions, class T> class Range {
        constexpr explicit Range(ZeroInitT) noexcept: Range<dimensions, T>{ZeroInit, typename std::conditional<dimensions == 1, void*, ZeroInitT*>::type{}} {}

        /** @brief Construct without initializing the contents */
-        explicit Range(NoInitT) noexcept: Range<dimensions, T>{NoInit, typename std::conditional<dimensions == 1, void*, NoInitT*>::type{}} {}
+        explicit Range(Magnum::NoInitT) noexcept: Range<dimensions, T>{Magnum::NoInit, typename std::conditional<dimensions == 1, void*, Magnum::NoInitT*>::type{}} {}

        /** @brief Construct a range from minimal and maximal coordinates */
        constexpr /*implicit*/ Range(const VectorType& min, const VectorType& max) noexcept: _min{min}, _max{max} {}
@ -306,8 +306,8 @@ template<UnsignedInt dimensions, class T> class Range {

        /* Called from Range(NoInit), either using the NoInit constructor (if
           available) or not doing anything */
-        explicit Range(NoInitT, NoInitT*) noexcept: _min{NoInit}, _max{NoInit} {}
-        explicit Range(NoInitT, void*) noexcept {}
+        explicit Range(Magnum::NoInitT, Magnum::NoInitT*) noexcept: _min{Magnum::NoInit}, _max{Magnum::NoInit} {}
+        explicit Range(Magnum::NoInitT, void*) noexcept {}

        /* Called from data(), always returning a T* */
        constexpr const VectorType* dataInternal(void*) const { return &_min; }
@ -373,7 +373,7 @@ template<class T> class Range2D: public Range<2, T> {
        constexpr explicit Range2D(ZeroInitT) noexcept: Range<2, T>{ZeroInit} {}

        /** @copydoc Range(NoInitT) */
-        explicit Range2D(NoInitT) noexcept: Range<2, T>{NoInit} {}
+        explicit Range2D(Magnum::NoInitT) noexcept: Range<2, T>{Magnum::NoInit} {}

        /** @copydoc Range(const VectorType&, const VectorType&) */
        constexpr /*implicit*/ Range2D(const Vector2<T>& min, const Vector2<T>& max) noexcept: Range<2, T>(min, max) {}
@ -526,8 +526,8 @@ template<class T> class Range3D: public Range<3, T> {
        /** @copydoc Range(ZeroInitT) */
        constexpr explicit Range3D(ZeroInitT) noexcept: Range<3, T>{ZeroInit} {}

-        /** @brief @copybrief Range(NoInitT) */
-        explicit Range3D(NoInitT) noexcept: Range<3, T>{NoInit} {}
+        /** @brief @copybrief Range(Magnum::NoInitT) */
+        explicit Range3D(Magnum::NoInitT) noexcept: Range<3, T>{Magnum::NoInit} {}

        /** @copydoc Range(const VectorType&, const VectorType&) */
        constexpr /*implicit*/ Range3D(const Vector3<T>& min, const Vector3<T>& max) noexcept: Range<3, T>(min, max) {}
--- a/src/Magnum/Math/RectangularMatrix.h
+++ b/src/Magnum/Math/RectangularMatrix.h
@ -128,7 +128,7 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
        constexpr explicit RectangularMatrix(ZeroInitT) noexcept: RectangularMatrix<cols, rows, T>{typename Implementation::GenerateSequence<cols>::Type{}, ZeroInit} {}

        /** @brief Construct without initializing the contents */
-        explicit RectangularMatrix(NoInitT) noexcept: RectangularMatrix<cols, rows, T>{typename Implementation::GenerateSequence<cols>::Type{}, NoInit} {}
+        explicit RectangularMatrix(Magnum::NoInitT) noexcept: RectangularMatrix<cols, rows, T>{typename Implementation::GenerateSequence<cols>::Type{}, Magnum::NoInit} {}

        /** @brief Construct from column vectors */
        template<class ...U> constexpr /*implicit*/ RectangularMatrix(const Vector<rows, T>& first, const U&... next) noexcept: _data{first, next...} {
@ -579,7 +579,7 @@ template<std::size_t cols, std::size_t rows, class T> inline RectangularMatrix<c
    #endif
    scalar, const RectangularMatrix<cols, rows, T>& matrix)
 {
-    RectangularMatrix<cols, rows, T> out{NoInit};
+    RectangularMatrix<cols, rows, T> out{Magnum::NoInit};

    for(std::size_t i = 0; i != cols; ++i)
        out[i] = scalar/matrix[i];
@ -764,7 +764,7 @@ template<std::size_t cols, std::size_t rows, class T> template<std::size_t size>
 }

 template<std::size_t cols, std::size_t rows, class T> inline RectangularMatrix<rows, cols, T> RectangularMatrix<cols, rows, T>::transposed() const {
-    RectangularMatrix<rows, cols, T> out{NoInit};
+    RectangularMatrix<rows, cols, T> out{Magnum::NoInit};

    /* Using ._data[] instead of [] to avoid function call indirection
       on debug builds (saves a lot, yet doesn't obfuscate too much) */
--- a/src/Magnum/Math/Tags.h
+++ b/src/Magnum/Math/Tags.h
@ -26,20 +26,26 @@
 */

 /** @file
- * @brief Tag type @ref Magnum::Math::NoInitT, @ref Magnum::Math::ZeroInitT, @ref Magnum::Math::IdentityInitT, tag @ref Magnum::Math::NoInit, @ref Magnum::Math::ZeroInit, @ref Magnum::Math::IdentityInit
+ * @brief Tag type @ref Magnum::Math::ZeroInitT, @ref Magnum::Math::IdentityInitT, tag @ref Magnum::Math::ZeroInit, @ref Magnum::Math::IdentityInit
 */

 #include <Corrade/Containers/Tags.h>

+#include "Magnum/Tags.h"
+
+#ifdef MAGNUM_BUILD_DEPRECATED
+#include <Corrade/Utility/Macros.h>
+#endif
+
 namespace Magnum { namespace Math {

+#ifdef MAGNUM_BUILD_DEPRECATED
 /**
@brief No initialization tag type
-
-Used to distinguish construction with no initialization at all.
-@see @ref NoInit
+@m_deprecated_since_latest Use @ref Magnum::NoInitT instead.
 */
-typedef Corrade::Containers::NoInitT NoInitT;
+typedef CORRADE_DEPRECATED("use Magnum::NoInitT instead") Magnum::NoInitT NoInitT;
+#endif

 /**
@brief Zero initialization tag type
@ -69,16 +75,14 @@ struct IdentityInitT {
    #endif
 };

+#ifdef MAGNUM_BUILD_DEPRECATED
 /**
@brief No initialization tag
-
-Use for construction with no initialization at all.
+@m_deprecated_since_latest Use @ref Magnum::NoInit instead.
 */
-#ifdef DOXYGEN_GENERATING_OUTPUT
+/** @todo when removing, clean up all Magnum::NoInit in Math to be NoInit again */
 /* Explicit constructor to avoid ambiguous calls when using {} */
-constexpr NoInitT NoInit{};
-#else
-using Corrade::Containers::NoInit;
+constexpr CORRADE_DEPRECATED("use Magnum::NoInit instead") Magnum::NoInitT NoInit{Magnum::NoInitT::Init{}};
 #endif

 /**
--- a/src/Magnum/Math/Test/AngleTest.cpp
+++ b/src/Magnum/Math/Test/AngleTest.cpp
@ -179,8 +179,8 @@ void AngleTest::constructDefault() {
 void AngleTest::constructNoInit() {
    Deg a{25.0f};
    Rad b{3.14f};
-    new(&a) Deg{NoInit};
-    new(&b) Rad{NoInit};
+    new(&a) Deg{Magnum::NoInit};
+    new(&b) Rad{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601
        /* The warning is reported for both debug and release build */
@ -197,12 +197,12 @@ void AngleTest::constructNoInit() {
        #endif
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<Deg, NoInitT>::value));
-    CORRADE_VERIFY((std::is_nothrow_constructible<Rad, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Deg, Magnum::NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Rad, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Deg>::value));
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Rad>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Deg>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Rad>::value));
 }

 void AngleTest::constructConversion() {
--- a/src/Magnum/Math/Test/BezierTest.cpp
+++ b/src/Magnum/Math/Test/BezierTest.cpp
@ -139,7 +139,7 @@ void BezierTest::constructDefault() {

 void BezierTest::constructNoInit() {
    QuadraticBezier2D a{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}};
-    new(&a) QuadraticBezier2D{NoInit};
+    new(&a) QuadraticBezier2D{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -147,10 +147,10 @@ void BezierTest::constructNoInit() {
        CORRADE_COMPARE(a, (QuadraticBezier2D{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}}));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<QuadraticBezier2D, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<QuadraticBezier2D, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, QuadraticBezier2D>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, QuadraticBezier2D>::value));
 }

 void BezierTest::constructConversion() {
--- a/src/Magnum/Math/Test/BoolVectorTest.cpp
+++ b/src/Magnum/Math/Test/BoolVectorTest.cpp
@ -136,7 +136,7 @@ void BoolVectorTest::constructDefault() {

 void BoolVectorTest::constructNoInit() {
    BoolVector19 a{0xa5, 0x5f, 0x07};
-    new(&a) BoolVector19{NoInit};
+    new(&a) BoolVector19{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -144,10 +144,10 @@ void BoolVectorTest::constructNoInit() {
        CORRADE_COMPARE(a, BoolVector19(0xa5, 0x5f, 0x07));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<BoolVector19, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<BoolVector19, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, BoolVector19>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, BoolVector19>::value));
 }

 void BoolVectorTest::constructOneValue() {
--- a/src/Magnum/Math/Test/ColorTest.cpp
+++ b/src/Magnum/Math/Test/ColorTest.cpp
@ -331,8 +331,8 @@ void ColorTest::constructDefault() {
 void ColorTest::constructNoInit() {
    Color3 a{1.0f, 0.5f, 0.75f};
    Color4 b{1.0f, 0.5f, 0.75f, 0.5f};
-    new(&a) Color3{NoInit};
-    new(&b) Color4{NoInit};
+    new(&a) Color3{Magnum::NoInit};
+    new(&b) Color4{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -341,12 +341,12 @@ void ColorTest::constructNoInit() {
        CORRADE_COMPARE(b, (Color4{1.0f, 0.5f, 0.75f, 0.5f}));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<Color3, NoInitT>::value));
-    CORRADE_VERIFY((std::is_nothrow_constructible<Color4, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Color3, Magnum::NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Color4, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Color3>::value));
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Color4>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Color3>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Color4>::value));
 }

 void ColorTest::constructOneValue() {
@ -508,7 +508,7 @@ void ColorTest::constructHsvDefault() {

 void ColorTest::constructHsvNoInit() {
    ColorHsv a{135.0_degf, 0.5f, 0.9f};
-    new(&a) ColorHsv{NoInit};
+    new(&a) ColorHsv{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -516,10 +516,10 @@ void ColorTest::constructHsvNoInit() {
        CORRADE_COMPARE(a, (ColorHsv{135.0_degf, 0.5f, 0.9f}));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<ColorHsv, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<ColorHsv, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, ColorHsv>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, ColorHsv>::value));
 }

 void ColorTest::constructHsvConversion() {
--- a/src/Magnum/Math/Test/ComplexTest.cpp
+++ b/src/Magnum/Math/Test/ComplexTest.cpp
@ -204,7 +204,7 @@ void ComplexTest::constructZero() {

 void ComplexTest::constructNoInit() {
    Complex a{0.5f, -3.7f};
-    new(&a) Complex{NoInit};
+    new(&a) Complex{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -212,10 +212,10 @@ void ComplexTest::constructNoInit() {
        CORRADE_COMPARE(a, Complex(0.5f, -3.7f));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<Complex, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Complex, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Complex>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Complex>::value));
 }

 void ComplexTest::constructFromVector() {
--- a/src/Magnum/Math/Test/CubicHermiteTest.cpp
+++ b/src/Magnum/Math/Test/CubicHermiteTest.cpp
@ -431,7 +431,7 @@ void CubicHermiteTest::constructIdentityQuaternion() {

 void CubicHermiteTest::constructNoInitScalar() {
    CubicHermite1D spline{2.0f, -2.0f, -0.5f};
-    new(&spline) CubicHermite1D{NoInit};
+    new(&spline) CubicHermite1D{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -439,15 +439,15 @@ void CubicHermiteTest::constructNoInitScalar() {
        CORRADE_COMPARE(spline, (CubicHermite1D{2.0f, -2.0f, -0.5f}));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermite1D, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermite1D, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, CubicHermite1D>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, CubicHermite1D>::value));
 }

 void CubicHermiteTest::constructNoInitVector() {
    CubicHermite2D spline{{1.0f, 2.0f}, {1.5f, -2.0f}, {3.0f, -0.5f}};
-    new(&spline) CubicHermite2D{NoInit};
+    new(&spline) CubicHermite2D{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -455,15 +455,15 @@ void CubicHermiteTest::constructNoInitVector() {
        CORRADE_COMPARE(spline, (CubicHermite2D{{1.0f, 2.0f}, {1.5f, -2.0f}, {3.0f, -0.5f}}));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermite2D, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermite2D, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, CubicHermite2D>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, CubicHermite2D>::value));
 }

 void CubicHermiteTest::constructNoInitComplex() {
    CubicHermiteComplex spline{{1.0f, 2.0f}, {1.5f, -2.0f}, {3.0f, -0.5f}};
-    new(&spline) CubicHermiteComplex{NoInit};
+    new(&spline) CubicHermiteComplex{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -471,10 +471,10 @@ void CubicHermiteTest::constructNoInitComplex() {
        CORRADE_COMPARE(spline, (CubicHermiteComplex{{1.0f, 2.0f}, {1.5f, -2.0f}, {3.0f, -0.5f}}));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteComplex, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteComplex, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, CubicHermiteComplex>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, CubicHermiteComplex>::value));
 }

 void CubicHermiteTest::constructNoInitQuaternion() {
@ -482,7 +482,7 @@ void CubicHermiteTest::constructNoInitQuaternion() {
        {{1.0f, 2.0f, -1.0f}, 3.0f},
        {{1.5f, -2.0f, 0.1f}, 1.1f},
        {{3.0f, -0.5f, 1.2f}, 0.3f}};
-    new(&spline) CubicHermiteQuaternion{NoInit};
+    new(&spline) CubicHermiteQuaternion{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -493,10 +493,10 @@ void CubicHermiteTest::constructNoInitQuaternion() {
            {{3.0f, -0.5f, 1.2f}, 0.3f}}));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteQuaternion, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteQuaternion, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, CubicHermiteQuaternion>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, CubicHermiteQuaternion>::value));
 }

 void CubicHermiteTest::constructConversionScalar() {
--- a/src/Magnum/Math/Test/DualComplexTest.cpp
+++ b/src/Magnum/Math/Test/DualComplexTest.cpp
@ -195,7 +195,7 @@ void DualComplexTest::constructZero() {

 void DualComplexTest::constructNoInit() {
    DualComplex a{{-1.0f, 2.5f}, {3.0f, -7.5f}};
-    new(&a) DualComplex{NoInit};
+    new(&a) DualComplex{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -203,10 +203,10 @@ void DualComplexTest::constructNoInit() {
        CORRADE_COMPARE(a, DualComplex({-1.0f, 2.5f}, {3.0f, -7.5f}));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<DualComplex, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<DualComplex, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, DualComplex>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, DualComplex>::value));
 }

 void DualComplexTest::constructFromVector() {
--- a/src/Magnum/Math/Test/DualQuaternionTest.cpp
+++ b/src/Magnum/Math/Test/DualQuaternionTest.cpp
@ -224,7 +224,7 @@ void DualQuaternionTest::constructZero() {

 void DualQuaternionTest::constructNoInit() {
    DualQuaternion a{{{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.1f, 3.3f}, 2.0f}};
-    new(&a) DualQuaternion{NoInit};
+    new(&a) DualQuaternion{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -232,10 +232,10 @@ void DualQuaternionTest::constructNoInit() {
        CORRADE_COMPARE(a, DualQuaternion({{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.1f, 3.3f}, 2.0f}));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<DualQuaternion, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<DualQuaternion, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, DualQuaternion>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, DualQuaternion>::value));
 }

 void DualQuaternionTest::constructFromVector() {
--- a/src/Magnum/Math/Test/DualTest.cpp
+++ b/src/Magnum/Math/Test/DualTest.cpp
@ -147,8 +147,8 @@ void DualTest::constructZero() {
 void DualTest::constructNoInit() {
    Dual a{2.0f, -7.5f};
    Math::Dual<Math::Quaternion<Float>> b{{{3.0f, 0.1f, 1.0f}, 1.0f}, {{0.1f, 0.0f, 1.0f}, 0.3f}};
-    new(&a) Dual{NoInit};
-    new(&b) Math::Dual<Math::Quaternion<Float>>{NoInit};
+    new(&a) Dual{Magnum::NoInit};
+    new(&b) Math::Dual<Math::Quaternion<Float>>{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -157,12 +157,12 @@ void DualTest::constructNoInit() {
        CORRADE_COMPARE(b, (Math::Dual<Math::Quaternion<Float>>{{{3.0f, 0.1f, 1.0f}, 1.0f}, {{0.1f, 0.0f, 1.0f}, 0.3f}}));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<Dual, NoInitT>::value));
-    CORRADE_VERIFY((std::is_nothrow_constructible<Math::Dual<Math::Quaternion<Float>>, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Dual, Magnum::NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Math::Dual<Math::Quaternion<Float>>, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Dual>::value));
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Math::Dual<Math::Quaternion<Float>>>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Dual>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Math::Dual<Math::Quaternion<Float>>>::value));
 }

 void DualTest::constructConversion() {
--- a/src/Magnum/Math/Test/FrustumTest.cpp
+++ b/src/Magnum/Math/Test/FrustumTest.cpp
@ -189,7 +189,7 @@ void FrustumTest::constructNoInit() {
        {-7.0f,  8.0f, -9.0f, 0.5f},
        { 7.0f,  8.0f,  9.0f, 0.6f}};

-    new(&a) Frustum{NoInit};
+    new(&a) Frustum{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -205,7 +205,7 @@ void FrustumTest::constructNoInit() {
    }

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY((std::is_nothrow_constructible<Frustum, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Frustum, Magnum::NoInitT>::value));
 }

 void FrustumTest::constructConversion() {
--- a/src/Magnum/Math/Test/HalfTest.cpp
+++ b/src/Magnum/Math/Test/HalfTest.cpp
@ -542,7 +542,7 @@ void HalfTest::constructData() {

 void HalfTest::constructNoInit() {
    Half a{3.5f};
-    new(&a) Half{NoInit};
+    new(&a) Half{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -550,10 +550,10 @@ void HalfTest::constructNoInit() {
        CORRADE_COMPARE(a, Half{3.5f});
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<Half, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Half, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Half>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Half>::value));
 }

 void HalfTest::constructCopy() {
--- a/src/Magnum/Math/Test/Matrix3Test.cpp
+++ b/src/Magnum/Math/Test/Matrix3Test.cpp
@ -207,7 +207,7 @@ void Matrix3Test::constructNoInit() {
    Matrix3 a{{3.0f,  5.0f, 8.0f},
              {4.5f,  4.0f, 7.0f},
              {7.9f, -1.0f, 8.0f}};
-    new(&a) Matrix3{NoInit};
+    new(&a) Matrix3{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -217,10 +217,10 @@ void Matrix3Test::constructNoInit() {
                                   {7.9f, -1.0f, 8.0f}));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Matrix3>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Matrix3>::value));
 }

 void Matrix3Test::constructOneValue() {
--- a/src/Magnum/Math/Test/Matrix4Test.cpp
+++ b/src/Magnum/Math/Test/Matrix4Test.cpp
@ -248,7 +248,7 @@ void Matrix4Test::constructNoInit() {
                 {4.5f,  4.0f, 7.0f,  2.0f},
                 {1.0f,  2.0f, 3.0f, -1.0f},
                 {7.9f, -1.0f, 8.0f, -1.5f}};
-    new(&a) Matrix4{NoInit};
+    new(&a) Matrix4{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -259,10 +259,10 @@ void Matrix4Test::constructNoInit() {
                                   {7.9f, -1.0f, 8.0f, -1.5f}));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Matrix4>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Matrix4>::value));
 }

 void Matrix4Test::constructOneValue() {
--- a/src/Magnum/Math/Test/MatrixTest.cpp
+++ b/src/Magnum/Math/Test/MatrixTest.cpp
@ -186,7 +186,7 @@ void MatrixTest::constructNoInit() {
                Vector4(4.5f,  4.0f, 7.0f,  2.0f),
                Vector4(1.0f,  2.0f, 3.0f, -1.0f),
                Vector4(7.9f, -1.0f, 8.0f, -1.5f)};
-    new(&a) Matrix4x4{NoInit};
+    new(&a) Matrix4x4{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -197,10 +197,10 @@ void MatrixTest::constructNoInit() {
                                     Vector4(7.9f, -1.0f, 8.0f, -1.5f)));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4x4, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4x4, Magnum::NoInitT>::value));

        /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Matrix4x4>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Matrix4x4>::value));
 }

 void MatrixTest::constructOneValue() {
--- a/src/Magnum/Math/Test/QuaternionTest.cpp
+++ b/src/Magnum/Math/Test/QuaternionTest.cpp
@ -247,7 +247,7 @@ void QuaternionTest::constructZero() {

 void QuaternionTest::constructNoInit() {
    Quaternion a{{1.0f, 2.0f, 3.0f}, -4.0f};
-    new(&a) Quaternion{NoInit};
+    new(&a) Quaternion{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -255,10 +255,10 @@ void QuaternionTest::constructNoInit() {
        CORRADE_COMPARE(a, Quaternion({1.0f, 2.0f, 3.0f}, -4.0f));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<Quaternion, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Quaternion, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Quaternion>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Quaternion>::value));
 }

 void QuaternionTest::constructFromVector() {
--- a/src/Magnum/Math/Test/RangeTest.cpp
+++ b/src/Magnum/Math/Test/RangeTest.cpp
@ -243,9 +243,9 @@ void RangeTest::constructNoInit() {
    Range2Di b{{3, 5}, {23, 78}};
    Range3Di c{{3, 5, -7}, {23, 78, 2}};

-    new(&a) Range1Di{NoInit};
-    new(&b) Range2Di{NoInit};
-    new(&c) Range3Di{NoInit};
+    new(&a) Range1Di{Magnum::NoInit};
+    new(&b) Range2Di{Magnum::NoInit};
+    new(&c) Range3Di{Magnum::NoInit};

    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
@ -256,14 +256,14 @@ void RangeTest::constructNoInit() {
        CORRADE_COMPARE(c, (Range3Di{{3, 5, -7}, {23, 78, 2}}));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<Range1Di, NoInitT>::value));
-    CORRADE_VERIFY((std::is_nothrow_constructible<Range2Di, NoInitT>::value));
-    CORRADE_VERIFY((std::is_nothrow_constructible<Range3Di, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Range1Di, Magnum::NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Range2Di, Magnum::NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Range3Di, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Range1Di>::value));
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Range2Di>::value));
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Range3Di>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Range1Di>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Range2Di>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Range3Di>::value));
 }

 void RangeTest::constructFromSize() {
--- a/src/Magnum/Math/Test/RectangularMatrixTest.cpp
+++ b/src/Magnum/Math/Test/RectangularMatrixTest.cpp
@ -183,7 +183,7 @@ void RectangularMatrixTest::constructNoInit() {
    Matrix3x4 a{Vector4(1.0f,  2.0f,  3.0f,  4.0f),
                Vector4(5.0f,  6.0f,  7.0f,  8.0f),
                Vector4(9.0f, 10.0f, 11.0f, 12.0f)};
-    new(&a) Matrix3x4{NoInit};
+    new(&a) Matrix3x4{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -193,10 +193,10 @@ void RectangularMatrixTest::constructNoInit() {
                                     Vector4(9.0f, 10.0f, 11.0f, 12.0f)));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3x4, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3x4, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Matrix3x4>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Matrix3x4>::value));
 }

 void RectangularMatrixTest::constructOneValue() {
--- a/src/Magnum/Math/Test/TagsTest.cpp
+++ b/src/Magnum/Math/Test/TagsTest.cpp
@ -39,7 +39,6 @@ TagsTest::TagsTest() {
 }

 void TagsTest::noDefaultConstructor() {
-    CORRADE_VERIFY(!std::is_default_constructible<NoInitT>::value);
    CORRADE_VERIFY(!std::is_default_constructible<ZeroInitT>::value);
    CORRADE_VERIFY(!std::is_default_constructible<IdentityInitT>::value);
 }
--- a/src/Magnum/Math/Test/UnitTest.cpp
+++ b/src/Magnum/Math/Test/UnitTest.cpp
@ -94,7 +94,7 @@ void UnitTest::constructDefault() {

 void UnitTest::constructNoInit() {
    Sec a{25.0f};
-    new(&a) Sec{NoInit};
+    new(&a) Sec{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -102,10 +102,10 @@ void UnitTest::constructNoInit() {
        CORRADE_COMPARE(a, Sec{25.0f});
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<Sec, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Sec, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Sec>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Sec>::value));
 }

 void UnitTest::constructConversion() {
--- a/src/Magnum/Math/Test/Vector2Test.cpp
+++ b/src/Magnum/Math/Test/Vector2Test.cpp
@ -125,7 +125,7 @@ void Vector2Test::constructDefault() {

 void Vector2Test::constructNoInit() {
    Vector2 a{1.5f, 2.5f};
-    new(&a) Vector2{NoInit};
+    new(&a) Vector2{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -133,10 +133,10 @@ void Vector2Test::constructNoInit() {
        CORRADE_COMPARE(a, (Vector2{1.5f, 2.5f}));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<Vector2, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Vector2, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Vector2>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Vector2>::value));
 }

 void Vector2Test::constructOneValue() {
--- a/src/Magnum/Math/Test/Vector3Test.cpp
+++ b/src/Magnum/Math/Test/Vector3Test.cpp
@ -125,7 +125,7 @@ void Vector3Test::constructDefault() {

 void Vector3Test::constructNoInit() {
    Vector3 a{1.0f, 2.5f, -3.0f};
-    new(&a) Vector3{NoInit};
+    new(&a) Vector3{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -133,10 +133,10 @@ void Vector3Test::constructNoInit() {
        CORRADE_COMPARE(a, (Vector3{1.0f, 2.5f, -3.0f}));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<Vector3, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Vector3, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Vector3>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Vector3>::value));
 }

 void Vector3Test::constructOneValue() {
--- a/src/Magnum/Math/Test/Vector4Test.cpp
+++ b/src/Magnum/Math/Test/Vector4Test.cpp
@ -146,7 +146,7 @@ void Vector4Test::constructDefault() {

 void Vector4Test::constructNoInit() {
    Vector4 a{1.0f, -2.5f, 3.0f, 4.1f};
-    new(&a) Vector4{NoInit};
+    new(&a) Vector4{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -154,10 +154,10 @@ void Vector4Test::constructNoInit() {
        CORRADE_COMPARE(a, (Vector4{1.0f, -2.5f, 3.0f, 4.1f}));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Vector4>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Vector4>::value));
 }

 void Vector4Test::constructOneValue() {
--- a/src/Magnum/Math/Test/VectorTest.cpp
+++ b/src/Magnum/Math/Test/VectorTest.cpp
@ -239,7 +239,7 @@ void VectorTest::constructDefault() {

 void VectorTest::constructNoInit() {
    Vector4 a{1.0f, 2.0f, -3.0f, 4.5f};
-    new(&a) Vector4{NoInit};
+    new(&a) Vector4{Magnum::NoInit};
    {
        #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
        CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@ -247,10 +247,10 @@ void VectorTest::constructNoInit() {
        CORRADE_COMPARE(a, (Vector4{1.0f, 2.0f, -3.0f, 4.5f}));
    }

-    CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, Magnum::NoInitT>::value));

    /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Vector4>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Vector4>::value));
 }

 void VectorTest::constructOneValue() {
--- a/src/Magnum/Math/Unit.h
+++ b/src/Magnum/Math/Unit.h
@ -57,7 +57,7 @@ template<template<class> class Derived, class T> class Unit {
        constexpr explicit Unit(ZeroInitT) noexcept: _value(T(0)) {}

        /** @brief Construct without initializing the contents */
-        explicit Unit(NoInitT) noexcept {}
+        explicit Unit(Magnum::NoInitT) noexcept {}

        /** @brief Explicit conversion from a unitless type */
        constexpr explicit Unit(T value) noexcept: _value(value) {}
--- a/src/Magnum/Math/Vector.h
+++ b/src/Magnum/Math/Vector.h
@ -197,7 +197,7 @@ template<std::size_t size, class T> class Vector {
        constexpr explicit Vector(ZeroInitT) noexcept: _data{} {}

        /** @brief Construct a vector without initializing the contents */
-        explicit Vector(NoInitT) noexcept {}
+        explicit Vector(Magnum::NoInitT) noexcept {}

        /** @brief Construct a vector from components */
        #ifdef DOXYGEN_GENERATING_OUTPUT
--- a/src/Magnum/Math/Vector2.h
+++ b/src/Magnum/Math/Vector2.h
@ -112,7 +112,7 @@ template<class T> class Vector2: public Vector<2, T> {
        constexpr explicit Vector2(ZeroInitT) noexcept: Vector<2, T>{ZeroInit} {}

        /** @copydoc Vector::Vector(NoInitT) */
-        explicit Vector2(NoInitT) noexcept: Vector<2, T>{NoInit} {}
+        explicit Vector2(Magnum::NoInitT) noexcept: Vector<2, T>{Magnum::NoInit} {}

        /** @copydoc Vector::Vector(T) */
        constexpr explicit Vector2(T value) noexcept: Vector<2, T>(value) {}
--- a/src/Magnum/Math/Vector3.h
+++ b/src/Magnum/Math/Vector3.h
@ -129,7 +129,7 @@ template<class T> class Vector3: public Vector<3, T> {
        constexpr explicit Vector3(ZeroInitT) noexcept: Vector<3, T>{ZeroInit} {}

        /** @copydoc Vector::Vector(NoInitT) */
-        explicit Vector3(NoInitT) noexcept: Vector<3, T>{NoInit} {}
+        explicit Vector3(Magnum::NoInitT) noexcept: Vector<3, T>{Magnum::NoInit} {}

        /** @copydoc Vector::Vector(T) */
        constexpr explicit Vector3(T value) noexcept: Vector<3, T>(value) {}
--- a/src/Magnum/Math/Vector4.h
+++ b/src/Magnum/Math/Vector4.h
@ -73,11 +73,11 @@ template<class T> class Vector4: public Vector<4, T> {
           fire! FFS. */
        constexpr explicit Vector4(ZeroInitT) noexcept: Vector<4, T>{ZeroInit} {}

-        /** @copydoc Magnum::Math::Vector::Vector(NoInitT) */
+        /** @copydoc Magnum::Math::Vector::Vector(Magnum::NoInitT) */
        /* For some freaking reason doxygen 1.8.17 needs a fully qualified name
           here but GUESS WHAT! Not in the other Vector2/3 classes! Dumpster
           fire! FFS. */
-        explicit Vector4(NoInitT) noexcept: Vector<4, T>{NoInit} {}
+        explicit Vector4(Magnum::NoInitT) noexcept: Vector<4, T>{Magnum::NoInit} {}

        /** @copydoc Magnum::Math::Vector::Vector(T) */
        /* For some freaking reason doxygen 1.8.17 needs a fully qualified name
--- a/src/Magnum/MeshTools/GenerateNormals.cpp
+++ b/src/Magnum/MeshTools/GenerateNormals.cpp
@ -147,7 +147,7 @@ template<class T> inline void generateSmoothNormalsIntoImplementation(const Cont
    /* Precalculate cross product and interior angles of each face --- the loop
       below would otherwise calculate it for every vertex, which is at least
       3x as much work */
-    Containers::Array<std::pair<Vector3, Math::Vector3<Rad>>> crossAngles{Math::NoInit, indices.size()/3};
+    Containers::Array<std::pair<Vector3, Math::Vector3<Rad>>> crossAngles{NoInit, indices.size()/3};
    for(std::size_t i = 0; i != crossAngles.size(); ++i) {
        const Vector3 v0 = positions[indices[i*3 + 0]];
        const Vector3 v1 = positions[indices[i*3 + 1]];
--- a/src/Magnum/Tags.h
+++ b/src/Magnum/Tags.h
@ -26,18 +26,29 @@
 */

 /** @file
- * @brief Tag type @ref Magnum::NoCreateT, tag @ref Magnum::NoCreate
+ * @brief Tag type @ref Magnum::NoInitT, @ref Magnum::NoCreateT, tag @ref Magnum::NoInit, @ref Magnum::NoCreate
 */

-#include "Corrade/configure.h"
+#include <Corrade/Containers/Tags.h>
+
 #include "Magnum/configure.h"

 namespace Magnum {

+/**
+@brief No initialization tag type
+@m_since_latest
+
+Used to distinguish construction with no initialization at all.
+@see @ref NoInit
+*/
+typedef Corrade::Containers::NoInitT NoInitT;
+
 /**
@brief No creation tag type

-Used to distinguish construction without creating the underlying OpenGL object.
+Used to distinguish construction without creating the underlying OpenGL /
+Vulkan / ... object.
@see @ref NoCreate
 */
 /* Explicit constructor to avoid ambiguous calls when using {} */
@ -48,14 +59,27 @@ struct NoCreateT {
    #endif
 };

+/**
+@brief No initialization tag
+@m_since_latest
+
+Use for construction with no initialization at all.
+*/
+#ifdef DOXYGEN_GENERATING_OUTPUT
+/* Explicit constructor to avoid ambiguous calls when using {} */
+constexpr NoInitT NoInit{};
+#else
+using Corrade::Containers::NoInit;
+#endif
+
 /**
@brief No creation tag

-Use for construction without creating the underlying OpenGL object. Note that
-calling anything on objects created this way is not defined (and not checked or
-guarded in any way) and may result in crashes. If you want delayed object
-creation with safety checks (however with some extra memory overhead), wrap
-the objects in an @ref Corrade::Containers::Optional.
+Use for construction without creating the underlying OpenGL / Vulkan / ...
+object. Note that calling anything on objects created this way is not defined
+(and not checked or guarded in any way) and may result in crashes. If you want
+delayed object creation with safety checks (however with some extra memory
+overhead), wrap the objects in an @ref Corrade::Containers::Optional.
 */
 constexpr NoCreateT NoCreate{NoCreateT::Init{}};

--- a/src/Magnum/Test/TagsTest.cpp
+++ b/src/Magnum/Test/TagsTest.cpp
@ -41,6 +41,7 @@ TagsTest::TagsTest() {
 }

 void TagsTest::noDefaultConstructor() {
+    CORRADE_VERIFY(!std::is_default_constructible<NoInitT>::value);
    CORRADE_VERIFY(!std::is_default_constructible<NoCreateT>::value);
 }