Help/release/3.29.rst

@@ -211,3 +211,10 @@ Changes made since CMake 3.29.0 include the following.
 * The :variable:`CMAKE_LINKER_TYPE` variable and corresponding
   :prop_tgt:`LINKER_TYPE` target property now work with compilers
   for the ``Swift`` language.
+
+3.29.2
+------
+
+* This version made no changes to documented features or interfaces.
+  Some implementation updates were made to support ecosystem changes
+  and/or fix regressions.

Modules/CMakePackageConfigHelpers.cmake

@@ -377,24 +377,6 @@ macro(WRITE_BASIC_PACKAGE_VERSION_FILE)
   write_basic_config_version_file(${ARGN})
 endmacro()
 
-function(__CMAKE_get_config_file_package_prefix outvar)
-  get_property(counter GLOBAL PROPERTY CMAKE_CONFIGURE_PACKAGE_CONFIG_FILE_COUNTER)
-  if(NOT counter)
-    set(counter 1)
-    set_property(GLOBAL PROPERTY CMAKE_CONFIGURE_PACKAGE_CONFIG_FILE_COUNTER ${counter})
-  endif()
-  set(${outvar} "PACKAGE_\${CMAKE_FIND_PACKAGE_NAME}_COUNTER_${counter}" PARENT_SCOPE)
-endfunction()
-
-function(__CMAKE_increment_config_file_counter)
-  get_property(counter GLOBAL PROPERTY CMAKE_CONFIGURE_PACKAGE_CONFIG_FILE_COUNTER)
-  if(NOT counter)
-    message(FATAL_ERROR "Internal error: global counter unexpectedly not set")
-  endif()
-  math(EXPR counter "${counter} + 1")
-  set_property(GLOBAL PROPERTY CMAKE_CONFIGURE_PACKAGE_CONFIG_FILE_COUNTER ${counter})
-endfunction()
-
 function(CONFIGURE_PACKAGE_CONFIG_FILE _inputFile _outputFile)
   set(options NO_SET_AND_CHECK_MACRO NO_CHECK_REQUIRED_COMPONENTS_MACRO)
   set(oneValueArgs INSTALL_DESTINATION INSTALL_PREFIX)
@@ -430,17 +412,15 @@ function(CONFIGURE_PACKAGE_CONFIG_FILE _inputFile _outputFile)
 
   file(RELATIVE_PATH PACKAGE_RELATIVE_PATH "${absInstallDir}" "${installPrefix}" )
 
-  __CMAKE_get_config_file_package_prefix(prefix_dir)
-
   foreach(var ${CCF_PATH_VARS})
     if(NOT DEFINED ${var})
       message(FATAL_ERROR "Variable ${var} does not exist")
     else()
       if(IS_ABSOLUTE "${${var}}")
