Avoid unhelpful -Wunused-variable

...at least from "g++ (GCC) 5.1.1 20150618 (Red Hat 5.1.1-4)" with
--disable-debug, when a namespace-scope const variable with a "complex"
initializer declared in an include file remains unused.

Avoid that warning via SAL_CONSTEXPR, which in turn requires large parts of
o3tl::is_typed_flags to be SAL_CONSTEXPR, which in turn requires a new
HAVE_CXX14_CONSTEXPR to allow assert in constexpr functions, which in turn
requires using -std=c++14 instead of -std=c++11 where available, which in turn
(a) requires to /not/ use -std=c++14 if it would run into a bug between Clang
and libstdc++ discussed at <https://llvm.org/bugs/show_bug.cgi?id=24115>
"llvm-nm fails to build with gcc 5.1's libstdc++" (and which hits us in
sfx2/source/control/thumbnailview.cxx), and (b) requires a new
HAVE_CXX14_SIZED_DEALLOCATION to work around GCC 5.1 -Werror=sized-deallocation
(where Clang >= 3.7 only supports C++14 sized deallocation when explictly
enabled via -fsized-deallocation, btw).

This effectively reverts ff6462e6307e6924dc6c8178043ae9032f4b4152 "avoid unused
variable warning:" again.

Change-Id: I424e3561452a3e6d8c8a9604d6c737cab49840c4
Reviewed-on: https://gerrit.libreoffice.org/18918
Reviewed-by: Stephan Bergmann <sbergman@redhat.com>
Tested-by: Stephan Bergmann <sbergman@redhat.com>

5 files changed, 141 insertions, 25 deletions

diff --git a/config_host/config_global.h.in b/config_host/config_global.h.in
index a029ff53c7e7..b2aa4da9353d 100644
--- a/config_host/config_global.h.in
+++ b/config_host/config_global.h.in
@@ -17,6 +17,8 @@ Any change in this header will cause a rebuild of almost everything.
 #define HAVE_CXX11_FINAL 0
 #define HAVE_CXX11_PERFECT_FORWARDING 0
 #define HAVE_CXX11_CONSTEXPR 0
+#define HAVE_CXX14_CONSTEXPR 0
+#define HAVE_CXX14_SIZED_DEALLOCATION 0
 #define HAVE_GCC_BUILTIN_ATOMIC 0
 /* _Pragma */
 #define HAVE_GCC_PRAGMA_OPERATOR 0
diff --git a/configure.ac b/configure.ac
index a84772b6932b..73855b01602e 100644
--- a/configure.ac
+++ b/configure.ac
@@ -6040,12 +6040,19 @@ if test "$COM" = MSC; then
     # MSVC supports (a subset of) CXX11 without any switch
 elif test "$GCC" = "yes"; then
     HAVE_CXX11=
-    AC_MSG_CHECKING([whether $CXX supports C++11])
-    for flag in -std=gnu++11 -std=gnu++0x -std=c++11 -std=c++0x ; do
+    AC_MSG_CHECKING([whether $CXX supports C++14 or C++11])
+    for flag in -std=gnu++14 -std=gnu++1y -std=c++14 -std=c++1y -std=gnu++11 -std=gnu++0x -std=c++11 -std=c++0x ; do
         save_CXXFLAGS=$CXXFLAGS
         CXXFLAGS="$CXXFLAGS $flag -Werror"
         AC_LANG_PUSH([C++])
-        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[void f() {}]])],[CXXFLAGS_CXX11=$flag])
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+            #include <algorithm>
+            #include <functional>
+            #include <vector>
+            void f(std::vector<int> & v, std::function<bool(int, int)> fn) {
+                std::sort(v.begin(), v.end(), fn);
+            }
+            ]])],[CXXFLAGS_CXX11=$flag])
         AC_LANG_POP([C++])
         CXXFLAGS=$save_CXXFLAGS
         if test -n "$CXXFLAGS_CXX11"; then
@@ -6319,6 +6326,49 @@ if test "$cxx11_constexpr" = yes; then
     AC_DEFINE([HAVE_CXX11_CONSTEXPR])
 fi
 
