Merge pull request #244 from bluescarni/pr/clang-tidy

Adding support for clang-tidy
bluescarni · Jun 2, 2020 · b03bf6b · b03bf6b
2 parents 9c81368 + 762f087
commit b03bf6b
Show file tree

Hide file tree

Showing 145 changed files with 1,700 additions and 185 deletions.
diff --git a/.clang-tidy b/.clang-tidy
diff --git a/config.hpp.in b/config.hpp.in
@@ -175,6 +175,17 @@
 
 #endif
 
+// Wrapper for the C++17 [[nodiscard]] attribute.
+#if MPPP_CPLUSPLUS >= 201703L
+
+#define MPPP_NODISCARD [[nodiscard]]
+
+#else
+
+#define MPPP_NODISCARD
+
+#endif
+
 // C++20 constinit.
 #if defined(__cpp_constinit)
 

diff --git a/doc/changelog.rst b/doc/changelog.rst
@@ -7,6 +7,8 @@ Changelog
 New
 ~~~
 
+- mp++ now builds cleanly with ``clang-tidy``
+  (`#244 <https://github.com/bluescarni/mppp/pull/244>`__).
 - Implement additional three-way comparison functions
   for :cpp:class:`~mppp::real`
   (`#243 <https://github.com/bluescarni/mppp/pull/243>`__).

diff --git a/include/mp++/complex.hpp b/include/mp++/complex.hpp
@@ -144,8 +144,10 @@ class MPPP_DLL_PUBLIC complex
 {
     // Make friends, for accessing the non-checking prec setting funcs.
     template <bool, typename F, typename Arg0, typename... Args>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
     friend complex &detail::mpc_nary_op_impl(::mpfr_prec_t, const F &, complex &, Arg0 &&, Args &&...);
     template <bool, typename F, typename Arg0, typename... Args>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
     friend complex detail::mpc_nary_op_return_impl(::mpfr_prec_t, const F &, Arg0 &&, Args &&...);
 
     // Utility function to check the precision upon init.
@@ -176,9 +178,9 @@ class MPPP_DLL_PUBLIC complex
     complex(const complex &);
     // Move constructor.
     complex(complex &&other) noexcept
+        : // Shallow copy other.
+          m_mpc(other.m_mpc)
     {
-        // Shallow copy other.
-        m_mpc = other.m_mpc;
         // Mark the other as moved-from.
         other.m_mpc.re->_mpfr_d = nullptr;
     }
@@ -194,6 +196,7 @@ class MPPP_DLL_PUBLIC complex
     };
     // From real-valued interoperable types + optional precision.
     template <typename T, typename... Args>
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
     explicit complex(gtag, std::true_type, T &&x, const Args &... args)
     {
         // Init the real part from x + optional explicit precision.
@@ -217,6 +220,7 @@ class MPPP_DLL_PUBLIC complex
     // NOTE: no need for std::forward, as this constructor will involve
     // only std::complex or complex128.
     template <typename T, typename... Args>
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
     explicit complex(gtag, std::false_type, const T &c, const Args &... args) : complex(c.real(), c.imag(), args...)
     {
     }
@@ -228,6 +232,7 @@ class MPPP_DLL_PUBLIC complex
 #else
     template <typename T, detail::enable_if_t<is_complex_interoperable<T>::value, int> = 0>
 #endif
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init, bugprone-forwarding-reference-overload)
     explicit complex(T &&x) : complex(gtag{}, is_rv_complex_interoperable<T>{}, std::forward<T>(x))
     {
     }
@@ -237,6 +242,7 @@ class MPPP_DLL_PUBLIC complex
 #else
     template <typename T, detail::enable_if_t<is_complex_interoperable<T>::value, int> = 0>
 #endif
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
     explicit complex(T &&x, complex_prec_t p) : complex(gtag{}, is_rv_complex_interoperable<T>{}, std::forward<T>(x), p)
     {
     }