-        string(REPLACE "${installPrefix}" "\${${prefix_dir}}"
+        string(REPLACE "${installPrefix}" "\${PACKAGE_PREFIX_DIR}"
                         PACKAGE_${var} "${${var}}")
       else()
-        set(PACKAGE_${var} "\${${prefix_dir}}/${${var}}")
+        set(PACKAGE_${var} "\${PACKAGE_PREFIX_DIR}/${${var}}")
       endif()
     endif()
   endforeach()
@@ -452,7 +432,7 @@ function(CONFIGURE_PACKAGE_CONFIG_FILE _inputFile _outputFile)
 ####### Any changes to this file will be overwritten by the next CMake run ####
 ####### The input file was ${inputFileName}                            ########
 
-get_filename_component(${prefix_dir} \"\${CMAKE_CURRENT_LIST_DIR}/${PACKAGE_RELATIVE_PATH}\" ABSOLUTE)
+get_filename_component(PACKAGE_PREFIX_DIR \"\${CMAKE_CURRENT_LIST_DIR}/${PACKAGE_RELATIVE_PATH}\" ABSOLUTE)
 ")
 
   if("${absInstallDir}" MATCHES "^(/usr)?/lib(64)?/.+")
@@ -463,7 +443,7 @@ get_filename_component(${prefix_dir} \"\${CMAKE_CURRENT_LIST_DIR}/${PACKAGE_RELA
 get_filename_component(_realCurr \"\${CMAKE_CURRENT_LIST_DIR}\" REALPATH)
 get_filename_component(_realOrig \"${absInstallDir}\" REALPATH)
 if(_realCurr STREQUAL _realOrig)
-  set(${prefix_dir} \"${installPrefix}\")
+  set(PACKAGE_PREFIX_DIR \"${installPrefix}\")
 endif()
 unset(_realOrig)
 unset(_realCurr)
@@ -501,10 +481,6 @@ endmacro()
 
   configure_file("${_inputFile}" "${_outputFile}" @ONLY)
 
-  # We're done writing the file. Make sure the next one has a unique prefix dir
-  # variable name (we may have multiple config files for the one package)
-  __CMAKE_increment_config_file_counter()
-
 endfunction()
 
 function(generate_apple_platform_selection_file _output_file)
@@ -545,14 +521,12 @@ function(generate_apple_platform_selection_file _output_file)
     set(_branch_INIT "")
   endif()
 
-  __CMAKE_get_config_file_package_prefix(prefix_dir)
-
   set(_else ELSE)
   foreach(_opt IN LISTS _config_file_options _else)
     if(_gpsf_${_opt})
       set(_config_file "${_gpsf_${_opt}}")
       if(NOT IS_ABSOLUTE "${_config_file}")
-        string(PREPEND _config_file "\${${prefix_dir}}/")
+        string(PREPEND _config_file [[${PACKAGE_PREFIX_DIR}/]])
       endif()
       set(_branch_${_opt} "include(\"${_config_file}\")")
     elseif(_gpsf_ERROR_VARIABLE)
@@ -626,13 +600,11 @@ function(generate_apple_architecture_selection_file _output_file)
     "endif()\n"
     )
 
-  __CMAKE_get_config_file_package_prefix(prefix_dir)
-
   foreach(pair IN ZIP_LISTS _gasf_SINGLE_ARCHITECTURES _gasf_SINGLE_ARCHITECTURE_INCLUDE_FILES)
     set(arch "${pair_0}")
     set(config_file "${pair_1}")
     if(NOT IS_ABSOLUTE "${config_file}")
-      string(PREPEND config_file "\${${prefix_dir}}/")
+      string(PREPEND config_file [[${PACKAGE_PREFIX_DIR}/]])
     endif()
     string(APPEND _branch_code
       "\n"
@@ -647,7 +619,7 @@ function(generate_apple_architecture_selection_file _output_file)
     string(JOIN " " universal_archs "${_gasf_UNIVERSAL_ARCHITECTURES}")
     set(config_file "${_gasf_UNIVERSAL_INCLUDE_FILE}")
     if(NOT IS_ABSOLUTE "${config_file}")
-      string(PREPEND config_file "\${${prefix_dir}}/")
+      string(PREPEND config_file [[${PACKAGE_PREFIX_DIR}/]])
     endif()
     string(APPEND _branch_code
       "\n"

Modules/FindJasper.cmake

@@ -74,14 +74,14 @@ if(JASPER_FOUND)
     endif()
     if(EXISTS "${JASPER_LIBRARY_RELEASE}")
       set_property(TARGET Jasper::Jasper APPEND PROPERTY
-        IMPORTED CONFIGURATION RELEASE)
+        IMPORTED_CONFIGURATIONS RELEASE)
       set_target_properties(Jasper::Jasper PROPERTIES
         IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "C"
         IMPORTED_LOCATION "${JASPER_LIBRARY_RELEASE}")
     endif()
     if(EXISTS "${JASPER_LIBRARY_DEBUG}")
       set_property(TARGET Jasper::Jasper APPEND PROPERTY
-        IMPORTED CONFIGURATION DEBUG)
+        IMPORTED_CONFIGURATIONS DEBUG)
       set_target_properties(Jasper::Jasper PROPERTIES
         IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "C"
         IMPORTED_LOCATION "${JASPER_LIBRARY_DEBUG}")

Modules/FindOpenSSL.cmake

@@ -310,8 +310,10 @@ if(WIN32 AND NOT CYGWIN)
     # Since OpenSSL 1.1, lib names are like libcrypto32MTd.lib and libssl32MTd.lib
     if( "${CMAKE_SIZEOF_VOID_P}" STREQUAL "8" )
         set(_OPENSSL_MSVC_ARCH_SUFFIX "64")
+        set(_OPENSSL_MSVC_FOLDER_SUFFIX "64")
     else()
         set(_OPENSSL_MSVC_ARCH_SUFFIX "32")
+        set(_OPENSSL_MSVC_FOLDER_SUFFIX "86")
     endif()
 
     if(OPENSSL_USE_STATIC_LIBS)
@@ -319,13 +321,13 @@ if(WIN32 AND NOT CYGWIN)
         "_static"
       )
       set(_OPENSSL_PATH_SUFFIXES_DEBUG
-        "lib/VC/x${_OPENSSL_MSVC_ARCH_SUFFIX}/${_OPENSSL_MSVC_RT_MODE}d"
+        "lib/VC/x${_OPENSSL_MSVC_FOLDER_SUFFIX}/${_OPENSSL_MSVC_RT_MODE}d"
         "lib/VC/static"
         "VC/static"
         "lib"
         )
       set(_OPENSSL_PATH_SUFFIXES_RELEASE
-        "lib/VC/x${_OPENSSL_MSVC_ARCH_SUFFIX}/${_OPENSSL_MSVC_RT_MODE}"
+        "lib/VC/x${_OPENSSL_MSVC_FOLDER_SUFFIX}/${_OPENSSL_MSVC_RT_MODE}"
         "lib/VC/static"
         "VC/static"
         "lib"
@@ -335,13 +337,13 @@ if(WIN32 AND NOT CYGWIN)
         ""
       )
       set(_OPENSSL_PATH_SUFFIXES_DEBUG
-        "lib/VC/x${_OPENSSL_MSVC_ARCH_SUFFIX}/${_OPENSSL_MSVC_RT_MODE}d"
+        "lib/VC/x${_OPENSSL_MSVC_FOLDER_SUFFIX}/${_OPENSSL_MSVC_RT_MODE}d"
         "lib/VC"
         "VC"
         "lib"
         )
       set(_OPENSSL_PATH_SUFFIXES_RELEASE
-        "lib/VC/x${_OPENSSL_MSVC_ARCH_SUFFIX}/${_OPENSSL_MSVC_RT_MODE}"
+        "lib/VC/x${_OPENSSL_MSVC_FOLDER_SUFFIX}/${_OPENSSL_MSVC_RT_MODE}"
         "lib/VC"
         "VC"
         "lib"
@@ -356,6 +358,7 @@ if(WIN32 AND NOT CYGWIN)
         libcrypto${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_ARCH_SUFFIX}${_OPENSSL_MSVC_RT_MODE}d
         libcrypto${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_RT_MODE}d
         libcrypto${_OPENSSL_STATIC_SUFFIX}d
+        libcrypto${_OPENSSL_STATIC_SUFFIX}
         libeay32${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_RT_MODE}d
         libeay32${_OPENSSL_STATIC_SUFFIX}d
         crypto${_OPENSSL_STATIC_SUFFIX}d
@@ -406,6 +409,7 @@ if(WIN32 AND NOT CYGWIN)
         libssl${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_ARCH_SUFFIX}${_OPENSSL_MSVC_RT_MODE}d
         libssl${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_RT_MODE}d
         libssl${_OPENSSL_STATIC_SUFFIX}d
+        libssl${_OPENSSL_STATIC_SUFFIX}
         ssleay32${_OPENSSL_STATIC_SUFFIX}${_OPENSSL_MSVC_RT_MODE}d
         ssleay32${_OPENSSL_STATIC_SUFFIX}d
         ssl${_OPENSSL_STATIC_SUFFIX}d

Source/CMakeVersion.cmake

 # CMake version number components.
 set(CMake_VERSION_MAJOR 3)
 set(CMake_VERSION_MINOR 29)
-set(CMake_VERSION_PATCH 1)
+set(CMake_VERSION_PATCH 2)
 #set(CMake_VERSION_RC 0)
 set(CMake_VERSION_IS_DIRTY 0)
 

Source/cmGlobalGenerator.cxx

@@ -28,6 +28,7 @@
 #include "cm_codecvt_Encoding.hxx"
 
 #include "cmAlgorithms.h"
+#include "cmCMakePath.h"
 #include "cmCPackPropertiesGenerator.h"
 #include "cmComputeTargetDepends.h"
 #include "cmCryptoHash.h"
@@ -270,17 +271,14 @@ void cmGlobalGenerator::ResolveLanguageCompiler(const std::string& lang,
 
   std::string changeVars;
   if (cname && !optional) {
-    std::string cnameString;
+    cmCMakePath cachedPath;
     if (!cmSystemTools::FileIsFullPath(*cname)) {
-      cnameString = cmSystemTools::FindProgram(*cname);
+      cachedPath = cmSystemTools::FindProgram(*cname);
     } else {
-      cnameString = *cname;
+      cachedPath = *cname;
     }
-    std::string pathString = path;
-    // get rid of potentially multiple slashes:
-    cmSystemTools::ConvertToUnixSlashes(cnameString);
-    cmSystemTools::ConvertToUnixSlashes(pathString);
-    if (cnameString != pathString) {
+    cmCMakePath foundPath = path;
+    if (foundPath.Normal() != cachedPath.Normal()) {
       cmValue cvars = this->GetCMakeInstance()->GetState()->GetGlobalProperty(
         "__CMAKE_DELETE_CACHE_CHANGE_VARS_");
       if (cvars) {

Source/cmNinjaTargetGenerator.cxx

@@ -2016,11 +2016,21 @@ void cmNinjaTargetGenerator::WriteSwiftObjectBuildStatement(
     this->LocalGenerator->AppendFlags(vars["FLAGS"], "-static");
   }
 
+  // Does this swift target emit a module file for importing into other
+  // targets?
+  auto isImportableTarget = [](cmGeneratorTarget const& tgt) -> bool {
+    // Everything except for executables that don't export anything should emit
+    // some way to import them.
+    if (tgt.GetType() == cmStateEnums::EXECUTABLE) {
+      return tgt.IsExecutableWithExports();
+    }
+    return true;
+  };
+
   // Swift modules only make sense to emit from things that can be imported.
   // Executables that don't export symbols can't be imported, so don't try to
   // emit a swiftmodule for them. It will break.
-  if (target.GetType() != cmStateEnums::EXECUTABLE ||
-      target.IsExecutableWithExports()) {
+  if (isImportableTarget(target)) {
     std::string const emitModuleFlag = "-emit-module";
     std::string const modulePathFlag = "-emit-module-path";
     this->LocalGenerator->AppendFlags(
@@ -2089,18 +2099,21 @@ void cmNinjaTargetGenerator::WriteSwiftObjectBuildStatement(
     if (!dep->IsLanguageUsed("Swift", config)) {
       continue;
     }
-    // Add dependencies on the emitted swiftmodule file from swift targets we
-    // depend on
-    std::string const depModuleName =
-      getTargetPropertyOrDefault(*dep, "Swift_MODULE_NAME", dep->GetName());
-    std::string const depModuleDir = getTargetPropertyOrDefault(
-      *dep, "Swift_MODULE_DIRECTORY",
-      dep->LocalGenerator->GetCurrentBinaryDirectory());
-    std::string const depModuleFilename = getTargetPropertyOrDefault(
-      *dep, "Swift_MODULE", cmStrCat(depModuleName, ".swiftmodule"));
-    std::string const depModuleFilepath =
-      this->ConvertToNinjaPath(cmStrCat(depModuleDir, '/', depModuleFilename));
-    objBuild.ImplicitDeps.push_back(depModuleFilepath);
+
+    // If the dependency emits a swiftmodule, add a dependency edge on that
+    // swiftmodule to the ninja build graph.
+    if (isImportableTarget(*dep)) {
+      std::string const depModuleName =
+        getTargetPropertyOrDefault(*dep, "Swift_MODULE_NAME", dep->GetName());
+      std::string const depModuleDir = getTargetPropertyOrDefault(
+        *dep, "Swift_MODULE_DIRECTORY",
+        dep->LocalGenerator->GetCurrentBinaryDirectory());
+      std::string const depModuleFilename = getTargetPropertyOrDefault(
+        *dep, "Swift_MODULE", cmStrCat(depModuleName, ".swiftmodule"));
+      std::string const depModuleFilepath = this->ConvertToNinjaPath(
+        cmStrCat(depModuleDir, '/', depModuleFilename));
+      objBuild.ImplicitDeps.push_back(depModuleFilepath);
+    }
   }
 
   objBuild.OrderOnlyDeps.push_back(this->OrderDependsTargetForTarget(config));

Tests/RunCMake/CMakePackage/ApplePlatformGenSubdir-stdout.txt

-(-- )?Hello from platform switch
-(-- )?Hello from arch switch
-(-- )?Hello from pkg_a

Tests/RunCMake/CMakePackage/ApplePlatformGenSubdir.cmake

-set(CMAKE_INSTALL_DATADIR share)
-set(SWITCH_DIR platform/cmake)
-
-include(CMakePackageConfigHelpers)
-
-file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/pkg_a-config.cmake.in [[
-@PACKAGE_INIT@
-include("@PACKAGE_SWITCH_DIR@/platform-switch.cmake")
-include("@PACKAGE_CMAKE_INSTALL_DATADIR@/pkg_a_included.cmake")
-]])
-configure_package_config_file(
-  ${CMAKE_CURRENT_BINARY_DIR}/pkg_a-config.cmake.in
-  ${CMAKE_CURRENT_BINARY_DIR}/install/pkg_a-config.cmake
-  INSTALL_DESTINATION .
-  PATH_VARS CMAKE_INSTALL_DATADIR SWITCH_DIR
-)
-file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/install/${CMAKE_INSTALL_DATADIR}/pkg_a_included.cmake
-  [[message(STATUS "Hello from pkg_a")]]
-)
-
-# To expose re-using the same package prefix variable, we need to use a
-# different install prefix but still with the same package name. This is
-# really contrived and not representative of what a package should do.
-generate_apple_platform_selection_file(
-  ${CMAKE_CURRENT_BINARY_DIR}/install/platform/cmake/platform-switch.cmake
-  INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX}/platform
-  INSTALL_DESTINATION cmake
-  MACOS_INCLUDE_FILE cmake/switch_included.cmake  # relative to install prefix
-)
-file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/install/platform/cmake/switch_included.cmake
-[[
-message(STATUS "Hello from platform switch")
-include("${CMAKE_CURRENT_LIST_DIR}/../arch/cmake/arch-switch.cmake")
-]]
-)
-
-generate_apple_architecture_selection_file(
-  ${CMAKE_CURRENT_BINARY_DIR}/install/platform/arch/cmake/arch-switch.cmake
-  INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX}/platform/arch
-  INSTALL_DESTINATION cmake
-  UNIVERSAL_ARCHITECTURES i386 x86_64 arm64 $(ARCHS_STANDARD)
-  UNIVERSAL_INCLUDE_FILE cmake/switch_included.cmake  # relative to install prefix
-)
-file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/install/platform/arch/cmake/switch_included.cmake
-  [[message(STATUS "Hello from arch switch")]]
-)
-
-find_package(pkg_a REQUIRED NO_DEFAULT_PATH
-  PATHS ${CMAKE_CURRENT_BINARY_DIR}/install
-)

Tests/RunCMake/CMakePackage/NestedConfigFile-stdout.txt

-(-- )?Hello from pkg_a
-(-- )?Hello from pkg_b

Tests/RunCMake/CMakePackage/NestedConfigFile.cmake

-set(CMAKE_INSTALL_DATADIR share)
-
-include(CMakePackageConfigHelpers)
-
-file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/pkg_a-config.cmake.in [[
-@PACKAGE_INIT@
-include("@PACKAGE_CMAKE_INSTALL_DATADIR@/pkg_a_included.cmake")
-]])
-configure_package_config_file(
-  ${CMAKE_CURRENT_BINARY_DIR}/pkg_a-config.cmake.in
-  ${CMAKE_CURRENT_BINARY_DIR}/install_pkg_a/pkg_a-config.cmake
-  INSTALL_DESTINATION .
-  PATH_VARS CMAKE_INSTALL_DATADIR
-)
-file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/install_pkg_a/share/pkg_a_included.cmake
-  [[message(STATUS "Hello from pkg_a")]]
-)
-
-file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/pkg_b-config.cmake.in [[
-@PACKAGE_INIT@
-include(CMakeFindDependencyMacro)
-find_dependency(pkg_a NO_DEFAULT_PATH
-    PATHS "@CMAKE_CURRENT_BINARY_DIR@/install_pkg_a"
-)
-include("@PACKAGE_CMAKE_INSTALL_DATADIR@/pkg_b_included.cmake")
-]])
-configure_package_config_file(
-  ${CMAKE_CURRENT_BINARY_DIR}/pkg_b-config.cmake.in
-  ${CMAKE_CURRENT_BINARY_DIR}/install_pkg_b/pkg_b-config.cmake
-  INSTALL_DESTINATION .
-  PATH_VARS CMAKE_INSTALL_DATADIR
-)
-file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/install_pkg_b/share/pkg_b_included.cmake
-  [[message(STATUS "Hello from pkg_b")]]
-)
-
-find_package(pkg_b REQUIRED NO_DEFAULT_PATH
-  PATHS ${CMAKE_CURRENT_BINARY_DIR}/install_pkg_b
-)

Tests/RunCMake/CMakePackage/RunCMakeTest.cmake

@@ -4,8 +4,6 @@ if(NOT RunCMake_GENERATOR_IS_MULTI_CONFIG)
   set(maybe_CMAKE_BUILD_TYPE -DCMAKE_BUILD_TYPE=Release)
 endif()
 
-run_cmake_with_options(NestedConfigFile ${maybe_CMAKE_BUILD_TYPE})
-
 function(apple_export platform system_name archs sysroot)
   set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/apple-export-${platform}-build)
   string(REPLACE ";" "\\;" archs "${archs}")
@@ -80,12 +78,6 @@ if(APPLE AND CMAKE_C_COMPILER_ID STREQUAL "AppleClang")
     set(enable_visionos 1)
   endif()
 
-  string(REPLACE ";" "\\;" macos_archs_for_cmd "${macos_archs}")
-  run_cmake_with_options(ApplePlatformGenSubdir
-    "-DCMAKE_OSX_ARCHITECTURES=${macos_archs_for_cmd}"
-    ${maybe_CMAKE_BUILD_TYPE}
-  )
-
   apple_export(macos Darwin "${macos_archs}" macosx)
   apple_export(ios iOS "arm64" iphoneos)
   apple_export(tvos tvOS "arm64" appletvos)

Tests/RunCMake/CompilerChange/CompilerPath-stdout.txt

+-- CMAKE_C_COMPILER is '[^']*/Tests/RunCMake/CompilerChange/cc1.sh'
+-- CACHE_ENTRY='cached'

Tests/RunCMake/CompilerChange/CompilerPath.cmake

+enable_language(C)
+message(STATUS "CMAKE_C_COMPILER is '${CMAKE_C_COMPILER}'")
+message(STATUS "CACHE_ENTRY='${CACHE_ENTRY}'")

Tests/RunCMake/CompilerChange/EmptyCompiler-override.cmake

-message(STATUS "CMAKE_C_COMPILER is \"${CMAKE_C_COMPILER}\"")
-file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/cc.cmake" "set(CMAKE_C_COMPILER \"${CMAKE_C_COMPILER}\")\n")
+message(STATUS "CMAKE_C_COMPILER is '${CMAKE_C_COMPILER}'")

Tests/RunCMake/CompilerChange/EmptyCompiler-stdout.txt

+-- CMAKE_C_COMPILER is '[^']*/Tests/RunCMake/CompilerChange/cc2.sh'
+.*
+-- CMAKE_C_COMPILER is 'CMAKE_C_COMPILER-NOTFOUND'

Tests/RunCMake/CompilerChange/FirstCompiler-stdout.txt

--- CMAKE_C_COMPILER is ".*/Tests/RunCMake/CompilerChange/cc1.sh"
+-- CMAKE_C_COMPILER is '[^']*/Tests/RunCMake/CompilerChange/cc1.sh'

Tests/RunCMake/CompilerChange/FirstCompiler.cmake

 enable_language(C)
-message(STATUS "CMAKE_C_COMPILER is \"${CMAKE_C_COMPILER}\"")
-file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/cc.cmake" "set(CMAKE_C_COMPILER \"${CMAKE_C_COMPILER}\")\n")
+message(STATUS "CMAKE_C_COMPILER is '${CMAKE_C_COMPILER}'")

Tests/RunCMake/CompilerChange/RunCMakeTest.cmake

@@ -25,34 +25,23 @@ set(cc3 CMAKE_C_COMPILER-NOTFOUND)
 configure_file(${ccIn} ${cc1} @ONLY)
 configure_file(${ccIn} ${cc2} @ONLY)
 
-# Use a single build tree for remaining tests without cleaning.
-set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/ChangeCompiler-build)
-set(RunCMake_TEST_NO_CLEAN 1)
-file(REMOVE_RECURSE "${RunCMake_TEST_BINARY_DIR}")
+block()
+  set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/ChangeCompiler-build)
+  set(ENV{RunCMake_TEST} "FirstCompiler")
+  run_cmake_with_options(FirstCompiler -DCMAKE_C_COMPILER=${cc1})
+  set(RunCMake_TEST_NO_CLEAN 1)
+  set(ENV{RunCMake_TEST} "SecondCompiler")
+  run_cmake_with_options(SecondCompiler -DCMAKE_C_COMPILER=${cc2})
+  set(ENV{RunCMake_TEST} "EmptyCompiler")
+  run_cmake_with_options(EmptyCompiler -DCMAKE_C_COMPILER=)
+endblock()
 