+AC_MSG_CHECKING([whether $CXX supports C++14 constexpr])
+save_CXXFLAGS=$CXXFLAGS
+CXXFLAGS="$CXXFLAGS $CXXFLAGS_CXX11"
+AC_LANG_PUSH([C++])
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+    struct S {
+        int n_;
+        constexpr bool f() {
+            int n = n_;
+            int i = 0;
+            while (n > 0) { --n; ++i; }
+            return i == 0;
+        }
+    };
+    ]])], [cxx14_constexpr=yes], [cxx14_constexpr=no])
+AC_LANG_POP([C++])
+CXXFLAGS=$save_CXXFLAGS
+AC_MSG_RESULT([$cxx14_constexpr])
+if test "$cxx14_constexpr" = yes; then
+    AC_DEFINE([HAVE_CXX14_CONSTEXPR])
+fi
+
+AC_MSG_CHECKING([whether $CXX supports C++14 sized deallocation])
+save_CXXFLAGS=$CXXFLAGS
+CXXFLAGS="$CXXFLAGS $CXXFLAGS_CXX11"
+AC_LANG_PUSH([C++])
+AC_RUN_IFELSE([AC_LANG_PROGRAM([[
+    #include <cstddef>
+    #include <cstdlib>
+    void operator delete(void *) throw () { std::exit(1); }
+    void operator delete(void *, std::size_t) throw () { std::exit(0); }
+    struct S { S() { throw 0; } };
+    ]],[[
+    try { new S; } catch (...) {}
+    return 1;
+    ]])], [cxx14_sized_deallocation=yes], [cxx14_sized_deallocation=no])
+AC_LANG_POP([C++])
+CXXFLAGS=$save_CXXFLAGS
+AC_MSG_RESULT([$cxx14_sized_deallocation])
+if test "$cxx14_sized_deallocation" = yes; then
+    AC_DEFINE([HAVE_CXX14_SIZED_DEALLOCATION])
+fi
+
 HAVE_GCC_PRAGMA_OPERATOR=
 dnl _Pragma support (may require C++11)
 if test "$GCC" = "yes"; then
diff --git a/include/o3tl/typed_flags_set.hxx b/include/o3tl/typed_flags_set.hxx
index 4755c09fb536..9b8cb817ee02 100644
--- a/include/o3tl/typed_flags_set.hxx
+++ b/include/o3tl/typed_flags_set.hxx
@@ -25,18 +25,21 @@
 #include <cassert>
 #include <type_traits>
 
