[CMake] Add an option to pass-in the plugin path

rintaro · rintaro · commit 2753f4dcb5bf · 2024-08-06T15:37:32.000-07:00
Add `SwiftTesting_MACRO` configuration option:
 * By default, the plugin is built using `SwiftTesting_MACRO_*` options
 * If it's explicitly "NO" (or other 'false' value), build Testing
   library without using the plugin
 * Otherwise, use the passed-in value as the plugin path

Update macOS install location to 'usr/lib/swift/testing' for libraries,
and 'usr/lib/host/plugins/testing' for plugin.

Correct the install RPATH.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -15,6 +15,8 @@ endif()
 project(SwiftTesting
   LANGUAGES CXX Swift)
 
+include(GNUInstallDirs)
+
 list(APPEND CMAKE_MODULE_PATH
   ${PROJECT_SOURCE_DIR}/cmake/modules
   ${PROJECT_SOURCE_DIR}/cmake/modules/shared)
diff --git a/Sources/CMakeLists.txt b/Sources/CMakeLists.txt
@@ -6,60 +6,108 @@
 # See http://swift.org/LICENSE.txt for license information
 # See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 
-# Macros must be built for the build machine, not the host.
-include(ExternalProject)
-if(NOT SwiftTesting_MACRO_MAKE_PROGRAM)
-  set(SwiftTesting_MACRO_MAKE_PROGRAM ${CMAKE_MAKE_PROGRAM})
-endif()
-if(NOT SwiftTesting_MACRO_Swift_COMPILER)
-  set(SwiftTesting_MACRO_Swift_COMPILER ${CMAKE_Swift_COMPILER})
-endif()
-if(NOT SwiftTesting_MACRO_AR)
-  set(SwiftTesting_MACRO_AR ${CMAKE_AR})
-endif()
-if(NOT SwiftTesting_MACRO_RANLIB)
-  set(SwiftTesting_MACRO_RANLIB ${CMAKE_RANLIB})
-endif()
+set(SwiftTesting_MACRO "<auto>" CACHE STRING
+    "Path to SwiftTesting macro plugin, or '<auto>' for automatically building it")
 
-find_package(SwiftSyntax CONFIG GLOBAL)
-if(SwiftSyntax_FOUND)
-  set(SwiftTesting_BuildMacrosAsExecutables NO)
-else()
-  set(SwiftTesting_BuildMacrosAsExecutables YES)
-endif()
+if(SwiftTesting_MACRO STREQUAL "<auto>")
+  # Macros must be built for the build machine, not the host.
+  include(ExternalProject)
+  if(NOT SwiftTesting_MACRO_MAKE_PROGRAM)
+    set(SwiftTesting_MACRO_MAKE_PROGRAM ${CMAKE_MAKE_PROGRAM})
+  endif()
+  if(NOT SwiftTesting_MACRO_Swift_COMPILER)
+    set(SwiftTesting_MACRO_Swift_COMPILER ${CMAKE_Swift_COMPILER})
+  endif()
+  if(NOT SwiftTesting_MACRO_Swift_FLAGS)
+    set(SwiftTesting_MACRO_Swift_FLAGS ${CMAKE_Swift_FLAGS})
+    set(SwiftTesting_MACRO_SWIFT_FLAGS_RELEASE ${CMAKE_Swift_FLAGS_RELEASE})
+    set(SwiftTesting_MACRO_SWIFT_FLAGS_RELWITHDEBINFO ${CMAKE_Swift_FLAGS_RELWITHDEBINFO})
+  endif()
+  if(NOT SwiftTesting_MACRO_AR)
+    set(SwiftTesting_MACRO_AR ${CMAKE_AR})
+  endif()
+  if(NOT SwiftTesting_MACRO_RANLIB)
+    set(SwiftTesting_MACRO_RANLIB ${CMAKE_RANLIB})
+  endif()
+  if(NOT SwiftTesting_MACRO_BUILD_TYPE)
+    set(SwiftTesting_MACRO_BUILD_TYPE ${CMAKE_BUILD_TYPE})
+  endif()
+
+  find_package(SwiftSyntax CONFIG GLOBAL)
+  if(SwiftSyntax_FOUND)
+    set(SwiftTesting_BuildMacrosAsExecutables NO)
+  else()
+    set(SwiftTesting_BuildMacrosAsExecutables YES)
+  endif()
 
