No need to use fully qualified name for \debugoperator.

src/Magnum/Array.h

@@ -199,7 +199,7 @@ template<class T> class Array3D: public Array<3, T> {
         constexpr Array2D<T> xy() const { return {(*this)[0], (*this)[1]}; } /**< @overload */
 };
 
-/** @debugoperator{Magnum::Array} */
+/** @debugoperator{Array} */
 template<UnsignedInt dimensions, class T> Debug& operator<<(Debug& debug, const Array<dimensions, T>& value) {
     debug << "Array(" << Corrade::Utility::Debug::nospace;
     for(UnsignedInt i = 0; i != dimensions; ++i) {
@@ -209,17 +209,17 @@ template<UnsignedInt dimensions, class T> Debug& operator<<(Debug& debug, const
     return debug << Corrade::Utility::Debug::nospace << ")";
 }
 
-/** @debugoperator{Magnum::Array1D} */
+/** @debugoperator{Array1D} */
 template<class T> inline Debug& operator<<(Debug& debug, const Array1D<T>& value) {
     return debug << static_cast<const Array<1, T>&>(value);
 }
 
-/** @debugoperator{Magnum::Array2D} */
+/** @debugoperator{Array2D} */
 template<class T> inline Debug& operator<<(Debug& debug, const Array2D<T>& value) {
     return debug << static_cast<const Array<2, T>&>(value);
 }
 
-/** @debugoperator{Magnum::Array3D} */
+/** @debugoperator{Array3D} */
 template<class T> inline Debug& operator<<(Debug& debug, const Array3D<T>& value) {
     return debug << static_cast<const Array<3, T>&>(value);
 }

src/Magnum/Audio/Buffer.h

@@ -246,7 +246,7 @@ class Buffer {
         ALuint _id;
 };
 
-/** @debugoperatorclassenum{Magnum::Audio::Buffer,Magnum::Audio::Buffer::Format} */
+/** @debugoperatorclassenum{Buffer,Buffer::Format} */
 MAGNUM_AUDIO_EXPORT Debug& operator<<(Debug& debug, Buffer::Format value);
 
 inline Buffer::Buffer(Buffer&& other): _id(other._id) {

src/Magnum/Audio/Context.h

@@ -476,7 +476,7 @@ MAGNUM_ASSERT_AUDIO_EXTENSION_SUPPORTED(Extensions::ALC::SOFTX::HRTF);
     } while(0)
 #endif
 
-/** @debugoperatorclassenum{Magnum::Audio::Context,Magnum::Audio::Context::HrtfStatus} */
+/** @debugoperatorclassenum{Context,Context::HrtfStatus} */
 MAGNUM_AUDIO_EXPORT Debug& operator<<(Debug& debug, Context::HrtfStatus value);
 
 }}

src/Magnum/Audio/Renderer.h

@@ -268,10 +268,10 @@ class Renderer {
         /*@}*/
 };
 
-/** @debugoperatorclassenum{Magnum::Audio::Renderer,Magnum::Audio::Renderer::Error} */
+/** @debugoperatorclassenum{Renderer,Renderer::Error} */
 MAGNUM_AUDIO_EXPORT Debug& operator<<(Debug& debug, Renderer::Error value);
 
-/** @debugoperatorclassenum{Magnum::Audio::Renderer,Magnum::Audio::Renderer::DistanceModel} */
+/** @debugoperatorclassenum{Renderer,Renderer::DistanceModel} */
 MAGNUM_AUDIO_EXPORT Debug& operator<<(Debug& debug, Renderer::DistanceModel value);
 
 }}

src/Magnum/Audio/Source.h

@@ -705,7 +705,7 @@ class MAGNUM_AUDIO_EXPORT Source {
         ALuint _id;
 };
 
