Add compile-only test for static analysis mode

The expansions in this mode use symbols that are left undefined on purpose,
so the file is compiled but never linked, and compiling it is the test.

Author: BaLiKfromUA

tests/ExtraTests/CMakeLists.txt

@@ -539,6 +539,20 @@ set_tests_properties(CompileConfiguration::FastCompile
     PASS_REGULAR_EXPRESSION "test cases:  6 \\| 1 passed \\| 1 failed \\| 4 failed as expected\nassertions: 13 \\| 6 passed \\| 2 failed \\| 5 failed as expected"
 )
 
+# The static analysis mode is not runnable, so compiling
+# this one is the whole test. GCC cannot compile the mode at all.
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  add_library(StaticAnalysisSupport OBJECT ${TESTS_DIR}/X08-StaticAnalysisSupport.cpp)
+  target_link_libraries(StaticAnalysisSupport PRIVATE Catch2::Catch2WithMain)
+  target_compile_definitions(StaticAnalysisSupport
+    PRIVATE
+      CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
+  )
+  # The mode's `TEST_CASE` expansion uses `[[maybe_unused]]`, which is
+  # a C++17 extension in C++14, and the build compiles with -Wpedantic.
+  target_compile_features(StaticAnalysisSupport PRIVATE cxx_std_17)
+endif()
+
 # This sets up a one-off executable that compiles against the amalgamated
 # files, and then runs it for a super simple check that the amalgamated
 # files are usable.
@@ -654,6 +668,10 @@ set(EXTRA_TEST_BINARIES
 #  DebugBreakMacros
 )
 
+if(TARGET StaticAnalysisSupport)
+  list(APPEND EXTRA_TEST_BINARIES StaticAnalysisSupport)
+endif()
+
 # Notice that we are modifying EXTRA_TEST_BINARIES destructively, do not
 # use it after this point!
 list(FILTER EXTRA_TEST_BINARIES EXCLUDE REGEX "DisabledExceptions.*")

tests/ExtraTests/X08-StaticAnalysisSupport.cpp

@@ -0,0 +1,102 @@
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+/**\file
+ * Test that the macros compile with
+ * `CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT`.
+ *
+ * The expansions in this mode are meant to be scanned, not run, and use
+ * symbols that are left undefined on purpose.
+ * 
+ * The compilation itself is the test.
+ */
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers_exception.hpp>
+#include <catch2/matchers/catch_matchers_string.hpp>
+
+#include <stdexcept>
+#include <string>
+
+// Left undefined on purpose. Their results are opaque to the compiler.
+int const* make_pointer();
+std::string make_string();
+
+namespace {
+
+    [[noreturn]]
+    void throws() {
+        throw std::runtime_error( "some exception" );
+    }
+    void doesnt_throw() {}
+
+} // namespace
+
+TEST_CASE( "REQUIRE and CHECK" ) {
+    int const* const ptr = make_pointer();
+
+    REQUIRE( ptr );
+    CHECK( *ptr == 42 );
+
+    REQUIRE_FALSE( ptr == nullptr );
+    CHECK_FALSE( ptr == nullptr );
+    CHECK_NOFAIL( *ptr == 42 );
+}
+
+TEST_CASE( "CHECKED_IF and CHECKED_ELSE" ) {
+    int const* const ptr = make_pointer();
+
+    CHECKED_IF( ptr ) {
+        CHECK( *ptr == 42 );
+    }
+    CHECKED_ELSE( ptr ) {
+        CHECK_FALSE( ptr );
+    }
+}
+
+TEST_CASE( "Exception assertions" ) {
+    REQUIRE_NOTHROW( doesnt_throw() );
+    CHECK_NOTHROW( doesnt_throw() );
+
+    REQUIRE_THROWS( throws() );
+    CHECK_THROWS( throws() );
+
+    REQUIRE_THROWS_AS( throws(), std::runtime_error );
+    CHECK_THROWS_AS( throws(), std::runtime_error );
+}
+
+// The matcher-based assertions are not modelled for static analysis atm,
+// but they still have to compile in this mode.
+TEST_CASE( "Matcher assertions" ) {
+    using namespace Catch::Matchers;
+
+    REQUIRE_THAT( make_string(), StartsWith( "some" ) );
+    CHECK_THAT( make_string(), Equals( "some string" ) );
+
+    REQUIRE_THROWS_WITH( throws(), "some exception" );
+    CHECK_THROWS_WITH( throws(), ContainsSubstring( "exception" ) );
+
+    REQUIRE_THROWS_MATCHES(
+        throws(), std::runtime_error, Message( "some exception" ) );
+    CHECK_THROWS_MATCHES(
+        throws(), std::runtime_error, Message( "some exception" ) );
+}
+
+TEST_CASE( "Non-assertion macros" ) {
+    STATIC_REQUIRE( 1 + 1 == 2 );
+    STATIC_REQUIRE_FALSE( 1 + 1 == 3 );
+    STATIC_CHECK( 1 + 1 == 2 );
+    STATIC_CHECK_FALSE( 1 + 1 == 3 );
+
+    SUCCEED( "succeeded" );
+
+    if ( make_pointer() ) {
+        FAIL( "failed" );
+    }
+    SKIP( "skipped" );
+}