Merge branch 'main' into import-extension-visibility

Author: DougGregor

CHANGELOG.md

@@ -4,6 +4,38 @@
 > This is in reverse chronological order, so newer entries are added to the top.
 
 ## Swift 6.0
+
+* Swift 5.10 missed a semantic check from [SE-0309][]. In type context, a reference to a
+  protocol `P` that has associated types or `Self` requirements should use
+  the `any` keyword, but this was not enforced in nested generic argument positions.
+  This is now an error as required by the proposal:
+
+  ```swift
+  protocol P { associatedtype A }
+  struct Outer<T> { struct Inner<U> { } }
+  let x = Outer<P>.Inner<P>()  // error
+  ```
+  To correct the error, add `any` where appropriate, for example
+  `Outer<any P>.Inner<any P>`.
+
+* Swift 5.10 accepted certain invalid opaque return types from [SE-0346][].
+  If a generic argument of a constrained opaque return type did not
+  satisfy the requirements on the primary associated type, the generic
+  argument was silently ignored and type checking would proceed as if it
+  weren't stated. This now results in a diagnostic:
+
+  ```swift
+  protocol P<A> { associatedtype A: Sequence }
+  struct G<A: Sequence>: P {}
+
+  func f() -> some P<Int> { return G<Array<Int>>() }  // error
+  ```
+
+  The return type above should be written as `some P<Array<Int>>` to match
+  the return statement. The old broken behavior in this situation can also
+  be restored, by removing the erroneous constraint and using the more general
+  upper bound `some P`.
+
 * [SE-0408][]:
   A `for`-`in` loop statement can now accept a pack expansion expression,
   enabling iteration over the elements of its respective value pack. This form
@@ -198,7 +230,9 @@
 
 ## Swift 5.10
 
-* Swift 5.10 closes all known static data-race safey holes in complete strict
+### 2024-03-05 (Xcode 15.3)
+
+* Swift 5.10 closes all known static data-race safety holes in complete strict
 concurrency checking.
 
   When writing code against `-strict-concurrency=complete`, Swift 5.10 will

CMakeLists.txt

@@ -100,6 +100,11 @@ include(FetchContent)
 # optional until we have a bootstrap story.
 check_language(Swift)
 if(CMAKE_Swift_COMPILER)
+  # we are not interested in logging any Swift module used
+  # when configuring the build system -- those are not useful
+  # since they will not contribute to the build of the compiler itself
+  unset(ENV{SWIFT_LOADED_MODULE_TRACE_FILE})
+
   enable_language(Swift)
   set(DEFAULT_SWIFT_MIN_RUNTIME_VERSION "${CMAKE_Swift_COMPILER_VERSION}")
 else()
@@ -217,10 +222,6 @@ option(SWIFT_BUILD_REMOTE_MIRROR
     "Build the Swift Remote Mirror Library"
     TRUE)
 
-option(SWIFT_BUILD_EXTERNAL_GENERIC_METADATA_BUILDER
-    "Build the Swift External Generic Metadata Builder Library"
-    TRUE)
-
 option(SWIFT_BUILD_DYNAMIC_STDLIB
     "Build dynamic variants of the Swift standard library"
     TRUE)
@@ -360,9 +361,11 @@ How swift-C++ bridging code is compiled:
 ]=] DEFAULT)
 
 option(SWIFT_USE_SYMLINKS "Use symlinks instead of copying binaries" ${CMAKE_HOST_UNIX})
-set(SWIFT_COPY_OR_SYMLINK "copy")
+set(SWIFT_COPY_OR_SYMLINK "copy_if_different")
+set(SWIFT_COPY_OR_SYMLINK_DIR "copy_directory")
 if(SWIFT_USE_SYMLINKS)
   set(SWIFT_COPY_OR_SYMLINK "create_symlink")
+  set(SWIFT_COPY_OR_SYMLINK_DIR "create_symlink")
 endif()
 
 # The following only works with the Ninja generator in CMake >= 3.0.