-/** @debugoperatorclassenum{Magnum::Audio::Source,Magnum::Audio::Source::State} */
+/** @debugoperatorclassenum{Source,Source::State} */
 MAGNUM_AUDIO_EXPORT Debug& operator<<(Debug& debug, Source::State value);
 
 inline Source::Source(Source&& other): _id(other._id) {

src/Magnum/Math/Angle.h

@@ -267,12 +267,12 @@ constexpr Rad<Float> operator "" _radf(long double value) { return Rad<Float>(Fl
 template<class T> constexpr Deg<T>::Deg(Unit<Rad, T> value): Unit<Math::Deg, T>(T(180)*T(value)/Math::Constants<T>::pi()) {}
 template<class T> constexpr Rad<T>::Rad(Unit<Deg, T> value): Unit<Math::Rad, T>(T(value)*Math::Constants<T>::pi()/T(180)) {}
 
-/** @debugoperator{Magnum::Math::Rad} */
+/** @debugoperator{Rad} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Unit<Rad, T>& value) {
     return debug << "Rad(" << Corrade::Utility::Debug::nospace << T(value) << Corrade::Utility::Debug::nospace << ")";
 }
 
-/** @debugoperator{Magnum::Math::Deg} */
+/** @debugoperator{Deg} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Unit<Deg, T>& value) {
     return debug << "Deg(" << Corrade::Utility::Debug::nospace << T(value) << Corrade::Utility::Debug::nospace << ")";
 }

src/Magnum/Math/Bezier.h

@@ -249,7 +249,7 @@ Convenience alternative to @cpp CubicBezier<3, T> @ce. See @ref CubicBezier and
 template<class T> using CubicBezier3D = CubicBezier<3, T>;
 #endif
 
-/** @debugoperator{Magnum::Math::Bezier} */
+/** @debugoperator{Bezier} */
 template<UnsignedInt order, UnsignedInt dimensions, class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Bezier<order, dimensions, T>& value) {
     debug << "Bezier(" << Corrade::Utility::Debug::nospace;
     for(UnsignedInt o = 0; o != order + 1; ++o) {

src/Magnum/Math/BoolVector.h

@@ -235,7 +235,7 @@ template<std::size_t size> class BoolVector {
         UnsignedByte _data[(size-1)/8+1];
 };
 
-/** @debugoperator{Magnum::Math::BoolVector} */
+/** @debugoperator{BoolVector} */
 template<std::size_t size> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const BoolVector<size>& value) {
     debug << "BoolVector(" << Corrade::Utility::Debug::nospace;
     for(std::size_t i = 0; i != size; ++i) {

src/Magnum/Math/Color.h

@@ -1179,7 +1179,7 @@ inline Color4<Float> operator "" _srgbaf(unsigned long long value) {
 }
 
 /**
-@debugoperator{Magnum::Math::Color3}
+@debugoperator{Color3}
 
 Prints the value as hex color (e.g. @cb{.shell-session} #ff33aa @ce). Other
 underlying types are handled by @ref operator<<(Corrade::Utility::Debug&, const Vector<size, T>&).
@@ -1187,7 +1187,7 @@ underlying types are handled by @ref operator<<(Corrade::Utility::Debug&, const
 MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Color3<UnsignedByte>& value);
 
 /**
-@debugoperator{Magnum::Math::Color4}
+@debugoperator{Color4}
 
 Prints the value as hex color (e.g. @cb{.shell-session} #9933aaff @ce). Other
 underlying types are handled by @ref operator<<(Corrade::Utility::Debug&, const Vector<size, T>&).

src/Magnum/Math/Complex.h

@@ -456,7 +456,7 @@ template<class T> inline Complex<T> operator/(T scalar, const Complex<T>& comple
     return {scalar/complex.real(), scalar/complex.imaginary()};
 }
 
-/** @debugoperator{Magnum::Math::Complex} */
+/** @debugoperator{Complex} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Complex<T>& value) {
     return debug << "Complex(" << Corrade::Utility::Debug::nospace
         << value.real() << Corrade::Utility::Debug::nospace << ","

src/Magnum/Math/Dual.h

@@ -323,7 +323,7 @@ template<class T, class U, class V = typename std::enable_if<!Implementation::Is
     }
 #endif
 
-/** @debugoperator{Magnum::Math::Dual} */
+/** @debugoperator{Dual} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Dual<T>& value) {
     return debug << "Dual(" << Corrade::Utility::Debug::nospace
         << value.real() << Corrade::Utility::Debug::nospace << ","

src/Magnum/Math/DualComplex.h

@@ -354,7 +354,7 @@ template<class T> class DualComplex: public Dual<Complex<T>> {
 
 MAGNUM_DUAL_OPERATOR_IMPLEMENTATION(DualComplex, Vector2, T)
 
-/** @debugoperator{Magnum::Math::DualQuaternion} */
+/** @debugoperator{DualComplex} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const DualComplex<T>& value) {
     return debug << "DualComplex({" << Corrade::Utility::Debug::nospace
           << value.real().real() << Corrade::Utility::Debug::nospace << ","

src/Magnum/Math/DualQuaternion.h

@@ -429,7 +429,7 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
 
 MAGNUM_DUAL_OPERATOR_IMPLEMENTATION(DualQuaternion, Quaternion, T)
 
-/** @debugoperator{Magnum::Math::DualQuaternion} */
+/** @debugoperator{DualQuaternion} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const DualQuaternion<T>& value) {
     return debug << "DualQuaternion({{" << Corrade::Utility::Debug::nospace
         << value.real().vector().x() << Corrade::Utility::Debug::nospace << ","

src/Magnum/Math/Frustum.h

@@ -146,7 +146,7 @@ template<class T> class Frustum {
         Vector4<T> _data[6];
 };
 
-/** @debugoperator{Magnum::Math::Frustum} */
+/** @debugoperator{Frustum} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Frustum<T>& value) {
     debug << "Frustum({" << Corrade::Utility::Debug::nospace;
     for(std::size_t i = 0; i != 6; ++i) {

src/Magnum/Math/Half.h

@@ -162,7 +162,7 @@ inline Half operator "" _h(long double value) { return Half(Float(value)); }
 
 }
 
-/** @debugoperator{Magnum::Math::Half} */
+/** @debugoperator{Half} */
 inline Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, Half value) {
     return debug << Float(value);
 }

src/Magnum/Math/Quaternion.h

@@ -508,7 +508,7 @@ template<class T> inline Quaternion<T> operator/(T scalar, const Quaternion<T>&
     return {scalar/quaternion.vector(), scalar/quaternion.scalar()};
 }
 
-/** @debugoperator{Magnum::Math::Quaternion} */
+/** @debugoperator{Quaternion} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Quaternion<T>& value) {
     return debug << "Quaternion({" << Corrade::Utility::Debug::nospace
         << value.vector().x() << Corrade::Utility::Debug::nospace << ","

src/Magnum/Math/Range.h

@@ -540,7 +540,7 @@ template<UnsignedInt dimensions, class T> inline Range<dimensions, T> join(const
     return {min(a.min(), b.min()), max(a.max(), b.max())};
 }
 
-/** @debugoperator{Magnum::Math::Range} */
+/** @debugoperator{Range} */
 template<UnsignedInt dimensions, class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Range<dimensions, T>& value) {
     debug << "Range({" << Corrade::Utility::Debug::nospace << value.min()[0];
     for(UnsignedInt i = 1; i != dimensions; ++i)

src/Magnum/Math/RectangularMatrix.h

@@ -588,7 +588,7 @@ template<std::size_t size, std::size_t cols, class T> inline RectangularMatrix<c
     return RectangularMatrix<1, size, T>(vector)*matrix;
 }
 
-/** @debugoperator{Magnum::Math::RectangularMatrix} */
+/** @debugoperator{RectangularMatrix} */
 template<std::size_t cols, std::size_t rows, class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Magnum::Math::RectangularMatrix<cols, rows, T>& value) {
     debug << "Matrix(" << Corrade::Utility::Debug::nospace;
     for(std::size_t row = 0; row != rows; ++row) {

src/Magnum/Math/Vector.h

@@ -1075,7 +1075,7 @@ operator/(const Vector<size, Integral>& a, const Vector<size, FloatingPoint>& b)
     return copy /= b;
 }
 
-/** @debugoperator{Magnum::Math::Vector} */
+/** @debugoperator{Vector} */
 template<std::size_t size, class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Vector<size, T>& value) {
     debug << "Vector(" << Corrade::Utility::Debug::nospace;
     for(std::size_t i = 0; i != size; ++i) {

src/Magnum/Resource.h

@@ -68,7 +68,7 @@ enum class ResourceState: UnsignedByte {
     Final
 };
 
-/** @debugoperatorenum{Magnum::ResourceState} */
+/** @debugoperatorenum{ResourceState} */
 MAGNUM_EXPORT Debug& operator<<(Debug& debug, ResourceState value);
 
 /**
@@ -99,7 +99,7 @@ class ResourceKey: public Utility::MurmurHash2::Digest {
         template<std::size_t size> constexpr ResourceKey(const char(&key)[size]): Utility::MurmurHash2::Digest(Utility::MurmurHash2()(key)) {}
 };
 
-/** @debugoperator{Magnum::ResourceKey} */
+/** @debugoperator{ResourceKey} */
 inline Debug& operator<<(Debug& debug, const ResourceKey& value) {
     return debug << static_cast<const Utility::HashDigest<sizeof(std::size_t)>&>(value);
 }

src/Magnum/SceneGraph/Animable.h

@@ -56,7 +56,7 @@ enum class AnimationState: UnsignedByte {
     Running
 };
 
-/** @debugoperatorenum{Magnum::SceneGraph::AnimationState} */
+/** @debugoperatorenum{AnimationState} */
 MAGNUM_SCENEGRAPH_EXPORT Debug& operator<<(Debug& debug, AnimationState value);
 
 /**

src/Magnum/Shapes/Composition.h

@@ -194,7 +194,7 @@ typedef Composition<2> Composition2D;
 typedef Composition<3> Composition3D;
 
 #ifdef DOXYGEN_GENERATING_OUTPUT
-/** @debugoperatorclassenum{Magnum::Shapes::Composition,Magnum::Shapes::Composition::Type} */
+/** @debugoperatorclassenum{Composition,Composition::Type} */
 template<UnsignedInt dimensions> Debug& operator<<(Debug& debug, typename Composition<dimensions>::Type value);
 #endif