@@ -268,6 +274,7 @@ class MPPP_DLL_PUBLIC complex
               detail::enable_if_t<
                   detail::conjunction<is_rv_complex_interoperable<T>, is_rv_complex_interoperable<U>>::value, int> = 0>
 #endif
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
     explicit complex(T &&re, U &&im)
     {
         // NOTE: the precision will be the largest between the
@@ -283,6 +290,7 @@ class MPPP_DLL_PUBLIC complex
               detail::enable_if_t<
                   detail::conjunction<is_rv_complex_interoperable<T>, is_rv_complex_interoperable<U>>::value, int> = 0>
 #endif
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
     explicit complex(T &&re, U &&im, complex_prec_t p)
     {
         real_imag_ctor_impl(std::forward<T>(re), std::forward<U>(im), static_cast<::mpfr_prec_t>(p));
@@ -306,6 +314,7 @@ class MPPP_DLL_PUBLIC complex
 #else
     template <typename T, detail::enable_if_t<is_string_type<T>::value, int> = 0>
 #endif
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
     explicit complex(const T &s, int base, complex_prec_t p) : complex(stag{}, s, base, static_cast<::mpfr_prec_t>(p))
     {
     }
@@ -315,6 +324,7 @@ class MPPP_DLL_PUBLIC complex
 #else
     template <typename T, detail::enable_if_t<is_string_type<T>::value, int> = 0>
 #endif
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
     explicit complex(const T &s, complex_prec_t p) : complex(s, 10, p)
     {
     }
@@ -399,6 +409,7 @@ class MPPP_DLL_PUBLIC complex
 #else
     template <typename T, detail::enable_if_t<is_complex_interoperable<T>::value, int> = 0>
 #endif
+    // NOLINTNEXTLINE(cppcoreguidelines-c-copy-assignment-signature, misc-unconventional-assign-operator)
     complex &operator=(T &&x)
     {
         dispatch_generic_assignment(std::forward<T>(x), is_rv_complex_interoperable<T>{});
@@ -414,7 +425,7 @@ class MPPP_DLL_PUBLIC complex
 #endif
 
     // Check validity.
-    bool is_valid() const noexcept
+    MPPP_NODISCARD bool is_valid() const noexcept
     {
         return mpc_realref(&m_mpc)->_mpfr_d != nullptr;
     }
@@ -607,11 +618,11 @@ class MPPP_DLL_PUBLIC complex
 #if MPPP_CPLUSPLUS >= 201703L
     // Helpers to construct re/im refs.
     // They require C++17.
-    re_cref real_cref() const
+    [[nodiscard]] re_cref real_cref() const
     {
         return re_cref{*this};
     }
-    im_cref imag_cref() const
+    [[nodiscard]] im_cref imag_cref() const
     {
         return im_cref{*this};
     }
@@ -625,7 +636,7 @@ class MPPP_DLL_PUBLIC complex
     }
 #endif
     // Extract copies of the real/imaginary parts.
-    std::pair<real, real> get_real_imag() const &;
+    MPPP_NODISCARD std::pair<real, real> get_real_imag() const &;
     // Move out the real/imaginary parts.
     std::pair<real, real> get_real_imag() &&
     {
@@ -639,7 +650,7 @@ class MPPP_DLL_PUBLIC complex
     }
 
     // Precision getter.
-    ::mpfr_prec_t get_prec() const
+    MPPP_NODISCARD ::mpfr_prec_t get_prec() const
     {
         assert(mpfr_get_prec(mpc_realref(&m_mpc)) == mpfr_get_prec(mpc_imagref(&m_mpc)));
 
@@ -679,7 +690,7 @@ class MPPP_DLL_PUBLIC complex
     complex &prec_round(::mpfr_prec_t);
 
     // mpc_t getters.
-    const mpc_struct_t *get_mpc_t() const
+    MPPP_NODISCARD const mpc_struct_t *get_mpc_t() const
     {
         return &m_mpc;
     }
@@ -689,16 +700,16 @@ class MPPP_DLL_PUBLIC complex
     }
 
     // Detect special values.
-    bool zero_p() const
+    MPPP_NODISCARD bool zero_p() const
     {
         return mpfr_zero_p(mpc_realref(&m_mpc)) != 0 && mpfr_zero_p(mpc_imagref(&m_mpc)) != 0;
     }
-    bool is_one() const;
+    MPPP_NODISCARD bool is_one() const;
 
 private:
     // Implementation of the conversion operator.
     template <typename T>
-    T dispatch_conversion(std::true_type) const
+    MPPP_NODISCARD T dispatch_conversion(std::true_type) const
     {
         if (std::is_same<T, bool>::value) {
             return static_cast<T>(!zero_p());
@@ -714,7 +725,7 @@ class MPPP_DLL_PUBLIC complex
         }
     }
     template <typename T>
-    T dispatch_conversion(std::false_type) const
+    MPPP_NODISCARD T dispatch_conversion(std::false_type) const
     {
         using value_type = typename T::value_type;
 
@@ -801,7 +812,7 @@ class MPPP_DLL_PUBLIC complex
             std::integral_constant<int, is_rv_complex_interoperable<T>::value + std::is_same<T, real>::value * 2>{});
     }
 
-    std::string to_string(int base = 10) const;
+    MPPP_NODISCARD std::string to_string(int base = 10) const;
 
 private:
     template <typename T>
@@ -903,7 +914,7 @@ namespace detail
 template <typename... Args>
 using complex_set_t = decltype(std::declval<complex &>().set(std::declval<const Args &>()...));
 
-}
+} // namespace detail
 
 #if defined(MPPP_HAVE_CONCEPTS)
 
