Merge commit '665515c781999a81094bbe4f8302a7cb1a6a6b39' into mchiu/freebsd

Author: michael-yuji

.gitignore

@@ -97,3 +97,4 @@ Runtimes/**/*.inc
 Runtimes/**/*.json
 Runtimes/**/*.modulemap
 Runtimes/**/*.in
+!Runtimes/**/*.cmake.in

CMakeLists.txt

@@ -464,6 +464,10 @@ option(SWIFT_STDLIB_ASSERTIONS
     "Enable internal checks for the Swift standard library (useful for debugging the library itself, does not affect checks required for safety)"
     "${SWIFT_STDLIB_ASSERTIONS_default}")
 
+option(SWIFT_STDLIB_ENABLE_STRICT_AVAILABILITY
+       "Enable strict availability; this will cause things to break at desk or in CI if the host OS is a lower version than some `@availability` annotations in the runtime code"
+       FALSE)
+
 option(SWIFT_BUILD_RUNTIME_WITH_HOST_COMPILER
        "Use the host compiler and not the internal clang to build the swift runtime"
        FALSE)
@@ -870,12 +874,7 @@ include(CMakePushCheckState)
 
 # Print out path and version of any installed commands
 message(STATUS "CMake (${CMAKE_COMMAND}) Version: ${CMAKE_VERSION}")
