From 6c9066be8c0d993301d9130b77c2a3eafd2c01b2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= <mosra@centrum.cz>
Date: Sat, 17 May 2014 13:28:35 +0200
Subject: [PATCH] doc: removed old Doxygen workarounds.

It can finally handle operators, yay! (Well, some of them...)
---
 src/Magnum/Context.h                        |   4 +-
 src/Magnum/Math/BoolVector.h                |  12 +--
 src/Magnum/Math/Complex.h                   |  22 ++---
 src/Magnum/Math/Dual.h                      |   6 +-
 src/Magnum/Math/DualComplex.h               |   2 -
 src/Magnum/Math/DualQuaternion.h            |   2 -
 src/Magnum/Math/Geometry/Distance.h         |  24 +----
 src/Magnum/Math/Quaternion.h                |  15 +--
 src/Magnum/Math/RectangularMatrix.h         |  34 +++----
 src/Magnum/Math/Vector.h                    | 101 ++++++++------------
 src/Magnum/MeshTools/CombineIndexedArrays.h |   4 +-
 src/Magnum/Resource.h                       |  10 +-
 src/Magnum/SceneGraph/Object.h              |   3 +-
 src/Magnum/Shapes/Collision.h               |   2 +-
 14 files changed, 84 insertions(+), 157 deletions(-)