-# Check build with compiler wrapper 1.
-set(RunCMake_TEST_OPTIONS -DCMAKE_C_COMPILER=${cc1})
-set(ENV{RunCMake_TEST} "FirstCompiler")
-run_cmake(FirstCompiler)
-include(${RunCMake_TEST_BINARY_DIR}/cc.cmake)
-if(NOT "${CMAKE_C_COMPILER}" STREQUAL "${cc1}")
-  message(FATAL_ERROR "FirstCompiler built with compiler:\n  ${CMAKE_C_COMPILER}\nand not with:\n  ${cc1}")
-endif()
-
-# Check rebuild with compiler wrapper 2.
-set(RunCMake_TEST_OPTIONS -DCMAKE_C_COMPILER=${cc2})
-set(ENV{RunCMake_TEST} "SecondCompiler")
-run_cmake(SecondCompiler)
-include(${RunCMake_TEST_BINARY_DIR}/cc.cmake)
-if(NOT "${CMAKE_C_COMPILER}" STREQUAL "${cc2}")
-  message(FATAL_ERROR "SecondCompiler built with compiler:\n  ${CMAKE_C_COMPILER}\nand not with:\n  ${cc2}")
-endif()
-
-# Check failure with an empty compiler string.
-set(RunCMake_TEST_OPTIONS -DCMAKE_C_COMPILER=)
-set(ENV{RunCMake_TEST} "EmptyCompiler")
-run_cmake(EmptyCompiler)
-include(${RunCMake_TEST_BINARY_DIR}/cc.cmake)
-if(NOT "${CMAKE_C_COMPILER}" STREQUAL "${cc3}")
-  message(FATAL_ERROR "Empty built with compiler:\n  ${CMAKE_C_COMPILER}\nand not with:\n  ${cc3}")
-endif()
+block()
+  set(cc1_dot ${RunCMake_BINARY_DIR}/./cc1.sh)
+  set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/CompilerPath-build)
+  set(RunCMake_TEST_VARIANT_DESCRIPTION "-step1")
+  run_cmake_with_options(CompilerPath "-DCMAKE_C_COMPILER=${cc1_dot}" -DCACHE_ENTRY=cached)
+  set(RunCMake_TEST_NO_CLEAN 1)
+  set(RunCMake_TEST_VARIANT_DESCRIPTION "-step2")
+  run_cmake_with_options(CompilerPath "-DCMAKE_C_COMPILER=${cc1_dot}")
+endblock()

Tests/RunCMake/CompilerChange/SecondCompiler-stdout.txt

--- CMAKE_C_COMPILER is ".*/Tests/RunCMake/CompilerChange/cc2.sh"
+-- CMAKE_C_COMPILER is '[^']*/Tests/RunCMake/CompilerChange/cc1.sh'
+.*
+-- CMAKE_C_COMPILER is '[^']*/Tests/RunCMake/CompilerChange/cc2.sh'