-if(XCODE)
-  set(version_flag -version)
-else()
-  set(version_flag --version)
-endif()
-execute_process(COMMAND ${CMAKE_MAKE_PROGRAM} ${version_flag}
+execute_process(COMMAND ${CMAKE_MAKE_PROGRAM} --version
   OUTPUT_VARIABLE _CMAKE_MAKE_PROGRAM_VERSION
   OUTPUT_STRIP_TRAILING_WHITESPACE)
 message(STATUS "CMake Make Program (${CMAKE_MAKE_PROGRAM}) Version: ${_CMAKE_MAKE_PROGRAM_VERSION}")
@@ -1145,14 +1144,6 @@ endif()
 # Configure SDKs.
 #
 
-if(XCODE)
-  # FIXME: It used to be the case that Xcode would force
-  # -m${platform}-version-min flags that would conflict with those computed
-  # by build-script. version-min flags are deprecated in favor of -target since
-  # clang-11, so we might be able to undo this.
-  set(SWIFT_SDKS "OSX")
-endif()
-
 # FIXME: the parameters we specify in SWIFT_SDKS are lacking architecture specifics,
 # so we need to hard-code it. For example, the SDK for Android is just 'ANDROID',
 # and we have to specify SWIFT_SDK_ANDROID_ARCHITECTURES separately.
@@ -1408,8 +1399,9 @@ endif()
 
 if(SWIFT_BUILD_STDLIB OR SWIFT_BUILD_SDK_OVERLAY)
   message(STATUS "Building Swift standard library and overlays for SDKs: ${SWIFT_SDKS}")
-  message(STATUS "  Build type:       ${SWIFT_STDLIB_BUILD_TYPE}")
-  message(STATUS "  Assertions:       ${SWIFT_STDLIB_ASSERTIONS}")
+  message(STATUS "  Build type:               ${SWIFT_STDLIB_BUILD_TYPE}")
+  message(STATUS "  Assertions:               ${SWIFT_STDLIB_ASSERTIONS}")
+  message(STATUS "  Strict availability:      ${SWIFT_STDLIB_ENABLE_STRICT_AVAILABILITY}")
   message(STATUS "")
 
   message(STATUS "Building Swift runtime with:")
@@ -1594,22 +1586,6 @@ swift_install_in_component(FILES "LICENSE.txt"
                            DESTINATION "share/swift"
                            COMPONENT license)
 
-# Add a documentation target so that documentation shows up in the
-# Xcode project.
-if(XCODE)
-  add_custom_target(Documentation
-      SOURCES
-        README.md
-        docs)
-
-  file(GLOB SWIFT_TOPLEVEL_HEADERS
-      ${CMAKE_CURRENT_SOURCE_DIR}/include/swift${dir}/*.h
-      ${CMAKE_CURRENT_SOURCE_DIR}/include/swift${dir}/*.td
-      ${CMAKE_CURRENT_SOURCE_DIR}/include/swift${dir}/*.def)
-  add_custom_target(Miscellaneous
-      SOURCES ${SWIFT_TOPLEVEL_HEADERS})
-endif()
-
 # New standard library build
 option(SWIFT_ENABLE_NEW_RUNTIME_BUILD "Build Swift runtimes with new build system" OFF)
 if(SWIFT_ENABLE_NEW_RUNTIME_BUILD)
@@ -1637,6 +1613,12 @@ if(SWIFT_ENABLE_NEW_RUNTIME_BUILD)
         set(stdlib_deployment_version_flag -DCMAKE_OSX_DEPLOYMENT_TARGET=${SWIFT_SDK_${sdk}_DEPLOYMENT_VERSION})
       endif()
 
+      if(sdk STREQUAL "OSX" AND SWIFT_SDK_${sdk}_DEPLOYMENT_VERSION VERSION_LESS "10.15")
+        set(build_concurrency NO)
+      else()
+        set(build_concurrency YES)
+      endif()
+
       ExternalProject_Add("${stdlib_target}-core"
         SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Runtimes/Core"
         # TODO: Add this once we're ready to start swapping out the libraries
@@ -1662,7 +1644,7 @@ if(SWIFT_ENABLE_NEW_RUNTIME_BUILD)
           -DCMAKE_COLOR_DIAGNOSTICS:BOOLEAN=${CMAKE_COLOR_DIAGNOSTICS}
           -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}
           -DSwiftCore_INSTALL_NESTED_SUBDIR=YES
-          -DSwiftCore_ENABLE_CONCURRENCY=YES)
+          -DSwiftCore_ENABLE_CONCURRENCY=${build_concurrency})
       if(NOT ${CMAKE_CROSSCOMPILING})
         add_dependencies("${stdlib_target}-core" swift-frontend)
       endif()

Runtimes/Core/CMakeLists.txt

@@ -78,7 +78,6 @@ set(SwiftCore_VENDOR_MODULE_DIR "${SwiftCore_CMAKE_MODULES_DIR}/vendor"
 include(GNUInstallDirs)
 include(CheckSymbolExists)
 include(CheckIncludeFileCXX)
-include(AvailabilityMacros)
 include(CompilerSettings)
 include(DefaultSettings)
 include(EmitSwiftInterface)
@@ -87,6 +86,7 @@ include(PlatformInfo)
 include(gyb)
 include(ResourceEmbedding)
 include(CatalystSupport)
+include(AvailabilityMacros)
 
 check_symbol_exists("asl_log" "asl.h" SwiftCore_HAS_ASL)
 check_symbol_exists("dladdr" "dlfcn.h" SwiftCore_HAS_DLADDR)
@@ -126,6 +126,7 @@ defaulted_option(SwiftCore_ENABLE_BACKTRACING "Enable backtracing runtime suppor
 defaulted_set(SwiftCore_BACKTRACER_PATH STRING "Set a fixed path to the Swift backtracer")
 defaulted_option(SwiftCore_ENABLE_FATALERROR_BACKTRACE "Build stdlib fatalError with backtrace output")
 defaulted_option(SwiftCore_ENABLE_PRESPECIALIZATION "Enable generic metadata prespecialization")
+defaulted_option(SwiftCore_ENABLE_STRICT_AVAILABILITY "Enable strict availability; this will cause things to break at desk or in CI if the host OS is a lower version than some `@availability` annotations in the runtime code")
 
 option(SwiftCore_ENABLE_CLOBBER_FREED_OBJECTS "" OFF)
 option(SwiftCore_ENABLE_RUNTIME_LEAK_CHECKER "" OFF)

Runtimes/Core/cmake/caches/Vendors/Apple/apple-common.cmake

@@ -12,6 +12,8 @@ set(SwiftCore_ENABLE_VECTOR_TYPES ON CACHE BOOL "")
 set(SwiftCore_ENABLE_RUNTIME_FUNCTION_COUNTERS ON CACHE BOOL "")
 set(SwiftCore_ENABLE_BACKDEPLOYMENT_SUPPORT ON CACHE BOOL "")
 set(SwiftCore_ENABLE_FILESYSTEM_SUPPORT ON CACHE BOOL "")
+set(SwiftCore_ENABLE_STRICT_AVAILABILITY ON CACHE BOOL "")
+
 set(SwiftCore_OPTIMIZATION_REMARKS "bitstream" CACHE STRING "")
 
 set(SwiftCore_INSTALL_NESTED_SUBDIR OFF CACHE BOOL "")

Runtimes/Core/cmake/modules/AvailabilityMacros.cmake

@@ -4,5 +4,39 @@ configure_file("${SwiftCore_SWIFTC_SOURCE_DIR}/utils/availability-macros.def"
 file(STRINGS "${CMAKE_CURRENT_BINARY_DIR}/availability-macros.def" availability_defs)
 list(FILTER availability_defs EXCLUDE REGEX "^\\s*(#.*)?$")
 foreach(def ${availability_defs})
-  add_compile_options("$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xfrontend -define-availability -Xfrontend \"${def}\">")
+  list(APPEND availability_definitions "-Xfrontend -define-availability -Xfrontend \"${def}\"")
+
+  if("${def}" MATCHES "SwiftStdlib .*")
+    # For each SwiftStdlib x.y, also define StdlibDeploymentTarget x.y, which,
+    # will expand to the current `-target` platform if the macro defines a
+    # newer platform as its availability.
+    #
+    # There is a setting, SwiftCore_ENABLE_STRICT_AVAILABILITY, which if set
+    # ON will cause us to use the "proper" availability instead.
+    string(REPLACE "SwiftStdlib" "StdlibDeploymentTarget" current "${def}")
+    if(NOT SwiftCore_ENABLE_STRICT_AVAILABILITY AND SwiftCore_SWIFT_AVAILABILITY_PLATFORM)
+      if("${SwiftCore_SWIFT_AVAILABILITY_PLATFORM}" STREQUAL "macOS" AND "${SwiftCore_VARIANT_AVAILABILITY_PLATFORM}" STREQUAL "iOS")
+        string(REGEX MATCH "iOS ([0-9]+(\.[0-9]+)+)" ios_platform_version "${def}")
+        string(REGEX MATCH "[0-9]+(\.[0-9]+)+" ios_version "${ios_platform_version}")
+        string(REGEX MATCH "macOS ([0-9]+(\.[0-9]+)+)" macos_platform_version "${def}")
+        string(REGEX MATCH "[0-9]+(\.[0-9]+)+" macos_version "${macos_platform_version}")
+        if((NOT macos_version STREQUAL "9999" OR NOT ios_version STREQUAL "9999") AND (macos_version VERSION_GREATER CMAKE_OSX_DEPLOYMENT_TARGET OR ios_version VERSION_GREATER SwiftCore_VARIANT_DEPLOYMENT_VERSION))
+          string(REGEX REPLACE ":.*" ": macOS ${CMAKE_OSX_DEPLOYMENT_VERSION}, iOS ${SwiftCore_VARIANT_DEPLOYMENT_VERSION}" current "${current}")
+        endif()
+      else()
+        string(REGEX MATCH "${SwiftCore_SWIFT_AVAILABILITY_PLATFORM} ([0-9]+(\.[0-9]+)+)" platform_version "${def}")
+        string(REGEX MATCH "[0-9]+(\.[0-9]+)+" version "${platform_version}")
+        if(NOT version STREQUAL "9999" AND version VERSION_GREATER CMAKE_OSX_DEPLOYMENT_TARGET)
+          string(REGEX REPLACE ":.*" ":${SwiftCore_SWIFT_AVAILABILITY_PLATFORM} ${CMAKE_OSX_DEPLOYMENT_TARGET}" current "${current}")
+        endif()
+      endif()
+    endif()
+    list(APPEND availability_definitions "-Xfrontend -define-availability -Xfrontend \"${current}\"")
+  endif()
 endforeach()
+
+list(JOIN availability_definitions "\n" availability_definitions)
+file(GENERATE
+  OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/availability-macros.rsp"
+  CONTENT "${availability_definitions}")
+add_compile_options("$<$<COMPILE_LANGUAGE:Swift>:SHELL:${CMAKE_Swift_RESPONSE_FILE_FLAG}${CMAKE_CURRENT_BINARY_DIR}/availability-macros.rsp>")

Runtimes/Core/cmake/modules/CatalystSupport.cmake

@@ -34,5 +34,12 @@ if(SwiftCore_COMPILER_VARIANT_TARGET)
     set(SwiftCore_VARIANT_MODULE_TRIPLE "${module_triple}" CACHE STRING "Triple used for installed swift{module,interface} files for the target variant")
     mark_as_advanced(SwiftCore_VARIANT_MODULE_TRIPLE)
     message(CONFIGURE_LOG "Swift target variant module triple: ${module_triple}")
+
+    string(JSON triple GET "${target_info_json}" "target" "triple")
+    if(triple MATCHES "apple-([a-zA-Z]+)([0-9]+[.0-9]*)-macabi")
+      set(SwiftCore_VARIANT_DEPLOYMENT_VERSION "${CMAKE_MATCH_2}")
+      mark_as_advanced(SwiftCore_VARIANT_DEPLOYMENT_VERSION)
+      message(CONFIGURE_LOG "Swift target variant deployment version: ${SwiftCore_VARIANT_DEPLOYMENT_VERSION}")
+    endif()
   endif()
 endif()

Runtimes/Core/cmake/modules/DefaultSettings.cmake

@@ -10,6 +10,8 @@ set(SwiftCore_ENABLE_BACKTRACING_default OFF) # TODO: enable this by default
 set(SwiftCore_ENABLE_STDIN_default ON)
 set(SwiftCore_ENABLE_TYPE_PRINTING_default ON)
 
+set(SwiftCore_ENABLE_STRICT_AVAILABILITY_default OFF)
+
 set(SwiftCore_BACKTRACER_PATH_default "")
 
 # Provide a boolean option that a user can optionally enable.
@@ -19,7 +21,7 @@ macro(defaulted_option variable helptext)
   if(NOT DEFINED ${variable}_default)
     set(${variable}_default OFF)
   endif()
-  option(${variable} ${helptext} ${${variable}_default})
+  option(${variable} "${helptext}" ${${variable}_default})
 endmacro()
 
 # Create a defaulted cache entry
@@ -50,6 +52,8 @@ elseif(CMAKE_SYSTEM_NAME STREQUAL "WASM")
   set(SwiftCore_CONCURRENCY_GLOBAL_EXECUTOR_default "none")
 elseif(LINUX OR ANDROID OR BSD)
   set(SwiftCore_OBJECT_FORMAT_default "elf")
+
+  set(SwiftCore_ENABLE_REFLECTION_default ON)
   set(SwiftCore_ENABLE_FATALERROR_BACKTRACE_default ON)
   if(LINUX)
     set(SwiftCore_THREADING_PACKAGE_default "LINUX")

Runtimes/Core/cmake/modules/DetectedPlatformInfo.cmake.in

@@ -0,0 +1,8 @@
+set(SwiftCore_SIZEOF_POINTER @SwiftCore_SIZEOF_POINTER@)
+set(SwiftCore_MODULE_TRIPLE @SwiftCore_MODULE_TRIPLE@)
+set(SwiftCore_PLATFORM_SUBIDR @SwiftCore_PLATFORM_SUBIDR@)
+set(SwiftCore_ARCH_SUBDIR @SwiftCore_ARCH_SUBDIR@)
+
+set(SwiftCore_SWIFT_AVAILABILITY_PLATFORM @SwiftCore_SWIFT_AVAILABILITY_PLATFORM@)
+
+set(SwiftCore_PLATFORM_INFO_SET 1)

Runtimes/Core/cmake/modules/ExperimentalFeatures.cmake

@@ -4,6 +4,7 @@ add_compile_options(
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature SE427NoInferenceOnExtension>"
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature NonescapableTypes>"
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature LifetimeDependence>"
+  "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature InoutLifetimeDependence>"
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature LifetimeDependenceMutableAccessors>"
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature MemberImportVisibility>"
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature TypedThrows>"

Runtimes/Core/cmake/modules/PlatformInfo.cmake

@@ -1,3 +1,9 @@
+include("${PROJECT_BINARY_DIR}/build/DetectedPlatformInfo.cmake" OPTIONAL)
+
+if(SwiftCore_PLATFORM_INFO_SET)
+  return()
+endif()
+
 if(NOT SwiftCore_SIZEOF_POINTER)
   set(SwiftCore_SIZEOF_POINTER "${CMAKE_SIZEOF_VOID_P}" CACHE STRING "Size of a pointer in bytes")
   message(CONFIGURE_LOG "Stdlib Pointer size: ${CMAKE_SIZEOF_VOID_P}")
@@ -36,3 +42,51 @@ if(NOT SwiftCore_ARCH_SUBDIR)
 
   message(CONFIGURE_LOG "Swift Arch: ${arch}")
 endif()
+
+# Note: *moduleTriple* doesn't have an "x" on the end of "macos"; just to be
+# safe, we support both cases here.
+set(availability_platform_macos "macOS")
+set(availaiblity_platform_macosx "macOS")
+set(availability_platform_ios "iOS")
+set(availability_platform_watchos "watchOS")
+set(availability_platform_tvos "tvOS")
+set(availability_platform_xros "visionOS")
+set(availability_platform_bridgeos "bridgeOS")
+
+if(NOT SwiftCore_SWIFT_AVAILABILITY_PLATFORM)
+  if(SwiftCore_MODULE_TRIPLE MATCHES ".*-([^-]+)-simulator$")
+    set(platform "${CMAKE_MATCH_1}")
+  elseif(SwiftCore_MODULE_TRIPLE MATCHES ".*-([^-]+)-msvc$")
+    set(platform "${CMAKE_MATCH_1}")
+  elseif(SwiftCore_MODULE_TRIPLE MATCHES ".*-([^-]+)$")
+    set(platform "${CMAKE_MATCH_1}")
+  else()
+    message(WARNING "Unable to extract platform name from triple ${SwiftCore_MODULE_TRIPLE}")
+  endif()
+
+  if(availability_platform_${platform})
+    set(SwiftCore_SWIFT_AVAILABILITY_PLATFORM "${availability_platform_${platform}}")
+  else()
+    set(SwiftCore_SWIFT_AVAILABILITY_PLATFORM "unknown")
+    message(WARNING "Unknown platform ${platform} for availability")
+  endif()
+endif()
+
+set(SwiftCore_VARIANT_AVAILABILITY_PLATFORM "none")
+if(SwiftCore_VARIANT_MODULE_TRIPLE)
+  if(SwiftCore_VARIANT_MODULE_TRIPLE MATCHES ".*-([^-]+)$")
+    set(platform "${CMAKE_MATCH_1}")
+  else()
+    message(FATAL_ERROR "Unable to extract platform name from triple ${SwiftCore_VARIANT_MODULE_TRIPLE}")
+  endif()
+
+  if(availability_platform_${platform})
+    set(SwiftCore_VARIANT_AVAILABILITY_PLATFORM "${availability_platform_${platform}}")
+  else()
+    message(WARNING "Unknown platform ${platform} for variant availability")
+  endif()
+endif()
+
+configure_file("${CMAKE_CURRENT_LIST_DIR}/DetectedPlatformInfo.cmake.in"
+  "${PROJECT_BINARY_DIR}/build/DetectedPlatformInfo.cmake"
+  @ONLY)