@@ -487,6 +490,14 @@ set(SWIFT_ANDROID_NDK_PATH "" CACHE STRING
 set(SWIFT_ANDROID_DEPLOY_DEVICE_PATH "" CACHE STRING
   "Path on an Android device where build products will be pushed. These are used when running the test suite against the device")
 
+#
+# User-configurable WebAssembly specific options.
+#
+
+option(SWIFT_ENABLE_WASI_THREADS
+  "Build the Standard Library with WASI threads support"
+  FALSE)
+
 #
 # User-configurable Darwin-specific options.
 #
@@ -653,8 +664,8 @@ option(SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED
   "Enable experimental distributed actors and functions"
   FALSE)
 
-option(SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS
-  "Enable experimental NoncopyableGenerics"
+option(SWIFT_ENABLE_EXPERIMENTAL_NONESCAPABLE_TYPES
+  "Enable experimental NonescapableTypes"
   FALSE)
 
 option(SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING
@@ -965,6 +976,18 @@ endif()
 set(SWIFT_USE_LINKER ${SWIFT_USE_LINKER_default} CACHE STRING
     "Build Swift with a non-default linker")
 
+include(CheckLinkerFlag)
+
+# Apple's linker complains about duplicate libraries, which CMake likes to do
+# to support ELF platforms. To silence that warning, we can use
+# -no_warn_duplicate_libraries, but only in versions of the linker that
+# support that flag.
+if(NOT LLVM_USE_LINKER AND ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+  check_linker_flag(C "-Wl,-no_warn_duplicate_libraries" SWIFT_LINKER_SUPPORTS_NO_WARN_DUPLICATE_LIBRARIES)
+else()
+  set(SWIFT_LINKER_SUPPORTS_NO_WARN_DUPLICATE_LIBRARIES OFF CACHE INTERNAL "")
+endif()
+
 #
 # Enable additional warnings.
 #
@@ -1252,7 +1275,7 @@ if(SWIFT_BUILD_STDLIB OR SWIFT_BUILD_SDK_OVERLAY)
   message(STATUS "Differentiable Programming Support: ${SWIFT_ENABLE_EXPERIMENTAL_DIFFERENTIABLE_PROGRAMMING}")
   message(STATUS "Concurrency Support:                ${SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY}")
   message(STATUS "Distributed Support:                ${SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED}")
-  message(STATUS "NoncopyableGenerics Support:        ${SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS}")
+  message(STATUS "NonEscapableTypes Support:          ${SWIFT_ENABLE_EXPERIMENTAL_NONESCAPABLE_TYPES}")
   message(STATUS "String Processing Support:          ${SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING}")
   message(STATUS "Backtracing Support:                ${SWIFT_ENABLE_BACKTRACING}")
   message(STATUS "Unicode Support:                    ${SWIFT_STDLIB_ENABLE_UNICODE_DATA}")
@@ -1274,11 +1297,6 @@ if(SWIFT_BUILD_REMOTE_MIRROR)
   message(STATUS "")
 endif()
 
-if(SWIFT_BUILD_EXTERNAL_GENERIC_METADATA_BUILDER)
-  message(STATUS "Building Swift External Generic Metadata Builder for SDKs: ${SWIFT_SDKS}")
-  message(STATUS "")
-endif()
-
 #
 # Find required dependencies.
 #

README.md

@@ -19,11 +19,16 @@
 | **Amazon Linux 2** | AArch64 |[![Build Status](https://ci.swift.org/job/oss-swift-package-amazon-linux-2-aarch64/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-amazon-linux-2-aarch64)|
 | **Universal Base Image 9** | x86_64 |[![Build Status](https://ci.swift.org/job/oss-swift-package-ubi-9/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-ubi-9)|
 
+**Cross-Compilation Targets**
+
+| **Target** | **Build** |
+|:---:|:---:|
+| **wasm32-unknown-wasi** |[![Build Status](https://ci.swift.org/job/oss-swift-pr-test-crosscompile-wasm-ubuntu-20_04/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-pr-test-crosscompile-wasm-ubuntu-20_04)|
+
 **Swift Community-Hosted CI Platforms**
 
 | **OS** | **Architecture** | **Build** |
 |---|:---:|:---:|
-|**[Ubuntu 20.04](https://github.com/apple/swift-community-hosted-continuous-integration/blob/main/nodes/wasm32_ubuntu_20.04.json)** | wasm32 |[![Build Status](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-20.04-webassembly/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-20.04-webassembly)|
 |**[Android](https://github.com/apple/swift-community-hosted-continuous-integration/blob/main/nodes/x86_64_ubuntu_16_04_LTS_android.json)** | ARMv7 |[![Build Status](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-16.04-android/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-16.04-android)|
 |**[Android](https://github.com/apple/swift-community-hosted-continuous-integration/blob/main/nodes/x86_64_ubuntu_16_04_LTS_android.json)** | AArch64 |[![Build Status](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-16.04-android-arm64/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-16.04-android-arm64)|
 |**[Windows 2019 (VS 2019)](https://github.com/apple/swift-community-hosted-continuous-integration/blob/main/nodes/x86_64_windows_2019_VS2019.json)** | x86_64 | [![Build Status](https://ci-external.swift.org/job/oss-swift-windows-x86_64-vs2019/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-windows-x86_64-vs2019)|

SwiftCompilerSources/CMakeLists.txt

@@ -98,10 +98,17 @@ function(add_swift_compiler_modules_library name)
                         "DEPENDS"
                         ${ARGN})
 
+  # Prior to 5.9, we have to use the experimental flag for C++ interop.
+  if (CMAKE_Swift_COMPILER_VERSION VERSION_LESS 5.9)
+    set(cxx_interop_flag "-enable-experimental-cxx-interop")
+  else()
+    set(cxx_interop_flag "-cxx-interoperability-mode=default")
+  endif()
+
   set(swift_compile_options
       "-color-diagnostics"
       "-Xfrontend" "-validate-tbd-against-ir=none"
-      "-Xfrontend" "-enable-experimental-cxx-interop"
+      "${cxx_interop_flag}"
       "-Xfrontend" "-disable-target-os-checking"
       "-Xcc" "-std=c++17"
       "-Xcc" "-DCOMPILED_WITH_SWIFT" "-Xcc" "-DSWIFT_TARGET"
@@ -148,10 +155,9 @@ function(add_swift_compiler_modules_library name)
       list(APPEND sdk_option "-resource-dir" "${swift_exec_bin_dir}/../bootstrapping0/lib/swift")
     endif()
   elseif(BOOTSTRAPPING_MODE STREQUAL "CROSSCOMPILE")
-    get_filename_component(swift_exec_bin_dir ${ALS_SWIFT_EXEC} DIRECTORY)
     # NOTE: prepending allows SWIFT_COMPILER_SOURCES_SDK_FLAGS to override the
     # resource directory if needed.
-    list(PREPEND sdk_option "-resource-dir" "${swift_exec_bin_dir}/../lib/swift")
+    list(PREPEND sdk_option "-resource-dir" "${SWIFTLIB_DIR}")
   endif()
   get_versioned_target_triple(target ${SWIFT_HOST_VARIANT_SDK}
       ${SWIFT_HOST_VARIANT_ARCH} "${deployment_version}")
@@ -225,6 +231,9 @@ function(add_swift_compiler_modules_library name)
         importedHeaderDependencies
       COMMENT "Building swift module ${module}")
 
+    if(BOOTSTRAPPING_MODE STREQUAL "CROSSCOMPILE")
+      add_dependencies(${dep_target} swift-stdlib-${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}-${SWIFT_HOST_VARIANT_ARCH})
+    endif()
     set("${module}_dep_target" ${dep_target})
     set(all_module_targets ${all_module_targets} ${dep_target})
   endforeach()

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -63,7 +63,7 @@ struct AliasAnalysis {
         let path = SmallProjectionPath(.anyValueFields)
         if let apply = inst as? ApplySite {
           // Workaround for quadratic complexity in ARCSequenceOpts.
-          // We need to use an ever lower budget to not get into noticable compile time troubles.
+          // We need to use an ever lower budget to not get into noticeable compile time troubles.
           let budget = complexityBudget / 10
           let effect = getOwnershipEffect(of: apply, for: obj, path: path, complexityBudget: budget, context)
           return effect.destroy

SwiftCompilerSources/Sources/Optimizer/DataStructures/InstructionRange.swift

@@ -60,16 +60,17 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
   }
 
   init(for value: Value, _ context: some Context) {
-    var begin: Instruction
+    self = InstructionRange(begin: InstructionRange.beginningInstruction(for: value), context)
+  }
+
+  static func beginningInstruction(for value: Value) -> Instruction {
     if let def = value.definingInstruction {
-      begin = def
+      return def
     } else if let result = TerminatorResult(value) {
-      begin = result.terminator
-    } else {
-      assert(Phi(value) != nil || value is FunctionArgument)
-      begin = value.parentBlock.instructions.first!
+      return result.terminator
     }
-    self = InstructionRange(begin: begin, context)
+    assert(Phi(value) != nil || value is FunctionArgument)
+    return value.parentBlock.instructions.first!
   }
 
   /// Insert a potential end instruction.

SwiftCompilerSources/Sources/Optimizer/DataStructures/Set.swift

@@ -176,3 +176,55 @@ struct InstructionSet : IntrusiveSet {
     context.freeNodeSet(bridged)
   }
 }
+
+/// A set of operands.
+///
+/// This is an extremely efficient implementation which does not need memory
+/// allocations or hash lookups.
+///
+/// This type should be a move-only type, but unfortunately we don't have move-only
+/// types yet. Therefore it's needed to call `deinitialize()` explicitly to
+/// destruct this data structure, e.g. in a `defer {}` block.
+struct OperandSet : IntrusiveSet {
+
+  private let context: BridgedPassContext
+  private let bridged: BridgedOperandSet
+
+  init(_ context: some Context) {
+    self.context = context._bridged
+    self.bridged = self.context.allocOperandSet()
+  }
+
+  func contains(_ operand: Operand) -> Bool {
+    bridged.contains(operand.bridged)
+  }
+
+  /// Returns true if `inst` was not contained in the set before inserting.
+  @discardableResult
+  mutating func insert(_ operand: Operand) -> Bool {
+    bridged.insert(operand.bridged)
+  }
+
+  mutating func erase(_ operand: Operand) {
+    bridged.erase(operand.bridged)
+  }
+
+  var description: String {
+    let function = bridged.getFunction().function
+    var d = "{\n"
+    for inst in function.instructions {
+      for op in inst.operands {
+        if contains(op) {
+          d += op.description
+        }
+      }
+    }
+    d += "}\n"
+    return d
+  }
+
+  /// TODO: once we have move-only types, make this a real deinit.
+  mutating func deinitialize() {
+    context.freeOperandSet(bridged)
+  }
+}

SwiftCompilerSources/Sources/Optimizer/DataStructures/Worklist.swift

@@ -75,3 +75,4 @@ struct Worklist<Set: IntrusiveSet> : CustomStringConvertible, NoReflectionChildr
 typealias BasicBlockWorklist = Worklist<BasicBlockSet>
 typealias InstructionWorklist = Worklist<InstructionSet>
 typealias ValueWorklist = Worklist<ValueSet>
+typealias OperandWorklist = Worklist<OperandSet>

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AllocVectorLowering.swift

@@ -414,7 +414,7 @@ private struct ComputeNonEscapingLiferange : EscapeVisitorWithResult {
       if dominates {
         liferange.insert(user)
       }
-      if !apply.type.isEscapable {
+      if !apply.isEscapable {
         return .abort
       }
       return .ignore

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/InitializeStaticGlobals.swift

@@ -113,10 +113,14 @@ private func getSequenceOfElementStores(firstStore: StoreInst) -> ([StoreInst],
     return nil
   }
   let structAddr = elementAddr.struct
-  if structAddr.type.isMoveOnly {
+  let structType = structAddr.type
+  if structType.isMoveOnly {
     return nil
   }
-  guard let fields = structAddr.type.getNominalFields(in: firstStore.parentFunction) else {
+  if structType.nominal.isStructWithUnreferenceableStorage {
+    return nil
+  }
+  guard let fields = structType.getNominalFields(in: firstStore.parentFunction) else {
     return nil
   }
   let numElements = fields.count