@@ -2975,12 +2986,14 @@ MPPP_DECLARE_COMPLEX_UDL(1024)
 template <std::size_t SSize>
 inline integer<SSize> &integer<SSize>::operator=(const complex &c)
 {
+    // NOLINTNEXTLINE(cppcoreguidelines-c-copy-assignment-signature, misc-unconventional-assign-operator)
     return *this = static_cast<integer<SSize>>(c);
 }
 
 template <std::size_t SSize>
 inline rational<SSize> &rational<SSize>::operator=(const complex &c)
 {
+    // NOLINTNEXTLINE(cppcoreguidelines-c-copy-assignment-signature, misc-unconventional-assign-operator)
     return *this = static_cast<rational<SSize>>(c);
 }
 

diff --git a/include/mp++/complex128.hpp b/include/mp++/complex128.hpp
@@ -51,8 +51,12 @@ namespace mppp
 // See also:
 // https://gcc.gnu.org/onlinedocs/gcc/Floating-Types.html
 #if (!defined(_ARCH_PPC)) || defined(__LONG_DOUBLE_IEEE128__)
+// NOTE: not sure about the correct syntax for 'using'+attributes
+// here. Let's leave it verbatim like from the quadmath.h header.
+// NOLINTNEXTLINE(modernize-use-using)
 typedef _Complex float __attribute__((mode(TC))) cplex128;
 #else
+// NOLINTNEXTLINE(modernize-use-using)
 typedef _Complex float __attribute__((mode(KC))) cplex128;
 #endif
 
@@ -91,6 +95,7 @@ constexpr complex128 conj(const complex128 &);
 class MPPP_DLL_PUBLIC complex128
 {
 public:
+    // NOLINTNEXTLINE(modernize-use-default-member-init)
     cplex128 m_value;
 
     using value_type = real128;
@@ -183,12 +188,15 @@ class MPPP_DLL_PUBLIC complex128
 #else
     template <typename T, detail::enable_if_t<is_string_type<T>::value, int> = 0>
 #endif
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
     explicit complex128(const T &s) : complex128(ptag{}, s)
     {
     }
     // Constructor from range of characters.
     explicit complex128(const char *, const char *);
 
+    ~complex128() = default;
+
     // Trivial copy assignment operator.
     complex128 &operator=(const complex128 &) = default;
     // Trivial move assignment operator.
@@ -209,6 +217,7 @@ class MPPP_DLL_PUBLIC complex128
 #endif
     MPPP_CONSTEXPR_14 complex128 &operator=(const T &x)
     {
+        // NOLINTNEXTLINE(cppcoreguidelines-c-copy-assignment-signature, misc-unconventional-assign-operator)
         return *this = complex128{x};
     }
 
@@ -220,6 +229,7 @@ class MPPP_DLL_PUBLIC complex128
 #endif
     MPPP_CONSTEXPR_14 complex128 &operator=(const T &c)
     {
+        // NOLINTNEXTLINE(cppcoreguidelines-c-copy-assignment-signature, misc-unconventional-assign-operator)
         return *this = complex128{c};
     }
 #if defined(MPPP_WITH_MPC)
@@ -234,15 +244,16 @@ class MPPP_DLL_PUBLIC complex128
 #endif
     complex128 &operator=(const T &s)
     {
+        // NOLINTNEXTLINE(cppcoreguidelines-c-copy-assignment-signature, misc-unconventional-assign-operator)
         return *this = complex128{s};
     }
 
     // Getters for the real/imaginary parts.
-    constexpr real128 real() const
+    MPPP_NODISCARD constexpr real128 real() const
     {
         return real128{__real__ m_value};
     }
-    constexpr real128 imag() const
+    MPPP_NODISCARD constexpr real128 imag() const
     {
         return real128{__imag__ m_value};
     }
@@ -372,7 +383,7 @@ class MPPP_DLL_PUBLIC complex128
     }
 
     // Conversion to string.