diff --git a/src/Magnum/Context.h b/src/Magnum/Context.h
index f998a6504..ec6b26c80 100644
--- a/src/Magnum/Context.h
+++ b/src/Magnum/Context.h
@@ -328,7 +328,7 @@ class MAGNUM_EXPORT Context {
          * OpenGL version (@ref Version::GL210 for desktop OpenGL,
          * @ref Version::GLES200 for OpenGL ES).
          * @see isExtensionSupported(Version) const
-         * @todoc Explicit reference when Doxygen is sane
+         * @todoc Explicit reference when Doxygen can handle const
          */
         Version supportedVersion(std::initializer_list<Version> versions) const;
 
@@ -348,7 +348,7 @@ class MAGNUM_EXPORT Context {
          * @see isExtensionSupported(const Extension&) const,
          *      @ref MAGNUM_ASSERT_EXTENSION_SUPPORTED(),
          *      @ref isExtensionDisabled()
-         * @todoc Explicit reference when Doxygen is sane
+         * @todoc Explicit reference when Doxygen can handle const
          */
         template<class T> bool isExtensionSupported() const {
             return isExtensionSupported<T>(version());
diff --git a/src/Magnum/Math/BoolVector.h b/src/Magnum/Math/BoolVector.h
index 8acef6041..5098858a6 100644
--- a/src/Magnum/Math/BoolVector.h
+++ b/src/Magnum/Math/BoolVector.h
@@ -106,8 +106,7 @@ template<std::size_t size> class BoolVector {
          * @brief Raw data
          * @return %Array of DataSize length
          *
-         * @see operator[](), @ref set()
-         * @todoc Make reference explicit when Doxygen can link to operator[]
+         * @see @ref operator[](), @ref set()
          */
         UnsignedByte* data() { return _data; }
         constexpr const UnsignedByte* data() const { return _data; } /**< @overload */
@@ -158,8 +157,7 @@ template<std::size_t size> class BoolVector {
         /**
          * @brief Bitwise AND
          *
-         * @see operator&=()
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator&=()
          */
         BoolVector<size> operator&(const BoolVector<size>& other) const {
             return BoolVector<size>(*this) &= other;
@@ -180,8 +178,7 @@ template<std::size_t size> class BoolVector {
         /**
          * @brief Bitwise OR
          *
-         * @see operator|=()
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator|=()
          */
         BoolVector<size> operator|(const BoolVector<size>& other) const {
             return BoolVector<size>(*this) |= other;
@@ -202,8 +199,7 @@ template<std::size_t size> class BoolVector {
         /**
          * @brief Bitwise XOR
          *
-         * @see operator^=()
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator^=()
          */
         BoolVector<size> operator^(const BoolVector<size>& other) const {
             return BoolVector<size>(*this) ^= other;
diff --git a/src/Magnum/Math/Complex.h b/src/Magnum/Math/Complex.h
index ab8fd8b4a..6e79309c1 100644
--- a/src/Magnum/Math/Complex.h
+++ b/src/Magnum/Math/Complex.h
@@ -137,7 +137,7 @@ template<class T> class Complex {
          *      c = v_x + iv_y
          * @f]
          * @see operator Vector2(), @ref transformVector()
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @todoc Explicit reference when Doxygen can handle conversion operators
          */
         constexpr explicit Complex(const Vector2<T>& vector): _real(vector.x()), _imaginary(vector.y()) {}
 
@@ -226,8 +226,7 @@ template<class T> class Complex {
         /**
          * @brief Add complex number
          *
-         * @see operator+=()
-         * @todoc Explicit reference when Doxygen can handle operators
+         * @see @ref operator+=(const Complex<T>&)
          */
         Complex<T> operator+(const Complex<T>& other) const {
             return Complex<T>(*this) += other;
@@ -260,8 +259,7 @@ template<class T> class Complex {
         /**
          * @brief Subtract complex number
          *
-         * @see operator-=()
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator-=(const Complex<T>&)
          */
         Complex<T> operator-(const Complex<T>& other) const {
             return Complex<T>(*this) -= other;
@@ -283,8 +281,7 @@ template<class T> class Complex {
         /**
          * @brief Multiply with scalar
          *
-         * @see operator*=(T)
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator*=(T)
          */
         Complex<T> operator*(T scalar) const {
             return Complex<T>(*this) *= scalar;
@@ -306,8 +303,7 @@ template<class T> class Complex {
         /**
          * @brief Divide with scalar
          *
-         * @see operator/=(T)
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator/=(T)
          */
         Complex<T> operator/(T scalar) const {
             return Complex<T>(*this) /= scalar;
@@ -413,7 +409,7 @@ template<class T> class Complex {
          * @f]
          * @see @ref Complex(const Vector2<T>&), operator Vector2(),
          *      @ref Matrix3::transformVector()
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @todoc Explicit reference when Doxygen can handle conversion operators
          */
         Vector2<T> transformVector(const Vector2<T>& vector) const {
             return Vector2<T>((*this)*Complex<T>(vector));
@@ -426,8 +422,7 @@ template<class T> class Complex {
 /** @relates Complex
 @brief Multiply scalar with complex
 
-Same as Complex::operator*(T) const.
-@todoc Make explicit reference when Doxygen can handle operators
+Same as @ref Complex::operator*(T) const.
 */
 template<class T> inline Complex<T> operator*(T scalar, const Complex<T>& complex) {
     return complex*scalar;
@@ -439,8 +434,7 @@ template<class T> inline Complex<T> operator*(T scalar, const Complex<T>& comple
 @f[
     \frac t c = \frac t a + i \frac t b
 @f]
-@see Complex::operator/()
-@todoc Make explicit reference when Doxygen can handle operators
+@see @ref Complex::operator/()
 */
 template<class T> inline Complex<T> operator/(T scalar, const Complex<T>& complex) {
     return {scalar/complex.real(), scalar/complex.imaginary()};
diff --git a/src/Magnum/Math/Dual.h b/src/Magnum/Math/Dual.h
index 982a311c3..7d5533353 100644
--- a/src/Magnum/Math/Dual.h
+++ b/src/Magnum/Math/Dual.h
@@ -95,8 +95,7 @@ template<class T> class Dual {
         /**
          * @brief Add dual number
          *
-         * @see operator+=()
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator+=()
          */
         Dual<T> operator+(const Dual<T>& other) const {
             return Dual<T>(*this)+=other;
@@ -129,8 +128,7 @@ template<class T> class Dual {
         /**
          * @brief Subtract dual number
          *
-         * @see operator-=()
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator-=()
          */
         Dual<T> operator-(const Dual<T>& other) const {
             return Dual<T>(*this)-=other;
diff --git a/src/Magnum/Math/DualComplex.h b/src/Magnum/Math/DualComplex.h
index 0b5ba54f8..01e1436e6 100644
--- a/src/Magnum/Math/DualComplex.h
+++ b/src/Magnum/Math/DualComplex.h
@@ -100,7 +100,6 @@ template<class T> class DualComplex: public Dual<Complex<T>> {
          * Creates unit dual complex number. @f[
          *      \hat c = (0 + i1) + \epsilon (0 + i0)
          * @f]
-         * @todoc Remove workaround when Doxygen is predictable
          */
         #ifdef DOXYGEN_GENERATING_OUTPUT
         constexpr /*implicit*/ DualComplex();
@@ -123,7 +122,6 @@ template<class T> class DualComplex: public Dual<Complex<T>> {
          * To be used in transformations later. @f[
          *      \hat c = (0 + i1) + \epsilon(v_x + iv_y)
          * @f]
-         * @todoc Remove workaround when Doxygen is predictable
          */
         #ifdef DOXYGEN_GENERATING_OUTPUT
         constexpr explicit DualComplex(const Vector2<T>& vector);
diff --git a/src/Magnum/Math/DualQuaternion.h b/src/Magnum/Math/DualQuaternion.h
index 8c086ffa3..4803a0c6d 100644
--- a/src/Magnum/Math/DualQuaternion.h
+++ b/src/Magnum/Math/DualQuaternion.h
@@ -106,7 +106,6 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
          * Creates unit dual quaternion. @f[
          *      \hat q = [\boldsymbol 0, 1] + \epsilon [\boldsymbol 0, 0]
          * @f]
-         * @todoc Remove workaround when Doxygen is predictable
          */
         #ifdef DOXYGEN_GENERATING_OUTPUT
         constexpr /*implicit*/ DualQuaternion();
@@ -130,7 +129,6 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
          *      \hat q = [\boldsymbol 0, 1] + \epsilon [\boldsymbol v, 0]
          * @f]
          * @see @ref transformPointNormalized()
-         * @todoc Remove workaround when Doxygen is predictable
          */
         #ifdef DOXYGEN_GENERATING_OUTPUT
         constexpr explicit DualQuaternion(const Vector3<T>& vector);
diff --git a/src/Magnum/Math/Geometry/Distance.h b/src/Magnum/Math/Geometry/Distance.h
index 69254294b..26dee4b2d 100644
--- a/src/Magnum/Math/Geometry/Distance.h
+++ b/src/Magnum/Math/Geometry/Distance.h
@@ -164,13 +164,7 @@ class Distance {
         template<class T> static T lineSegmentPointSquared(const Vector3<T>& a, const Vector3<T>& b, const Vector3<T>& point);
 };
 
-/** @todoc Remove workaround when Doxygen is sane */
-#ifdef DOXYGEN_GENERATING_OUTPUT
-template<class T> static
-#else
-template<class T>
-#endif
-T Distance::lineSegmentPoint(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point) {
+template<class T> T Distance::lineSegmentPoint(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point) {
     const Vector2<T> pointMinusA = point - a;
     const Vector2<T> pointMinusB = point - b;
     const Vector2<T> bMinusA = b - a;
@@ -190,13 +184,7 @@ T Distance::lineSegmentPoint(const Vector2<T>& a, const Vector2<T>& b, const Vec
     return std::abs(Vector2<T>::cross(bMinusA, -pointMinusA))/std::sqrt(bDistanceA);
 }
 
-/** @todoc Remove workaround when Doxygen is sane */
-#ifdef DOXYGEN_GENERATING_OUTPUT
-template<class T> static
-#else
-template<class T>
-#endif
-T Distance::lineSegmentPointSquared(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point) {
+template<class T> T Distance::lineSegmentPointSquared(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point) {
     const Vector2<T> pointMinusA = point - a;
     const Vector2<T> pointMinusB = point - b;
     const Vector2<T> bMinusA = b - a;
@@ -216,13 +204,7 @@ T Distance::lineSegmentPointSquared(const Vector2<T>& a, const Vector2<T>& b, co
     return Math::pow<2>(Vector2<T>::cross(bMinusA, -pointMinusA))/bDistanceA;
 }
 
-/** @todoc Remove workaround when Doxygen is sane */
-#ifdef DOXYGEN_GENERATING_OUTPUT
-template<class T> static
-#else
-template<class T>
-#endif
-T Distance::lineSegmentPointSquared(const Vector3<T>& a, const Vector3<T>& b, const Vector3<T>& point) {
+template<class T> T Distance::lineSegmentPointSquared(const Vector3<T>& a, const Vector3<T>& b, const Vector3<T>& point) {
     const Vector3<T> pointMinusA = point - a;
     const Vector3<T> pointMinusB = point - b;
     const T pointDistanceA = pointMinusA.dot();
diff --git a/src/Magnum/Math/Quaternion.h b/src/Magnum/Math/Quaternion.h
index 035249ec5..bcc3d68a4 100644
--- a/src/Magnum/Math/Quaternion.h
+++ b/src/Magnum/Math/Quaternion.h
@@ -230,8 +230,7 @@ template<class T> class Quaternion {
         /**
          * @brief Add quaternion
          *
-         * @see operator+=()
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator+=()
          */
         Quaternion<T> operator+(const Quaternion<T>& other) const {
             return Quaternion<T>(*this) += other;
@@ -284,8 +283,7 @@ template<class T> class Quaternion {
         /**
          * @brief Multiply with scalar
          *
-         * @see operator*=(T)
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator*=(T)
          */
         Quaternion<T> operator*(T scalar) const {
             return Quaternion<T>(*this) *= scalar;
@@ -307,8 +305,7 @@ template<class T> class Quaternion {
         /**
          * @brief Divide with scalar
          *
-         * @see operator/=(T)
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator/=(T)
          */
         Quaternion<T> operator/(T scalar) const {
             return Quaternion<T>(*this) /= scalar;
@@ -434,8 +431,7 @@ template<class T> class Quaternion {
 /** @relates Quaternion
 @brief Multiply scalar with quaternion
 
-Same as Quaternion::operator*(T) const.
-@todoc Make explicit reference when Doxygen can handle operators
+Same as @ref Quaternion::operator*(T) const.
 */
 template<class T> inline Quaternion<T> operator*(T scalar, const Quaternion<T>& quaternion) {
     return quaternion*scalar;
@@ -447,8 +443,7 @@ template<class T> inline Quaternion<T> operator*(T scalar, const Quaternion<T>&
 @f[
     \frac a q = [\frac a {\boldsymbol q_V}, \frac a {q_S}]
 @f]
-@see Quaternion::operator/()
-@todoc Make explicit reference when Doxygen can handle operators
+@see @ref Quaternion::operator/()
 */
 template<class T> inline Quaternion<T> operator/(T scalar, const Quaternion<T>& quaternion) {
     return {scalar/quaternion.vector(), scalar/quaternion.scalar()};
diff --git a/src/Magnum/Math/RectangularMatrix.h b/src/Magnum/Math/RectangularMatrix.h
index dd160b4ca..6f1c46f26 100644
--- a/src/Magnum/Math/RectangularMatrix.h
+++ b/src/Magnum/Math/RectangularMatrix.h
@@ -164,8 +164,7 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
          * @return One-dimensional array of `cols*rows` length in column-major
          *      order.
          *
-         * @see operator[]()
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator[]()
          */
         T* data() { return _data[0].data(); }
         constexpr const T* data() const { return _data[0].data(); } /**< @overload */
@@ -173,7 +172,7 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
         /**
          * @brief %Matrix column
          *
-         * Particular elements can be accessed using Vector::operator[](),
+         * Particular elements can be accessed using @ref Vector::operator[](),
          * e.g.:
          * @code
          * RectangularMatrix<4, 3, Float> m;
@@ -181,7 +180,6 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
          * @endcode
          *
          * @see @ref row(), @ref data()
-         * @todoc Make explicit reference when Doxygen can handle operators
          */
         Vector<rows, T>& operator[](std::size_t col) { return _data[col]; }
         constexpr const Vector<rows, T>& operator[](std::size_t col) const { return _data[col]; } /**< @overload */
@@ -192,8 +190,7 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
          * Consider using @ref transposed() when accessing rows frequently, as
          * this is slower than accessing columns due to the way the matrix is
          * stored.
-         * @see operator[]()
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator[]()
          */
         Vector<cols, T> row(std::size_t row) const;
 
@@ -208,9 +205,8 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
         /**
          * @brief Non-equality operator
          *
-         * @see Vector::operator<(), Vector::operator<=(),
-         *      Vector::operator>=(), Vector::operator>()
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref Vector::operator<(), @ref Vector::operator<=(),
+         *      @ref Vector::operator>=(), @ref Vector::operator>()
          */
         bool operator!=(const RectangularMatrix<cols, rows, T>& other) const {
             return !operator==(other);
@@ -242,8 +238,7 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
         /**
          * @brief Add matrix
          *
-         * @see operator+=()
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator+=()
          */
         RectangularMatrix<cols, rows, T> operator+(const RectangularMatrix<cols, rows, T>& other) const {
             return RectangularMatrix<cols, rows, T>(*this)+=other;
@@ -289,8 +284,7 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
         /**
          * @brief Multiply matrix with number
          *
-         * @see operator*=(T), operator*(T, const RectangularMatrix<cols, rows, T>&)
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator*=(T), @ref operator*(T, const RectangularMatrix<cols, rows, T>&)
          */
         RectangularMatrix<cols, rows, T> operator*(T number) const {
             return RectangularMatrix<cols, rows, T>(*this) *= number;
@@ -313,9 +307,8 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
         /**
          * @brief Divide matrix with number
          *
-         * @see operator/=(T),
-         *      operator/(T, const RectangularMatrix<cols, rows, T>&)
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator/=(T),
+         *      @ref operator/(T, const RectangularMatrix<cols, rows, T>&)
          */
         RectangularMatrix<cols, rows, T> operator/(T number) const {
             return RectangularMatrix<cols, rows, T>(*this) /= number;
@@ -457,8 +450,7 @@ template<class T> using Matrix4x3 = RectangularMatrix<4, 3, T>;
 /** @relates RectangularMatrix
 @brief Multiply number with matrix
 
-Same as RectangularMatrix::operator*(T) const.
-@todoc Make explicit reference when Doxygen can handle operators
+Same as @ref RectangularMatrix::operator*(T) const.
 */
 template<std::size_t cols, std::size_t rows, class T> inline RectangularMatrix<cols, rows, T> operator*(
     #ifdef DOXYGEN_GENERATING_OUTPUT
@@ -477,8 +469,7 @@ template<std::size_t cols, std::size_t rows, class T> inline RectangularMatrix<c
 The computation is done column-wise. @f[
     \boldsymbol B_j = \frac a {\boldsymbol A_j}
 @f]
-@see RectangularMatrix::operator/(T) const
-@todoc Make explicit reference when Doxygen can handle operators
+@see @ref RectangularMatrix::operator/(T) const
 */
 template<std::size_t cols, std::size_t rows, class T> inline RectangularMatrix<cols, rows, T> operator/(
     #ifdef DOXYGEN_GENERATING_OUTPUT
@@ -502,8 +493,7 @@ template<std::size_t cols, std::size_t rows, class T> inline RectangularMatrix<c
 Internally the same as multiplying one-column matrix with one-row matrix. @f[
     (\boldsymbol {aA})_{ji} = \boldsymbol a_i \boldsymbol A_j
 @f]
-@see RectangularMatrix::operator*(const RectangularMatrix<size, cols, T>&) const
-@todoc Make explicit reference when Doxygen can handle operators
+@see @ref RectangularMatrix::operator*(const RectangularMatrix<size, cols, T>&) const
 */
 template<std::size_t size, std::size_t cols, class T> inline RectangularMatrix<cols, size, T> operator*(const Vector<size, T>& vector, const RectangularMatrix<cols, 1, T>& matrix) {
     return RectangularMatrix<1, size, T>(vector)*matrix;
diff --git a/src/Magnum/Math/Vector.h b/src/Magnum/Math/Vector.h
index 3d7de1285..42c916d27 100644
--- a/src/Magnum/Math/Vector.h
+++ b/src/Magnum/Math/Vector.h
@@ -190,8 +190,7 @@ template<std::size_t size, class T> class Vector {
          * @brief Raw data
          * @return One-dimensional array of `size` length.
          *
-         * @see operator[]()
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator[]()
          */
         T* data() { return _data; }
         constexpr const T* data() const { return _data; } /**< @overload */
@@ -280,8 +279,7 @@ template<std::size_t size, class T> class Vector {
         /**
          * @brief Add vector
          *
-         * @see operator+=(), @ref sum()
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator+=(), @ref sum()
          */
         Vector<size, T> operator+(const Vector<size, T>& other) const {
             return Vector<size, T>(*this) += other;
@@ -316,9 +314,8 @@ template<std::size_t size, class T> class Vector {
          * The computation is done in-place. @f[
          *      \boldsymbol a_i = b \boldsymbol a_i
          * @f]
-         * @see operator*=(const Vector<size, T>&),
-         *      operator*=(Vector<size, Integral>&, FloatingPoint)
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator*=(const Vector<size, T>&),
+         *      @ref operator*=(Vector<size, Integral>&, FloatingPoint)
          */
         Vector<size, T>& operator*=(T number) {
             for(std::size_t i = 0; i != size; ++i)
@@ -330,10 +327,9 @@ template<std::size_t size, class T> class Vector {
         /**
          * @brief Multiply vector with number
          *
-         * @see operator*(const Vector<size, T>&) const,
-         *      operator*=(T), operator*(T, const Vector<size, T>&),
-         *      operator*(const Vector<size, Integral>&, FloatingPoint)
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator*(const Vector<size, T>&) const,
+         *      @ref operator*=(T), operator*(T, const Vector<size, T>&),
+         *      @ref operator*(const Vector<size, Integral>&, FloatingPoint)
          */
         Vector<size, T> operator*(T number) const {
             return Vector<size, T>(*this) *= number;
@@ -345,9 +341,8 @@ template<std::size_t size, class T> class Vector {
          * The computation is done in-place. @f[
          *      \boldsymbol a_i = \frac{\boldsymbol a_i} b
          * @f]
-         * @see operator/=(const Vector<size, T>&),
-         *      operator/=(Vector<size, Integral>&, FloatingPoint)
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator/=(const Vector<size, T>&),
+         *      @ref operator/=(Vector<size, Integral>&, FloatingPoint)
          */
         Vector<size, T>& operator/=(T number) {
             for(std::size_t i = 0; i != size; ++i)
@@ -359,10 +354,9 @@ template<std::size_t size, class T> class Vector {
         /**
          * @brief Divide vector with number
          *
-         * @see operator/(const Vector<size, T>&) const,
-         *      operator/=(T), operator/(T, const Vector<size, T>&),
-         *      operator/(const Vector<size, Integral>&, FloatingPoint)
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator/(const Vector<size, T>&) const,
+         *      @ref operator/=(T), operator/(T, const Vector<size, T>&),
+         *      @ref operator/(const Vector<size, Integral>&, FloatingPoint)
          */
         Vector<size, T> operator/(T number) const {
             return Vector<size, T>(*this) /= number;
@@ -374,9 +368,8 @@ template<std::size_t size, class T> class Vector {
          * The computation is done in-place. @f[
          *      \boldsymbol a_i = \boldsymbol a_i \boldsymbol b_i
          * @f]
-         * @see operator*=(T),
-         *      operator*=(Vector<size, Integral>&, const Vector<size, FloatingPoint>&)
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator*=(T),
+         *      @ref operator*=(Vector<size, Integral>&, const Vector<size, FloatingPoint>&)
          */
         Vector<size, T>& operator*=(const Vector<size, T>& other) {
             for(std::size_t i = 0; i != size; ++i)
@@ -388,10 +381,9 @@ template<std::size_t size, class T> class Vector {
         /**
          * @brief Multiply vector component-wise
          *
-         * @see operator*(T) const, operator*=(const Vector<size, T>&),
-         *      operator*(const Vector<size, Integral>&, const Vector<size, FloatingPoint>&),
+         * @see @ref operator*(T) const, @ref operator*=(const Vector<size, T>&),
+         *      @ref operator*(const Vector<size, Integral>&, const Vector<size, FloatingPoint>&),
          *      @ref product()
-         * @todoc Make explicit reference when Doxygen can handle operators
          */
         Vector<size, T> operator*(const Vector<size, T>& other) const {
             return Vector<size, T>(*this) *= other;
@@ -403,9 +395,8 @@ template<std::size_t size, class T> class Vector {
          * The computation is done in-place. @f[
          *      \boldsymbol a_i = \frac{\boldsymbol a_i}{\boldsymbol b_i}
          * @f]
-         * @see operator/=(T),
-         *      operator/=(Vector<size, Integral>&, const Vector<size, FloatingPoint>&)
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator/=(T),
+         *      @ref operator/=(Vector<size, Integral>&, const Vector<size, FloatingPoint>&)
          */
         Vector<size, T>& operator/=(const Vector<size, T>& other) {
             for(std::size_t i = 0; i != size; ++i)
@@ -417,9 +408,8 @@ template<std::size_t size, class T> class Vector {
         /**
          * @brief Divide vector component-wise
          *
-         * @see operator/(T) const, operator/=(const Vector<size, T>&),
-         *      operator/(const Vector<size, Integral>&, const Vector<size, FloatingPoint>&)
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator/(T) const, @ref operator/=(const Vector<size, T>&),
+         *      @ref operator/(const Vector<size, Integral>&, const Vector<size, FloatingPoint>&)
          */
         Vector<size, T> operator/(const Vector<size, T>& other) const {
             return Vector<size, T>(*this) /= other;
@@ -503,23 +493,22 @@ template<std::size_t size, class T> class Vector {
          *      \boldsymbol a_1 = \frac{\boldsymbol a \cdot \boldsymbol b}{\boldsymbol b \cdot \boldsymbol b} \boldsymbol b =
          *          (\boldsymbol a \cdot \boldsymbol b) \boldsymbol b
          * @f]
-         * @see dot()
+         * @see dot() const
+         * @todoc Explicit reference when Doxygen can handle const
          */
         Vector<size, T> projectedOntoNormalized(const Vector<size, T>& line) const;
 
         /**
          * @brief Sum of values in the vector
          *
-         * @see operator+()
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator+()
          */
         T sum() const;
 
         /**
          * @brief Product of values in the vector
          *
-         * @see operator*(const Vector<size, T>&) const
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @see @ref operator*(const Vector<size, T>&) const
          */
         T product() const;
 
@@ -550,8 +539,7 @@ template<std::size_t size, class T> class Vector {
 /** @relates Vector
 @brief Multiply number with vector
 
-Same as Vector::operator*(T) const.
-@todoc Make explicit reference when Doxygen can handle operators
+Same as @ref Vector::operator*(T) const.
 */
 template<std::size_t size, class T> inline Vector<size, T> operator*(
     #ifdef DOXYGEN_GENERATING_OUTPUT
@@ -570,8 +558,7 @@ template<std::size_t size, class T> inline Vector<size, T> operator*(
 @f[
     \boldsymbol c_i = \frac b {\boldsymbol a_i}
 @f]
-@see Vector::operator/(T) const
-@todoc Make explicit reference when Doxygen can handle operators
+@see @ref Vector::operator/(T) const
 */
 template<std::size_t size, class T> inline Vector<size, T> operator/(
     #ifdef DOXYGEN_GENERATING_OUTPUT
@@ -860,9 +847,8 @@ operator>>(const Vector<size, Integral>& vector,
 /** @relates Vector
 @brief Multiply integral vector with floating-point number and assign
 
-Similar to Vector::operator*=(T), except that the multiplication is done in
-floating-point. The computation is done in-place.
-@todoc Make explicit reference when Doxygen can handle operators
+Similar to @ref Vector::operator*=(T), except that the multiplication is done
+in floating-point. The computation is done in-place.
 */
 template<std::size_t size, class Integral, class FloatingPoint> inline
 #ifdef DOXYGEN_GENERATING_OUTPUT
@@ -880,9 +866,8 @@ operator*=(Vector<size, Integral>& vector, FloatingPoint number) {
 /** @relates Vector
 @brief Multiply integral vector with floating-point number
 
-Similar to Vector::operator*(T) const, except that the multiplication is done
-in floating-point.
-@todoc Make explicit reference when Doxygen can handle operators
+Similar to @ref Vector::operator*(T) const, except that the multiplication is
+done in floating-point.
 */
 template<std::size_t size, class Integral, class FloatingPoint> inline
 #ifdef DOXYGEN_GENERATING_OUTPUT
@@ -898,8 +883,7 @@ operator*(const Vector<size, Integral>& vector, FloatingPoint number) {
 /** @relates Vector
 @brief Multiply floating-point number with integral vector
 
-Same as operator*(const Vector<size, Integral>&, FloatingPoint).
-@todoc Make explicit reference when Doxygen can handle operators
+Same as @ref operator*(const Vector<size, Integral>&, FloatingPoint).
 */
 template<std::size_t size, class FloatingPoint, class Integral> inline
 #ifdef DOXYGEN_GENERATING_OUTPUT
@@ -914,9 +898,8 @@ operator*(FloatingPoint number, const Vector<size, Integral>& vector) {
 /** @relates Vector
 @brief Divide integral vector with floating-point number and assign
 
-Similar to Vector::operator/=(T), except that the division is done in
+Similar to @ref Vector::operator/=(T), except that the division is done in
 floating-point. The computation is done in-place.
-@todoc Make explicit reference when Doxygen can handle operators
 */
 template<std::size_t size, class Integral, class FloatingPoint> inline
 #ifdef DOXYGEN_GENERATING_OUTPUT
@@ -934,9 +917,8 @@ operator/=(Vector<size, Integral>& vector, FloatingPoint number) {
 /** @relates Vector
 @brief Divide integral vector with floating-point number
 
-Similar to Vector::operator/(T) const, except that the division is done in
+Similar to @ref Vector::operator/(T) const, except that the division is done in
 floating-point.
-@todoc Make explicit reference when Doxygen can handle operators
 */
 template<std::size_t size, class Integral, class FloatingPoint> inline
 #ifdef DOXYGEN_GENERATING_OUTPUT
@@ -952,9 +934,8 @@ operator/(const Vector<size, Integral>& vector, FloatingPoint number) {
 /** @relates Vector
 @brief Multiply integral vector with floating-point vector component-wise and assign
 
-Similar to Vector::operator*=(const Vector<size, T>&), except that the
+Similar to @ref Vector::operator*=(const Vector<size, T>&), except that the
 multiplication is done in floating-point. The computation is done in-place.
-@todoc Make explicit reference when Doxygen can handle operators
 */
 template<std::size_t size, class Integral, class FloatingPoint> inline
 #ifdef DOXYGEN_GENERATING_OUTPUT
@@ -972,11 +953,10 @@ operator*=(Vector<size, Integral>& a, const Vector<size, FloatingPoint>& b) {
 /** @relates Vector
 @brief Multiply integral vector with floating-point vector component-wise
 
-Similar to Vector::operator*(const Vector<size, T>&) const, except that
+Similar to @ref Vector::operator*(const Vector<size, T>&) const, except that
 the multiplication is done in floating-point. The result is always integral
 vector, convert both arguments to the same floating-point type to have
 floating-point result.
-@todoc Make explicit reference when Doxygen can handle operators
 */
 template<std::size_t size, class Integral, class FloatingPoint> inline
 #ifdef DOXYGEN_GENERATING_OUTPUT
@@ -992,8 +972,7 @@ operator*(const Vector<size, Integral>& a, const Vector<size, FloatingPoint>& b)
 /** @relates Vector
 @brief Multiply floating-point vector with integral vector component-wise
 
-Same as operator*(const Vector<size, Integral>&, const Vector<size, FloatingPoint>&).
-@todoc Make explicit reference when Doxygen can handle operators
+Same as @ref operator*(const Vector<size, Integral>&, const Vector<size, FloatingPoint>&).
 */
 template<std::size_t size, class FloatingPoint, class Integral> inline
 #ifdef DOXYGEN_GENERATING_OUTPUT
@@ -1008,9 +987,8 @@ operator*(const Vector<size, FloatingPoint>& a, const Vector<size, Integral>& b)
 /** @relates Vector
 @brief Divide integral vector with floating-point vector component-wise and assign
 
-Similar to Vector::operator/=(const Vector<size, T>&), except that the division
-is done in floating-point. The computation is done in-place.
-@todoc Make explicit reference when Doxygen can handle operators
+Similar to @ref Vector::operator/=(const Vector<size, T>&), except that the
+division is done in floating-point. The computation is done in-place.
 */
 template<std::size_t size, class Integral, class FloatingPoint> inline
 #ifdef DOXYGEN_GENERATING_OUTPUT
@@ -1028,11 +1006,10 @@ operator/=(Vector<size, Integral>& a, const Vector<size, FloatingPoint>& b) {
 /** @relates Vector
 @brief Divide integral vector with floating-point vector component-wise
 
-Similar to Vector::operator/(const Vector<size, T>&) const, except that
+Similar to @ref Vector::operator/(const Vector<size, T>&) const, except that
 the division is done in floating-point. The result is always integral vector,
 convert both arguments to the same floating-point type to have floating-point
 result.
-@todoc Make explicit reference when Doxygen can handle operators
 */
 template<std::size_t size, class Integral, class FloatingPoint> inline
 #ifdef DOXYGEN_GENERATING_OUTPUT
diff --git a/src/Magnum/MeshTools/CombineIndexedArrays.h b/src/Magnum/MeshTools/CombineIndexedArrays.h
index 4feb71e9a..1d031331e 100644
--- a/src/Magnum/MeshTools/CombineIndexedArrays.h
+++ b/src/Magnum/MeshTools/CombineIndexedArrays.h
@@ -194,8 +194,8 @@ template<class ...T> std::vector<UnsignedInt> combineIndexedArrays(const std::pa
 
 #ifdef MAGNUM_BUILD_DEPRECATED
 /**
- * @copybrief combineIndexedArrays(const std::pair<const std::vector<UnsignedInt>&, std::vector<T>&>&...)
- * @deprecated Use @ref Magnum::MeshTools::combineIndexedArrays(const std::pair<const std::vector<UnsignedInt>&, std::vector<T>&>&...) "combineIndexedArrays(const std::pair<const std::vector<UnsignedInt>&, std::vector<T>&>&...)" instead.
+ * @copybrief combineIndexedArrays()
+ * @deprecated Use @ref Magnum::MeshTools::combineIndexedArrays() "combineIndexedArrays(const std::pair<const std::vector<UnsignedInt>&, std::vector<T>&>&...)" instead.
  */
 template<class ...T> inline CORRADE_DEPRECATED("use combineIndexedArrays(const std::pair<const std::vector<UnsignedInt>&, std::vector<T>&>&...) instead") std::vector<UnsignedInt> combineIndexedArrays(const std::tuple<const std::vector<UnsignedInt>&, std::vector<T>&>&... indexedArrays) {
     return combineIndexedArrays(std::make_pair(std::cref(std::get<0>(indexedArrays)), std::ref(std::get<1>(indexedArrays)))...);
diff --git a/src/Magnum/Resource.h b/src/Magnum/Resource.h
index c051a83e4..ef6db1f3f 100644
--- a/src/Magnum/Resource.h
+++ b/src/Magnum/Resource.h
@@ -156,7 +156,7 @@ class Resource {
          * @brief %Resource state
          *
          * @see operator bool(), @ref ResourceManager::state()
-         * @todoc Make explicit reference when Doxygen can handle operators
+         * @todoc Explicit reference when Doxygen can handle conversion operators
          */
         ResourceState state() {
             acquire();
@@ -202,10 +202,10 @@ class Resource {
         #ifdef MAGNUM_BUILD_DEPRECATED
         /**
          * @overload
-         * @deprecated Use the explicit operator*() or operator->() instead.
-         *      Implicit conversion is no longer allowed if it might throw an
-         *      assertion.
-         * @todoc Explicit reference when Doxygen can handle operators
+         * @deprecated Use the explicit @ref operator*() or operator->()
+         *      instead. Implicit conversion is no longer allowed if it might
+         *      throw an assertion.
+         * @todoc Explicit reference when Doxygen can handle operator->()
          */
         CORRADE_DEPRECATED("use operator*() or operator->() instead") operator U&() { return **this; }
         #endif
diff --git a/src/Magnum/SceneGraph/Object.h b/src/Magnum/SceneGraph/Object.h
index 86d5f560e..662b837f5 100644
--- a/src/Magnum/SceneGraph/Object.h
+++ b/src/Magnum/SceneGraph/Object.h
@@ -288,7 +288,6 @@ template<class Transformation> class Object: public AbstractObject<Transformatio
         /**
          * @copybrief transformations()
          * @deprecated Use @ref Magnum::SceneGraph::Object::transformations() "transformations(std::vector<std::reference_wrapper<Object<Transformation>>>, const typename Transformation::DataType&)" instead.
-         * @todoc fix this when Doxygen is sane (see related function in AbstractObject)
          */
         CORRADE_DEPRECATED("use transformations(std::vector<std::reference_wrapper<Object<Transformation>>>, const typename Transformation::DataType&) instead") std::vector<typename Transformation::DataType> transformations(const std::vector<Object<Transformation>*>& objects, const typename Transformation::DataType& initialTransformation = typename Transformation::DataType()) const;
 
@@ -322,7 +321,7 @@ template<class Transformation> class Object: public AbstractObject<Transformatio
         #ifdef MAGNUM_BUILD_DEPRECATED
         /**
          * @copybrief setClean(std::vector<std::reference_wrapper<Object<Transformation>>>)
-         * @deprecated Use @ref Magnum::SceneGraph::Object::setClean(std::vector<std::reference_wrapper<Object<Transformation>>> "setClean(std::vector<std::reference_wrapper<Object<Transformation>>>" instead.
+         * @deprecated Use @ref Magnum::SceneGraph::Object::setClean(std::vector<std::reference_wrapper<Object<Transformation>>>) "setClean(std::vector<std::reference_wrapper<Object<Transformation>>>)" instead.
          */
         CORRADE_DEPRECATED("use setClean(std::vector<std::reference_wrapper<Object<Transformation>>>) instead") static void setClean(const std::vector<Object<Transformation>*>& objects);
 
diff --git a/src/Magnum/Shapes/Collision.h b/src/Magnum/Shapes/Collision.h
index cba6175be..71687ccf0 100644
--- a/src/Magnum/Shapes/Collision.h
+++ b/src/Magnum/Shapes/Collision.h
@@ -98,7 +98,7 @@ template<UnsignedInt dimensions> class Collision {
          * @brief Separation distance
          *
          * @see @ref separationNormal(), operator bool()
-         * @todoc explicit reference when Doxygen can do it for operator bool
+         * @todoc Explicit reference when Doxygen can handle conversion operators
          */
         Float separationDistance() const {
             return _separationDistance;