Upgrade to C++17

docs/configuration.md

@@ -10,7 +10,6 @@
 [Default reporter](#default-reporter)<br>
 [Bazel support](#bazel-support)<br>
 [C++11 toggles](#c11-toggles)<br>
-[C++17 toggles](#c17-toggles)<br>
 [Other toggles](#other-toggles)<br>
 [Enabling stringification](#enabling-stringification)<br>
 [Disabling exceptions](#disabling-exceptions)<br>
@@ -128,23 +127,6 @@ Catch's selection, by defining either `CATCH_CONFIG_CPP11_TO_STRING` or
 `CATCH_CONFIG_NO_CPP11_TO_STRING`.
 
 
-## C++17 toggles
-
-    CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS  // Override std::uncaught_exceptions (instead of std::uncaught_exception) support detection
-    CATCH_CONFIG_CPP17_STRING_VIEW          // Override std::string_view support detection (Catch provides a StringMaker specialization by default)
-    CATCH_CONFIG_CPP17_VARIANT              // Override std::variant support detection (checked by CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER)
-    CATCH_CONFIG_CPP17_OPTIONAL             // Override std::optional support detection (checked by CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER)
-    CATCH_CONFIG_CPP17_BYTE                 // Override std::byte support detection (Catch provides a StringMaker specialization by default)
-
-> `CATCH_CONFIG_CPP17_STRING_VIEW` was [introduced](https://github.com/catchorg/Catch2/issues/1376) in Catch2 2.4.1.
-
-Catch contains basic compiler/standard detection and attempts to use
-some C++17 features whenever appropriate. This automatic detection
-can be manually overridden in both directions, that is, a feature
-can be enabled by defining the macro in the table above, and disabled
-by using `_NO_` in the macro, e.g. `CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS`.
-
-
 ## Other toggles
 
     CATCH_CONFIG_COUNTER                    // Use __COUNTER__ to generate unique names for test cases
@@ -221,8 +203,8 @@ By default, Catch does not stringify some types from the standard library. This
 
     CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER     // Provide StringMaker specialization for std::pair
     CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER    // Provide StringMaker specialization for std::tuple
-    CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER  // Provide StringMaker specialization for std::variant, std::monostate (on C++17)
-    CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER // Provide StringMaker specialization for std::optional (on C++17)
+    CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER  // Provide StringMaker specialization for std::variant, std::monostate
+    CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER // Provide StringMaker specialization for std::optional
     CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS     // Defines all of the above
 
 > `CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER` was [introduced](https://github.com/catchorg/Catch2/issues/1380) in Catch2 2.4.1.

docs/contributing.md

@@ -211,16 +211,10 @@ and so on.
 
 ### C++ standard version
 
-Catch2 currently targets C++14 as the minimum supported C++ version.
+Catch2 currently targets C++17 as the minimum supported C++ version.
 Features from higher language versions should be used only sparingly,
 when the benefits from using them outweigh the maintenance overhead.
 
-Example of good use of polyfilling features is our use of `conjunction`,
-where if available we use `std::conjunction` and otherwise provide our
-own implementation. The reason it is good is that the surface area for
-maintenance is quite small, and `std::conjunction` can directly use
-compiler built-ins, thus providing significant compilation benefits.
-
 Example of bad use of polyfilling features would be to keep around two
 sets of metaprogramming in the stringification implementation, once
 using C++14 compliant TMP and once using C++17's `if constexpr`. While

docs/other-macros.md

@@ -72,8 +72,8 @@ including the Catch2 header.
 Example:
 ```cpp
 TEST_CASE("STATIC_REQUIRE showcase", "[traits]") {
-    STATIC_REQUIRE( std::is_void<void>::value );
-    STATIC_REQUIRE_FALSE( std::is_void<int>::value );
+    STATIC_REQUIRE( std::is_void_v<void> );
+    STATIC_REQUIRE_FALSE( std::is_void_v<int> );
 }
 ```
 
@@ -86,8 +86,8 @@ becomes equivalent to `CHECK` instead of `REQUIRE`.
 Example:
 ```cpp
 TEST_CASE("STATIC_CHECK showcase", "[traits]") {
-    STATIC_CHECK( std::is_void<void>::value );
-    STATIC_CHECK_FALSE( std::is_void<int>::value );
+    STATIC_CHECK( std::is_void_v<void> );
+    STATIC_CHECK_FALSE( std::is_void_v<int> );
 }
 ```
 

docs/test-cases-and-sections.md

@@ -264,7 +264,7 @@ You can also have different arities in the _template-arg_ packs:
 ```cpp
 TEMPLATE_PRODUCT_TEST_CASE("Product with differing arities", "[template][product]", std::tuple, (int, (int, double), (int, double, float))) {
     TestType x;
-    REQUIRE(std::tuple_size<TestType>::value >= 1);
+    REQUIRE(std::tuple_size_v<TestType> >= 1);
 }
 ```
 

docs/why-catch.md

@@ -15,7 +15,7 @@ So what does Catch2 bring to the party that differentiates it from these? Apart
 ## Key Features
 
 * Quick and easy to get started. Just download two files, add them into your project and you're away.
-* No external dependencies. As long as you can compile C++14 and have the C++ standard library available.
+* No external dependencies. As long as you can compile C++17 and have the C++ standard library available.
 * Write test cases as, self-registering, functions (or methods, if you prefer).
 * Divide test cases into sections, each of which is run in isolation (eliminates the need for fixtures).
 * Use BDD-style Given-When-Then sections as well as traditional unit test cases.