-    std::string to_string() const;
+    MPPP_NODISCARD std::string to_string() const;
 
     // Complex absolute value.
     complex128 &abs();
@@ -1211,6 +1222,7 @@ inline complex128 operator"" _icq()
 template <std::size_t SSize>
 inline integer<SSize> &integer<SSize>::operator=(const complex128 &x)
 {
+    // NOLINTNEXTLINE(cppcoreguidelines-c-copy-assignment-signature, misc-unconventional-assign-operator)
     return *this = static_cast<integer<SSize>>(x);
 }
 
@@ -1219,13 +1231,15 @@ inline integer<SSize> &integer<SSize>::operator=(const complex128 &x)
 template <std::size_t SSize>
 inline rational<SSize> &rational<SSize>::operator=(const complex128 &x)
 {
+    // NOLINTNEXTLINE(cppcoreguidelines-c-copy-assignment-signature, misc-unconventional-assign-operator)
     return *this = static_cast<rational<SSize>>(x);
 }
 
 // Implementation of real128's assignment
 // from complex128.
 inline MPPP_CONSTEXPR_14 real128 &real128::operator=(const complex128 &x)
 {
+    // NOLINTNEXTLINE(cppcoreguidelines-c-copy-assignment-signature, misc-unconventional-assign-operator)
     return *this = static_cast<real128>(x);
 }
 

diff --git a/include/mp++/detail/gmp.hpp b/include/mp++/detail/gmp.hpp
@@ -35,6 +35,7 @@ using mpz_size_t = decltype(std::declval<mpz_struct_t>()._mp_size);
 
 // Simple RAII holder for GMP integers.
 struct mpz_raii {
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
     mpz_raii()
     {
         ::mpz_init(&m_mpz);
@@ -60,6 +61,7 @@ using mpq_struct_t = std::remove_extent<::mpq_t>::type;
 
 // Simple RAII holder for GMP rationals.
 struct mpq_raii {
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
     mpq_raii()
     {
         ::mpq_init(&m_mpq);
@@ -80,6 +82,7 @@ using mpf_struct_t = std::remove_extent<::mpf_t>::type;
 
 // Simple RAII holder for GMP floats.
 struct mpf_raii {
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
     explicit mpf_raii(::mp_bitcnt_t prec)
     {
         ::mpf_init2(&m_mpf, prec);

diff --git a/include/mp++/detail/integer_literals.hpp b/include/mp++/detail/integer_literals.hpp
@@ -138,10 +138,15 @@ inline
         }
     }();
 
+#if MPPP_CPLUSPLUS >= 201703L
+    assert(base == 2 || base == 8 || base == 10 || base == 16);
+#endif
+
     // Run the checks on the rest of the literal,
     // after we already checked the first 2 digits.
     // For bases 2 and 16, we need to have other digits,
     // otherwise the literal is malformed.
+    // NOLINTNEXTLINE(hicpp-multiway-paths-covered)
     switch (base) {
         case 2:
             if (str_length == 2u) {

diff --git a/include/mp++/detail/mpfr.hpp b/include/mp++/detail/mpfr.hpp
@@ -71,6 +71,7 @@ constexpr bool real_prec_check(::mpfr_prec_t p)
 struct mpfr_raii {
     // A constructor from a precision value, will set the value to NaN.
     // No check is performed on the precision.
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
     explicit mpfr_raii(::mpfr_prec_t prec)
     {
         ::mpfr_init2(&m_mpfr, prec);
@@ -91,6 +92,7 @@ struct mpfr_raii {
 static_assert(std::numeric_limits<long double>::max_digits10 < nl_max<int>() / 4, "Overflow error.");
 static_assert(std::numeric_limits<long double>::max_digits10 * 4 < nl_max<::mpfr_prec_t>(), "Overflow error.");
 static_assert(std::numeric_limits<long double>::max_digits10 * 4 < nl_max<::mp_bitcnt_t>(), "Overflow error.");
+// NOLINTNEXTLINE(bugprone-misplaced-widening-cast)
 static_assert(real_prec_check(static_cast<::mpfr_prec_t>(std::numeric_limits<long double>::max_digits10 * 4)),
               "The precision required to represent long double is outside the MPFR min/max precision bounds.");