-ExternalProject_Add(TestingMacros
-  PREFIX "tm"
-  SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/TestingMacros"
-  CMAKE_ARGS
-    -DCMAKE_Swift_COMPILER=${SwiftTesting_MACRO_Swift_COMPILER}
-    -DCMAKE_AR=${SwiftTesting_MACRO_AR}
-    -DCMAKE_RANLIB=${SwiftTesting_MACRO_RANLIB}
-    -DCMAKE_MAKE_PROGRAM=${SwiftTesting_MACRO_MAKE_PROGRAM}
-    -DSwiftTesting_BuildMacrosAsExecutables=${SwiftTesting_BuildMacrosAsExecutables}
-    -DSwiftSyntax_DIR=${SwiftSyntax_DIR}
-    -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>)
-ExternalProject_Get_Property(TestingMacros BINARY_DIR)
-ExternalProject_Get_Property(TestingMacros INSTALL_DIR)
+  # Build and install the plugin into the current build directry.
+  set(SwiftTesting_MACRO_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/plugin")
 
-include(AvailabilityDefinitions)
-include(CompilerSettings)
-add_subdirectory(_TestingInternals)
-add_subdirectory(Testing)
+  ExternalProject_Add(TestingMacros
+    PREFIX "tm"
+    SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/TestingMacros"
+    BUILD_ALWAYS ON
+    CMAKE_ARGS
+      -DCMAKE_MAKE_PROGRAM=${SwiftTesting_MACRO_MAKE_PROGRAM}
+      -DCMAKE_Swift_COMPILER=${SwiftTesting_MACRO_Swift_COMPILER}
+      -DCMAKE_Swift_FLAGS=${SwiftTesting_MACRO_Swift_FLAGS}
+      -DCMAKE_Swift_FLAGS_RELEASE=${SwiftTesting_MACRO_Swift_FLAGS_RELEASE}
+      -DCMAKE_Swift_FLAGS_RELWITHDEBINFO=${SwiftTesting_MACRO_Swift_FLAGS_RELWITHDEBINFO}
+      -DCMAKE_AR=${SwiftTesting_MACRO_AR}
+      -DCMAKE_RANLIB=${SwiftTesting_MACRO_RANLIB}
+      -DCMAKE_BUILD_TYPE=${CSwiftTesting_MACRO_BUILD_TYPE}
+      -DSwiftTesting_BuildMacrosAsExecutables=${SwiftTesting_BuildMacrosAsExecutables}
+      -DSwiftSyntax_DIR=${SwiftSyntax_DIR}
+      -DCMAKE_INSTALL_PREFIX=${SwiftTesting_MACRO_INSTALL_PREFIX})
 
-if(NOT SwiftTesting_BuildMacrosAsExecutables)
-  # Hardcode the known library names based on system name as a workaround since
+  # Hardcode the known file names based on system name as a workaround since
   # TestingMacros uses `ExternalProject` and we cannot directly query the
   # properties of its targets here.
-  if("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
-    set(SwiftTesting_TestingMacrosLibraryName "libTestingMacros.dylib")
-  elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
-    set(SwiftTesting_TestingMacrosLibraryName "libTestingMacros.so")
+  if(NOT SwiftTesting_BuildMacrosAsExecutables)
+    if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
+      set(SwiftTesting_MACRO_PATH "${SwiftTesting_MACRO_INSTALL_PREFIX}/lib/libTestingMacros.dylib")
+      install(PROGRAMS "${SwiftTesting_MACRO_PATH}"
+        DESTINATION lib/swift/host/plugins/testing)
+    elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
+      set(SwiftTesting_MACRO_PATH "${SwiftTesting_MACRO_INSTALL_PREFIX}/lib/libTestingMacros.so")
+      install(PROGRAMS "${SwiftTesting_MACRO_PATH}"
+        DESTINATION lib/swift/host/plugins)
+    elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+      set(SwiftTesting_MACRO_PATH "${SwiftTesting_MACRO_INSTALL_PREFIX}/bin/TestingMacros.dll")
+      install(PROGRAMS "${SwiftTesting_MACRO_PATH}"
+        DESTINATION bin)
+    else()
+      message(FATAL_ERROR "Unable to determine the library name for TestingMacros based on system name: ${CMAKE_HOST_SYSTEM_NAME}")
+    endif()
   else()
-    message(FATAL_ERROR "Unable to determine the library name for TestingMacros based on system name: ${CMAKE_SYSTEM_NAME}")
+    if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+      set(SwiftTesting_MACRO_PATH "${SwiftTesting_MACRO_INSTALL_PREFIX}/bin/TestingMacros.exe")
+    else()
+      set(SwiftTesting_MACRO_PATH "${SwiftTesting_MACRO_INSTALL_PREFIX}/bin/TestingMacros")
+    endif()
   endif()
+elseif(SwiftTesting_MACRO)
+  # Use the passed-in plugin path.
+  set(SwiftTesting_MACRO_PATH "${SwiftTesting_MACRO}")
+  add_custom_target(TestingMacros DEPENDS "${SwiftTesting_MACRO_PATH}")
+else()
+  # If it's explicitly "NO", do not compile the library with macros.
+  add_custom_target(TestingMacros)
+endif()
 
-  install(PROGRAMS "${INSTALL_DIR}/lib/${SwiftTesting_TestingMacrosLibraryName}"
-    # TODO: Finalize the install path
-    DESTINATION lib/swift/host/plugins)
+if(NOT SwiftTesting_MACRO_PATH)
+  message(STATUS "TestingMacros: (none)")
+elseif(SwiftTesting_MACRO_PATH)
+  if(SwiftTesting_MACRO_PATH MATCHES [[\.(dylib|so|dll)$]])
+    message(STATUS "TestingMacros: ${SwiftTesting_MACRO_PATH} (shared library)")
+    add_compile_options("$<$<COMPILE_LANGUAGE:Swift>:SHELL:-load-plugin-library ${SwiftTesting_MACRO_PATH}>")
+  else()
+    message(STATUS "TestingMacros: ${SwiftTesting_MACRO_PATH} (executable)")
+    add_compile_options("$<$<COMPILE_LANGUAGE:Swift>:SHELL:-load-plugin-exectuable ${SwiftTesting_MACRO_PATH}#TestingMacros>")
+  endif()
 endif()
+
+include(AvailabilityDefinitions)
+include(CompilerSettings)
+add_subdirectory(_TestingInternals)
+add_subdirectory(Testing)
diff --git a/Sources/Testing/CMakeLists.txt b/Sources/Testing/CMakeLists.txt
@@ -100,21 +100,5 @@ target_compile_options(Testing PRIVATE
   -enable-library-evolution
   -emit-module-interface -emit-module-interface-path $<TARGET_PROPERTY:Testing,Swift_MODULE_DIRECTORY>/Testing.swiftinterface)
 
-if(SwiftTesting_BuildMacrosAsExecutables)
-  if(CMAKE_HOST_WIN32)
-    set(_TestingMacros_ExecutableSuffix ".exe")
-  endif()
-
-  target_compile_options(Testing PUBLIC
-    "SHELL:$<$<COMPILE_LANGUAGE:Swift>:-load-plugin-executable ${BINARY_DIR}/TestingMacros${_TestingMacros_ExecutableSuffix}#TestingMacros>")
-else()
-  target_compile_options(Testing PUBLIC
-    "SHELL:$<$<COMPILE_LANGUAGE:Swift>:-plugin-path ${BINARY_DIR}>")
-endif()
-
-# TODO: @rpath-relative install name
-# This may or may not involve the `-(no-)toolchain-stdlib-rpath` Swift flag.
-
 include(SwiftModuleInstallation)
-# TODO: Finalize the install path
 _swift_testing_install_target(Testing)
diff --git a/Sources/TestingMacros/CMakeLists.txt b/Sources/TestingMacros/CMakeLists.txt
@@ -59,12 +59,19 @@ if(SwiftTesting_BuildMacrosAsExecutables)
 else()
   add_library(TestingMacros SHARED)
 
-  # Install the macro plugin to the default location.
-  #
-  # This is not the plugin's actual, final install location -- it's only
-  # relative to this external project's install dir. The final location is
-  # determined by the "outer" project.
-  install(TARGETS TestingMacros)
+  target_link_options(TestingMacros PRIVATE "-no-toolchain-stdlib-rpath")
+  # Not setting RPATH means it requires all the dependencies are already loaded
+  # in the process, because 'plugin' directory wouldn't contain any dependencies.
+  set_property(TARGET TestingMacros PROPERTY INSTALL_RPATH)
+  set_property(TARGET TestingMacros PROPERTY BUILD_WITH_INSTALL_RPATH YES)
+
+  if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
+    install(TARGETS TestingMacros
+      RUNTIME DESTINATION bin)
+  else()
+    # Other platforms, TestingMacros is installed by the parent project.
+    install(TARGETS TestingMacros)
+  endif()
 endif()
 
 target_sources(TestingMacros PRIVATE
diff --git a/cmake/modules/SwiftModuleInstallation.cmake b/cmake/modules/SwiftModuleInstallation.cmake
@@ -28,9 +28,21 @@ function(_swift_testing_install_target module)
     set(swift swift)
   endif()
 
+  target_compile_options(Testing PRIVATE "-no-toolchain-stdlib-rpath")
+
+  if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+    set(lib_destination_dir "lib/${swift}/${swift_os}/testing")
+    set_property(TARGET ${module} PROPERTY
+      INSTALL_RPATH "@loader_path/..")
+  else()
+    set(lib_destination_dir "lib/${swift}/${swift_os}")
+    set_property(TARGET ${module} PROPERTY
+      INSTALL_RPATH "$ORIGIN")
+  endif()
+
   install(TARGETS ${module}
-    ARCHIVE DESTINATION lib/${swift}/${swift_os}
-    LIBRARY DESTINATION lib/${swift}/${swift_os}
+    ARCHIVE DESTINATION "${lib_destination_dir}"
+    LIBRARY DESTINATION "${lib_destination_dir}"
     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
   if(type STREQUAL EXECUTABLE)
     return()
@@ -52,13 +64,17 @@ function(_swift_testing_install_target module)
     mark_as_advanced(SwiftTesting_MODULE_TRIPLE)
   endif()
 
+  set(module_dir "${lib_destination_dir}/${module_name}.swiftmodule")
   install(FILES $<TARGET_PROPERTY:${module},Swift_MODULE_DIRECTORY>/${module_name}.swiftdoc
-    DESTINATION lib/${swift}/${swift_os}/${module_name}.swiftmodule
+    DESTINATION "${module_dir}"
     RENAME ${SwiftTesting_MODULE_TRIPLE}.swiftdoc)
   install(FILES $<TARGET_PROPERTY:${module},Swift_MODULE_DIRECTORY>/${module_name}.swiftmodule
-    DESTINATION lib/${swift}/${swift_os}/${module_name}.swiftmodule
+    DESTINATION "${module_dir}"
     RENAME ${SwiftTesting_MODULE_TRIPLE}.swiftmodule)
-  install(FILES $<TARGET_PROPERTY:${module},Swift_MODULE_DIRECTORY>/${module_name}.swiftinterface
-    DESTINATION lib/${swift}/${swift_os}/${module_name}.swiftmodule
-    RENAME ${SwiftTesting_MODULE_TRIPLE}.swiftinterface)
+  if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+    # Only Darwin has stable ABI. 
+    install(FILES $<TARGET_PROPERTY:${module},Swift_MODULE_DIRECTORY>/${module_name}.swiftinterface
+      DESTINATION "${module_dir}"
+      RENAME ${SwiftTesting_MODULE_TRIPLE}.swiftinterface)
+  endif()
 endfunction()
