Merge branch 'main' into disable-property-wrapper-based-isolation

Author: DougGregor

.github/CODEOWNERS

@@ -69,6 +69,8 @@
 /include/swift/PrintAsClang                        @zoecarver @hyp @egorzhdan
 # TODO: /include/swift/SIL/
 # TODO: /include/swift/SILOptimizer/
+/include/swift/SIL/*Coverage*                      @hamishknight
+/include/swift/SIL/SILProfiler.h                   @hamishknight
 /include/swift/SIL/SILDebug*                       @adrian-prantl
 /include/swift/SILOptimizer/Utils/Distributed*     @ktoso
 /include/swift/Sema/                               @hborla @slavapestov @xedin
@@ -94,23 +96,28 @@
 /lib/ClangImporter/DWARFImporter*                   @adrian-prantl
 /lib/DependencyScan                                 @artemcm
 /lib/Driver                                         @artemcm
+/lib/DriverTool/autolink_extract_main.cpp           @MaxDesiatov @etcwilde
 /lib/DriverTool/swift_symbolgraph_extract_main.cpp  @QuietMisdreavus
 /lib/Frontend/*ModuleInterface*                     @artemcm @tshortli
 # TODO: /lib/IRGen/
 /lib/IDE/                                           @ahoppen @bnbarham @rintaro
 /lib/IDETool/                                       @ahoppen @bnbarham @rintaro
 /lib/Index/                                         @bnbarham
 /lib/Refactoring/                                   @ahoppen @bnbarham
+/lib/IRGen/*Coverage*                               @hamishknight
 /lib/IRGen/*Debug*                                  @adrian-prantl
 /lib/IRGen/*Distributed*                            @ktoso
 /lib/Parse/                                         @ahoppen @bnbarham @CodaFi @DougGregor @rintaro
 /lib/PrintAsClang                                   @zoecarver @hyp @egorzhdan
 # TODO: /lib/SIL/
+/lib/SIL/IR/*Coverage*                              @hamishknight
+/lib/SIL/IR/SILProfiler.cpp                         @hamishknight
 /lib/SIL/IR/SILDebug*                               @adrian-prantl
 /lib/SIL/IR/SILLocation*                            @adrian-prantl
 # TODO: /lib/SILGen/
 /lib/SILGen/*Distributed*                           @ktoso
 # TODO: /lib/SILOptimizer/
+/lib/SILOptimizer/Mandatory/FlowIsolation.cpp       @kavon
 /lib/SILOptimizer/Utils/Distributed*                @ktoso
 /lib/Sema/                                          @hborla @slavapestov @xedin
 /lib/Sema/*Availability*                            @tshortli
@@ -143,6 +150,7 @@
 /test/DebugInfo/                                    @adrian-prantl
 /test/Distributed/                                  @ktoso
 /test/Driver/                                       @artemcm
+/test/Driver/static*                                @MaxDesiatov @etcwilde
 /test/Generics/                                     @hborla @slavapestov
 # TODO: /test/IRGen/
 /test/IDE/                                          @ahoppen @bnbarham @rintaro
@@ -151,6 +159,7 @@
 /test/SourceKit/                                    @ahoppen @bnbarham @rintaro
 /test/Interop/                                      @zoecarver @hyp @egorzhdan
 /test/Parse/                                        @ahoppen @bnbarham @CodaFi @DougGregor @rintaro
+/test/Profiler                                      @hamishknight
 # TODO: /test/SIL/
 # TODO: /test/SILGen/
 # TODO: /test/SILOptimizer/

CHANGELOG.md

@@ -5,6 +5,102 @@
 
 ## Swift 5.9
 
+* [SE-0382][], [SE-0389][], [SE-0394][], [SE-0397][]:
+
+  Swift 5.9 includes a new macro system that can be used to eliminate boilerplate and provide new forms of expressive APIs. Macros are declared with the new `macro` introducer:
+
+  ```swift
+  @freestanding(expression)
+  macro assert(_ condition: Bool) = #externalMacro(module: "PowerAssertMacros", type: "AssertMacro")
+  ```
+
+  Macros have parameter and result types, like functions, but are defined as separate programs that operate on syntax trees (using [swift-syntax][]) and produce new syntax trees that are incorporated into the program. Freestanding macros, indicated with the `@freestanding` attribute, are expanded in source code with a leading `#`:
+
+  ```swift
+  #assert(x + y == z) // expands to check the result of x + y == z and report failure if it's false
+  ```
+
+  Macros can also be marked as `@attached`, in which case they will be meaning that they will be expanded using custom attribute syntax. For example:
+
+  ```swift
+  @attached(peer, names: overloaded)
+  macro AddCompletionHandler() = #externalMacro(
+    module: "ConcurrencyHelperMacros",
+    type: "AddCompletionHandlerMacro"
+  )
+  
+  @AddCompletionHandler
+  func fetchAvatar(from url: URL) throws -> Image { ... }
+  
+  // expands to...
+  func fetchAvatar(from url: URL, completionHandler: @escaping (Result<Image, Error>) -> Void) {
+    Task.detached {
+      do {
+        let result = try await fetchAvatar(from: url)
+        completionHandler(.success(result))
+      } catch {
+        completionHandler(.failure(error))
+      }
+    }
+  }
+  ```
+
+  Macros are implemented in separate programs, which are executed by the Swift compiler. The Swift Package Manager's manifest provides a new `macro` target type to describe macros:
+
+  ```swift
+  import PackageDescription
+  import CompilerPluginSupport
+  
+  let package = Package(
+      name: "ConcurrencyHelpers",
+      dependencies: [
+          .package(url: "https://github.com/apple/swift-syntax", from: "509.0.0"),
+      ],
+      targets: [
+          .macro(name: "ConcurrencyHelperMacros",
+                 dependencies: [
+                     .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
+                     .product(name: "SwiftCompilerPlugin", package: "swift-syntax")
+                 ]),
+          .target(name: "ConcurrencyHelpers", dependencies: ["ConcurrencyHelperMacros"]),
+          .testTarget(name: "ConcurrencyHelperMacroTests", dependencies: ["ConcurrencyHelperMacros"]),
+      ]
+  )
+  ```
+
+* [SE-0380][]:
+
+  `if` and `switch` statements may now be used as expressions to:
+
+  * Return values from functions, properties, and closures (either with
+    implicit or explicit `return`)
+  * Throw errors using `throw`
+  * Assign values to variables
+  * Declare variables
+
+  Each branch of the `if` or `switch` must be a single expression, the value
+  of which becomes the value of the overall expression when that branch is
+  chosen.
+
+  ```swift
+  let bullet =
+    if isRoot && (count == 0 || !willExpand) { "" }
+    else if count == 0 { "- " }
+    else if maxDepth <= 0 { "▹ " }
+    else { "▿ " }
+  ```
+
+  ```swift
+  public static func width(_ x: Unicode.Scalar) -> Int {
+    switch x.value {
+      case 0..<0x80: 1
+      case 0x80..<0x0800: 2
+      case 0x0800..<0x1_0000: 3
+      default: 4
+    }
+  }
+  ```
+
 * [#64927][]:
 
   Swift 5.9 introduces warnings that catch conversions from an inout
@@ -9732,7 +9828,11 @@ using the `.dynamicType` member to retrieve the type of an expression should mig
 [SE-0370]: <https://github.com/apple/swift-evolution/blob/main/proposals/0370-pointer-family-initialization-improvements.md>
 [SE-0376]: <https://github.com/apple/swift-evolution/blob/main/proposals/0376-function-back-deployment.md>
 [SE-0377]: <https://github.com/apple/swift-evolution/blob/main/proposals/0377-parameter-ownership-modifiers.md>
-
+[SE-0380]: <https://github.com/apple/swift-evolution/blob/main/proposals/0380-if-switch-expressions.md>
+[SE-0382]: https://github.com/apple/swift-evolution/blob/main/proposals/0382-expression-macros.md
+[SE-0389]: https://github.com/apple/swift-evolution/blob/main/proposals/0389-attached-macros.md
+[SE-0394]: https://github.com/apple/swift-evolution/blob/main/proposals/0394-swiftpm-expression-macros.md
+[SE-0397]: https://github.com/apple/swift-evolution/blob/main/proposals/0397-freestanding-declaration-macros.md
 [#64927]: <https://github.com/apple/swift/issues/64927>
 [#42697]: <https://github.com/apple/swift/issues/42697>
 [#42728]: <https://github.com/apple/swift/issues/42728>
@@ -9774,3 +9874,4 @@ using the `.dynamicType` member to retrieve the type of an expression should mig
 [#57081]: <https://github.com/apple/swift/issues/57081>
 [#57225]: <https://github.com/apple/swift/issues/57225>
 [#56139]: <https://github.com/apple/swift/issues/56139>
+[swift-syntax]: https://github.com/apple/swift-syntax

CMakeLists.txt

@@ -609,6 +609,10 @@ option(SWIFT_ENABLE_EXPERIMENTAL_CXX_INTEROP
   "Enable experimental C++ interop modules"
   FALSE)
 
+option(SWIFT_ENABLE_CXX_INTEROP_SWIFT_BRIDGING_HEADER
+  "Install the <swift/bridging> C++ interoperability header alongside compiler"
+  TRUE)
+
 option(SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED
   "Enable experimental distributed actors and functions"
   FALSE)
@@ -642,6 +646,11 @@ option(SWIFT_THREADING_PACKAGE
    Valid package names are 'pthreads', 'darwin', 'linux', 'win32', 'c11', 'none'
    or the empty string for the SDK default.")
 
+option(SWIFT_THREADING_HAS_DLSYM
+  "Enable the use of the dlsym() function.  This gets used to provide TSan
+   support on some platforms."
+  TRUE)
+
 option(SWIFT_ENABLE_MACCATALYST
   "Build the Standard Library and overlays with MacCatalyst support"
   FALSE)
@@ -687,13 +696,6 @@ if(NOT EXISTS "${SWIFT_PATH_TO_SWIFT_SYNTAX_SOURCE}")
   message(SEND_ERROR "swift-syntax is required to build the Swift compiler. Please run update-checkout or specify SWIFT_PATH_TO_SWIFT_SYNTAX_SOURCE")
 endif()
 
-# Use dispatch as the system scheduler by default.
-# For convenience, we set this to false when concurrency is disabled.
-set(SWIFT_CONCURRENCY_USES_DISPATCH FALSE)
-if(SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY AND "${SWIFT_CONCURRENCY_GLOBAL_EXECUTOR}" STREQUAL "dispatch")
-  set(SWIFT_CONCURRENCY_USES_DISPATCH TRUE)
-endif()
-
 set(SWIFT_BUILD_HOST_DISPATCH FALSE)
 if(SWIFT_ENABLE_DISPATCH AND NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
   # Only build libdispatch for the host if the host tools are being built and
@@ -702,9 +704,9 @@ if(SWIFT_ENABLE_DISPATCH AND NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
     set(SWIFT_BUILD_HOST_DISPATCH TRUE)
   endif()
 
-  if(SWIFT_BUILD_HOST_DISPATCH OR SWIFT_CONCURRENCY_USES_DISPATCH)
+  if(SWIFT_BUILD_HOST_DISPATCH)
     if(NOT EXISTS "${SWIFT_PATH_TO_LIBDISPATCH_SOURCE}")
-      message(SEND_ERROR "SourceKit and concurrency require libdispatch on non-Darwin hosts.  Please specify SWIFT_PATH_TO_LIBDISPATCH_SOURCE")
+      message(SEND_ERROR "SourceKit requires libdispatch on non-Darwin hosts.  Please specify SWIFT_PATH_TO_LIBDISPATCH_SOURCE")
     endif()
   endif()
 endif()
@@ -1046,6 +1048,14 @@ elseif("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "ANDROID")
   set(SWIFT_PRIMARY_VARIANT_SDK_default  "${SWIFT_HOST_VARIANT_SDK}")
   set(SWIFT_PRIMARY_VARIANT_ARCH_default "${SWIFT_HOST_VARIANT_ARCH}")
 
+elseif("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "WASI")
+  set(SWIFT_HOST_VARIANT "wasi" CACHE STRING
+      "Deployment OS for Swift host tools (the compiler) [wasi]")
+
+  configure_sdk_unix("WASI" "wasm32")
+  set(SWIFT_PRIMARY_VARIANT_SDK_default  "${SWIFT_HOST_VARIANT_SDK}")
+  set(SWIFT_PRIMARY_VARIANT_ARCH_default "${SWIFT_HOST_VARIANT_ARCH}")
+
 elseif("${SWIFT_HOST_VARIANT_SDK}" MATCHES "(OSX|IOS*|TVOS*|WATCHOS*)")
 
   set(SWIFT_HOST_VARIANT "macosx" CACHE STRING

SwiftCompilerSources/CMakeLists.txt

@@ -87,6 +87,10 @@ function(add_swift_compiler_modules_library name)
     list(APPEND swift_compile_options "-O" "-cross-module-optimization")
   endif()
 
+  if(NOT LLVM_ENABLE_ASSERTIONS)
+    list(APPEND swift_compile_options "-Xcc" "-DNDEBUG")
+  endif()
+
   if(NOT SWIFT_STDLIB_SUPPORT_BACK_DEPLOYMENT)
     list(APPEND swift_compile_options "-Xfrontend" "-disable-legacy-type-info")
   endif()
@@ -227,7 +231,7 @@ else()
   add_subdirectory(Sources)
 
   # TODO: generate this dynamically through the modulemap; this cannot use `sed`
-  # as that is not available on all paltforms (e.g. Windows).
+  # as that is not available on all platforms (e.g. Windows).
   #
   # step 1: generate a dummy source file, which just includes all headers
   # defined in include/swift/module.modulemap

SwiftCompilerSources/Sources/Basic/Utils.swift

@@ -64,11 +64,21 @@ public struct StringRef : CustomStringConvertible, NoReflectionChildren {
 
   public var string: String { _bridged.string }
   public var description: String { string }
-  
+
+  public var count: Int {
+    Int(_bridged.__bytes_endUnsafe() - _bridged.__bytes_beginUnsafe())
+  }
+
+  public subscript(index: Int) -> UInt8 {
+    let buffer = UnsafeBufferPointer<UInt8>(start: _bridged.__bytes_beginUnsafe(),
+                                            count: count)
+    return buffer[index]
+  }
+
   public static func ==(lhs: StringRef, rhs: StaticString) -> Bool {
     let lhsBuffer = UnsafeBufferPointer<UInt8>(
       start: lhs._bridged.__bytes_beginUnsafe(),
-      count: Int(lhs._bridged.__bytes_endUnsafe() - lhs._bridged.__bytes_beginUnsafe()))
+      count: lhs.count)
     return rhs.withUTF8Buffer { (rhsBuffer: UnsafeBufferPointer<UInt8>) in
       if lhsBuffer.count != rhsBuffer.count { return false }
       return lhsBuffer.elementsEqual(rhsBuffer, by: ==)

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -68,19 +68,17 @@ struct AliasAnalysis {
         let inst = bridgedInst.instruction
         let val = bridgedVal.value
         let path = AliasAnalysis.getPtrOrAddressPath(for: val)
-        if let apply = inst as? ApplySite {
-          let effect = getMemoryEffect(of: apply, for: val, path: path, context)
-          switch (effect.read, effect.write) {
-            case (false, false): return .None
-            case (true, false):  return .MayRead
-            case (false, true):  return .MayWrite
-            case (true, true):   return .MayReadWrite
+        switch inst {
+        case let apply as ApplySite:
+          return getMemoryEffect(ofApply: apply, for: val, path: path, context).bridged
+        case let builtin as BuiltinInst:
+          return getMemoryEffect(ofBuiltin: builtin, for: val, path: path, context).bridged
+        default:
+          if val.at(path).isEscaping(using: EscapesToInstructionVisitor(target: inst, isAddress: true), context) {
+            return .MayReadWrite
           }
+          return .None
         }
-        if val.at(path).isEscaping(using: EscapesToInstructionVisitor(target: inst, isAddress: true), context) {
-          return .MayReadWrite
-        }
-        return .None
       },
 
       // isObjReleasedFn
@@ -121,7 +119,7 @@ struct AliasAnalysis {
   }
 }
 
-private func getMemoryEffect(of apply: ApplySite, for address: Value, path: SmallProjectionPath, _ context: FunctionPassContext) -> SideEffects.Memory {
+private func getMemoryEffect(ofApply apply: ApplySite, for address: Value, path: SmallProjectionPath, _ context: FunctionPassContext) -> SideEffects.Memory {
   let calleeAnalysis = context.calleeAnalysis
   let visitor = SideEffectsVisitor(apply: apply, calleeAnalysis: calleeAnalysis, isAddress: true)
   let memoryEffects: SideEffects.Memory
@@ -132,7 +130,7 @@ private func getMemoryEffect(of apply: ApplySite, for address: Value, path: Smal
     memoryEffects = result.memory
   } else {
     // `address` has unknown escapes. So we have to take the global effects of the called function(s).
-    memoryEffects = calleeAnalysis.getSideEffects(of: apply).memory
+    memoryEffects = calleeAnalysis.getSideEffects(ofApply: apply).memory
   }
   // Do some magic for `let` variables. Function calls cannot modify let variables.
   // The only exception is that the let variable is directly passed to an indirect out of the
@@ -144,14 +142,28 @@ private func getMemoryEffect(of apply: ApplySite, for address: Value, path: Smal
   return memoryEffects
 }
 
+private func getMemoryEffect(ofBuiltin builtin: BuiltinInst, for address: Value, path: SmallProjectionPath, _ context: FunctionPassContext) -> SideEffects.Memory {
+
+  switch builtin.id {
+  case .Once, .OnceWithContext:
+    if !address.at(path).isEscaping(using: AddressVisibleByBuiltinOnceVisitor(), context) {
+      return SideEffects.Memory()
+    }
+    let callee = builtin.operands[1].value
+    return context.calleeAnalysis.getSideEffects(ofCallee: callee).memory
+  default:
+    return builtin.memoryEffects
+  }
+}
+
 private func getOwnershipEffect(of apply: ApplySite, for value: Value, path: SmallProjectionPath, _ context: FunctionPassContext) -> SideEffects.Ownership {
   let visitor = SideEffectsVisitor(apply: apply, calleeAnalysis: context.calleeAnalysis, isAddress: false)
   if let result = value.at(path).visit(using: visitor, context) {
     // The resulting effects are the argument effects to which `value` escapes to.
     return result.ownership
   } else {
     // `value` has unknown escapes. So we have to take the global effects of the called function(s).
-    return visitor.calleeAnalysis.getSideEffects(of: apply).ownership
+    return visitor.calleeAnalysis.getSideEffects(ofApply: apply).ownership
   }
 }
 
@@ -180,6 +192,11 @@ private struct SideEffectsVisitor : EscapeVisitorWithResult {
   var followLoads: Bool { !isAddress }
 }
 
+private struct AddressVisibleByBuiltinOnceVisitor : EscapeVisitor {
+  var followTrivialTypes: Bool { true }
+  var followLoads: Bool { false }
+}
+
 /// Lets `ProjectedValue.isEscaping` return true if the value is "escaping" to the `target` instruction.
 private struct EscapesToInstructionVisitor : EscapeVisitor {
   let target: Instruction
@@ -229,3 +246,13 @@ private struct IsIndirectResultWalker: AddressDefUseWalker {
   }
 }
 
+private extension SideEffects.Memory {
+  var bridged: swift.MemoryBehavior {
+    switch (read, write) {
+      case (false, false): return .None
+      case (true, false):  return .MayRead
+      case (false, true):  return .MayWrite
+      case (true, true):   return .MayReadWrite
+    }
+  }
+}