diff --git a/src/Magnum/AbstractResourceLoader.h b/src/Magnum/AbstractResourceLoader.h
index 5d84979ed..051aed47c 100644
--- a/src/Magnum/AbstractResourceLoader.h
+++ b/src/Magnum/AbstractResourceLoader.h
@@ -152,7 +152,11 @@ template<class T> class AbstractResourceLoader {
         }
 
         /** @overload */
-        template<class U, class = typename std::enable_if<!std::is_same<typename std::decay<U>::type, std::nullptr_t>::value>::type> void set(ResourceKey key, U&& data, ResourceDataState state, ResourcePolicy policy) {
+        template<class U
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<!std::is_same<typename std::decay<U>::type, std::nullptr_t>::value, int>::type = 0
+            #endif
+        > void set(ResourceKey key, U&& data, ResourceDataState state, ResourcePolicy policy) {
             set(key, new typename std::decay<U>::type(std::forward<U>(data)), state, policy);
         }
 
@@ -172,7 +176,11 @@ template<class T> class AbstractResourceLoader {
         }
 
         /** @overload */
-        template<class U, class = typename std::enable_if<!std::is_same<typename std::decay<U>::type, std::nullptr_t>::value>::type> void set(ResourceKey key, U&& data) {
+        template<class U
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<!std::is_same<typename std::decay<U>::type, std::nullptr_t>::value, int>::type = 0
+            #endif
+        > void set(ResourceKey key, U&& data) {
             set(key, new typename std::decay<U>::type(std::forward<U>(data)));
         }
 
diff --git a/src/Magnum/Animation/Track.h b/src/Magnum/Animation/Track.h
index 34f97ca31..f8fe1001d 100644
--- a/src/Magnum/Animation/Track.h
+++ b/src/Magnum/Animation/Track.h
@@ -734,7 +734,11 @@ template<class K, class V, class R
         /** @brief Convert a mutable view to a const one */
         /* This is the only variant that works on MSVC 2015, std::remove_const
            in the signature didn't work there */
-        template<class K2, class V2, class = typename std::enable_if<std::is_same<const K2, K>::value && std::is_same<const V2, V>::value>::type> /*implicit*/ TrackView(const TrackView<K2, V2, R>& other) noexcept: TrackViewStorage<K>{other._keys, other._values, other._interpolation, other._interpolator, other._before, other._after} {}
+        template<class K2, class V2
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<std::is_same<const K2, K>::value && std::is_same<const V2, V>::value, int>::type = 0
+            #endif
+        > /*implicit*/ TrackView(const TrackView<K2, V2, R>& other) noexcept: TrackViewStorage<K>{other._keys, other._values, other._interpolation, other._interpolator, other._before, other._after} {}
 
         /**
          * @brief Interpolation function
diff --git a/src/Magnum/Array.h b/src/Magnum/Array.h
index 636f1eac2..deb0e95c3 100644
--- a/src/Magnum/Array.h
+++ b/src/Magnum/Array.h
@@ -82,11 +82,11 @@ template<UnsignedInt dimensions, class T> class CORRADE_DEPRECATED("use Math::Ve
          * @param first     First value
          * @param next      Next values
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        template<class ...U> constexpr /*implicit*/ Array(T first, U... next);
-        #else
-        template<class ...U, class V = typename std::enable_if<sizeof...(U)+1 == dimensions, T>::type> constexpr /*implicit*/ Array(T first, U... next): _data{first, next...} {}
-        #endif
+        template<class ...U
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<sizeof...(U)+1 == dimensions, int>::type = 0
+            #endif
+        > constexpr /*implicit*/ Array(T first, U... next): _data{first, next...} {}
 
         /** @brief Construct array with one value for all fields */
         #ifdef DOXYGEN_GENERATING_OUTPUT
@@ -95,8 +95,7 @@ template<UnsignedInt dimensions, class T> class CORRADE_DEPRECATED("use Math::Ve
         #ifdef CORRADE_TARGET_MSVC /* MSVC warns for the constructor delegation */
         CORRADE_IGNORE_DEPRECATED_PUSH
         #endif
-        template<class U, class V = typename std::enable_if<std::is_same<T, U>::value && dimensions != 1, T>::type>
-        constexpr /*implicit*/ Array(U value): Array(typename Containers::Implementation::GenerateSequence<dimensions>::Type{}, value) {}
+        template<class U, typename std::enable_if<std::is_same<T, U>::value && dimensions != 1, int>::type = 0> constexpr /*implicit*/ Array(U value): Array(typename Containers::Implementation::GenerateSequence<dimensions>::Type{}, value) {}
         #ifdef CORRADE_TARGET_MSVC
         CORRADE_IGNORE_DEPRECATED_POP
         #endif
diff --git a/src/Magnum/GL/Attribute.h b/src/Magnum/GL/Attribute.h
index 6700c64a9..3a59f9861 100644
--- a/src/Magnum/GL/Attribute.h
+++ b/src/Magnum/GL/Attribute.h
@@ -786,18 +786,18 @@ MAGNUM_GL_EXPORT bool hasVertexFormat(Magnum::VertexFormat format);
 
 namespace Implementation {
 
-template<UnsignedInt location, class T> constexpr DynamicAttribute::Kind kindFor(typename std::enable_if<std::is_same<typename Implementation::Attribute<T>::ScalarType, Float>::value, typename GL::Attribute<location, T>::DataOptions>::type options) {
+template<UnsignedInt location, class T, typename std::enable_if<std::is_same<typename Implementation::Attribute<T>::ScalarType, Float>::value, int>::type = 0> constexpr DynamicAttribute::Kind kindFor(typename GL::Attribute<location, T>::DataOptions options) {
     return options & GL::Attribute<location, T>::DataOption::Normalized ?
         DynamicAttribute::Kind::GenericNormalized : DynamicAttribute::Kind::Generic;
 }
 
 #ifndef MAGNUM_TARGET_GLES2
-template<UnsignedInt location, class T> constexpr DynamicAttribute::Kind kindFor(typename std::enable_if<std::is_integral<typename Implementation::Attribute<T>::ScalarType>::value, typename GL::Attribute<location, T>::DataOptions>::type) {
+template<UnsignedInt location, class T, typename std::enable_if<std::is_integral<typename Implementation::Attribute<T>::ScalarType>::value, int>::type = 0> constexpr DynamicAttribute::Kind kindFor(typename GL::Attribute<location, T>::DataOptions) {
     return DynamicAttribute::Kind::Integral;
 }
 
 #ifndef MAGNUM_TARGET_GLES
-template<UnsignedInt location, class T> constexpr DynamicAttribute::Kind kindFor(typename std::enable_if<std::is_same<typename Implementation::Attribute<T>::ScalarType, Double>::value, typename GL::Attribute<location, T>::DataOptions>::type) {
+template<UnsignedInt location, class T, typename std::enable_if<std::is_same<typename Implementation::Attribute<T>::ScalarType, Double>::value, int>::type = 0> constexpr DynamicAttribute::Kind kindFor(typename GL::Attribute<location, T>::DataOptions) {
     return DynamicAttribute::Kind::Long;
 }
 #endif
diff --git a/src/Magnum/GL/Context.h b/src/Magnum/GL/Context.h
index b4ababbab..5f7f95104 100644
--- a/src/Magnum/GL/Context.h
+++ b/src/Magnum/GL/Context.h
@@ -109,7 +109,11 @@ class MAGNUM_GL_EXPORT Extension {
         constexpr const char* string() const { return _string; }
 
         /** @brief Construct from a compile-time extension */
-        template<class E, class = typename std::enable_if<Implementation::IsExtension<E>::value>::type> constexpr /*implicit*/ Extension(const E&): _index{E::Index}, _requiredVersion{E::requiredVersion()}, _coreVersion{E::coreVersion()}, _string{E::string()} {}
+        template<class E
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<Implementation::IsExtension<E>::value, int>::type = 0
+            #endif
+        > constexpr /*implicit*/ Extension(const E&): _index{E::Index}, _requiredVersion{E::requiredVersion()}, _coreVersion{E::coreVersion()}, _string{E::string()} {}
 
     private:
         std::size_t _index;
diff --git a/src/Magnum/GL/Mesh.h b/src/Magnum/GL/Mesh.h
index 9595dd515..3c8afb41a 100644
--- a/src/Magnum/GL/Mesh.h
+++ b/src/Magnum/GL/Mesh.h
@@ -911,7 +911,7 @@ class MAGNUM_GL_EXPORT Mesh: public AbstractObject {
         template<class ...T
             #ifndef DOXYGEN_GENERATING_OUTPUT
             /* So it doesn't clash with the DynamicAttribute overload */
-            , class = typename std::enable_if<!Implementation::IsDynamicAttribute<T...>::value>::type
+            , typename std::enable_if<!Implementation::IsDynamicAttribute<T...>::value, int>::type = 0
             #endif
         > Mesh& addVertexBuffer(Buffer& buffer, GLintptr offset, const T&... attributes) {
             addVertexBufferInternal(buffer, offset, strideOfInterleaved(attributes...), 0, attributes...);
@@ -952,7 +952,7 @@ class MAGNUM_GL_EXPORT Mesh: public AbstractObject {
         template<class ...T
             #ifndef DOXYGEN_GENERATING_OUTPUT
             /* So it doesn't clash with the DynamicAttribute overload */
-            , class = typename std::enable_if<!Implementation::IsDynamicAttribute<T...>::value>::type
+            , typename std::enable_if<!Implementation::IsDynamicAttribute<T...>::value, int>::type = 0
             #endif
         > Mesh& addVertexBufferInstanced(Buffer& buffer, UnsignedInt divisor, GLintptr offset, const T&... attributes) {
             addVertexBufferInternal(buffer, offset, strideOfInterleaved(attributes...), divisor, attributes...);
@@ -996,7 +996,7 @@ class MAGNUM_GL_EXPORT Mesh: public AbstractObject {
         template<class ...T
             #ifndef DOXYGEN_GENERATING_OUTPUT
             /* So it doesn't clash with the DynamicAttribute overload */
-            , class = typename std::enable_if<!Implementation::IsDynamicAttribute<T...>::value>::type
+            , typename std::enable_if<!Implementation::IsDynamicAttribute<T...>::value, int>::type = 0
             #endif
         > Mesh& addVertexBuffer(Buffer&& buffer, GLintptr offset, const T&... attributes) {
             addVertexBuffer<T...>(buffer, offset, attributes...);
@@ -1015,7 +1015,7 @@ class MAGNUM_GL_EXPORT Mesh: public AbstractObject {
         template<class ...T
             #ifndef DOXYGEN_GENERATING_OUTPUT
             /* So it doesn't clash with the DynamicAttribute overload */
-            , class = typename std::enable_if<!Implementation::IsDynamicAttribute<T...>::value>::type
+            , typename std::enable_if<!Implementation::IsDynamicAttribute<T...>::value, int>::type = 0
             #endif
         > Mesh& addVertexBufferInstanced(Buffer&& buffer, UnsignedInt divisor, GLintptr offset, const T&... attributes) {
             addVertexBufferInstanced<T...>(buffer, divisor, offset, attributes...);
@@ -1224,7 +1224,7 @@ class MAGNUM_GL_EXPORT Mesh: public AbstractObject {
         }
         void addVertexBufferInternal(Buffer&, GLintptr, GLsizei, GLuint) {}
 
-        template<UnsignedInt location, class T> void addVertexAttribute(typename std::enable_if<std::is_same<typename Implementation::Attribute<T>::ScalarType, Float>::value, Buffer&>::type buffer, const Attribute<location, T>& attribute, GLintptr offset, GLsizei stride, GLuint divisor) {
+        template<UnsignedInt location, class T, typename std::enable_if<std::is_same<typename Implementation::Attribute<T>::ScalarType, Float>::value, int>::type = 0> void addVertexAttribute(Buffer& buffer, const Attribute<location, T>& attribute, GLintptr offset, GLsizei stride, GLuint divisor) {
             for(UnsignedInt i = 0; i != Attribute<location, T>::Vectors; ++i)
                 attributePointerInternal(buffer,
                     location+i,
@@ -1237,7 +1237,7 @@ class MAGNUM_GL_EXPORT Mesh: public AbstractObject {
         }
 
         #ifndef MAGNUM_TARGET_GLES2
-        template<UnsignedInt location, class T> void addVertexAttribute(typename std::enable_if<std::is_integral<typename Implementation::Attribute<T>::ScalarType>::value, Buffer&>::type buffer, const Attribute<location, T>& attribute, GLintptr offset, GLsizei stride, GLuint divisor) {
+        template<UnsignedInt location, class T, typename std::enable_if<std::is_integral<typename Implementation::Attribute<T>::ScalarType>::value, int>::type = 0> void addVertexAttribute(Buffer& buffer, const Attribute<location, T>& attribute, GLintptr offset, GLsizei stride, GLuint divisor) {
             attributePointerInternal(buffer,
                 location,
                 GLint(attribute.components()),
@@ -1249,7 +1249,7 @@ class MAGNUM_GL_EXPORT Mesh: public AbstractObject {
         }
 
         #ifndef MAGNUM_TARGET_GLES
-        template<UnsignedInt location, class T> void addVertexAttribute(typename std::enable_if<std::is_same<typename Implementation::Attribute<T>::ScalarType, Double>::value, Buffer&>::type buffer, const Attribute<location, T>& attribute, GLintptr offset, GLsizei stride, GLuint divisor) {
+        template<UnsignedInt location, class T, typename std::enable_if<std::is_same<typename Implementation::Attribute<T>::ScalarType, Double>::value, int>::type = 0> void addVertexAttribute(Buffer& buffer, const Attribute<location, T>& attribute, GLintptr offset, GLsizei stride, GLuint divisor) {
             for(UnsignedInt i = 0; i != Attribute<location, T>::Vectors; ++i)
                 attributePointerInternal(buffer,
                     location+i,
diff --git a/src/Magnum/GL/MultisampleTexture.h b/src/Magnum/GL/MultisampleTexture.h
index a1f8a2040..d1000908b 100644
--- a/src/Magnum/GL/MultisampleTexture.h
+++ b/src/Magnum/GL/MultisampleTexture.h
@@ -165,7 +165,7 @@ MultisampleTexture: public AbstractTexture {
          *      @gl_extension{EXT,texture_view}
          */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 2>::type>
+        template<UnsignedInt d = dimensions, typename std::enable_if<d == 2, int>::type = 0>
         #endif
         static MultisampleTexture<dimensions> view(MultisampleTexture2DArray& original, TextureFormat internalFormat, Int layer);
 
@@ -186,7 +186,7 @@ MultisampleTexture: public AbstractTexture {
          *      @gl_extension{EXT,texture_view}
          */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 3>::type>
+        template<UnsignedInt d = dimensions, typename std::enable_if<d == 3, int>::type = 0>
         #endif
         static MultisampleTexture<dimensions> view(MultisampleTexture2DArray& original, TextureFormat internalFormat, Int layerOffset, Int layerCount);
 
@@ -252,7 +252,7 @@ MultisampleTexture: public AbstractTexture {
          * @requires_gl42 Extension @gl_extension{ARB,shader_image_load_store}
          */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 2>::type>
+        template<UnsignedInt d = dimensions, typename std::enable_if<d == 2, int>::type = 0>
         #endif
         void bindImage(Int imageUnit, ImageAccess access, ImageFormat format) {
             bindImageInternal(imageUnit, 0, false, 0, access, format);
@@ -279,7 +279,7 @@ MultisampleTexture: public AbstractTexture {
          *      multisample 2D array textures.
          */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 3>::type>
+        template<UnsignedInt d = dimensions, typename std::enable_if<d == 3, int>::type = 0>
         #endif
         void bindImage(Int imageUnit, Int layer, ImageAccess access, ImageFormat format) {
             bindImageInternal(imageUnit, 0, false, layer, access, format);
@@ -305,7 +305,7 @@ MultisampleTexture: public AbstractTexture {
          *      multisample 2D array textures.
          */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 3>::type>
+        template<UnsignedInt d = dimensions, typename std::enable_if<d == 3, int>::type = 0>
         #endif
         void bindImageLayered(Int imageUnit, ImageAccess access, ImageFormat format) {
             bindImageInternal(imageUnit, 0, true, 0, access, format);
diff --git a/src/Magnum/GL/Shader.h b/src/Magnum/GL/Shader.h
index c6d2b0ad0..299ba8015 100644
--- a/src/Magnum/GL/Shader.h
+++ b/src/Magnum/GL/Shader.h
@@ -716,8 +716,7 @@ class MAGNUM_GL_EXPORT Shader: public AbstractObject {
         #else
         /* Otherwise passing a char* is ambiguous between this and the
            StringView overload. Sigh, C++. */
-        template<class U, class = typename std::enable_if<std::is_same<U&&, Containers::String&&>::value>::type>
-        Shader& addSource(U&& source) {
+        template<class U, typename std::enable_if<std::is_same<U&&, Containers::String&&>::value, int>::type = 0> Shader& addSource(U&& source) {
             return addSourceInternal(Utility::move(source));
         }
         #endif
diff --git a/src/Magnum/GL/Texture.h b/src/Magnum/GL/Texture.h
index 27da138ba..fb3f46a90 100644
--- a/src/Magnum/GL/Texture.h
+++ b/src/Magnum/GL/Texture.h
@@ -196,7 +196,7 @@ Texture: public AbstractTexture {
          * @requires_gles Texture views are not available in WebGL.
          */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt d = dimensions, class = typename std::enable_if<d <= 2>::type>
+        template<UnsignedInt d = dimensions, typename std::enable_if<d <= 2, int>::type = 0>
         #endif
         static Texture<dimensions> view(TextureArray<dimensions>& original, TextureFormat internalFormat, Int levelOffset, Int levelCount, Int layer);
 
@@ -217,7 +217,7 @@ Texture: public AbstractTexture {
          * @requires_gles Texture views are not available in WebGL.
          */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 2>::type>
+        template<UnsignedInt d = dimensions, typename std::enable_if<d == 2, int>::type = 0>
         #endif
         static Texture<dimensions> view(CubeMapTexture& original, TextureFormat internalFormat, Int levelOffset, Int levelCount, Int layer);
 
@@ -238,7 +238,7 @@ Texture: public AbstractTexture {
          * @requires_gles Texture views are not available in WebGL.
          */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 2>::type>
+        template<UnsignedInt d = dimensions, typename std::enable_if<d == 2, int>::type = 0>
         #endif
         static Texture<dimensions> view(CubeMapTextureArray& original, TextureFormat internalFormat, Int levelOffset, Int levelCount, Int layer);
         #endif
@@ -320,7 +320,7 @@ Texture: public AbstractTexture {
          * @requires_gles Shader image load/store is not available in WebGL.
          */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 1 || d == 2>::type>
+        template<UnsignedInt d = dimensions, typename std::enable_if<d == 1 || d == 2, int>::type = 0>
         #endif
         void bindImage(Int imageUnit, Int level, ImageAccess access, ImageFormat format) {
             bindImageInternal(imageUnit, level, false, 0, access, format);
@@ -348,7 +348,7 @@ Texture: public AbstractTexture {
          * @requires_gles Shader image load/store is not available in WebGL.
          */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 3>::type>
+        template<UnsignedInt d = dimensions, typename std::enable_if<d == 3, int>::type = 0>
         #endif
         void bindImage(Int imageUnit, Int level, Int layer, ImageAccess access, ImageFormat format) {
             bindImageInternal(imageUnit, level, false, layer, access, format);
@@ -375,7 +375,7 @@ Texture: public AbstractTexture {
          * @requires_gles Shader image load/store is not available in WebGL.
          */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 3>::type>
+        template<UnsignedInt d = dimensions, typename std::enable_if<d == 3, int>::type = 0>
         #endif
         void bindImageLayered(Int imageUnit, Int level, ImageAccess access, ImageFormat format) {
             bindImageInternal(imageUnit, level, true, 0, access, format);
diff --git a/src/Magnum/GL/TextureArray.h b/src/Magnum/GL/TextureArray.h
index 652c90518..8219e82ca 100644
--- a/src/Magnum/GL/TextureArray.h
+++ b/src/Magnum/GL/TextureArray.h
@@ -199,7 +199,7 @@ TextureArray: public AbstractTexture {
          * @requires_gles Texture views are not available in WebGL.
          */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 2>::type>
+        template<UnsignedInt d = dimensions, typename std::enable_if<d == 2, int>::type = 0>
         #endif
         static TextureArray<dimensions> view(CubeMapTexture& original, TextureFormat internalFormat, Int levelOffset, Int levelCount, Int layerOffset, Int layerCount);
 
@@ -220,7 +220,7 @@ TextureArray: public AbstractTexture {
          * @requires_gles Texture views are not available in WebGL.
          */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 2>::type>
+        template<UnsignedInt d = dimensions, typename std::enable_if<d == 2, int>::type = 0>
         #endif
         static TextureArray<dimensions> view(CubeMapTextureArray& original, TextureFormat internalFormat, Int levelOffset, Int levelCount, Int layerOffset, Int layerCount);
         #endif
diff --git a/src/Magnum/Image.h b/src/Magnum/Image.h
index e938c38dc..f362ed090 100644
--- a/src/Magnum/Image.h
+++ b/src/Magnum/Image.h
@@ -358,9 +358,9 @@ template<UnsignedInt dimensions> class Image {
         template<class T
             #ifndef DOXYGEN_GENERATING_OUTPUT
             /* Otherwise this catches too much, resulting in weird errors */
-            , class = typename std::enable_if<std::is_enum<T>::value || std::is_integral<T>::value>::type
+            , typename std::enable_if<std::is_enum<T>::value || std::is_integral<T>::value, int>::type = 0
             #endif
-            > /*implicit*/ Image(T format) noexcept: Image{{}, format} {}
+        > /*implicit*/ Image(T format) noexcept: Image{{}, format} {}
 
         /** @brief Copying is not allowed */
         Image(const Image<dimensions>&) = delete;
diff --git a/src/Magnum/ImageView.h b/src/Magnum/ImageView.h
index ce1e9f112..7df1b75a5 100644
--- a/src/Magnum/ImageView.h
+++ b/src/Magnum/ImageView.h
@@ -424,13 +424,21 @@ template<UnsignedInt dimensions, class T> class ImageView {
          * there's no concept of 2D arrays of 1D images. Use the @p flags
          * parameter to add arbitrary other flags.
          */
-        template<UnsignedInt otherDimensions, class = typename std::enable_if<(otherDimensions < dimensions)>::type> /*implicit*/ ImageView(const ImageView<otherDimensions, T>& other, ImageFlags<dimensions> flags = {}) noexcept;
+        template<UnsignedInt otherDimensions
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<(otherDimensions < dimensions), int>::type = 0
+            #endif
+        > /*implicit*/ ImageView(const ImageView<otherDimensions, T>& other, ImageFlags<dimensions> flags = {}) noexcept;
 
         /**
          * @brief Convert a mutable view to a const one
          * @m_since{2019,10}
          */
-        template<class U, class = typename std::enable_if<std::is_const<T>::value && !std::is_const<U>::value>::type> /*implicit*/ ImageView(const ImageView<dimensions, U>& other) noexcept;
+        template<class U
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<std::is_const<T>::value && !std::is_const<U>::value, int>::type = 0
+            #endif
+        > /*implicit*/ ImageView(const ImageView<dimensions, U>& other) noexcept;
 
         /**
          * @brief Layout flags
@@ -830,13 +838,21 @@ template<UnsignedInt dimensions, class T> class CompressedImageView {
          * there's no concept of 2D arrays of 1D images. Use the @p flags
          * parameter to add arbitrary other flags.
          */
-        template<UnsignedInt otherDimensions, class = typename std::enable_if<(otherDimensions < dimensions)>::type> /*implicit*/ CompressedImageView(const CompressedImageView<otherDimensions, T>& other, ImageFlags<dimensions> flags = {}) noexcept;
+        template<UnsignedInt otherDimensions
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<(otherDimensions < dimensions), int>::type = 0
+            #endif
+        > /*implicit*/ CompressedImageView(const CompressedImageView<otherDimensions, T>& other, ImageFlags<dimensions> flags = {}) noexcept;
 
         /**
          * @brief Convert a mutable view to a const one
          * @m_since{2019,10}
          */
-        template<class U, class = typename std::enable_if<std::is_const<T>::value && !std::is_const<U>::value>::type> /*implicit*/ CompressedImageView(const CompressedImageView<dimensions, U>& other) noexcept;
+        template<class U
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<std::is_const<T>::value && !std::is_const<U>::value, int>::type = 0
+            #endif
+        > /*implicit*/ CompressedImageView(const CompressedImageView<dimensions, U>& other) noexcept;
 
         /**
          * @brief Layout flags
@@ -994,8 +1010,8 @@ template<UnsignedInt dimensions, class T> template<class U> inline ImageView<dim
         "format types larger than 32bits are not supported");
 }
 
-#ifndef DOXYGEN_GENERATING_OUTPUT /* it complains otherwise. why? don't know, don't want to know */
-template<UnsignedInt dimensions, class T> template<UnsignedInt otherDimensions, class> ImageView<dimensions, T>::ImageView(const ImageView<otherDimensions, T>& other, const ImageFlags<dimensions> flags) noexcept:
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<UnsignedInt dimensions, class T> template<UnsignedInt otherDimensions, typename std::enable_if<(otherDimensions < dimensions), int>::type> ImageView<dimensions, T>::ImageView(const ImageView<otherDimensions, T>& other, const ImageFlags<dimensions> flags) noexcept:
     _storage{other._storage},
     _format{other._format},
     _formatExtra{other._formatExtra},
@@ -1004,9 +1020,9 @@ template<UnsignedInt dimensions, class T> template<UnsignedInt otherDimensions,
     _flags{ImageFlag<dimensions>(UnsignedShort(other._flags)&~UnsignedShort(ImageFlag2D::Array))|flags},
     _size{Math::Vector<dimensions, Int>::pad(other._size, 1)},
     _data{other._data} {}
-#endif
 
-template<UnsignedInt dimensions, class T> template<class U, class> ImageView<dimensions, T>::ImageView(const ImageView<dimensions, U>& other) noexcept: _storage{other._storage}, _format{other._format}, _formatExtra{other._formatExtra}, _pixelSize{other._pixelSize}, _flags{other._flags}, _size{other._size}, _data{other._data} {}
+template<UnsignedInt dimensions, class T> template<class U, typename std::enable_if<std::is_const<T>::value && !std::is_const<U>::value, int>::type> ImageView<dimensions, T>::ImageView(const ImageView<dimensions, U>& other) noexcept: _storage{other._storage}, _format{other._format}, _formatExtra{other._formatExtra}, _pixelSize{other._pixelSize}, _flags{other._flags}, _size{other._size}, _data{other._data} {}
+#endif
 
 template<UnsignedInt dimensions, class T> template<class U> inline  CompressedImageView<dimensions, T>::CompressedImageView(const CompressedPixelStorage storage, const U format, const VectorTypeFor<dimensions, Int>& size, const Containers::ArrayView<ErasedType> data, const ImageFlags<dimensions> flags) noexcept: CompressedImageView{storage, UnsignedInt(format), size, data, flags} {
     static_assert(sizeof(U) <= 4,
@@ -1018,17 +1034,17 @@ template<UnsignedInt dimensions, class T> template<class U> inline CompressedIma
         "format types larger than 32bits are not supported");
 }
 
-#ifndef DOXYGEN_GENERATING_OUTPUT /* it complains otherwise. why? don't know, don't want to know */
-template<UnsignedInt dimensions, class T> template<UnsignedInt otherDimensions, class> CompressedImageView<dimensions, T>::CompressedImageView(const CompressedImageView<otherDimensions, T>& other, const ImageFlags<dimensions> flags) noexcept:
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<UnsignedInt dimensions, class T> template<UnsignedInt otherDimensions, typename std::enable_if<(otherDimensions < dimensions), int>::type> CompressedImageView<dimensions, T>::CompressedImageView(const CompressedImageView<otherDimensions, T>& other, const ImageFlags<dimensions> flags) noexcept:
     _storage{other._storage},
     _format{other._format},
     /* Removing the Array bit and transferring the rest, as documented */
     _flags{ImageFlag<dimensions>(UnsignedShort(other._flags)&~UnsignedShort(ImageFlag2D::Array))|flags},
     _size{Math::Vector<dimensions, Int>::pad(other._size, 1)},
     _data{other._data} {}
-#endif
 
-template<UnsignedInt dimensions, class T> template<class U, class> CompressedImageView<dimensions, T>::CompressedImageView(const CompressedImageView<dimensions, U>& other) noexcept: _storage{other._storage}, _format{other._format}, _flags{other._flags}, _size{other._size}, _data{other._data} {}
+template<UnsignedInt dimensions, class T> template<class U, typename std::enable_if<std::is_const<T>::value && !std::is_const<U>::value, int>::type> CompressedImageView<dimensions, T>::CompressedImageView(const CompressedImageView<dimensions, U>& other) noexcept: _storage{other._storage}, _format{other._format}, _flags{other._flags}, _size{other._size}, _data{other._data} {}
+#endif
 
 }
 
diff --git a/src/Magnum/Math/Bezier.h b/src/Magnum/Math/Bezier.h
index 4aeedc273..1cafce876 100644
--- a/src/Magnum/Math/Bezier.h
+++ b/src/Magnum/Math/Bezier.h
@@ -119,11 +119,9 @@ template<UnsignedInt order, UnsignedInt dimensions, class T> class Bezier {
          * inverse operation.
          */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt order_ = order> static typename std::enable_if<order_ == 3, Bezier<order, dimensions, T>>::type
-        #else
-        static Bezier<order, dimensions, T>
+        template<UnsignedInt order_ = order, typename std::enable_if<order_ == 3, int>::type = 0>
         #endif
-        fromCubicHermite(const CubicHermite<VectorType>& a, const CubicHermite<VectorType>& b) {
+        static Bezier<order, dimensions, T> fromCubicHermite(const CubicHermite<VectorType>& a, const CubicHermite<VectorType>& b) {
             return {a.point(), a.outTangent()/T(3) - a.point(), b.point() - b.inTangent()/T(3), b.point()};
         }
 
diff --git a/src/Magnum/Math/BitVector.h b/src/Magnum/Math/BitVector.h
index 61903ef12..73b81b37c 100644
--- a/src/Magnum/Math/BitVector.h
+++ b/src/Magnum/Math/BitVector.h
@@ -112,18 +112,25 @@ template<std::size_t size> class BitVector {
          * @param first Value for first 8bit segment
          * @param next  Values for next Bbit segments
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        template<class ...T> constexpr /*implicit*/ BitVector(UnsignedByte first, T... next) noexcept;
-        #else
-        template<class ...T, class U = typename std::enable_if<sizeof...(T)+1 == DataSize, bool>::type> constexpr /*implicit*/ BitVector(UnsignedByte first, T... next) noexcept: _data{first, UnsignedByte(next)...} {}
-        #endif
+        template<class ...T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            /* For some reason MSVC 2015 and 2017 doesn't understand the value
+               parameter here, only a type parameter. Don't need to prevent any
+               ambiguity with this constructor so it's fine. */
+            #ifndef CORRADE_MSVC2017_COMPATIBILITY
+            , typename std::enable_if<sizeof...(T)+1 == DataSize, int>::type = 0
+            #else
+            , class = typename std::enable_if<sizeof...(T)+1 == DataSize>::type
+            #endif
+            #endif
+        > constexpr /*implicit*/ BitVector(UnsignedByte first, T... next) noexcept: _data{first, UnsignedByte(next)...} {}
 
         /** @brief Construct a bit vector with one value for all fields */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        explicit BitVector(T value) noexcept;
-        #else
-        template<class T, class U = typename std::enable_if<std::is_same<bool, T>::value && size != 1, bool>::type> constexpr explicit BitVector(T value) noexcept: BitVector(typename Containers::Implementation::GenerateSequence<DataSize>::Type{}, value ? FullSegmentMask : 0) {}
-        #endif
+        template<class T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<std::is_same<bool, T>::value && size != 1, int>::type = 0
+            #endif
+        > constexpr explicit BitVector(T value) noexcept: BitVector(typename Containers::Implementation::GenerateSequence<DataSize>::Type{}, value ? FullSegmentMask : 0) {}
 
         /** @brief Construct a bit vector from external representation */
         template<class U, class = decltype(Implementation::BitVectorConverter<size, U>::from(std::declval<U>()))> constexpr explicit BitVector(const U& other) noexcept: BitVector{Implementation::BitVectorConverter<size, U>::from(other)} {}
diff --git a/src/Magnum/Math/Color.h b/src/Magnum/Math/Color.h
index 86f0e46a7..6057668f8 100644
--- a/src/Magnum/Math/Color.h
+++ b/src/Magnum/Math/Color.h
@@ -48,7 +48,7 @@ namespace Magnum { namespace Math {
 namespace Implementation {
 
 /* Convert color from HSV */
-template<class T> typename std::enable_if<IsFloatingPoint<T>::value, Color3<T>>::type fromHsv(ColorHsv<T> hsv) {
+template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> Color3<T> fromHsv(ColorHsv<T> hsv) {
     /* Remove repeats */
     hsv.hue -= floor(T(hsv.hue)/T(360))*Deg<T>(360);
     if(hsv.hue < Deg<T>(0)) hsv.hue += Deg<T>(360);
@@ -70,7 +70,7 @@ template<class T> typename std::enable_if<IsFloatingPoint<T>::value, Color3<T>>:
         default: CORRADE_INTERNAL_DEBUG_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
     }
 }
-template<class T> inline typename std::enable_if<IsIntegral<T>::value, Color3<T>>::type fromHsv(const ColorHsv<typename TypeTraits<T>::FloatingPointType>& hsv) {
+template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Color3<T> fromHsv(const ColorHsv<typename TypeTraits<T>::FloatingPointType>& hsv) {
     return pack<Color3<T>>(fromHsv<typename TypeTraits<T>::FloatingPointType>(hsv));
 }
 
@@ -92,54 +92,54 @@ template<class T> Deg<T> hue(const Color3<T>& color, T max, T delta) {
 }
 
 /* Hue, saturation, value for floating-point types */
-template<class T> inline Deg<T> hue(typename std::enable_if<IsFloatingPoint<T>::value, const Color3<T>&>::type color) {
+template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline Deg<T> hue(const Color3<T>& color) {
     T max = color.max();
     T delta = max - color.min();
     return hue(color, max, delta);
 }
-template<class T> inline T saturation(typename std::enable_if<IsFloatingPoint<T>::value, const Color3<T>&>::type color) {
+template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline T saturation(const Color3<T>& color) {
     T max = color.max();
     T delta = max - color.min();
     return max != T(0) ? delta/max : T(0);
 }
-template<class T> inline T value(typename std::enable_if<IsFloatingPoint<T>::value, const Color3<T>&>::type color) {
+template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline T value(const Color3<T>& color) {
     return color.max();
 }
 
 /* Hue, saturation, value for integral types */
-template<class T> inline Deg<typename Color3<T>::FloatingPointType> hue(typename std::enable_if<IsIntegral<T>::value, const Color3<T>&>::type color) {
+template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Deg<typename Color3<T>::FloatingPointType> hue(const Color3<T>& color) {
     return hue<typename Color3<T>::FloatingPointType>(unpack<Color3<typename Color3<T>::FloatingPointType>>(color));
 }
-template<class T> inline typename Color3<T>::FloatingPointType saturation(typename std::enable_if<IsIntegral<T>::value, const Color3<T>&>::type& color) {
+template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline typename Color3<T>::FloatingPointType saturation(const Color3<T>& color) {
     return saturation<typename Color3<T>::FloatingPointType>(unpack<Color3<typename Color3<T>::FloatingPointType>>(color));
 }
-template<class T> inline typename Color3<T>::FloatingPointType value(typename std::enable_if<IsIntegral<T>::value, const Color3<T>&>::type color) {
+template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline typename Color3<T>::FloatingPointType value(const Color3<T>& color) {
     return unpack<typename Color3<T>::FloatingPointType>(color.max());
 }
 
 /* Convert color to HSV */
-template<class T> inline ColorHsv<T> toHsv(typename std::enable_if<IsFloatingPoint<T>::value, const Color3<T>&>::type color) {
+template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline ColorHsv<T> toHsv(const Color3<T>& color) {
     T max = color.max();
     T delta = max - color.min();
 
     return ColorHsv<T>{hue<typename Color3<T>::FloatingPointType>(color, max, delta), max != T(0) ? delta/max : T(0), max};
 }
-template<class T> inline ColorHsv<typename TypeTraits<T>::FloatingPointType> toHsv(typename std::enable_if<IsIntegral<T>::value, const Color3<T>&>::type color) {
+template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline ColorHsv<typename TypeTraits<T>::FloatingPointType> toHsv(const Color3<T>& color) {
     return toHsv<typename TypeTraits<T>::FloatingPointType>(unpack<Color3<typename TypeTraits<T>::FloatingPointType>>(color));
 }
 
 /* sRGB -> RGB conversion */
-template<class T> typename std::enable_if<IsFloatingPoint<T>::value, Color3<T>>::type fromSrgb(const Vector3<T>& srgb) {
+template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline Color3<T> fromSrgb(const Vector3<T>& srgb) {
     constexpr const T a(T(0.055));
     return lerp(srgb/T(12.92), pow((srgb + Vector3<T>{a})/(T(1.0) + a), T(2.4)), srgb > Vector3<T>(T(0.04045)));
 }
-template<class T> typename std::enable_if<IsFloatingPoint<T>::value, Color4<T>>::type fromSrgbAlpha(const Vector4<T>& srgbAlpha) {
+template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline Color4<T> fromSrgbAlpha(const Vector4<T>& srgbAlpha) {
     return {fromSrgb<T>(srgbAlpha.rgb()), srgbAlpha.a()};
 }
-template<class T> inline typename std::enable_if<IsIntegral<T>::value, Color3<T>>::type fromSrgb(const Vector3<typename Color3<T>::FloatingPointType>& srgb) {
+template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Color3<T> fromSrgb(const Vector3<typename Color3<T>::FloatingPointType>& srgb) {
     return pack<Color3<T>>(fromSrgb<typename Color3<T>::FloatingPointType>(srgb));
 }
-template<class T> inline typename std::enable_if<IsIntegral<T>::value, Color4<T>>::type fromSrgbAlpha(const Vector4<typename Color4<T>::FloatingPointType>& srgbAlpha) {
+template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Color4<T> fromSrgbAlpha(const Vector4<typename Color4<T>::FloatingPointType>& srgbAlpha) {
     return {fromSrgb<T>(srgbAlpha.rgb()), pack<T>(srgbAlpha.a())};
 }
 template<class T, class Integral> inline Color3<T> fromSrgbIntegral(const Vector3<Integral>& srgb) {
@@ -152,23 +152,23 @@ template<class T, class Integral> inline Color4<T> fromSrgbAlphaIntegral(const V
 }
 
 /* Integer linear RGB -> linear RGB conversion */
-template<class T> inline typename std::enable_if<IsFloatingPoint<T>::value, Color3<T>>::type fromLinearRgbInt(UnsignedInt linear) {
+template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline Color3<T> fromLinearRgbInt(UnsignedInt linear) {
     return {unpack<T>(UnsignedByte(linear >> 16)),
             unpack<T>(UnsignedByte(linear >> 8)),
             unpack<T>(UnsignedByte(linear))};
 }
-template<class T> inline typename std::enable_if<IsFloatingPoint<T>::value, Color4<T>>::type fromLinearRgbaInt(UnsignedInt linear) {
+template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline Color4<T> fromLinearRgbaInt(UnsignedInt linear) {
     return {unpack<T>(UnsignedByte(linear >> 24)),
             unpack<T>(UnsignedByte(linear >> 16)),
             unpack<T>(UnsignedByte(linear >> 8)),
             unpack<T>(UnsignedByte(linear))};
 }
-template<class T> inline typename std::enable_if<IsIntegral<T>::value, Color3<T>>::type fromLinearRgbInt(UnsignedInt linear) {
+template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Color3<T> fromLinearRgbInt(UnsignedInt linear) {
     return {pack<T>(unpack<Float>(UnsignedByte(linear >> 16))),
             pack<T>(unpack<Float>(UnsignedByte(linear >> 8))),
             pack<T>(unpack<Float>(UnsignedByte(linear)))};
 }
-template<class T> inline typename std::enable_if<IsIntegral<T>::value, Color4<T>>::type fromLinearRgbaInt(UnsignedInt linear) {
+template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Color4<T> fromLinearRgbaInt(UnsignedInt linear) {
     return {pack<T>(unpack<Float>(UnsignedByte(linear >> 24))),
             pack<T>(unpack<Float>(UnsignedByte(linear >> 16))),
             pack<T>(unpack<Float>(UnsignedByte(linear >> 8))),
@@ -176,17 +176,17 @@ template<class T> inline typename std::enable_if<IsIntegral<T>::value, Color4<T>
 }
 
 /* RGB -> sRGB conversion */
-template<class T> Vector3<typename Color3<T>::FloatingPointType> toSrgb(typename std::enable_if<IsFloatingPoint<T>::value, const Color3<T>&>::type rgb) {
+template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> Vector3<typename Color3<T>::FloatingPointType> toSrgb(const Color3<T>& rgb) {
     constexpr const T a = T(0.055);
     return lerp(rgb*T(12.92), (T(1.0) + a)*pow(rgb, T(1.0)/T(2.4)) - Vector3<T>{a}, rgb > Vector3<T>(T(0.0031308)));
 }
-template<class T> Vector4<typename Color4<T>::FloatingPointType> toSrgbAlpha(typename std::enable_if<IsFloatingPoint<T>::value, const Color4<T>&>::type rgba) {
+template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> Vector4<typename Color4<T>::FloatingPointType> toSrgbAlpha(const Color4<T>& rgba) {
     return {toSrgb<T>(rgba.rgb()), rgba.a()};
 }
-template<class T> inline Vector3<typename Color3<T>::FloatingPointType> toSrgb(typename std::enable_if<IsIntegral<T>::value, const Color3<T>&>::type rgb) {
+template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Vector3<typename Color3<T>::FloatingPointType> toSrgb(const Color3<T>& rgb) {
     return toSrgb<typename Color3<T>::FloatingPointType>(unpack<Color3<typename Color3<T>::FloatingPointType>>(rgb));
 }
-template<class T> inline Vector4<typename Color4<T>::FloatingPointType> toSrgbAlpha(typename std::enable_if<IsIntegral<T>::value, const Color4<T>&>::type rgba) {
+template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Vector4<typename Color4<T>::FloatingPointType> toSrgbAlpha(const Color4<T>& rgba) {
     return {toSrgb<T>(rgba.rgb()), unpack<typename Color3<T>::FloatingPointType>(rgba.a())};
 }
 template<class T, class Integral> inline Vector3<Integral> toSrgbIntegral(const Color3<T>& rgb) {
@@ -199,23 +199,23 @@ template<class T, class Integral> inline Vector4<Integral> toSrgbAlphaIntegral(c
 }
 
 /* Linear RGB -> integer linear RGB conversion */
-template<class T> inline typename std::enable_if<IsFloatingPoint<T>::value, UnsignedInt>::type toLinearRgbInt(const Color3<T>& linear) {
+template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline UnsignedInt toLinearRgbInt(const Color3<T>& linear) {
     return (pack<UnsignedByte>(linear[0]) << 16) |
            (pack<UnsignedByte>(linear[1]) << 8) |
             pack<UnsignedByte>(linear[2]);
 }
-template<class T> inline typename std::enable_if<IsFloatingPoint<T>::value, UnsignedInt>::type toLinearRgbaInt(const Color4<T>& linear) {
+template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> inline UnsignedInt toLinearRgbaInt(const Color4<T>& linear) {
     return (pack<UnsignedByte>(linear[0]) << 24) |
            (pack<UnsignedByte>(linear[1]) << 16) |
            (pack<UnsignedByte>(linear[2]) << 8) |
             pack<UnsignedByte>(linear[3]);
 }
-template<class T> inline typename std::enable_if<IsIntegral<T>::value, UnsignedInt>::type toLinearRgbInt(const Color3<T>& linear) {
+template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline UnsignedInt toLinearRgbInt(const Color3<T>& linear) {
     return (pack<UnsignedByte>(unpack<Float>(linear[0])) << 16) |
            (pack<UnsignedByte>(unpack<Float>(linear[1])) << 8) |
             pack<UnsignedByte>(unpack<Float>(linear[2]));
 }
-template<class T> inline typename std::enable_if<IsIntegral<T>::value, UnsignedInt>::type toLinearRgbaInt(const Color4<T>& linear) {
+template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline UnsignedInt toLinearRgbaInt(const Color4<T>& linear) {
     return (pack<UnsignedByte>(unpack<Float>(linear[0])) << 24) |
            (pack<UnsignedByte>(unpack<Float>(linear[1])) << 16) |
            (pack<UnsignedByte>(unpack<Float>(linear[2])) << 8) |
@@ -223,7 +223,7 @@ template<class T> inline typename std::enable_if<IsIntegral<T>::value, UnsignedI
 }
 
 /* CIE XYZ -> RGB conversion */
-template<class T> typename std::enable_if<IsFloatingPoint<T>::value, Color3<T>>::type fromXyz(const Vector3<T>& xyz) {
+template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> Color3<T> fromXyz(const Vector3<T>& xyz) {
     /* Taken from https://en.wikipedia.org/wiki/Talk:SRGB#Rounded_vs._Exact,
        the rounded matrices from the main article don't round-trip perfectly */
     return Matrix3x3<T>{
@@ -231,12 +231,12 @@ template<class T> typename std::enable_if<IsFloatingPoint<T>::value, Color3<T>>:
         Vector3<T>{T(-329)/T(214), T(1648619)/T(878810), T(-2585)/T(12673)},
         Vector3<T>{T(-1974)/T(3959), T(36519)/T(878810), T(705)/T(667)}}*xyz;
 }
-template<class T> inline typename std::enable_if<IsIntegral<T>::value, Color3<T>>::type fromXyz(const Vector3<typename Color3<T>::FloatingPointType>& xyz) {
+template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Color3<T> fromXyz(const Vector3<typename Color3<T>::FloatingPointType>& xyz) {
     return pack<Color3<T>>(fromXyz<typename Color3<T>::FloatingPointType>(xyz));
 }
 
 /* RGB -> CIE XYZ conversion */
-template<class T> Vector3<typename Color3<T>::FloatingPointType> toXyz(typename std::enable_if<IsFloatingPoint<T>::value, const Color3<T>&>::type rgb) {
+template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> Vector3<typename Color3<T>::FloatingPointType> toXyz(const Color3<T>& rgb) {
     /* Taken from https://en.wikipedia.org/wiki/Talk:SRGB#Rounded_vs._Exact,
        the rounded matrices from the main article don't round-trip perfectly */
     return (Matrix3x3<T>{
@@ -244,7 +244,7 @@ template<class T> Vector3<typename Color3<T>::FloatingPointType> toXyz(typename
         Vector3<T>{T(87881)/T(245763), T(175762)/T(245763), T(87881)/T(737289)},
         Vector3<T>{T(12673)/T(70218), T(12673)/T(175545), T(1001167)/T(1053270)}})*rgb;
 }
-template<class T> inline Vector3<typename Color3<T>::FloatingPointType> toXyz(typename std::enable_if<IsIntegral<T>::value, const Color3<T>&>::type rgb) {
+template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> inline Vector3<typename Color3<T>::FloatingPointType> toXyz(const Color3<T>& rgb) {
     return toXyz<typename Color3<T>::FloatingPointType>(unpack<Color3<typename Color3<T>::FloatingPointType>>(rgb));
 }
 
@@ -256,10 +256,10 @@ template<class T> inline Vector3<typename Color3<T>::FloatingPointType> toXyz(ty
    projects created directly using VS (enabled by default since 15.5) but not
    projects using CMake. Not using SFINAE in this case makes it work. Minimal
    repro case here: https://twitter.com/czmosra/status/1039446378248896513 */
-template<class T> constexpr typename std::enable_if<IsFloatingPoint<T>::value, T>::type fullChannel() {
+template<class T, typename std::enable_if<IsFloatingPoint<T>::value, int>::type = 0> constexpr T fullChannel() {
     return T(1.0);
 }
-template<class T> constexpr typename std::enable_if<IsIntegral<T>::value, T>::type fullChannel() {
+template<class T, typename std::enable_if<IsIntegral<T>::value, int>::type = 0> constexpr T fullChannel() {
     return Implementation::bitMax<T>();
 }
 #else
diff --git a/src/Magnum/Math/CubicHermite.h b/src/Magnum/Math/CubicHermite.h
index 4d6a99757..3c480eb80 100644
--- a/src/Magnum/Math/CubicHermite.h
+++ b/src/Magnum/Math/CubicHermite.h
@@ -88,13 +88,11 @@ template<class T> class CubicHermite {
          * Enabled only on vector underlying types. See
          * @ref Bezier::fromCubicHermite() for the inverse operation.
          */
-        template<UnsignedInt dimensions, class U> static
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        CubicHermite<T>
-        #else
-        typename std::enable_if<std::is_base_of<Vector<dimensions, U>, T>::value, CubicHermite<T>>::type
-        #endif
-        fromBezier(const CubicBezier<dimensions, U>& a, const CubicBezier<dimensions, U>& b) {
+        template<UnsignedInt dimensions, class U
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<std::is_base_of<Vector<dimensions, U>, T>::value, int>::type = 0
+            #endif
+        > static CubicHermite<T> fromBezier(const CubicBezier<dimensions, U>& a, const CubicBezier<dimensions, U>& b) {
             return CORRADE_CONSTEXPR_DEBUG_ASSERT(a[3] == b[0],
                 "Math::CubicHermite::fromBezier(): segments are not adjacent"),
                 CubicHermite<T>{3*(a[3] - a[2]), a[3], 3*(b[1] - a[3])};
@@ -124,7 +122,10 @@ template<class T> class CubicHermite {
          * @ref outTangent() is constructed as zero. Enabled only for complex
          * and quaternion types.
          */
-        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} {}
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class U = T, typename std::enable_if<std::is_constructible<U, IdentityInitT>::value, int>::type = 0>
+        #endif
+        constexpr explicit CubicHermite(IdentityInitT) noexcept: _inTangent{ZeroInit}, _point{IdentityInit}, _outTangent{ZeroInit} {}
 
         /** @brief Construct a cubic Hermite spline point without initializing its contents */
         explicit CubicHermite(Magnum::NoInitT) noexcept: CubicHermite{Magnum::NoInit, typename std::conditional<std::is_constructible<T, Magnum::NoInitT>::value, Magnum::NoInitT*, void*>::type{}} {}
diff --git a/src/Magnum/Math/Dual.h b/src/Magnum/Math/Dual.h
index 10728b2d3..5ba1c2d40 100644
--- a/src/Magnum/Math/Dual.h
+++ b/src/Magnum/Math/Dual.h
@@ -81,18 +81,17 @@ template<class T> class Dual {
         #ifdef DOXYGEN_GENERATING_OUTPUT
         constexpr explicit Dual(ZeroInitT) 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> constexpr explicit Dual(ZeroInitT) noexcept: _real{}, _dual{} {}
-        template<class U = T, class V = T, class = typename std::enable_if<std::is_constructible<U, ZeroInitT>::value>::type> constexpr explicit Dual(ZeroInitT) noexcept: _real{ZeroInit}, _dual{ZeroInit} {}
+        template<class U = T, typename std::enable_if<std::is_standard_layout<U>::value && std::is_trivial<U>::value, int>::type = 0> constexpr explicit Dual(ZeroInitT) noexcept: _real{}, _dual{} {}
+        template<class U = T, typename std::enable_if<std::is_constructible<U, ZeroInitT>::value, int>::type = 0>
+        constexpr explicit Dual(ZeroInitT) noexcept: _real{ZeroInit}, _dual{ZeroInit} {}
         #endif
 
         /** @brief Construct without initializing the contents */
         #ifdef DOXYGEN_GENERATING_OUTPUT
         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(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} {}
+        template<class U = T, typename std::enable_if<std::is_standard_layout<U>::value && std::is_trivial<U>::value, int>::type = 0> explicit Dual(Magnum::NoInitT) noexcept {}
+        template<class U = T, typename std::enable_if<std::is_constructible<U, Magnum::NoInitT>::value, int>::type = 0> explicit Dual(Magnum::NoInitT) noexcept: _real{Magnum::NoInit}, _dual{Magnum::NoInit} {}
         #endif
 
         /**
@@ -275,7 +274,11 @@ template<class T> class Dual {
          * @see @ref operator*(const Dual<U>&) const,
          *      @ref operator*(const T&, const Dual<U>&)
          */
-        template<class U, class V = typename std::enable_if<!Implementation::IsDual<U>::value, void>::type> Dual<decltype(std::declval<T>()*std::declval<U>())> operator*(const U& other) const {
+        template<class U
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<!Implementation::IsDual<U>::value, int>::type = 0
+            #endif
+        > Dual<decltype(std::declval<T>()*std::declval<U>())> operator*(const U& other) const {
             return {_real*other, _dual*other};
         }
 
@@ -287,7 +290,7 @@ template<class T> class Dual {
          * @f]
          * @see @ref operator/(const U&) const
          */
-        template<class U> auto operator/(const Dual<U>& other) const -> Dual<decltype(std::declval<T>()/std::declval<U>())> {
+        template<class U> Dual<decltype(std::declval<T>()/std::declval<U>())> operator/(const Dual<U>& other) const {
             return {_real/other._real, (_dual*other._real - _real*other._dual)/(other._real*other._real)};
         }
 
@@ -300,7 +303,11 @@ template<class T> class Dual {
          * @f]
          * @see @ref operator/(const Dual<U>&) const
          */
-        template<class U, class V = typename std::enable_if<!Implementation::IsDual<U>::value, Dual<decltype(std::declval<T>()/std::declval<U>())>>::type> V operator/(const U& other) const {
+        template<class U,
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            typename std::enable_if<!Implementation::IsDual<U>::value, int>::type = 0
+            #endif
+        > Dual<decltype(std::declval<T>()/std::declval<U>())> operator/(const U& other) const {
             return {_real/other, _dual/other};
         }
 
@@ -328,7 +335,11 @@ Equivalent to @ref Dual::operator*(const Dual<U>&) const assuming that
      \hat a \hat b = a_0 b_0 + \epsilon (a_0 b_\epsilon + a_\epsilon b_0) = a_0 b_0 + \epsilon a_0 b_\epsilon
 @f]
 */
-template<class T, class U, class V = typename std::enable_if<!Implementation::IsDual<T>::value, Dual<decltype(std::declval<T>()*std::declval<U>())>>::type> inline V operator*(const T& a, const Dual<U>& b) {
+template<class T, class U
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<!Implementation::IsDual<T>::value, int>::type = 0
+    #endif
+> inline Dual<decltype(std::declval<T>()*std::declval<U>())> operator*(const T& a, const Dual<U>& b) {
     return {a*b.real(), a*b.dual()};
 }
 
diff --git a/src/Magnum/Math/Functions.h b/src/Magnum/Math/Functions.h
index 1e273aaa3..8f72b8e2c 100644
--- a/src/Magnum/Math/Functions.h
+++ b/src/Magnum/Math/Functions.h
@@ -252,7 +252,11 @@ the operations component-wise.
 @see @ref isNan(), @ref Constants::inf(),
     @ref isInf(const Containers::StridedArrayView1D<const T>&)
 */
-template<class T> inline typename std::enable_if<IsScalar<T>::value, bool>::type isInf(T value) {
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type = 0
+    #endif
+> inline bool isInf(T value) {
     return std::isinf(UnderlyingTypeOf<T>(value));
 }
 
@@ -276,7 +280,11 @@ Equivalent to @cpp value != value @ce.
     @ref isNan(const Containers::StridedArrayView1D<const T>&)
 */
 /* defined in Vector.h */
-template<class T> typename std::enable_if<IsScalar<T>::value, bool>::type isNan(T value);
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type
+    #endif
+> bool isNan(T value);
 
 /**
 @overload
@@ -298,7 +306,11 @@ template<std::size_t size, class T> inline BitVector<size> isNan(const Vector<si
     @ref Vector::min(), @ref Utility::min()
 */
 /* defined in Vector.h */
-template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type min(T value, T min);
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type
+    #endif
+> constexpr T min(T value, T min);
 
 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> min(const Vector<size, T>& value, const Vector<size, T>& min) {
@@ -325,7 +337,11 @@ template<std::size_t size, class T> inline Vector<size, T> min(const Vector<size
     @ref Vector::max(), @ref Utility::max()
 */
 /* defined in Vector.h */
-template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type max(T a, T b);
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type
+    #endif
+> constexpr T max(T a, T b);
 
 /** @overload */
 template<std::size_t size, class T> Vector<size, T> max(const Vector<size, T>& value, const Vector<size, T>& max) {
@@ -351,7 +367,11 @@ template<std::size_t size, class T> inline Vector<size, T> max(const Vector<size
     @ref Vector::minmax(),
     @ref Range::Range(const Containers::Pair<VectorType, VectorType>&)
 */
-template<class T> inline typename std::enable_if<IsScalar<T>::value, Containers::Pair<T, T>>::type minmax(T a, T b) {
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type = 0
+    #endif
+> inline Containers::Pair<T, T> minmax(T a, T b) {
     return a < b ? Containers::pair(a, b) : Containers::pair(b, a);
 }
 
@@ -376,7 +396,11 @@ set to @p max. Equivalent to:
 @see @ref min(), @ref max()
 */
 /* defined in Vector.h */
-template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type clamp(T value, T min, T max);
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type
+    #endif
+> constexpr T clamp(T value, T min, T max);
 
 /** @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) {
@@ -399,7 +423,11 @@ template<std::size_t size, class T> inline Vector<size, T> clamp(const Vector<si
 
 Returns `1` if @p x > 0, `0` if @p x = 0 and `-1` if @p x < 0.
 */
-template<class T> inline typename std::enable_if<IsScalar<T>::value, UnderlyingTypeOf<T>>::type sign(T scalar) {
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type = 0
+    #endif
+> inline UnderlyingTypeOf<T> sign(T scalar) {
     if(scalar > T(0)) return UnderlyingTypeOf<T>(1);
     if(scalar < T(0)) return UnderlyingTypeOf<T>(-1);
     return UnderlyingTypeOf<T>(0);
@@ -414,7 +442,11 @@ template<std::size_t size, class T> inline Vector<size, UnderlyingTypeOf<T>> sig
 }
 
 /** @brief Absolute value */
-template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type abs(T a) {
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type = 0
+    #endif
+> inline T abs(T a) {
     return T(std::abs(UnderlyingTypeOf<T>(a)));
 }
 
@@ -427,7 +459,11 @@ template<std::size_t size, class T> inline Vector<size, T> abs(const Vector<size
 }
 
 /** @brief Nearest not larger integer */
-template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type floor(T a) {
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type = 0
+    #endif
+> inline T floor(T a) {
     return T(std::floor(UnderlyingTypeOf<T>(a)));
 }
 
@@ -440,7 +476,11 @@ template<std::size_t size, class T> inline Vector<size, T> floor(const Vector<si
 }
 
 /** @brief Round value to nearest integer */
-template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type round(T a) {
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type = 0
+    #endif
+> inline T round(T a) {
     return T(std::round(UnderlyingTypeOf<T>(a)));
 }
 
@@ -453,7 +493,11 @@ template<std::size_t size, class T> inline Vector<size, T> round(const Vector<si
 }
 
 /** @brief Nearest not smaller integer */
-template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type ceil(T a) {
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type = 0
+    #endif
+> inline T ceil(T a) {
     return T(std::ceil(UnderlyingTypeOf<T>(a)));
 }
 
@@ -481,7 +525,11 @@ Calculates the remainder @f$ r @f$ of a floating point division: @f[
 
 @m_keyword{mod(),GLSL mod(),}
 */
-template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type fmod(T a, T b) {
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type = 0
+    #endif
+> inline T fmod(T a, T b) {
     return T(std::fmod(UnderlyingTypeOf<T>(a), UnderlyingTypeOf<T>(b)));
 }
 
@@ -526,13 +574,11 @@ See @ref select() for constant interpolation using the same API and
     @ref lerp(const CubicHermiteQuaternion<T>&, const CubicHermiteQuaternion<T>&, T)
 @m_keyword{mix(),GLSL mix(),}
 */
-template<class T, class U> inline
+template<class T, class U
     #ifndef DOXYGEN_GENERATING_OUTPUT
-    typename std::enable_if<(IsVector<T>::value || IsScalar<T>::value) && !Implementation::IsBitVectorOrScalar<U>::value, T>::type
-    #else
-    T
+    , typename std::enable_if<(IsVector<T>::value || IsScalar<T>::value) && !Implementation::IsBitVectorOrScalar<U>::value, int>::type = 0
     #endif
-lerp(const T& a, const T& b, U t) {
+> inline T lerp(const T& a, const T& b, U t) {
     return Implementation::lerp(a, b, t);
 }
 
@@ -587,7 +633,11 @@ expression combines that with @ref clamp() to ensure the value is in bounds:
 
 @see @ref select()
 */
-template<class T> inline UnderlyingTypeOf<typename std::enable_if<IsScalar<T>::value, T>::type> lerpInverted(T a, T b, T lerp) {
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type = 0
+    #endif
+> inline UnderlyingTypeOf<T> lerpInverted(T a, T b, T lerp) {
     return (lerp - a)/(b - a);
 }
 
@@ -623,7 +673,11 @@ Computes and returns @f$ ab + c @f$. On some architectures might be faster than
 doing the computation manually. Works only on types that satisfy
 @ref IsUnitless.
 */
-template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type fma(T a, T b, T c) {
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type = 0
+    #endif
+> inline T fma(T a, T b, T c) {
     static_assert(IsUnitless<T>::value, "expecting a unitless type");
     /* On Emscripten it works with -O2 but not with -O1 (function not defined).
        I guess that's only because -O2 optimizes it out, so disabling it there. */
@@ -693,7 +747,11 @@ Returns integral power of base to the exponent. Works only on types that
 satisfy @ref IsUnitless.
 @see @ref pow(T, T)
 */
-template<UnsignedInt exponent, class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type pow(T base) {
+template<UnsignedInt exponent, class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type = 0
+    #endif
+> constexpr T pow(T base) {
     static_assert(IsUnitless<T>::value, "expected a unitless type");
     return Implementation::Pow<exponent>::pow(base);
 }
@@ -713,7 +771,11 @@ Returns power of @p base to the @p exponent. Works only on types that satisfy
 @ref IsUnitless.
 @see @ref pow(T), @ref exp()
 */
-template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type pow(T base, T exponent) {
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type = 0
+    #endif
+> inline T pow(T base, T exponent) {
     static_assert(IsUnitless<T>::value, "expected a unitless type");
     return std::pow(base, exponent);
 }
@@ -732,7 +794,11 @@ template<std::size_t size, class T> inline Vector<size, T> pow(const Vector<size
 Works only on types that satisfy @ref IsUnitless.
 @see @ref sqrtInverted(), @ref Vector::length(), @ref sqrt(const Dual<T>&)
 */
-template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type sqrt(T a) {
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type = 0
+    #endif
+> inline T sqrt(T a) {
     static_assert(IsUnitless<T>::value, "expecting a unitless type");
     return std::sqrt(a);
 }
@@ -752,7 +818,11 @@ Works only on types that satisfy @ref IsUnitless.
 @see @ref sqrt(), @ref Vector::lengthInverted()
 @m_keyword{inversesqrt(),GLSL inversesqrt(),}
 */
-template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type sqrtInverted(T a) {
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type = 0
+    #endif
+> inline T sqrtInverted(T a) {
     static_assert(IsUnitless<T>::value, "expecting a unitless type");
     return T(1)/std::sqrt(a);
 }
diff --git a/src/Magnum/Math/FunctionsBatch.h b/src/Magnum/Math/FunctionsBatch.h
index 1e7e83054..4b7c2ed67 100644
--- a/src/Magnum/Math/FunctionsBatch.h
+++ b/src/Magnum/Math/FunctionsBatch.h
@@ -292,7 +292,7 @@ template<class T, std::size_t size> inline T max(const T(&array)[size]) {
 }
 
 namespace Implementation {
-    template<class T> inline typename std::enable_if<IsScalar<T>::value, void>::type minmax(T& min, T& max, T value) {
+    template<class T, typename std::enable_if<IsScalar<T>::value, int>::type = 0> inline void minmax(T& min, T& max, T value) {
         if(value < min)
             min = value;
         else if(value > max)
diff --git a/src/Magnum/Math/Packing.h b/src/Magnum/Math/Packing.h
index 9c307f97d..a37452b6c 100644
--- a/src/Magnum/Math/Packing.h
+++ b/src/Magnum/Math/Packing.h
@@ -82,14 +82,14 @@ representation to use. Example usage:
 */
 template<class FloatingPoint, class Integral, UnsignedInt bits> inline FloatingPoint unpack(const Integral& value);
 #else
-template<class FloatingPoint, class Integral, UnsignedInt bits = sizeof(Integral)*8> inline typename std::enable_if<IsScalar<Integral>::value && std::is_unsigned<Integral>::value, FloatingPoint>::type unpack(const Integral& value) {
+template<class FloatingPoint, class Integral, UnsignedInt bits = sizeof(Integral)*8, typename std::enable_if<IsScalar<Integral>::value && std::is_unsigned<Integral>::value, int>::type = 0> inline FloatingPoint unpack(const Integral& value) {
     static_assert(IsFloatingPoint<FloatingPoint>::value && IsIntegral<Integral>::value,
         "unpacking must be done from integral to floating-point type");
     static_assert(bits <= sizeof(Integral)*8,
         "bit count larger than size of the integral type");
     return FloatingPoint(value/UnderlyingTypeOf<FloatingPoint>(Implementation::bitMax<Integral, bits>()));
 }
-template<class FloatingPoint, class Integral, UnsignedInt bits = sizeof(Integral)*8> inline typename std::enable_if<IsScalar<Integral>::value && std::is_signed<Integral>::value, FloatingPoint>::type unpack(const Integral& value) {
+template<class FloatingPoint, class Integral, UnsignedInt bits = sizeof(Integral)*8, typename std::enable_if<IsScalar<Integral>::value && std::is_signed<Integral>::value, int>::type = 0> inline FloatingPoint unpack(const Integral& value) {
     static_assert(IsFloatingPoint<FloatingPoint>::value && IsIntegral<Integral>::value,
         "unpacking must be done from integral to floating-point type");
     static_assert(bits <= sizeof(Integral)*8,
@@ -111,7 +111,7 @@ template<class FloatingPoint, std::size_t size, class Integral, UnsignedInt bits
 #ifdef DOXYGEN_GENERATING_OUTPUT
 template<class FloatingPoint, UnsignedInt bits, class Integral> inline FloatingPoint unpack(const Integral& value);
 #else
-template<class FloatingPoint, UnsignedInt bits, class Integral> inline typename std::enable_if<IsScalar<Integral>::value, FloatingPoint>::type unpack(const Integral& value) {
+template<class FloatingPoint, UnsignedInt bits, class Integral, typename std::enable_if<IsScalar<Integral>::value, int>::type = 0> inline FloatingPoint unpack(const Integral& value) {
     return unpack<FloatingPoint, Integral, bits>(value);
 }
 template<class FloatingPoint, UnsignedInt bits, std::size_t size, class Integral> inline FloatingPoint unpack(const Vector<size, Integral>& value) {
@@ -139,7 +139,7 @@ given *signed* integral type.
 #ifdef DOXYGEN_GENERATING_OUTPUT
 template<class Integral, class FloatingPoint> inline Integral pack(const FloatingPoint& value);
 #else
-template<class Integral, class FloatingPoint, UnsignedInt bits = sizeof(Integral)*8> inline typename std::enable_if<IsScalar<FloatingPoint>::value, Integral>::type pack(FloatingPoint value) {
+template<class Integral, class FloatingPoint, UnsignedInt bits = sizeof(Integral)*8, typename std::enable_if<IsScalar<FloatingPoint>::value, int>::type = 0> inline Integral pack(FloatingPoint value) {
     static_assert(IsFloatingPoint<FloatingPoint>::value && IsIntegral<Integral>::value,
         "packing must be done from floating-point to integral type");
     static_assert(bits <= sizeof(Integral)*8,
@@ -167,7 +167,7 @@ representation to use. Example usage:
 #ifdef DOXYGEN_GENERATING_OUTPUT
 template<class Integral, UnsignedInt bits, class FloatingPoint> inline Integral pack(FloatingPoint value);
 #else
-template<class Integral, UnsignedInt bits, class FloatingPoint> inline typename std::enable_if<IsScalar<FloatingPoint>::value, Integral>::type pack(FloatingPoint value) {
+template<class Integral, UnsignedInt bits, class FloatingPoint, typename std::enable_if<IsScalar<FloatingPoint>::value, int>::type = 0> inline Integral pack(FloatingPoint value) {
     return pack<Integral, FloatingPoint, bits>(value);
 }
 template<class Integral, UnsignedInt bits, std::size_t size, class FloatingPoint> inline Integral pack(const Vector<size, FloatingPoint>& value) {
diff --git a/src/Magnum/Math/Range.h b/src/Magnum/Math/Range.h
index 11180097a..80a03d10a 100644
--- a/src/Magnum/Math/Range.h
+++ b/src/Magnum/Math/Range.h
@@ -144,7 +144,7 @@ template<UnsignedInt dimensions, class T> class Range {
         constexpr /*implicit*/ Range(const VectorType& min, const VectorType& max) noexcept: _min{min}, _max{max} {}
         /** @overload */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt d = dimensions, class = typename std::enable_if<d == 1>::type>
+        template<UnsignedInt d = dimensions, typename std::enable_if<d == 1, int>::type = 0>
         #endif
         constexpr /*implicit*/ Range(const Vector<dimensions, T>& min, const Vector<dimensions, T>& max) noexcept: _min{Implementation::RangeTraits<dimensions, T>::fromVector(min)}, _max{Implementation::RangeTraits<dimensions, T>::fromVector(max)} {}
 
@@ -161,7 +161,7 @@ template<UnsignedInt dimensions, class T> class Range {
 
         /** @overload */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt d = dimensions, class = typename std::enable_if<d != 1>::type>
+        template<UnsignedInt d = dimensions, typename std::enable_if<d != 1, int>::type = 0>
         #endif
         constexpr /*implicit*/ Range(const Containers::Pair<Vector<dimensions, T>, Vector<dimensions, T>>& minmax) noexcept: _min{minmax.first()}, _max{minmax.second()} {}
 
@@ -311,7 +311,7 @@ template<UnsignedInt dimensions, class T> class Range {
          * @m_since_latest
          */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt d = dimensions, class = typename std::enable_if<d != 1>::type>
+        template<UnsignedInt d = dimensions, typename std::enable_if<d != 1, int>::type = 0>
         #endif
         Range<dimensions, T> scaled(T scaling) const {
             return {_min*scaling, _max*scaling};
@@ -334,7 +334,7 @@ template<UnsignedInt dimensions, class T> class Range {
          * @m_since_latest
          */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<UnsignedInt d = dimensions, class = typename std::enable_if<d != 1>::type>
+        template<UnsignedInt d = dimensions, typename std::enable_if<d != 1, int>::type = 0>
         #endif
         Range<dimensions, T> scaledFromCenter(T scaling) const {
             /* Can't use *T(0.5) because that won't work for integers */
diff --git a/src/Magnum/Math/Test/TypeTraitsTest.cpp b/src/Magnum/Math/Test/TypeTraitsTest.cpp
index 307f07350..972b0c29c 100644
--- a/src/Magnum/Math/Test/TypeTraitsTest.cpp
+++ b/src/Magnum/Math/Test/TypeTraitsTest.cpp
@@ -359,10 +359,10 @@ template<class T> void TypeTraitsTest::equalsFloatingPointNaN() {
 }
 
 /* Argh! Why there is no standard std::abs() for unsigned types? */
-template<class T, class U = typename std::enable_if<std::is_unsigned<T>::value>::type> T abs(T value) {
+template<class T, typename std::enable_if<std::is_unsigned<T>::value, int>::type = 0> T abs(T value) {
     return value;
 }
-template<class T, class U = T, class V = typename std::enable_if<!std::is_unsigned<T>::value>::type> T abs(T value) {
+template<class T, typename std::enable_if<!std::is_unsigned<T>::value, int>::type = 0> T abs(T value) {
     return std::abs(value);
 }
 
diff --git a/src/Magnum/Math/TypeTraits.h b/src/Magnum/Math/TypeTraits.h
index 67c942b1b..a75661ec6 100644
--- a/src/Magnum/Math/TypeTraits.h
+++ b/src/Magnum/Math/TypeTraits.h
@@ -405,7 +405,11 @@ Calls @ref TypeTraits<T>::equals() --- using fuzzy compare for floating-point
 types and doing equality comparison on integral types. Scalar complement to
 @ref equal(const Vector<size, T>& a, const Vector<size, T>&).
 */
-template<class T> inline typename std::enable_if<IsScalar<T>::value, bool>::type equal(T a, T b) {
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type = 0
+    #endif
+> inline bool equal(T a, T b) {
     return TypeTraits<T>::equals(a, b);
 }
 
@@ -417,7 +421,11 @@ Calls @ref TypeTraits<T>::equals() --- using fuzzy compare for floating-point
 types and doing equality comparison on integral types. Scalar complement to
 @ref notEqual(const Vector<size, T>& a, const Vector<size, T>&).
 */
-template<class T> inline typename std::enable_if<IsScalar<T>::value, bool>::type notEqual(T a, T b) {
+template<class T
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<IsScalar<T>::value, int>::type = 0
+    #endif
+> inline bool notEqual(T a, T b) {
     return !TypeTraits<T>::equals(a, b);
 }
 
diff --git a/src/Magnum/Math/Unit.h b/src/Magnum/Math/Unit.h
index 4a1b6c8e7..2bf5787a2 100644
--- a/src/Magnum/Math/Unit.h
+++ b/src/Magnum/Math/Unit.h
@@ -178,12 +178,11 @@ template<template<class> class Derived, class T> class Unit {
          * Similar to @ref operator*=(T), except that the multiplication is
          * done in floating-point.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        template<class FloatingPoint> Unit<Derived, T>&
-        #else
-        template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Unit<Derived, T>&>::type
-        #endif
-        operator*=(FloatingPoint number) {
+        template<class FloatingPoint
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
+            #endif
+        > Unit<Derived, T>& operator*=(FloatingPoint number) {
             _value = T(_value*number);
             return *this;
         }
@@ -199,12 +198,11 @@ template<template<class> class Derived, class T> class Unit {
            an out-of-class overload wrapped in CORRADE_MSVC2015_COMPATIBILITY
            which is (and the two don't conflict, apparently, so both are
            present) */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        template<class FloatingPoint> constexpr Unit<Derived, T>
-        #else
-        template<class FloatingPoint, class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Unit<Derived, T>>::type
-        #endif
-        operator*(FloatingPoint number) const {
+        template<class FloatingPoint, class Integral = T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
+            #endif
+        > constexpr Unit<Derived, T> operator*(FloatingPoint number) const {
             return Unit<Derived, T>{T(_value*number)};
         }
 
@@ -214,12 +212,11 @@ template<template<class> class Derived, class T> class Unit {
          *
          * Same as @ref operator*(FloatingPoint) const.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        template<class FloatingPoint> friend constexpr Unit<Derived, T>
-        #else
-        template<class FloatingPoint, class Integral = T> friend constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Unit<Derived, T>>::type
-        #endif
-        operator*(FloatingPoint number, const Unit<Derived, T>& value) {
+        template<class FloatingPoint
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
+            #endif
+        > friend constexpr Unit<Derived, T> operator*(FloatingPoint number, const Unit<Derived, T>& value) {
             return Unit<Derived, T>{T(value._value*number)};
         }
 
@@ -241,12 +238,11 @@ template<template<class> class Derived, class T> class Unit {
          * Similar to @ref operator/=(T), except that the division is done in
          * floating-point.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        template<class FloatingPoint> Unit<Derived, T>&
-        #else
-        template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Unit<Derived, T>&>::type
-        #endif
-        operator/=(FloatingPoint number) {
+        template<class FloatingPoint
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
+            #endif
+        > Unit<Derived, T>& operator/=(FloatingPoint number) {
             _value = T(_value/number);
             return *this;
         }
@@ -258,12 +254,11 @@ template<template<class> class Derived, class T> class Unit {
          * Similar to @ref operator/(T) const, except that the division is done
          * in floating-point.
         */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        template<class FloatingPoint> constexpr Unit<Derived, T>
-        #else
-        template<class FloatingPoint, class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Unit<Derived, T>>::type
-        #endif
-        operator/(FloatingPoint number) const {
+        template<class FloatingPoint
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
+            #endif
+        > constexpr Unit<Derived, T> operator/(FloatingPoint number) const {
             return Unit<Derived, T>{T(_value/number)};
         }
 
@@ -278,12 +273,10 @@ template<template<class> class Derived, class T> class Unit {
          *
          * Enabled only for integral types.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        Unit<Derived, T>&
-        #else
-        template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Unit<Derived, T>&>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
         #endif
-        operator%=(Unit<Derived, T> other) {
+        Unit<Derived, T>& operator%=(Unit<Derived, T> other) {
             _value %= other._value;
             return *this;
         }
@@ -294,12 +287,10 @@ template<template<class> class Derived, class T> class Unit {
          *
          * Enabled only for integral types.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        constexpr Unit<Derived, T>
-        #else
-        template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Unit<Derived, T>>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
         #endif
-        operator%(Unit<Derived, T> other) const {
+        constexpr Unit<Derived, T> operator%(Unit<Derived, T> other) const {
             return Unit<Derived, T>{_value%other._value};
         }
 
@@ -314,7 +305,7 @@ template<template<class> class Derived, class T> class Unit {
    picked up correctly (and doesn't conflict with the in-class one). See
    UnitTest::multiplyDivideIntegral() for regression tests, the same issue and
    a matching workaround is done in Vector as well. */
-template<template<class> class Derived, class FloatingPoint, class Integral> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Unit<Derived, Integral>>::type operator*(FloatingPoint number, const Unit<Derived, Integral>& value) {
+template<template<class> class Derived, class FloatingPoint, class Integral, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> constexpr Unit<Derived, Integral> operator*(FloatingPoint number, const Unit<Derived, Integral>& value) {
     return value*number;
 }
 #endif
diff --git a/src/Magnum/Math/Vector.h b/src/Magnum/Math/Vector.h
index 3690f2d0c..2b74d0650 100644
--- a/src/Magnum/Math/Vector.h
+++ b/src/Magnum/Math/Vector.h
@@ -55,18 +55,18 @@ namespace Magnum { namespace Math {
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 /* Documented in Functions.h, defined here because Vector needs them */
-template<class T> inline typename std::enable_if<IsScalar<T>::value, bool>::type isNan(T value) {
+template<class T, typename std::enable_if<IsScalar<T>::value, int>::type = 0> inline bool isNan(T value) {
     return std::isnan(UnderlyingTypeOf<T>(value));
 }
 /* Keeping the same parameter names as in Functions.h so the note about
    NaN propagation works here too */
-template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type min(T value, T min) {
+template<class T, typename std::enable_if<IsScalar<T>::value, int>::type = 0> constexpr T min(T value, T min) {
     return min < value ? min : value;
 }
-template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type max(T value, T max) {
+template<class T, typename std::enable_if<IsScalar<T>::value, int>::type = 0> constexpr T max(T value, T max) {
     return value < max ? max : value;
 }
-template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type clamp(T value, T min, T max) {
+template<class T, typename std::enable_if<IsScalar<T>::value, int>::type = 0> constexpr T clamp(T value, T min, T max) {
     return Math::min(Math::max(value, min), max);
 }
 #endif
@@ -139,13 +139,11 @@ dot product is clamped to the @f$ [-1, +1] @f$ range before being passed to
     @ref angle(const Complex<T>&, const Complex<T>&),
     @ref angle(const Quaternion<T>&, const Quaternion<T>&)
 */
-template<std::size_t size, class FloatingPoint> inline
-#ifdef DOXYGEN_GENERATING_OUTPUT
-Rad<FloatingPoint>
-#else
-typename std::enable_if<std::is_floating_point<FloatingPoint>::value, Rad<FloatingPoint>>::type
-#endif
-angle(const Vector<size, FloatingPoint>& normalizedA, const Vector<size, FloatingPoint>& normalizedB) {
+template<std::size_t size, class FloatingPoint
+    #ifndef DOXYGEN_GENERATING_OUTPUT
+    , typename std::enable_if<std::is_floating_point<FloatingPoint>::value, int>::type = 0
+    #endif
+> inline Rad<FloatingPoint> angle(const Vector<size, FloatingPoint>& normalizedA, const Vector<size, FloatingPoint>& normalizedB) {
     CORRADE_DEBUG_ASSERT(normalizedA.isNormalized() && normalizedB.isNormalized(),
         "Math::angle(): vectors" << normalizedA << "and" << normalizedB << "are not normalized", {});
     return Rad<FloatingPoint>(std::acos(clamp(dot(normalizedA, normalizedB), FloatingPoint(-1), FloatingPoint(1))));
@@ -217,11 +215,11 @@ template<std::size_t size, class T> class Vector {
         explicit Vector(Magnum::NoInitT) noexcept {}
 
         /** @brief Construct a vector from components */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        template<class ...U> constexpr /*implicit*/ Vector(T first, U... next) noexcept;
-        #else
-        template<class ...U, class V = typename std::enable_if<sizeof...(U)+1 == size, T>::type> constexpr /*implicit*/ Vector(T first, U... next) noexcept: _data{first, next...} {}
-        #endif
+        template<class ...U
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<sizeof...(U)+1 == size, int>::type = 0
+            #endif
+        > constexpr /*implicit*/ Vector(T first, U... next) noexcept: _data{first, next...} {}
 
         /**
          * @brief Construct a vector from a fixed-size array
@@ -243,9 +241,9 @@ template<std::size_t size, class T> class Vector {
 
         /** @brief Construct a vector with one value for all components */
         #ifdef DOXYGEN_GENERATING_OUTPUT
-        constexpr explicit Vector(T value) noexcept;
+        constexpr explicit Vector(T value) noexcept; /* showing T instead of U */
         #else
-        template<class U, class V = typename std::enable_if<std::is_same<T, U>::value && size != 1, T>::type> constexpr explicit Vector(U value) noexcept: Vector(typename Containers::Implementation::GenerateSequence<size>::Type{}, value) {}
+        template<class U, typename std::enable_if<std::is_same<T, U>::value && size != 1, int>::type = 0> constexpr explicit Vector(U value) noexcept: Vector(typename Containers::Implementation::GenerateSequence<size>::Type{}, value) {}
         #endif
 
         /**
@@ -399,12 +397,10 @@ template<std::size_t size, class T> class Vector {
          * @f]
          * @see @ref flipped(), @ref Vector2::perpendicular()
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        constexpr Vector<size, T>
-        #else
-        template<class U = T> constexpr typename std::enable_if<std::is_signed<U>::value, Vector<size, T>>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class U = T, typename std::enable_if<std::is_signed<U>::value, int>::type = 0>
         #endif
-        operator-() const {
+        constexpr Vector<size, T> operator-() const {
             return negateInternal(typename Containers::Implementation::GenerateSequence<size>::Type{});
         }
 
@@ -503,12 +499,11 @@ template<std::size_t size, class T> class Vector {
          * Similar to @ref operator*=(T), except that the multiplication is
          * done in floating-point. The computation is done in-place.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        template<class FloatingPoint> Vector<size, T>&
-        #else
-        template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, T>&>::type
-        #endif
-        operator*=(FloatingPoint scalar) {
+        template<class FloatingPoint
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
+            #endif
+        > Vector<size, T>& operator*=(FloatingPoint scalar) {
             for(std::size_t i = 0; i != size; ++i)
                 _data[i] = T(_data[i]*scalar);
 
@@ -521,12 +516,11 @@ template<std::size_t size, class T> class Vector {
          * Similar to @ref operator*(T) const, except that the multiplication
          * is done in floating-point.
         */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        template<class FloatingPoint> constexpr Vector<size, T>
-        #else
-        template<class FloatingPoint, class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, T>>::type
-        #endif
-        operator*(FloatingPoint scalar) const {
+        template<class FloatingPoint
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
+            #endif
+        > constexpr Vector<size, T> operator*(FloatingPoint scalar) const {
             return multiplyIntegerInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{});
         }
 
@@ -539,11 +533,11 @@ template<std::size_t size, class T> class Vector {
            an out-of-class overload wrapped in CORRADE_MSVC2015_COMPATIBILITY
            which is (and the two don't conflict, apparently, so both are
            present) */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        template<class FloatingPoint> friend constexpr Vector<size, T>
-        #else
-        template<class FloatingPoint, class Integral = T> friend constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, T>>::type
-        #endif
+        template<class FloatingPoint
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
+            #endif
+        > friend constexpr Vector<size, T>
         operator*(FloatingPoint scalar, const Vector<size, T>& vector) {
             return vector*scalar;
         }
@@ -600,12 +594,11 @@ template<std::size_t size, class T> class Vector {
          * Similar to @ref operator/=(T), except that the division is done in
          * floating-point. The computation is done in-place.
         */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        template<class FloatingPoint> Vector<size, Integral>&
-        #else
-        template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, T>&>::type
-        #endif
-        operator/=(FloatingPoint scalar) {
+        template<class FloatingPoint
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
+            #endif
+        > Vector<size, T>& operator/=(FloatingPoint scalar) {
             for(std::size_t i = 0; i != size; ++i)
                 _data[i] = T(_data[i]/scalar);
 
@@ -618,12 +611,11 @@ template<std::size_t size, class T> class Vector {
          * Similar to @ref operator/(T) const, except that the division is done
          * in floating-point.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        template<class FloatingPoint> Vector<size, T> constexpr
-        #else
-        template<class FloatingPoint, class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, T>>::type
-        #endif
-        operator/(FloatingPoint scalar) const {
+        template<class FloatingPoint
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
+            #endif
+        > constexpr Vector<size, T> operator/(FloatingPoint scalar) const {
             return divideIntegerInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{});
         }
 
@@ -661,12 +653,11 @@ template<std::size_t size, class T> class Vector {
          * multiplication is done in floating-point. The computation is done
          * in-place.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        template<class FloatingPoint> Vector<size, T>&
-        #else
-        template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, T>&>::type
-        #endif
-        operator*=(const Vector<size, FloatingPoint>& other) {
+        template<class FloatingPoint
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
+            #endif
+        > Vector<size, T>& operator*=(const Vector<size, FloatingPoint>& other) {
             for(std::size_t i = 0; i != size; ++i)
                 _data[i] = T(_data[i]*other._data[i]);
 
@@ -683,7 +674,7 @@ template<std::size_t size, class T> class Vector {
          */
         template<class FloatingPoint
             #ifndef DOXYGEN_GENERATING_OUTPUT
-            , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value>::type* = nullptr
+            , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
             #endif
         > constexpr Vector<size, T> operator*(const Vector<size, FloatingPoint>& other) const {
             return multiplyIntegerInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{});
@@ -701,7 +692,7 @@ template<std::size_t size, class T> class Vector {
            Integral*FloatingPoint variant above */
         template<class Integral
             #ifndef DOXYGEN_GENERATING_OUTPUT
-            , class FloatingPoint = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value>::type* = nullptr
+            , class FloatingPoint = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
             #endif
         > constexpr Vector<size, Integral> operator*(const Vector<size, Integral>& other) const {
             return other**this;
@@ -740,12 +731,11 @@ template<std::size_t size, class T> class Vector {
          * division is done in floating-point. The computation is done
          * in-place.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        template<class FloatingPoint> Vector<size, T>&
-        #else
-        template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, T>&>::type
-        #endif
-        operator/=(const Vector<size, FloatingPoint>& other) {
+        template<class FloatingPoint
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
+            #endif
+        > Vector<size, T>& operator/=(const Vector<size, FloatingPoint>& other) {
             for(std::size_t i = 0; i != size; ++i)
                 _data[i] = T(_data[i]/other._data[i]);
 
@@ -760,12 +750,11 @@ template<std::size_t size, class T> class Vector {
          * always an integral vector, convert both arguments to the same
          * floating-point type to have a floating-point result.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        template<class FloatingPoint> constexpr Vector<size, T>
-        #else
-        template<class FloatingPoint, class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, T>>::type
-        #endif
-        operator/(const Vector<size, FloatingPoint>& other) const {
+        template<class FloatingPoint
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0
+            #endif
+        > constexpr Vector<size, T> operator/(const Vector<size, FloatingPoint>& other) const {
             return divideIntegerInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{});
         }
 
@@ -774,12 +763,10 @@ template<std::size_t size, class T> class Vector {
          *
          * Enabled only for integral types. The computation is done in-place.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        Vector<size, T>&
-        #else
-        template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>&>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
         #endif
-        operator%=(T scalar) {
+        Vector<size, T>& operator%=(T scalar) {
             for(std::size_t i = 0; i != size; ++i)
                 _data[i] %= scalar;
 
@@ -791,12 +778,10 @@ template<std::size_t size, class T> class Vector {
          *
          * Enabled only for integral types.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        constexpr Vector<size, T>
-        #else
-        template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
         #endif
-        operator%(T scalar) const {
+        constexpr Vector<size, T> operator%(T scalar) const {
             return moduloInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{});
         }
 
@@ -805,12 +790,10 @@ template<std::size_t size, class T> class Vector {
          *
          * Enabled only for integral types. The computation is done in-place.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        Vector<size, T>&
-        #else
-        template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>&>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
         #endif
-        operator%=(const Vector<size, T>& other) {
+        Vector<size, T>&  operator%=(const Vector<size, T>& other) {
             for(std::size_t i = 0; i != size; ++i)
                 _data[i] %= other._data[i];
 
@@ -822,12 +805,10 @@ template<std::size_t size, class T> class Vector {
          *
          * Enabled only for integral types.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        constexpr Vector<size, T>
-        #else
-        template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
         #endif
-        operator%(const Vector<size, T>& other) const {
+        constexpr Vector<size, T> operator%(const Vector<size, T>& other) const {
             return moduloInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{});
         }
 
@@ -836,12 +817,10 @@ template<std::size_t size, class T> class Vector {
          *
          * Enabled only for integral types.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        constexpr Vector<size, T>
-        #else
-        template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
         #endif
-        operator~() const {
+        constexpr Vector<size, T> operator~() const {
             return invertInternal(typename Containers::Implementation::GenerateSequence<size>::Type{});
         }
 
@@ -850,12 +829,10 @@ template<std::size_t size, class T> class Vector {
          *
          * Enabled only for integral types. The computation is done in-place.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        Vector<size, T>&
-        #else
-        template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>&>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
         #endif
-        operator&=(const Vector<size, T>& other) {
+        Vector<size, T>& operator&=(const Vector<size, T>& other) {
             for(std::size_t i = 0; i != size; ++i)
                 _data[i] &= other._data[i];
 
@@ -867,12 +844,10 @@ template<std::size_t size, class T> class Vector {
          *
          * Enabled only for integral types.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        constexpr Vector<size, T>
-        #else
-        template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
         #endif
-        operator&(const Vector<size, T>& other) const {
+        constexpr Vector<size, T> operator&(const Vector<size, T>& other) const {
             return andInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{});
         }
 
@@ -881,12 +856,10 @@ template<std::size_t size, class T> class Vector {
          *
          * Enabled only for integral types. The computation is done in-place.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        Vector<size, T>&
-        #else
-        template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>&>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
         #endif
-        operator|=(const Vector<size, T>& other) {
+        Vector<size, T>& operator|=(const Vector<size, T>& other) {
             for(std::size_t i = 0; i != size; ++i)
                 _data[i] |= other._data[i];
 
@@ -898,12 +871,10 @@ template<std::size_t size, class T> class Vector {
          *
          * Enabled only for integral types.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        constexpr Vector<size, T>
-        #else
-        template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
         #endif
-        operator|(const Vector<size, T>& other) const {
+        constexpr Vector<size, T> operator|(const Vector<size, T>& other) const {
             return orInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{});
         }
 
@@ -912,12 +883,10 @@ template<std::size_t size, class T> class Vector {
          *
          * Enabled only for integral types. The computation is done in-place.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        Vector<size, T>&
-        #else
-        template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>&>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
         #endif
-        operator^=(const Vector<size, T>& other) {
+        Vector<size, T>& operator^=(const Vector<size, T>& other) {
             for(std::size_t i = 0; i != size; ++i)
                 _data[i] ^= other._data[i];
 
@@ -929,12 +898,10 @@ template<std::size_t size, class T> class Vector {
          *
          * Enabled only for integral types.
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        constexpr Vector<size, T>
-        #else
-        template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
         #endif
-        operator^(const Vector<size, T>& other) const {
+        constexpr Vector<size, T> operator^(const Vector<size, T>& other) const {
             return xorInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{});
         }
 
@@ -946,7 +913,7 @@ template<std::size_t size, class T> class Vector {
         #ifdef DOXYGEN_GENERATING_OUTPUT
         Vector<size, T>& operator<<=(T shift)
         #else
-        template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>&>::type operator<<=(typename std::common_type<T>::type shift)
+        template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Vector<size, T>& operator<<=(typename std::common_type<T>::type shift)
         #endif
         {
             for(std::size_t i = 0; i != size; ++i)
@@ -963,8 +930,7 @@ template<std::size_t size, class T> class Vector {
         #ifdef DOXYGEN_GENERATING_OUTPUT
         constexpr Vector<size, T> operator<<(T shift) const
         #else
-        template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>>::type
-        operator<<(typename std::common_type<T>::type shift) const
+        template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Vector<size, T> operator<<(typename std::common_type<T>::type shift) const
         #endif
         {
             return shiftLeftInternal(shift, typename Containers::Implementation::GenerateSequence<size>::Type{});
@@ -978,7 +944,7 @@ template<std::size_t size, class T> class Vector {
         #ifdef DOXYGEN_GENERATING_OUTPUT
         Vector<size, T>& operator>>=(T shift)
         #else
-        template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>&>::type operator>>=(typename std::common_type<T>::type shift)
+        template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Vector<size, T>& operator>>=(typename std::common_type<T>::type shift)
         #endif
         {
             for(std::size_t i = 0; i != size; ++i)
@@ -995,8 +961,8 @@ template<std::size_t size, class T> class Vector {
         #ifdef DOXYGEN_GENERATING_OUTPUT
         constexpr Vector<size, T> operator>>(T shift) const
         #else
-        template<class Integral = T>
-        constexpr typename std::enable_if<std::is_integral<Integral>::value, Vector<size, T>>::type operator>>(typename std::common_type<T>::type shift) const
+        template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0>
+        constexpr Vector<size, T> operator>>(typename std::common_type<T>::type shift) const
         #endif
         {
             return shiftRightInternal(shift, typename Containers::Implementation::GenerateSequence<size>::Type{});
@@ -1051,12 +1017,10 @@ template<std::size_t size, class T> class Vector {
          * @see @ref length(), @ref Math::sqrtInverted(), @ref normalized(),
          *      @ref resized()
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        T
-        #else
-        template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, T>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0>
         #endif
-        lengthInverted() const { return T(1)/length(); }
+        T lengthInverted() const { return T(1)/length(); }
 
         /**
          * @brief Normalized vector (of unit length)
@@ -1065,12 +1029,10 @@ template<std::size_t size, class T> class Vector {
          * @see @ref isNormalized(), @ref lengthInverted(), @ref resized()
          * @m_keyword{normalize(),GLSL normalize(),}
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        Vector<size, T>
-        #else
-        template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, Vector<size, T>>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0>
         #endif
-        normalized() const { return *this*lengthInverted(); }
+        Vector<size, T> normalized() const { return *this*lengthInverted(); }
 
         /**
          * @brief Resized vector
@@ -1083,12 +1045,10 @@ template<std::size_t size, class T> class Vector {
          *
          * @see @ref normalized()
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        Vector<size, T>
-        #else
-        template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, Vector<size, T>>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0>
         #endif
-        resized(T length) const {
+        Vector<size, T> resized(T length) const {
             return *this*(lengthInverted()*length);
         }
 
@@ -1101,12 +1061,10 @@ template<std::size_t size, class T> class Vector {
          * @f]
          * @see @ref Math::dot(), @ref projectedOntoNormalized()
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        Vector<size, T>
-        #else
-        template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, Vector<size, T>>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0>
         #endif
-        projected(const Vector<size, T>& line) const {
+        Vector<size, T> projected(const Vector<size, T>& line) const {
             return line*Math::dot(*this, line)/line.dot();
         }
 
@@ -1121,11 +1079,10 @@ template<std::size_t size, class T> class Vector {
          * @see @ref Math::dot()
          */
         #ifdef DOXYGEN_GENERATING_OUTPUT
-        Vector<size, T>
         #else
-        template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, Vector<size, T>>::type
+        template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0>
         #endif
-        projectedOntoNormalized(const Vector<size, T>& line) const;
+        Vector<size, T> projectedOntoNormalized(const Vector<size, T>& line) const;
 
         /**
          * @brief Flipped vector
@@ -1398,8 +1355,7 @@ extern template MAGNUM_EXPORT Debug& operator<<(Debug&, const Vector<4, Double>&
     constexpr Type_<T> operator+() const {                                  \
         return Math::Vector<size, T>::operator+();                          \
     }                                                                       \
-    template<class U = T> constexpr typename std::enable_if<std::is_signed<U>::value, Type_<T>>::type \
-    operator-() const {                                                     \
+    template<class U = T, typename std::enable_if<std::is_signed<U>::value, int>::type = 0> constexpr Type_<T> operator-() const { \
         return Math::Vector<size, T>::negateInternal(typename Containers::Implementation::GenerateSequence<size>::Type{}); \
     }                                                                       \
     Type_<T>& operator+=(const Math::Vector<size, T>& other) {              \
@@ -1427,14 +1383,14 @@ extern template MAGNUM_EXPORT Debug& operator<<(Debug&, const Vector<4, Double>&
     friend constexpr Type_<T> operator*(typename std::common_type<T>::type scalar, const Type_<T>& vector) { \
         return scalar*static_cast<const Math::Vector<size, T>&>(vector);    \
     }                                                                       \
-    template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type_<T>&>::type operator*=(FloatingPoint scalar) { \
+    template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> Type_<T>& operator*=(FloatingPoint scalar) { \
         Math::Vector<size, T>::operator*=(scalar);                          \
         return *this;                                                       \
     }                                                                       \
-    template<class FloatingPoint, class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type_<T>>::type operator*(FloatingPoint scalar) const { \
+    template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> constexpr Type_<T> operator*(FloatingPoint scalar) const { \
         return Math::Vector<size, T>::multiplyIntegerInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
     }                                                                       \
-    template<class FloatingPoint, class Integral = T> friend constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type_<T>>::type operator*(FloatingPoint scalar, const Type_<T>& vector) { \
+    template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> friend constexpr Type_<T> operator*(FloatingPoint scalar, const Type_<T>& vector) { \
         return scalar*static_cast<const Math::Vector<size, T>&>(vector);    \
     }                                                                       \
                                                                             \
@@ -1448,11 +1404,11 @@ extern template MAGNUM_EXPORT Debug& operator<<(Debug&, const Vector<4, Double>&
     friend constexpr Type_<T> operator/(typename std::common_type<T>::type scalar, const Type_<T>& vector) { \
         return scalar/static_cast<const Math::Vector<size, T>&>(vector);    \
     }                                                                       \
-    template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type_<T>&>::type operator/=(FloatingPoint scalar) { \
+    template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> Type_<T>& operator/=(FloatingPoint scalar) { \
         Math::Vector<size, T>::operator/=(scalar);                          \
         return *this;                                                       \
     }                                                                       \
-    template<class FloatingPoint, class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type_<T>>::type operator/(FloatingPoint scalar) const { \
+    template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> constexpr Type_<T> operator/(FloatingPoint scalar) const { \
         return Math::Vector<size, T>::divideIntegerInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
     }                                                                       \
                                                                             \
@@ -1463,14 +1419,14 @@ extern template MAGNUM_EXPORT Debug& operator<<(Debug&, const Vector<4, Double>&
     constexpr Type_<T> operator*(const Math::Vector<size, T>& other) const { \
         return Math::Vector<size, T>::multiplyInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
     }                                                                       \
-    template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type_<T>&>::type operator*=(const Math::Vector<size, FloatingPoint>& other) { \
+    template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> Type_<T>& operator*=(const Math::Vector<size, FloatingPoint>& other) { \
         Math::Vector<size, T>::operator*=(other);                           \
         return *this;                                                       \
     }                                                                       \
-    template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value>::type* = nullptr> constexpr Type_<T> operator*(const Math::Vector<size, FloatingPoint>& other) const { \
+    template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> constexpr Type_<T> operator*(const Math::Vector<size, FloatingPoint>& other) const { \
         return Math::Vector<size, T>::multiplyIntegerInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
     }                                                                       \
-    template<class Integral, class FloatingPoint = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value>::type* = nullptr> constexpr Type_<Integral> operator*(const Math::Vector<size, Integral>& other) const { \
+    template<class Integral, class FloatingPoint = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> constexpr Type_<Integral> operator*(const Math::Vector<size, Integral>& other) const { \
         return other**this;                                                 \
     }                                                                       \
                                                                             \
@@ -1481,78 +1437,78 @@ extern template MAGNUM_EXPORT Debug& operator<<(Debug&, const Vector<4, Double>&
     constexpr Type_<T> operator/(const Math::Vector<size, T>& other) const { \
         return Math::Vector<size, T>::divideInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
     }                                                                       \
-    template<class FloatingPoint, class Integral = T> typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type_<T>&>::type operator/=(const Math::Vector<size, FloatingPoint>& other) { \
+    template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> Type_<T>& operator/=(const Math::Vector<size, FloatingPoint>& other) { \
         Math::Vector<size, T>::operator/=(other);                           \
         return *this;                                                       \
     }                                                                       \
-    template<class FloatingPoint, class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type_<T>>::type operator/(const Math::Vector<size, FloatingPoint>& other) const { \
+    template<class FloatingPoint, class Integral = T, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> constexpr Type_<T> operator/(const Math::Vector<size, FloatingPoint>& other) const { \
         return Math::Vector<size, T>::divideIntegerInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
     }                                                                       \
                                                                             \
-    template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Type_<T>&>::type operator%=(T scalar) { \
+    template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Type_<T>& operator%=(T scalar) { \
         Math::Vector<size, T>::operator%=(scalar);                          \
         return *this;                                                       \
     }                                                                       \
-    template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Type_<T>>::type operator%(T scalar) const { \
+    template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Type_<T> operator%(T scalar) const { \
         return Math::Vector<size, T>::moduloInternal(scalar, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
     }                                                                       \
-    template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Type_<T>&>::type operator%=(const Math::Vector<size, T>& other) { \
+    template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Type_<T>& operator%=(const Math::Vector<size, T>& other) { \
         Math::Vector<size, T>::operator%=(other);                           \
         return *this;                                                       \
     }                                                                       \
-    template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Type_<T>>::type operator%(const Math::Vector<size, T>& other) const { \
+    template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Type_<T> operator%(const Math::Vector<size, T>& other) const { \
         return Math::Vector<size, T>::moduloInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
     }                                                                       \
                                                                             \
-    template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Type_<T>>::type operator~() const { \
+    template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Type_<T> operator~() const { \
         return Math::Vector<size, T>::invertInternal(typename Containers::Implementation::GenerateSequence<size>::Type{}); \
     }                                                                       \
-    template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Type_<T>&>::type operator&=(const Math::Vector<size, T>& other) { \
+    template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Type_<T>& operator&=(const Math::Vector<size, T>& other) { \
         Math::Vector<size, T>::operator&=(other);                           \
         return *this;                                                       \
     }                                                                       \
-    template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Type_<T>>::type operator&(const Math::Vector<size, T>& other) const { \
+    template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Type_<T> operator&(const Math::Vector<size, T>& other) const { \
         return Math::Vector<size, T>::andInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
     }                                                                       \
-    template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Type_<T>&>::type operator|=(const Math::Vector<size, T>& other) { \
+    template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Type_<T>& operator|=(const Math::Vector<size, T>& other) { \
         Math::Vector<size, T>::operator|=(other);                           \
         return *this;                                                       \
     }                                                                       \
-    template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Type_<T>>::type operator|(const Math::Vector<size, T>& other) const { \
+    template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Type_<T> operator|(const Math::Vector<size, T>& other) const { \
         return Math::Vector<size, T>::orInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
     }                                                                       \
-    template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Type_<T>&>::type operator^=(const Math::Vector<size, T>& other) { \
+    template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Type_<T>& operator^=(const Math::Vector<size, T>& other) { \
         Math::Vector<size, T>::operator^=(other);                           \
         return *this;                                                       \
     }                                                                       \
-    template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Type_<T>>::type operator^(const Math::Vector<size, T>& other) const { \
+    template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Type_<T> operator^(const Math::Vector<size, T>& other) const { \
         return Math::Vector<size, T>::xorInternal(other, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
     }                                                                       \
-    template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Type_<T>&>::type operator<<=(typename std::common_type<T>::type shift) { \
+    template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Type_<T>& operator<<=(typename std::common_type<T>::type shift) { \
         Math::Vector<size, T>::operator<<=(shift);                          \
         return *this;                                                       \
     }                                                                       \
-    template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Type_<T>>::type operator<<(typename std::common_type<T>::type shift) const { \
+    template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Type_<T> operator<<(typename std::common_type<T>::type shift) const { \
         return Math::Vector<size, T>::shiftLeftInternal(shift, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
     }                                                                       \
-    template<class Integral = T> typename std::enable_if<std::is_integral<Integral>::value, Type_<T>&>::type operator>>=(typename std::common_type<T>::type shift) { \
+    template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> Type_<T>& operator>>=(typename std::common_type<T>::type shift) { \
         Math::Vector<size, T>::operator>>=(shift);                          \
         return *this;                                                       \
     }                                                                       \
-    template<class Integral = T> constexpr typename std::enable_if<std::is_integral<Integral>::value, Type_<T>>::type operator>>(typename std::common_type<T>::type shift) const { \
+    template<class Integral = T, typename std::enable_if<std::is_integral<Integral>::value, int>::type = 0> constexpr Type_<T> operator>>(typename std::common_type<T>::type shift) const { \
         return Math::Vector<size, T>::shiftRightInternal(shift, typename Containers::Implementation::GenerateSequence<size>::Type{}); \
     }                                                                       \
                                                                             \
-    template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, Type_<T>>::type normalized() const { \
+    template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0> Type_<T> normalized() const { \
         return Math::Vector<size, T>::normalized();                         \
     }                                                                       \
-    template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, Type_<T>>::type resized(T length) const { \
+    template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0> Type_<T> resized(T length) const { \
         return Math::Vector<size, T>::resized(length);                      \
     }                                                                       \
-    template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, Type_<T>>::type projected(const Math::Vector<size, T>& other) const { \
+    template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0> Type_<T> projected(const Math::Vector<size, T>& other) const { \
         return Math::Vector<size, T>::projected(other);                     \
     }                                                                       \
-    template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, Type_<T>>::type projectedOntoNormalized(const Math::Vector<size, T>& other) const { \
+    template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0> Type_<T> projectedOntoNormalized(const Math::Vector<size, T>& other) const { \
         return Math::Vector<size, T>::projectedOntoNormalized(other);       \
     }                                                                       \
     constexpr Type_<T> flipped() const {                                    \
@@ -1570,12 +1526,12 @@ extern template MAGNUM_EXPORT Debug& operator<<(Debug&, const Vector<4, Double>&
    VectorTest::subclass() and corresponding cases in Vector2Test, Vector3Test,
    Vector4Test and ColorTest for regression tests. The same issue and a
    matching workaround is done in Unit as well. */
-template<std::size_t size, class FloatingPoint, class Integral> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Vector<size, Integral>>::type operator*(FloatingPoint scalar, const Vector<size, Integral>& vector) {
+template<std::size_t size, class FloatingPoint, class Integral, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> constexpr Vector<size, Integral> operator*(FloatingPoint scalar, const Vector<size, Integral>& vector) {
     return vector*scalar;
 }
 
 #define MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(size, Type)                   \
-    template<class FloatingPoint, class Integral> constexpr typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, Type<Integral>>::type operator*(FloatingPoint scalar, const Type<Integral>& vector) { \
+    template<class FloatingPoint, class Integral, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> constexpr Type<Integral> operator*(FloatingPoint scalar, const Type<Integral>& vector) { \
         return vector*scalar;                                               \
     }
 #endif
@@ -1617,12 +1573,10 @@ template<std::size_t size, class T> inline BitVector<size> Vector<size, T>::oper
 }
 
 template<std::size_t size, class T>
-#ifdef DOXYGEN_GENERATING_OUTPUT
-inline Vector<size, T>
-#else
-template<class U> inline typename std::enable_if<std::is_floating_point<U>::value, Vector<size, T>>::type
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<class U, typename std::enable_if<std::is_floating_point<U>::value, int>::type>
 #endif
-Vector<size, T>::projectedOntoNormalized(const Vector<size, T>& line) const {
+inline Vector<size, T> Vector<size, T>::projectedOntoNormalized(const Vector<size, T>& line) const {
     CORRADE_DEBUG_ASSERT(line.isNormalized(),
         "Math::Vector::projectedOntoNormalized(): line" << line << "is not normalized", {});
     return line*Math::dot(*this, line);
diff --git a/src/Magnum/Math/Vector2.h b/src/Magnum/Math/Vector2.h
index caf359a7b..78285dd38 100644
--- a/src/Magnum/Math/Vector2.h
+++ b/src/Magnum/Math/Vector2.h
@@ -220,12 +220,10 @@ template<class T> class Vector2: public Vector<2, T> {
          *      @ref Vector::operator-() const "operator-() const"
          */
         /* For some reason @ref operator-() const doesn't work since 1.8.17 */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        Vector2<T>
-        #else
-        template<class U = T> typename std::enable_if<std::is_signed<U>::value, Vector2<T>>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class U = T, typename std::enable_if<std::is_signed<U>::value, int>::type = 0>
         #endif
-        perpendicular() const { return {-y(), x()}; }
+        Vector2<T> perpendicular() const { return {-y(), x()}; }
 
         /**
          * @brief Aspect ratio
@@ -235,12 +233,10 @@ template<class T> class Vector2: public Vector<2, T> {
          *      a = \frac{v_x}{v_y}
          * @f]
          */
-        #ifdef DOXYGEN_GENERATING_OUTPUT
-        T
-        #else
-        template<class U = T> typename std::enable_if<std::is_floating_point<U>::value, T>::type
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        template<class U = T, typename std::enable_if<std::is_floating_point<U>::value, int>::type = 0>
         #endif
-        aspectRatio() const { return x()/y(); }
+        T aspectRatio() const { return x()/y(); }
 
         MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(2, Vector2)
 
diff --git a/src/Magnum/MeshTools/Interleave.h b/src/Magnum/MeshTools/Interleave.h
index 91300d966..f560c2e81 100644
--- a/src/Magnum/MeshTools/Interleave.h
+++ b/src/Magnum/MeshTools/Interleave.h
@@ -50,7 +50,7 @@ namespace Implementation {
    resolution (the functions would otherwise need to be de-inlined to break
    cyclic dependencies) */
 struct AttributeCount {
-    template<class T, class ...U> typename std::enable_if<!std::is_convertible<T, std::size_t>::value, std::size_t>::type operator()(const T& first, const U&...
+    template<class T, class ...U, typename std::enable_if<!std::is_convertible<T, std::size_t>::value, int>::type = 0> std::size_t operator()(const T& first, const U&...
         #ifndef CORRADE_NO_ASSERT
         next
         #endif
@@ -90,7 +90,7 @@ template<class T> constexpr std::size_t typeSize() {
 /* Stride, taking gaps into account. It must be in the structure, same reason
    as above */
 struct Stride {
-    template<class T, class ...U> typename std::enable_if<!std::is_convertible<T, std::size_t>::value, std::size_t>::type operator()(const T&, const U&... next) const {
+    template<class T, class ...U, typename std::enable_if<!std::is_convertible<T, std::size_t>::value, int>::type = 0> std::size_t operator()(const T&, const U&... next) const {
         return typeSize<T>() + Stride{}(next...);
     }
     template<class... T> std::size_t operator()(std::size_t gap, const T&... next) const {
@@ -100,7 +100,7 @@ struct Stride {
 };
 
 /* Copy data to the buffer */
-template<class T> typename std::enable_if<!std::is_convertible<T, std::size_t>::value, std::size_t>::type writeOneInterleaved(std::size_t stride, char* startingOffset, const T& attributeList) {
+template<class T, typename std::enable_if<!std::is_convertible<T, std::size_t>::value, int>::type = 0> std::size_t writeOneInterleaved(std::size_t stride, char* startingOffset, const T& attributeList) {
     auto it = attributeList.begin();
     for(std::size_t i = 0; i != attributeList.size(); ++i, ++it)
         std::memcpy(startingOffset + i*stride, reinterpret_cast<const char*>(&*it), typeSize<T>());
@@ -150,7 +150,7 @@ would be 21 bytes, causing possible performance loss.
 template<class T, class ...U
     #ifndef DOXYGEN_GENERATING_OUTPUT
     /* So it doesn't clash with the MeshData variant */
-    , class = typename std::enable_if<Utility::IsIterable<T>::value>::type
+    , typename std::enable_if<Utility::IsIterable<T>::value, int>::type = 0
     #endif
 > Containers::Array<char> interleave(const T& first, const U&... next)
 {
diff --git a/src/Magnum/Platform/ScreenedApplication.h b/src/Magnum/Platform/ScreenedApplication.h
index 661fac76c..aa82f12bb 100644
--- a/src/Magnum/Platform/ScreenedApplication.h
+++ b/src/Magnum/Platform/ScreenedApplication.h
@@ -295,8 +295,8 @@ template<class Application> class BasicScreenedApplication:
         CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now") const BasicScreenedApplication<Application>& operator*() const { return *this; }
         CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now") operator BasicScreenedApplication<Application>*() { return this; }
         CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now") operator const BasicScreenedApplication<Application>*() const { return this; }
-        template<class T, class = typename std::enable_if<std::is_base_of<BasicScreenedApplication<Application>, T>::value>::type> CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now") operator T*() { return static_cast<T*>(this); }
-        template<class T, class = typename std::enable_if<std::is_base_of<BasicScreenedApplication<Application>, T>::value>::type> CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now") operator const T*() const { return static_cast<const T*>(this); }
+        template<class T, typename std::enable_if<std::is_base_of<BasicScreenedApplication<Application>, T>::value, int>::type = 0> CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now") operator T*() { return static_cast<T*>(this); }
+        template<class T, typename std::enable_if<std::is_base_of<BasicScreenedApplication<Application>, T>::value, int>::type = 0> CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now") operator const T*() const { return static_cast<const T*>(this); }
         CORRADE_DEPRECATED("Platform::Screen::application() returns a reference now, use hasApplication() instead") bool operator!() const { return false; }
         #endif
 
diff --git a/src/Magnum/SceneGraph/AbstractFeature.h b/src/Magnum/SceneGraph/AbstractFeature.h
index 03f9a6170..1c4fe4d49 100644
--- a/src/Magnum/SceneGraph/AbstractFeature.h
+++ b/src/Magnum/SceneGraph/AbstractFeature.h
@@ -161,7 +161,7 @@ template<UnsignedInt dimensions, class T> class AbstractFeature
         /* This is here to avoid ambiguity with deleted copy constructor when
            passing `*this` from class subclassing both AbstractFeature and
            AbstractObject */
-        template<class U, class = typename std::enable_if<std::is_base_of<AbstractObject<dimensions, T>, U>::value>::type> AbstractFeature(U& object): AbstractFeature(static_cast<AbstractObject<dimensions, T>&>(object)) {}
+        template<class U, typename std::enable_if<std::is_base_of<AbstractObject<dimensions, T>, U>::value, int>::type = 0> AbstractFeature(U& object): AbstractFeature(static_cast<AbstractObject<dimensions, T>&>(object)) {}
         #endif
 
         virtual ~AbstractFeature() = 0;
diff --git a/src/Magnum/SceneGraph/Animable.h b/src/Magnum/SceneGraph/Animable.h
index f506cd44a..6ddbd5586 100644
--- a/src/Magnum/SceneGraph/Animable.h
+++ b/src/Magnum/SceneGraph/Animable.h
@@ -139,7 +139,7 @@ template<UnsignedInt dimensions, class T> class Animable: public AbstractGrouped
         #ifndef DOXYGEN_GENERATING_OUTPUT
         /* This is here to avoid ambiguity with deleted copy constructor when
            passing `*this` from class subclassing both Animable and AbstractObject */
-        template<class U, class = typename std::enable_if<std::is_base_of<AbstractObject<dimensions, T>, U>::value>::type> explicit Animable(U& object): Animable<dimensions, T>{static_cast<AbstractObject<dimensions, T>&>(object)} {}
+        template<class U, typename std::enable_if<std::is_base_of<AbstractObject<dimensions, T>, U>::value, int>::type = 0> explicit Animable(U& object): Animable<dimensions, T>{static_cast<AbstractObject<dimensions, T>&>(object)} {}
         #endif
 
         ~Animable();
diff --git a/src/Magnum/SceneGraph/Camera.h b/src/Magnum/SceneGraph/Camera.h
index dc678fb72..9fec34d71 100644
--- a/src/Magnum/SceneGraph/Camera.h
+++ b/src/Magnum/SceneGraph/Camera.h
@@ -100,7 +100,7 @@ template<UnsignedInt dimensions, class T> class Camera: public AbstractFeature<d
         #ifndef DOXYGEN_GENERATING_OUTPUT
         /* This is here to avoid ambiguity with deleted copy constructor when
            passing `*this` from class subclassing both Camera and AbstractObject */
-        template<class U, class = typename std::enable_if<std::is_base_of<AbstractObject<dimensions, T>, U>::value>::type> explicit Camera(U& object): Camera<dimensions, T>{static_cast<AbstractObject<dimensions, T>&>(object)} {}
+        template<class U, typename std::enable_if<std::is_base_of<AbstractObject<dimensions, T>, U>::value, int>::type = 0> explicit Camera(U& object): Camera<dimensions, T>{static_cast<AbstractObject<dimensions, T>&>(object)} {}
         #endif
 
         ~Camera();
diff --git a/src/Magnum/SceneGraph/Drawable.h b/src/Magnum/SceneGraph/Drawable.h
index 8fbcf315e..16898f826 100644
--- a/src/Magnum/SceneGraph/Drawable.h
+++ b/src/Magnum/SceneGraph/Drawable.h
@@ -162,7 +162,7 @@ template<UnsignedInt dimensions, class T> class Drawable: public AbstractGrouped
         #ifndef DOXYGEN_GENERATING_OUTPUT
         /* This is here to avoid ambiguity with deleted copy constructor when
            passing `*this` from class subclassing both Drawable and AbstractObject */
-        template<class U, class = typename std::enable_if<std::is_base_of<AbstractObject<dimensions, T>, U>::value>::type> explicit Drawable(U& object): Drawable<dimensions, T>{static_cast<AbstractObject<dimensions, T>&>(object)} {}
+        template<class U, typename std::enable_if<std::is_base_of<AbstractObject<dimensions, T>, U>::value, int>::type = 0> explicit Drawable(U& object): Drawable<dimensions, T>{static_cast<AbstractObject<dimensions, T>&>(object)} {}
         #endif
 
         /**
diff --git a/src/Magnum/Trade/MaterialData.h b/src/Magnum/Trade/MaterialData.h
index dfbab0c34..75c1ef2b5 100644
--- a/src/Magnum/Trade/MaterialData.h
+++ b/src/Magnum/Trade/MaterialData.h
@@ -1408,7 +1408,7 @@ class MAGNUM_TRADE_EXPORT MaterialAttributeData {
          */
         template<class T
             #ifndef DOXYGEN_GENERATING_OUTPUT
-            , class = typename std::enable_if<!std::is_convertible<const T&, Containers::StringView>::value && !std::is_convertible<const T&, Containers::ArrayView<const void>>::value>::type
+            , typename std::enable_if<!std::is_convertible<const T&, Containers::StringView>::value && !std::is_convertible<const T&, Containers::ArrayView<const void>>::value, int>::type = 0
             #endif
         > constexpr /*implicit*/ MaterialAttributeData(Containers::StringView name, const T& value) noexcept;
 
@@ -1447,7 +1447,7 @@ class MAGNUM_TRADE_EXPORT MaterialAttributeData {
         #ifndef DOXYGEN_GENERATING_OUTPUT
         /* "Sure can't be constexpr" overloads to avoid going through the
            *insane* overload puzzle when not needed */
-        template<class T, class = typename std::enable_if<!std::is_convertible<const T&, Containers::StringView>::value && !std::is_convertible<const T&, Containers::ArrayView<const void>>::value>::type> /*implicit*/ MaterialAttributeData(const char* name, const T& value) noexcept: MaterialAttributeData{name, Implementation::MaterialAttributeTypeFor<T>::type(), sizeof(T), &value} {}
+        template<class T, typename std::enable_if<!std::is_convertible<const T&, Containers::StringView>::value && !std::is_convertible<const T&, Containers::ArrayView<const void>>::value, int>::type = 0> /*implicit*/ MaterialAttributeData(const char* name, const T& value) noexcept: MaterialAttributeData{name, Implementation::MaterialAttributeTypeFor<T>::type(), sizeof(T), &value} {}
         /*implicit*/ MaterialAttributeData(const char* name, Containers::StringView value) noexcept: MaterialAttributeData{name, MaterialAttributeType::String, 0, &value} {}
         #endif
 
@@ -1466,7 +1466,7 @@ class MAGNUM_TRADE_EXPORT MaterialAttributeData {
          */
         template<class T
             #ifndef DOXYGEN_GENERATING_OUTPUT
-            , class = typename std::enable_if<!std::is_convertible<const T&, Containers::StringView>::value>::type
+            , typename std::enable_if<!std::is_convertible<const T&, Containers::StringView>::value, int>::type = 0
             #endif
         > /*implicit*/ MaterialAttributeData(MaterialAttribute name, const T& value) noexcept: MaterialAttributeData{name, Implementation::MaterialAttributeTypeFor<T>::type(), &value} {}
 
@@ -1677,18 +1677,18 @@ class MAGNUM_TRADE_EXPORT MaterialAttributeData {
 
             constexpr explicit Storage(Containers::StringView name, Containers::StringView value) noexcept: s{MaterialAttributeType::String, name, value} {}
 
-            template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 1, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _1{type, name, value} {}
-            template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 4 && !std::is_pointer<T>::value, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _4{type, name, value} {}
-            template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 8 && !Math::IsVector<T>::value && !std::is_pointer<T>::value, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _8{type, name, value} {}
-            template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 8 && Math::IsVector<T>::value && !std::is_pointer<T>::value, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _8v{type, name, value} {}
+            template<class T, typename std::enable_if<sizeof(T) == 1, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _1{type, name, value} {}
+            template<class T, typename std::enable_if<sizeof(T) == 4 && !std::is_pointer<T>::value, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _4{type, name, value} {}
+            template<class T, typename std::enable_if<sizeof(T) == 8 && !Math::IsVector<T>::value && !std::is_pointer<T>::value, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _8{type, name, value} {}
+            template<class T, typename std::enable_if<sizeof(T) == 8 && Math::IsVector<T>::value && !std::is_pointer<T>::value, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _8v{type, name, value} {}
             constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const void* value) noexcept: p{type, name, value} {}
-            template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 12, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _12{type, name, value} {}
-            template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 16 && Math::IsVector<T>::value, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _16{type, name, value} {}
-            template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 16 && !Math::IsVector<T>::value, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _16m{type, name, value} {}
-            template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 24, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _24{type, name, value} {}
-            template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 32, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _32{type, name, value} {}
-            template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 36, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _36{type, name, value} {}
-            template<class T> constexpr explicit Storage(typename std::enable_if<sizeof(T) == 48, MaterialAttributeType>::type type, Containers::StringView name, const T& value) noexcept: _48{type, name, value} {}
+            template<class T, typename std::enable_if<sizeof(T) == 12, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _12{type, name, value} {}
+            template<class T, typename std::enable_if<sizeof(T) == 16 && Math::IsVector<T>::value, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _16{type, name, value} {}
+            template<class T, typename std::enable_if<sizeof(T) == 16 && !Math::IsVector<T>::value, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _16m{type, name, value} {}
+            template<class T, typename std::enable_if<sizeof(T) == 24, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _24{type, name, value} {}
+            template<class T, typename std::enable_if<sizeof(T) == 32, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _32{type, name, value} {}
+            template<class T, typename std::enable_if<sizeof(T) == 36, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _36{type, name, value} {}
+            template<class T, typename std::enable_if<sizeof(T) == 48, int>::type = 0> constexpr explicit Storage(MaterialAttributeType type, Containers::StringView name, const T& value) noexcept: _48{type, name, value} {}
 
             MaterialAttributeType type;
             char data[Implementation::MaterialAttributeDataSize];
@@ -3563,7 +3563,7 @@ namespace Implementation {
 /* The 2 extra bytes are for a null byte after the name and a type */
 template<class T
     #ifndef DOXYGEN_GENERATING_OUTPUT
-    , class
+    , typename std::enable_if<!std::is_convertible<const T&, Containers::StringView>::value && !std::is_convertible<const T&, Containers::ArrayView<const void>>::value, int>::type
     #endif
 > constexpr MaterialAttributeData::MaterialAttributeData(const Containers::StringView name, const T& value) noexcept:
     _data{Implementation::MaterialAttributeTypeFor<T>::type(), (
diff --git a/src/Magnum/Trade/MeshData.h b/src/Magnum/Trade/MeshData.h
index 72a2f8f3d..ffb533ead 100644
--- a/src/Magnum/Trade/MeshData.h
+++ b/src/Magnum/Trade/MeshData.h
@@ -313,7 +313,7 @@ class MAGNUM_TRADE_EXPORT MeshIndexData {
          * @ref MeshIndexData(std::nullptr_t) constructor.
          */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<class T, class = typename std::enable_if<std::is_convertible<T, Containers::ArrayView<const void>>::value>::type> explicit MeshIndexData(MeshIndexType type, T&& data) noexcept;
+        template<class T, typename std::enable_if<std::is_convertible<T, Containers::ArrayView<const void>>::value, int>::type = 0> explicit MeshIndexData(MeshIndexType type, T&& data) noexcept;
         #else
         explicit MeshIndexData(MeshIndexType type, Containers::ArrayView<const void> data) noexcept;
         #endif
@@ -523,7 +523,7 @@ class MAGNUM_TRADE_EXPORT MeshAttributeData {
            offset-only constructor (where 0 passed to offset would match with
            std::nullptr_t). 0 as null pointer constant was deprecated in C++11
            already, WHY IS THIS STILL A PROBLEM?! */
-        template<class U, class = typename std::enable_if<std::is_convertible<U, std::nullptr_t>::value && !std::is_convertible<U, std::size_t>::value>::type> explicit MeshAttributeData(MeshAttribute name, VertexFormat format, U, UnsignedShort arraySize = 0, Int morphTargetId = -1) noexcept: MeshAttributeData{nullptr, name, format, nullptr, arraySize, morphTargetId} {}
+        template<class U, typename std::enable_if<std::is_convertible<U, std::nullptr_t>::value && !std::is_convertible<U, std::size_t>::value, int>::type = 0> explicit MeshAttributeData(MeshAttribute name, VertexFormat format, U, UnsignedShort arraySize = 0, Int morphTargetId = -1) noexcept: MeshAttributeData{nullptr, name, format, nullptr, arraySize, morphTargetId} {}
         #endif
 
         /**
@@ -1770,7 +1770,11 @@ class MAGNUM_TRADE_EXPORT MeshData {
          *      @ref isVertexFormatImplementationSpecific(),
          *      @ref attributeArraySize()
          */
-        template<class T, class = typename std::enable_if<!std::is_array<T>::value>::type> Containers::StridedArrayView1D<const T> attribute(UnsignedInt id) const;
+        template<class T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<!std::is_array<T>::value, int>::type = 0
+            #endif
+        > Containers::StridedArrayView1D<const T> attribute(UnsignedInt id) const;
 
         /**
          * @brief Data for given array attribute in a concrete type
@@ -1782,7 +1786,11 @@ class MAGNUM_TRADE_EXPORT MeshData {
          * @ref attributeArraySize() for given attribute. For non-array
          * attributes the second dimension has a size of @cpp 1 @ce.
          */
-        template<class T, class = typename std::enable_if<std::is_array<T>::value>::type> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> attribute(UnsignedInt id) const;
+        template<class T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<std::is_array<T>::value, int>::type = 0
+            #endif
+        > Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> attribute(UnsignedInt id) const;
 
         /**
          * @brief Mutable data for given attribute in a concrete type
@@ -1791,7 +1799,11 @@ class MAGNUM_TRADE_EXPORT MeshData {
          * Expects that the mesh is mutable.
          * @see @ref vertexDataFlags()
          */
-        template<class T, class = typename std::enable_if<!std::is_array<T>::value>::type> Containers::StridedArrayView1D<T> mutableAttribute(UnsignedInt id);
+        template<class T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<!std::is_array<T>::value, int>::type = 0
+            #endif
+        > Containers::StridedArrayView1D<T> mutableAttribute(UnsignedInt id);
 
         /**
          * @brief Mutable data for given array attribute in a concrete type
@@ -1803,7 +1815,11 @@ class MAGNUM_TRADE_EXPORT MeshData {
          * @ref attributeArraySize() for given attribute. For non-array
          * attributes the second dimension has a size of @cpp 1 @ce.
          */
-        template<class T, class = typename std::enable_if<std::is_array<T>::value>::type> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> mutableAttribute(UnsignedInt id);
+        template<class T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<std::is_array<T>::value, int>::type = 0
+            #endif
+        > Containers::StridedArrayView2D<typename std::remove_extent<T>::type> mutableAttribute(UnsignedInt id);
 
         /**
          * @brief Data for given named attribute
@@ -1853,7 +1869,11 @@ class MAGNUM_TRADE_EXPORT MeshData {
          *      @ref mutableAttribute(MeshAttribute, UnsignedInt, Int),
          *      @ref isVertexFormatImplementationSpecific()
          */
-        template<class T, class = typename std::enable_if<!std::is_array<T>::value>::type> Containers::StridedArrayView1D<const T> attribute(MeshAttribute name, UnsignedInt id = 0, Int morphTargetId = -1) const;
+        template<class T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<!std::is_array<T>::value, int>::type = 0
+            #endif
+        > Containers::StridedArrayView1D<const T> attribute(MeshAttribute name, UnsignedInt id = 0, Int morphTargetId = -1) const;
 
         /**
          * @brief Data for given named array attribute in a concrete type
@@ -1865,7 +1885,11 @@ class MAGNUM_TRADE_EXPORT MeshData {
          * @ref attributeArraySize() for given attribute. For non-array
          * attributes the second dimension has a size of @cpp 1 @ce.
          */
-        template<class T, class = typename std::enable_if<std::is_array<T>::value>::type> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> attribute(MeshAttribute name, UnsignedInt id = 0, Int morphTargetId = -1) const;
+        template<class T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<std::is_array<T>::value, int>::type = 0
+            #endif
+        > Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> attribute(MeshAttribute name, UnsignedInt id = 0, Int morphTargetId = -1) const;
 
         /**
          * @brief Mutable data for given named attribute in a concrete type
@@ -1874,7 +1898,11 @@ class MAGNUM_TRADE_EXPORT MeshData {
          * returns a mutable view. Expects that the mesh is mutable.
          * @see @ref vertexDataFlags()
          */
-        template<class T, class = typename std::enable_if<!std::is_array<T>::value>::type> Containers::StridedArrayView1D<T> mutableAttribute(MeshAttribute name, UnsignedInt id = 0, Int morphTargetId = -1);
+        template<class T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<!std::is_array<T>::value, int>::type = 0
+            #endif
+        > Containers::StridedArrayView1D<T> mutableAttribute(MeshAttribute name, UnsignedInt id = 0, Int morphTargetId = -1);
 
         /**
          * @brief Mutable data for given named array attribute in a concrete type
@@ -1886,7 +1914,11 @@ class MAGNUM_TRADE_EXPORT MeshData {
          * @ref attributeArraySize() for given attribute. For non-array
          * attributes the second dimension has a size of @cpp 1 @ce.
          */
-        template<class T, class = typename std::enable_if<std::is_array<T>::value>::type> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> mutableAttribute(MeshAttribute name, UnsignedInt id = 0, Int morphTargetId = -1);
+        template<class T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<std::is_array<T>::value, int>::type = 0
+            #endif
+        > Containers::StridedArrayView2D<typename std::remove_extent<T>::type> mutableAttribute(MeshAttribute name, UnsignedInt id = 0, Int morphTargetId = -1);
 
         /**
          * @brief Indices as 32-bit integers
@@ -2330,7 +2362,7 @@ namespace Implementation {
 }
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
-template<class T, class> MeshIndexData::MeshIndexData(const MeshIndexType type, T&& data) noexcept: _type{type} {
+template<class T, typename std::enable_if<std::is_convertible<T, Containers::ArrayView<const void>>::value, int>::type> MeshIndexData::MeshIndexData(const MeshIndexType type, T&& data) noexcept: _type{type} {
     const Containers::ArrayView<const void> erased = data;
     CORRADE_ASSERT(!isMeshIndexTypeImplementationSpecific(type),
         "Trade::MeshIndexData: can't create index data from a contiguous view and an implementation-specific type" << Debug::hex << meshIndexTypeUnwrap(type) << Debug::nospace << ", pass a strided view instead", );
@@ -2737,7 +2769,8 @@ template<class T> bool MeshData::checkVertexFormatCompatibility(const MeshAttrib
 }
 #endif
 
-template<class T, class> Containers::StridedArrayView1D<const T> MeshData::attribute(const UnsignedInt id) const {
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<class T, typename std::enable_if<!std::is_array<T>::value, int>::type> Containers::StridedArrayView1D<const T> MeshData::attribute(const UnsignedInt id) const {
     Containers::StridedArrayView2D<const char> data = attribute(id);
     #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
     if(!data.stride()[1]) return {};
@@ -2748,7 +2781,7 @@ template<class T, class> Containers::StridedArrayView1D<const T> MeshData::attri
     return Containers::arrayCast<1, const T>(data);
 }
 
-template<class T, class> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> MeshData::attribute(const UnsignedInt id) const {
+template<class T, typename std::enable_if<std::is_array<T>::value, int>::type> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> MeshData::attribute(const UnsignedInt id) const {
     Containers::StridedArrayView2D<const char> data = attribute(id);
     #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
     if(!data.stride()[1]) return {};
@@ -2759,7 +2792,7 @@ template<class T, class> Containers::StridedArrayView2D<const typename std::remo
     return Containers::arrayCast<2, const typename std::remove_extent<T>::type>(data);
 }
 
-template<class T, class> Containers::StridedArrayView1D<T> MeshData::mutableAttribute(const UnsignedInt id) {
+template<class T, typename std::enable_if<!std::is_array<T>::value, int>::type> Containers::StridedArrayView1D<T> MeshData::mutableAttribute(const UnsignedInt id) {
     Containers::StridedArrayView2D<char> data = mutableAttribute(id);
     #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
     if(!data.stride()[1]) return {};
@@ -2770,7 +2803,7 @@ template<class T, class> Containers::StridedArrayView1D<T> MeshData::mutableAttr
     return Containers::arrayCast<1, T>(data);
 }
 
-template<class T, class> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> MeshData::mutableAttribute(const UnsignedInt id) {
+template<class T, typename std::enable_if<std::is_array<T>::value, int>::type> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> MeshData::mutableAttribute(const UnsignedInt id) {
     Containers::StridedArrayView2D<char> data = mutableAttribute(id);
     #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
     if(!data.stride()[1]) return {};
@@ -2781,7 +2814,7 @@ template<class T, class> Containers::StridedArrayView2D<typename std::remove_ext
     return Containers::arrayCast<2, typename std::remove_extent<T>::type>(data);
 }
 
-template<class T, class> Containers::StridedArrayView1D<const T> MeshData::attribute(const MeshAttribute name, const UnsignedInt id, const Int morphTargetId) const {
+template<class T, typename std::enable_if<!std::is_array<T>::value, int>::type> Containers::StridedArrayView1D<const T> MeshData::attribute(const MeshAttribute name, const UnsignedInt id, const Int morphTargetId) const {
     const UnsignedInt attributeId = findAttributeIdInternal(name, id, morphTargetId);
     #ifndef CORRADE_NO_ASSERT
     if(morphTargetId == -1) CORRADE_ASSERT(attributeId != ~UnsignedInt{},
@@ -2798,7 +2831,7 @@ template<class T, class> Containers::StridedArrayView1D<const T> MeshData::attri
     return Containers::arrayCast<1, const T>(data);
 }
 
-template<class T, class> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> MeshData::attribute(const MeshAttribute name, const UnsignedInt id, const Int morphTargetId) const {
+template<class T, typename std::enable_if<std::is_array<T>::value, int>::type> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> MeshData::attribute(const MeshAttribute name, const UnsignedInt id, const Int morphTargetId) const {
     const UnsignedInt attributeId = findAttributeIdInternal(name, id, morphTargetId);
     #ifndef CORRADE_NO_ASSERT
     if(morphTargetId == -1) CORRADE_ASSERT(attributeId != ~UnsignedInt{},
@@ -2815,7 +2848,7 @@ template<class T, class> Containers::StridedArrayView2D<const typename std::remo
     return Containers::arrayCast<2, const typename std::remove_extent<T>::type>(data);
 }
 
-template<class T, class> Containers::StridedArrayView1D<T> MeshData::mutableAttribute(const MeshAttribute name, const UnsignedInt id, const Int morphTargetId) {
+template<class T, typename std::enable_if<!std::is_array<T>::value, int>::type> Containers::StridedArrayView1D<T> MeshData::mutableAttribute(const MeshAttribute name, const UnsignedInt id, const Int morphTargetId) {
     const UnsignedInt attributeId = findAttributeIdInternal(name, id, morphTargetId);
     #ifndef CORRADE_NO_ASSERT
     if(morphTargetId == -1) CORRADE_ASSERT(attributeId != ~UnsignedInt{},
@@ -2833,7 +2866,7 @@ template<class T, class> Containers::StridedArrayView1D<T> MeshData::mutableAttr
     return Containers::arrayCast<1, T>(data);
 }
 
-template<class T, class> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> MeshData::mutableAttribute(const MeshAttribute name, const UnsignedInt id, const Int morphTargetId) {
+template<class T, typename std::enable_if<std::is_array<T>::value, int>::type> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> MeshData::mutableAttribute(const MeshAttribute name, const UnsignedInt id, const Int morphTargetId) {
     const UnsignedInt attributeId = findAttributeIdInternal(name, id, morphTargetId);
     #ifndef CORRADE_NO_ASSERT
     if(morphTargetId == -1) CORRADE_ASSERT(attributeId != ~UnsignedInt{},
@@ -2850,6 +2883,7 @@ template<class T, class> Containers::StridedArrayView2D<typename std::remove_ext
     #endif
     return Containers::arrayCast<2, typename std::remove_extent<T>::type>(data);
 }
+#endif
 
 }}
 
diff --git a/src/Magnum/Trade/SceneData.h b/src/Magnum/Trade/SceneData.h
index 54310f4af..cc6c6f5f1 100644
--- a/src/Magnum/Trade/SceneData.h
+++ b/src/Magnum/Trade/SceneData.h
@@ -2528,7 +2528,11 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @see @ref field(SceneField) const, @ref mutableField(UnsignedInt),
          *      @ref fieldArraySize()
          */
-        template<class T, class = typename std::enable_if<!std::is_array<T>::value>::type> Containers::StridedArrayView1D<const T> field(UnsignedInt id) const;
+        template<class T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<!std::is_array<T>::value, int>::type = 0
+            #endif
+        > Containers::StridedArrayView1D<const T> field(UnsignedInt id) const;
 
         /**
          * @brief Data for given array field in a concrete type
@@ -2541,7 +2545,11 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @ref fieldArraySize(UnsignedInt) const for given field. For
          * non-array fields the second dimension has a size of @cpp 1 @ce.
          */
-        template<class T, class = typename std::enable_if<std::is_array<T>::value>::type> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> field(UnsignedInt id) const;
+        template<class T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<std::is_array<T>::value, int>::type = 0
+            #endif
+        > Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> field(UnsignedInt id) const;
 
         /**
          * @brief Mutable data for given field in a concrete type
@@ -2551,7 +2559,11 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * Expects that the scene is mutable.
          * @see @ref dataFlags()
          */
-        template<class T, class = typename std::enable_if<!std::is_array<T>::value>::type> Containers::StridedArrayView1D<T> mutableField(UnsignedInt id);
+        template<class T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<!std::is_array<T>::value, int>::type = 0
+            #endif
+        > Containers::StridedArrayView1D<T> mutableField(UnsignedInt id);
 
         /**
          * @brief Mutable data for given array field in a concrete type
@@ -2564,7 +2576,11 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @ref fieldArraySize(UnsignedInt) const for given field. For
          * non-array fields the second dimension has a size of @cpp 1 @ce.
          */
-        template<class T, class = typename std::enable_if<std::is_array<T>::value>::type> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> mutableField(UnsignedInt id);
+        template<class T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<std::is_array<T>::value, int>::type = 0
+            #endif
+        > Containers::StridedArrayView2D<typename std::remove_extent<T>::type> mutableField(UnsignedInt id);
 
         /**
          * @brief Data for given named field
@@ -2608,7 +2624,11 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @see @ref hasField(), @ref field(UnsignedInt) const,
          *      @ref mutableField(SceneField)
          */
-        template<class T, class = typename std::enable_if<!std::is_array<T>::value>::type> Containers::StridedArrayView1D<const T> field(SceneField name) const;
+        template<class T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<!std::is_array<T>::value, int>::type = 0
+            #endif
+        > Containers::StridedArrayView1D<const T> field(SceneField name) const;
 
         /**
          * @brief Data for given named array field in a concrete type
@@ -2621,7 +2641,11 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @ref fieldArraySize(SceneField) const for given field. For non-array
          * fields the second dimension has a size of @cpp 1 @ce.
          */
-        template<class T, class = typename std::enable_if<std::is_array<T>::value>::type> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> field(SceneField name) const;
+        template<class T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<std::is_array<T>::value, int>::type = 0
+            #endif
+        > Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> field(SceneField name) const;
 
         /**
          * @brief Mutable data for given named field
@@ -2631,7 +2655,11 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * Expects that the scene is mutable.
          * @see @ref dataFlags()
          */
-        template<class T, class = typename std::enable_if<!std::is_array<T>::value>::type> Containers::StridedArrayView1D<T> mutableField(SceneField name);
+        template<class T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<!std::is_array<T>::value, int>::type = 0
+            #endif
+        > Containers::StridedArrayView1D<T> mutableField(SceneField name);
 
         /**
          * @brief Mutable data for given named array field in a concrete type
@@ -2644,7 +2672,11 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @ref fieldArraySize(SceneField) const for given field. For non-array
          * fields the second dimension has a size of @cpp 1 @ce.
          */
-        template<class T, class = typename std::enable_if<std::is_array<T>::value>::type> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> mutableField(SceneField name);
+        template<class T
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<std::is_array<T>::value, int>::type = 0
+            #endif
+        > Containers::StridedArrayView2D<typename std::remove_extent<T>::type> mutableField(SceneField name);
 
         /**
          * @brief Contents of given bit field
@@ -4265,7 +4297,8 @@ template<class T> bool SceneData::checkFieldTypeCompatibility(const SceneFieldDa
 }
 #endif
 
-template<class T, class> Containers::StridedArrayView1D<const T> SceneData::field(const UnsignedInt id) const {
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<class T, typename std::enable_if<!std::is_array<T>::value, int>::type> Containers::StridedArrayView1D<const T> SceneData::field(const UnsignedInt id) const {
     Containers::StridedArrayView2D<const char> data = field(id);
     #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
     if(!data.stride()[1]) return {};
@@ -4276,7 +4309,7 @@ template<class T, class> Containers::StridedArrayView1D<const T> SceneData::fiel
     return Containers::arrayCast<1, const T>(data);
 }
 
-template<class T, class> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> SceneData::field(const UnsignedInt id) const {
+template<class T, typename std::enable_if<std::is_array<T>::value, int>::type> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> SceneData::field(const UnsignedInt id) const {
     Containers::StridedArrayView2D<const char> data = field(id);
     #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
     if(!data.stride()[1]) return {};
@@ -4287,7 +4320,7 @@ template<class T, class> Containers::StridedArrayView2D<const typename std::remo
     return Containers::arrayCast<2, const typename std::remove_extent<T>::type>(data);
 }
 
-template<class T, class> Containers::StridedArrayView1D<T> SceneData::mutableField(const UnsignedInt id) {
+template<class T, typename std::enable_if<!std::is_array<T>::value, int>::type> Containers::StridedArrayView1D<T> SceneData::mutableField(const UnsignedInt id) {
     Containers::StridedArrayView2D<char> data = mutableField(id);
     #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
     if(!data.stride()[1]) return {};
@@ -4298,7 +4331,7 @@ template<class T, class> Containers::StridedArrayView1D<T> SceneData::mutableFie
     return Containers::arrayCast<1, T>(data);
 }
 
-template<class T, class> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> SceneData::mutableField(const UnsignedInt id) {
+template<class T, typename std::enable_if<std::is_array<T>::value, int>::type> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> SceneData::mutableField(const UnsignedInt id) {
     Containers::StridedArrayView2D<char> data = mutableField(id);
     #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
     if(!data.stride()[1]) return {};
@@ -4309,7 +4342,7 @@ template<class T, class> Containers::StridedArrayView2D<typename std::remove_ext
     return Containers::arrayCast<2, typename std::remove_extent<T>::type>(data);
 }
 
-template<class T, class> Containers::StridedArrayView1D<const T> SceneData::field(const SceneField name) const {
+template<class T, typename std::enable_if<!std::is_array<T>::value, int>::type> Containers::StridedArrayView1D<const T> SceneData::field(const SceneField name) const {
     const UnsignedInt fieldId = findFieldIdInternal(name);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
         "Trade::SceneData::field(): field" << name << "not found", {});
@@ -4323,7 +4356,7 @@ template<class T, class> Containers::StridedArrayView1D<const T> SceneData::fiel
     return Containers::arrayCast<1, const T>(data);
 }
 
-template<class T, class> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> SceneData::field(const SceneField name) const {
+template<class T, typename std::enable_if<std::is_array<T>::value, int>::type> Containers::StridedArrayView2D<const typename std::remove_extent<T>::type> SceneData::field(const SceneField name) const {
     const UnsignedInt fieldId = findFieldIdInternal(name);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
         "Trade::SceneData::field(): field" << name << "not found", {});
@@ -4337,7 +4370,7 @@ template<class T, class> Containers::StridedArrayView2D<const typename std::remo
     return Containers::arrayCast<2, const typename std::remove_extent<T>::type>(data);
 }
 
-template<class T, class> Containers::StridedArrayView1D<T> SceneData::mutableField(const SceneField name) {
+template<class T, typename std::enable_if<!std::is_array<T>::value, int>::type> Containers::StridedArrayView1D<T> SceneData::mutableField(const SceneField name) {
     const UnsignedInt fieldId = findFieldIdInternal(name);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
         "Trade::SceneData::mutableField(): field" << name << "not found", {});
@@ -4351,7 +4384,7 @@ template<class T, class> Containers::StridedArrayView1D<T> SceneData::mutableFie
     return Containers::arrayCast<1, T>(data);
 }
 
-template<class T, class> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> SceneData::mutableField(const SceneField name) {
+template<class T, typename std::enable_if<std::is_array<T>::value, int>::type> Containers::StridedArrayView2D<typename std::remove_extent<T>::type> SceneData::mutableField(const SceneField name) {
     const UnsignedInt fieldId = findFieldIdInternal(name);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
         "Trade::SceneData::mutableField(): field" << name << "not found", {});
@@ -4364,6 +4397,7 @@ template<class T, class> Containers::StridedArrayView2D<typename std::remove_ext
     #endif
     return Containers::arrayCast<2, typename std::remove_extent<T>::type>(data);
 }
+#endif
 
 }}
 
diff --git a/src/Magnum/Vk/Extensions.h b/src/Magnum/Vk/Extensions.h
index d8fee7157..61f1c8e90 100644
--- a/src/Magnum/Vk/Extensions.h
+++ b/src/Magnum/Vk/Extensions.h
@@ -214,7 +214,11 @@ class MAGNUM_VK_EXPORT InstanceExtension {
         constexpr Containers::StringView string() const { return _string; }
 
         /** @brief Construct from a compile-time instance extension */
-        template<class E, class = typename std::enable_if<Implementation::IsInstanceExtension<E>::value>::type> constexpr /*implicit*/ InstanceExtension(const E&): _index{E::InstanceIndex}, _requiredVersion{E::requiredVersion()}, _coreVersion{E::coreVersion()}, _string{E::string()} {}
+        template<class E
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<Implementation::IsInstanceExtension<E>::value, int>::type = 0
+            #endif
+        > constexpr /*implicit*/ InstanceExtension(const E&): _index{E::InstanceIndex}, _requiredVersion{E::requiredVersion()}, _coreVersion{E::coreVersion()}, _string{E::string()} {}
 
     private:
         std::size_t _index;
@@ -253,7 +257,11 @@ class MAGNUM_VK_EXPORT Extension {
 
         /** @brief Construct from a compile-time device extension */
         /** @todo prohibit conversion from GL/AL extensions also? */
-        template<class E, class = typename std::enable_if<Implementation::IsExtension<E>::value>::type> constexpr /*implicit*/ Extension(const E&): _index{E::Index}, _requiredVersion{E::requiredVersion()}, _coreVersion{E::coreVersion()}, _string{E::string()} {}
+        template<class E
+            #ifndef DOXYGEN_GENERATING_OUTPUT
+            , typename std::enable_if<Implementation::IsExtension<E>::value, int>::type = 0
+            #endif
+        > constexpr /*implicit*/ Extension(const E&): _index{E::Index}, _requiredVersion{E::requiredVersion()}, _coreVersion{E::coreVersion()}, _string{E::string()} {}
 
     private:
         std::size_t _index;
diff --git a/src/Magnum/Vk/Implementation/structureHelpers.h b/src/Magnum/Vk/Implementation/structureHelpers.h
index d11ca78b1..0f9c97ac1 100644
--- a/src/Magnum/Vk/Implementation/structureHelpers.h
+++ b/src/Magnum/Vk/Implementation/structureHelpers.h
@@ -101,7 +101,7 @@ template<class T> inline const void** structureFind(const void*& next, const T&
 
 class AnyStructure {
     public:
-        template<class T, class = typename std::enable_if<IsVulkanStructure<T>::value>::type> /*implicit*/ AnyStructure(const T& structure): _structure{reinterpret_cast<const VkBaseOutStructure*>(&structure)} {}
+        template<class T, typename std::enable_if<IsVulkanStructure<T>::value, int>::type = 0> /*implicit*/ AnyStructure(const T& structure): _structure{reinterpret_cast<const VkBaseOutStructure*>(&structure)} {}
 
         /*implicit*/ operator const VkBaseOutStructure&() const { return *_structure; }