[CMake] Remove unused variable LLDB_TEST_CXX_COMPILER

[JDevlieghere]

Summary

CMake allows you to set a custom CXX compiler for the API test suite.
However, this variable is never used, because dotest uses the same
compiler to build C and CXX sources.

I'm not sure if this variable was added with the intention of supporting
a different compiler or if this is just a remnant of old functionality.
Given that this hasn't been working for a while, I assume it's safe to
remove.

[JDevlieghere]

I did a bit of digging and there's more context in https://reviews.llvm.org/D39215. It sounds to me like the motivation for the two variables isn't relevant anymore, so I still think removing the CXX variant is desirable.

[labath]

Overall, I think it would be better to just pass the c++ compiler instead of having dotest try to guess it from the c compiler name. But, it's easy to reintroduce this option once we get to that point.

[xiaobai]

I thought this option was so that you could specify which compilers to use to build from a cache or command line? I don't think you just want to set LLDB_TEST_COMPILER to clang since clang++ is what is used to compile C++ code. Maybe I'm mis-remembering or mistaken here.

[JDevlieghere]

In D69401#1720432, @xiaobai wrote:

I thought this option was so that you could specify which compilers to use to build from a cache or command line? I don't think you just want to set LLDB_TEST_COMPILER to clang since clang++ is what is used to compile C++ code. Maybe I'm mis-remembering or mistaken here.

Yes, that's indeed the point. However, dotest expects you to set the C compiler and then infers the C++ compiler from it, which for clang is just appending ++ at the end. I'm sure it must do something sensible for gcc as well, as I believe people are running the test suite with that compiler.

[xiaobai]

In D69401#1720494, @JDevlieghere wrote:

In D69401#1720432, @xiaobai wrote:

I thought this option was so that you could specify which compilers to use to build from a cache or command line? I don't think you just want to set LLDB_TEST_COMPILER to clang since clang++ is what is used to compile C++ code. Maybe I'm mis-remembering or mistaken here.

Yes, that's indeed the point. However, dotest expects you to set the C compiler and then infers the C++ compiler from it, which for clang is just appending ++ at the end. I'm sure it must do something sensible for gcc as well, as I believe people are running the test suite with that compiler.

Right, I see. I'm not sure I like the inference in dotest, and I assume cl is left untouched here (if it's even possible to use cl as the compiler on windows for tests). I do like the simplification to the build though so ship it!

lldb/CMakeLists.txt

if(LLDB_INCLUDE_TESTS)
   # Set the path to the default lldb test executable.
   set(LLDB_DEFAULT_TEST_EXECUTABLE "${LLVM_RUNTIME_OUTPUT_INTDIR}/lldb${CMAKE_EXECUTABLE_SUFFIX}")
 
   # Set the paths to default llvm tools.
   set(LLDB_DEFAULT_TEST_DSYMUTIL "${LLVM_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin/dsymutil${CMAKE_EXECUTABLE_SUFFIX}")
   set(LLDB_DEFAULT_TEST_FILECHECK "${LLVM_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin/FileCheck${CMAKE_EXECUTABLE_SUFFIX}")
 
   if (TARGET clang)
-    set(LLDB_DEFAULT_TEST_C_COMPILER "${LLVM_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin/clang${CMAKE_EXECUTABLE_SUFFIX}")
-    set(LLDB_DEFAULT_TEST_CXX_COMPILER "${LLVM_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin/clang++${CMAKE_EXECUTABLE_SUFFIX}")
+    set(LLDB_DEFAULT_TEST_COMPILER "${LLVM_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin/clang${CMAKE_EXECUTABLE_SUFFIX}")
   else()
-    set(LLDB_DEFAULT_TEST_C_COMPILER "")
-    set(LLDB_DEFAULT_TEST_CXX_COMPILER "")
+    set(LLDB_DEFAULT_TEST_COMPILER "")
   endif()
 
   set(LLDB_TEST_EXECUTABLE "${LLDB_DEFAULT_TEST_EXECUTABLE}" CACHE PATH "lldb executable used for testing")