+#include <config_global.h>
+#include <sal/types.h>
+
 namespace o3tl {
 
 namespace detail {
 
-template<typename T> inline
+template<typename T> inline SAL_CONSTEXPR
 typename std::enable_if<std::is_signed<T>::value, bool>::type isNonNegative(
     T value)
 {
     return value >= 0;
 }
 
-template<typename T> inline
+template<typename T> inline SAL_CONSTEXPR
 typename std::enable_if<std::is_unsigned<T>::value, bool>::type isNonNegative(T)
 {
     return true;
@@ -70,19 +73,23 @@ struct is_typed_flags {
     public:
         typedef is_typed_flags Unwrapped;
 
-        explicit Wrap(typename std::underlying_type<E>::type value):
+        explicit SAL_CONSTEXPR Wrap(
+            typename std::underlying_type<E>::type value):
             value_(value)
         {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
             assert(detail::isNonNegative(value));
             assert((value & ~M) == 0);
+#endif
         }
 
-        operator E() { return static_cast<E>(value_); }
+        SAL_CONSTEXPR operator E() const { return static_cast<E>(value_); }
 
-        explicit operator typename std::underlying_type<E>::type()
+        explicit SAL_CONSTEXPR operator typename std::underlying_type<E>::type()
+            const
         { return value_; }
 
-        explicit operator bool() { return value_ != 0; }
+        explicit SAL_CONSTEXPR operator bool() const { return value_ != 0; }
 
     private:
         typename std::underlying_type<E>::type value_;
@@ -94,17 +101,19 @@ struct is_typed_flags {
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator ~(E rhs) {
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator ~(E rhs) {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(rhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         o3tl::typed_flags<E>::mask
         & ~static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator ~(
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator ~(
     typename o3tl::typed_flags<E>::Wrap rhs)
 {
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
@@ -113,44 +122,53 @@ inline typename o3tl::typed_flags<E>::Wrap operator ~(
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator ^(E lhs, E rhs) {
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator ^(
+    E lhs, E rhs)
+{
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(lhs)));
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(rhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         ^ static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator ^(
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator ^(
     E lhs, typename o3tl::typed_flags<E>::Wrap rhs)
 {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(lhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         ^ static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator ^(
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator ^(
     typename o3tl::typed_flags<E>::Wrap lhs, E rhs)
 {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(rhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         ^ static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename W>
-inline typename o3tl::typed_flags<typename W::Unwrapped::Self>::Wrap operator ^(
+inline SAL_CONSTEXPR
+typename o3tl::typed_flags<typename W::Unwrapped::Self>::Wrap operator ^(
     W lhs, W rhs)
 {
     return static_cast<W>(
@@ -163,44 +181,53 @@ inline typename o3tl::typed_flags<typename W::Unwrapped::Self>::Wrap operator ^(
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator &(E lhs, E rhs) {
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator &(
+    E lhs, E rhs)
+{
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(lhs)));
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(rhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         & static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator &(
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator &(
     E lhs, typename o3tl::typed_flags<E>::Wrap rhs)
 {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(lhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         & static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator &(
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator &(
     typename o3tl::typed_flags<E>::Wrap lhs, E rhs)
 {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(rhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         & static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename W>
-inline typename o3tl::typed_flags<typename W::Unwrapped::Self>::Wrap operator &(
+inline SAL_CONSTEXPR
+typename o3tl::typed_flags<typename W::Unwrapped::Self>::Wrap operator &(
     W lhs, W rhs)
 {
     return static_cast<W>(
@@ -213,44 +240,50 @@ inline typename o3tl::typed_flags<typename W::Unwrapped::Self>::Wrap operator &(
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator |(E lhs, E rhs) {
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator |(E lhs, E rhs) {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(lhs)));
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(rhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         | static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator |(
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator |(
     E lhs, typename o3tl::typed_flags<E>::Wrap rhs)
 {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(lhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         | static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator |(
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator |(
     typename o3tl::typed_flags<E>::Wrap lhs, E rhs)
 {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(rhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         | static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename W>
-inline typename o3tl::typed_flags<typename W::Unwrapped::Self>::Wrap operator |(
+inline SAL_CONSTEXPR typename o3tl::typed_flags<typename W::Unwrapped::Self>::Wrap operator |(
     W lhs, W rhs)
 {
     return static_cast<W>(
diff --git a/include/svx/dlgutil.hxx b/include/svx/dlgutil.hxx
index c60fd93ca35f..284d3554cdbb 100644
--- a/include/svx/dlgutil.hxx
+++ b/include/svx/dlgutil.hxx
@@ -33,8 +33,8 @@ SVX_DLLPUBLIC FieldUnit GetModuleFieldUnit( const SfxItemSet& );
 SVX_DLLPUBLIC FieldUnit GetModuleFieldUnit();
 SVX_DLLPUBLIC bool GetApplyCharUnit( const SfxItemSet& );
 
-#define OUTPUT_DRAWMODE_COLOR    DrawModeFlags::Default
-#define OUTPUT_DRAWMODE_CONTRAST (DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill | DrawModeFlags::SettingsText | DrawModeFlags::SettingsGradient)
+SAL_CONSTEXPR DrawModeFlags const OUTPUT_DRAWMODE_COLOR = DrawModeFlags::Default;
+SAL_CONSTEXPR DrawModeFlags const OUTPUT_DRAWMODE_CONTRAST = DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill | DrawModeFlags::SettingsText | DrawModeFlags::SettingsGradient;
 
 #endif
 
diff --git a/sal/cpprt/operators_new_delete.cxx b/sal/cpprt/operators_new_delete.cxx
index 064caa5946f5..5fbd9c09be7d 100644
--- a/sal/cpprt/operators_new_delete.cxx
+++ b/sal/cpprt/operators_new_delete.cxx
@@ -18,8 +18,11 @@
  */
 
 #include <algorithm>
+#include <cstddef>
 #include <new>
 #include <string.h>
+
+#include <config_global.h>
 #include <osl/diagnose.h>
 #include <rtl/alloc.h>
 
@@ -152,6 +155,20 @@ void SAL_CALL operator delete (void * p) throw ()
     deallocate (p, ScalarTraits());
 }
 
+#if HAVE_CXX14_SIZED_DEALLOCATION
+#if defined __clang__
+#pragma GCC diagnostic push // as happens on Mac OS X:
+#pragma GCC diagnostic ignored "-Wimplicit-exception-spec-mismatch"
+#endif
+void SAL_CALL operator delete (void * p, std::size_t) noexcept
+{
+    deallocate (p, ScalarTraits());
+}
+#if defined __clang__
+#pragma GCC diagnostic pop
+#endif
+#endif
+
 // T * p = new(nothrow) T; delete(nothrow) p;
 
 void* SAL_CALL operator new (std::size_t n, std::nothrow_t const &) throw ()
@@ -176,6 +193,20 @@ void SAL_CALL operator delete[] (void * p) throw ()
     deallocate (p, VectorTraits());
 }
 
+#if HAVE_CXX14_SIZED_DEALLOCATION
+#if defined __clang__
+#pragma GCC diagnostic push // as happens on Mac OS X:
+#pragma GCC diagnostic ignored "-Wimplicit-exception-spec-mismatch"
+#endif
+void SAL_CALL operator delete[] (void * p, std::size_t) noexcept
+{
+    deallocate (p, VectorTraits());
+}
+#if defined __clang__
+#pragma GCC diagnostic pop
+#endif
+#endif
+
 // T * p = new(nothrow) T[n]; delete(nothrow)[] p;
 
 void* SAL_CALL operator new[] (std::size_t n, std::nothrow_t const &) throw ()