-  set(LLDB_TEST_C_COMPILER "${LLDB_DEFAULT_TEST_C_COMPILER}" CACHE PATH "C Compiler to use for building LLDB test inferiors")
-  set(LLDB_TEST_CXX_COMPILER "${LLDB_DEFAULT_TEST_CXX_COMPILER}" CACHE PATH "C++ Compiler to use for building LLDB test inferiors")
+  set(LLDB_TEST_COMPILER "${LLDB_DEFAULT_TEST_COMPILER}" CACHE PATH "C Compiler to use for building LLDB test inferiors")
   set(LLDB_TEST_DSYMUTIL "${LLDB_DEFAULT_TEST_DSYMUTIL}" CACHE PATH "dsymutil used for generating dSYM bundles")
   set(LLDB_TEST_FILECHECK "${LLDB_DEFAULT_TEST_FILECHECK}" CACHE PATH "FileCheck used for testing purposes")
 
-  if (("${LLDB_TEST_C_COMPILER}" STREQUAL "") OR
-      ("${LLDB_TEST_CXX_COMPILER}" STREQUAL ""))
-    message(FATAL_ERROR "LLDB test compilers not specified. Tests will not run.")
+  if ("${LLDB_TEST_COMPILER}" STREQUAL "")
+    message(FATAL_ERROR "LLDB test compiler not specified. Tests will not run.")
   endif()
 
   add_custom_target(lldb-test-deps)
   set_target_properties(lldb-test-deps PROPERTIES FOLDER "lldb misc")
   add_lldb_test_dependency(lldb)
 
   # lldb-test is an hard dependency for the testsuite.
   add_lldb_test_dependency(lldb-test)

lldb/docs/resources/build.rst

 If you want to run the test suite, you will need a compiler to build the test
 programs. If you have Clang checked out, that will be used by default.
 Alternatively, you can specify a C and C++ compiler to be used by the test
 suite.
 
 ::
 
   > cmake -G Ninja \
-      -DLLDB_TEST_C_COMPILER=<path to C compiler> \
-      -DLLDB_TEST_CXX_COMPILER=<path to C++ compiler> \
+      -DLLDB_TEST_COMPILER=<path to C compiler> \
       <path to root of llvm source tree>
 
 It is strongly recommend to use a release build for the compiler to speed up
 test execution.
 
 Windows
 ^^^^^^^
 

 
 Sample command line:
 
 ::
 
   > cmake -G Ninja^
       -DLLDB_TEST_DEBUG_TEST_CRASHES=1^
       -DPYTHON_HOME=C:\Python35^
-      -DLLDB_TEST_C_COMPILER=d:\src\llvmbuild\ninja_release\bin\clang.exe^
+      -DLLDB_TEST_COMPILER=d:\src\llvmbuild\ninja_release\bin\clang.exe^
       <path to root of llvm source tree>
 
 
 Building with ninja is both faster and simpler than building with Visual Studio,
 but chances are you still want to debug LLDB with an IDE. One solution is to run
 cmake twice and generate the output into two different folders. One for
 compiling (the ninja folder), and one for editing, browsing and debugging.
 

lldb/docs/resources/test.rst

 Running the Full Test Suite
 ---------------------------
 
 The easiest way to run the LLDB test suite is to use the ``check-lldb`` build
 target.
 
 By default, the ``check-lldb`` target builds the test programs with the same
 compiler that was used to build LLDB. To build the tests with a different
-compiler, you can set the ``LLDB_TEST_C_COMPILER`` or the
-``LLDB_TEST_CXX_COMPILER`` CMake variables.
+compiler, you can set the ``LLDB_TEST_COMPILER`` CMake variable.
 
 It is possible to customize the architecture of the test binaries and compiler
 used by appending ``-A`` and ``-C`` options respectively to the CMake variable
 ``LLDB_TEST_USER_ARGS``. For example, to test LLDB against 32-bit binaries
 built with a custom version of clang, do:
 
 ::
 

lldb/test/API/CMakeLists.txt

set(LLDB_TEST_COMMON_ARGS
   -u CXXFLAGS
   -u CFLAGS
   )
 
 list(APPEND LLDB_TEST_COMMON_ARGS
   --executable ${LLDB_TEST_EXECUTABLE}
   --dsymutil ${LLDB_TEST_DSYMUTIL}
   --filecheck ${LLDB_TEST_FILECHECK}
-  -C ${LLDB_TEST_C_COMPILER}
+  --compiler ${LLDB_TEST_COMPILER}
   )
 
 if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
   # All tests are currently flaky on Windows, so rerun them all once when they fail.
   set(LLDB_TEST_COMMON_ARGS ${LLDB_TEST_COMMON_ARGS} --rerun-all-issues)
 
   set(LLDB_TEST_DEBUG_TEST_CRASHES
     0