Merge branch 'main' into distributed-protocol-requirement-accessors

Author: ktoso

CHANGELOG.md

@@ -1,9 +1,61 @@
 # CHANGELOG
 
-> **Note**\
+> [!NOTE]
 > This is in reverse chronological order, so newer entries are added to the top.
 
 ## Swift 6.0
+* [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
+  supports pattern matching, control transfer statements, and other features
+  available to a `Sequence`-driven `for`-`in` loop, except for the `where`
+  clause. Below is an example implementation of the equality operator for
+  tuples of arbitrary length using pack iteration:
+
+  ```swift
+  func == <each Element: Equatable>(lhs: (repeat each Element),
+                                    rhs: (repeat each Element)) -> Bool {
+
+    for (left, right) in repeat (each lhs, each rhs) {
+      guard left == right else { return false }
+    }
+    return true
+  }
+  ```
+
+  The elements of the value pack corresponding to the pack expansion expression
+  are evaluated on demand, meaning the i<sup>th</sup> element is evaluated on
+  the i<sup>th</sup> iteration:
+
+  ```swift
+  func doSomething(_: some Any) {}
+
+  func evaluateFirst<each T>(_ t: repeat each T) {
+    for _ in repeat doSomething(each t) {
+      break
+    }
+  }
+
+  evaluateFirst(1, 2, 3) 
+  // 'doSomething' will be called only on the first element of the pack.
+  ```
+
+* [SE-0352][]:
+  The Swift 6 language mode will open existential values with
+  "self-conforming" types (such as `any Error` or `@objc` protocols)
+  passed to generic functions. For example:
+
+  ```swift
+  func takeError<E: Error>(_ error: E) { }
+
+  func passError(error: any Error) {
+    takeError(error)  // Swift 5 does not open `any Error`, Swift 6 does
+  }
+  ```
+
+  This behavior can be enabled prior to the Swift 6 language mode
+  using the upcoming language feature `ImplicitOpenExistentials`.
+
 * [SE-0422][]:
   Non-built-in expression macros can now be used as default arguments that
   expand at each call site. For example, a custom `#CurrentFile` macro used as
@@ -285,6 +337,8 @@ concurrency checking.
 
 ## Swift 5.9.2
 
+### 2023-12-11 (Xcode 15.1)
+
 * [SE-0407][]:
 
   Member macros can specify a list of protocols via the `conformances` argument to the macro role. The macro implementation will be provided with those protocols that are listed but have not already been implemented by the type to which the member macro is attached, in the same manner as extension macros.
@@ -10129,10 +10183,12 @@ using the `.dynamicType` member to retrieve the type of an expression should mig
 [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
 [SE-0407]: https://github.com/apple/swift-evolution/blob/main/proposals/0407-member-macro-conformances.md
+[SE-0408]: https://github.com/apple/swift-evolution/blob/main/proposals/0408-pack-iteration.md
 [SE-0411]: https://github.com/apple/swift-evolution/blob/main/proposals/0411-isolated-default-values.md
 [SE-0417]: https://github.com/apple/swift-evolution/blob/main/proposals/0417-task-executor-preference.md
 [SE-0412]: https://github.com/apple/swift-evolution/blob/main/proposals/0412-strict-concurrency-for-global-variables.md
 [SE-0413]: https://github.com/apple/swift-evolution/blob/main/proposals/0413-typed-throws.md
+[SE-0422]: https://github.com/apple/swift-evolution/blob/main/proposals/0422-caller-side-default-argument-macro-expression.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>

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"

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -420,6 +420,41 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
           return .continueWalk
         }
         return isEscaping
+
+      case .AtomicLoad:
+        // Treat atomic loads as regular loads and just walk down their uses.
+        if !followLoads(at: path) {
+          return .continueWalk
+        }
+
+        // Even when analyzing atomics, a loaded trivial value can be ignored.
+        if hasRelevantType(bi, at: path.projectionPath) {
+          return .continueWalk
+        }
+
+        return walkDownUses(ofValue: bi, path: path.with(knownType: nil))
+
+      case .AtomicStore, .AtomicRMW:
+        // If we shouldn't follow the store, then we can keep walking.
+        if !path.followStores {
+          return .continueWalk
+        }
+
+        // Be conservative and just say the store is escaping.
+        return isEscaping
+
+      case .CmpXChg:
+        // If we have to follow loads or stores of a cmpxchg, then just bail.
+        if followLoads(at: path) || path.followStores {
+          return isEscaping
+        }
+
+        return .continueWalk
+
+      case .Fence:
+        // Fences do not affect escape analysis.
+        return .continueWalk
+
       default:
         return isEscaping
       }

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -185,7 +185,7 @@ struct LifetimeDependence : CustomStringConvertible {
   var parentValue: Value { scope.parentValue }
 
   var function: Function {
-    dependentValue.parentFunction // dependentValue can't be undef
+    dependentValue.parentFunction
   }
 
   var description: String {

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -47,9 +47,6 @@ extension Value {
   /// check, because it treats a value_to_bridge_object instruction as "trivial".
   /// It can also handle non-trivial enums with trivial cases.
   func isTrivial(_ context: some Context) -> Bool {
-    if self is Undef {
-      return true
-    }
     var worklist = ValueWorklist(context)
     defer { worklist.deinitialize() }
 
@@ -64,12 +61,12 @@ extension Value {
       switch v {
       case is ValueToBridgeObjectInst:
         break
-      case is StructInst, is TupleInst:
-        let inst = (v as! SingleValueInstruction)
-        worklist.pushIfNotVisited(contentsOf: inst.operands.values.filter { !($0 is Undef) })
+      case let si as StructInst:
+        worklist.pushIfNotVisited(contentsOf: si.operands.values)
+      case let ti as TupleInst:
+        worklist.pushIfNotVisited(contentsOf: ti.operands.values)
       case let en as EnumInst:
-        if let payload = en.payload,
-           !(payload is Undef) {
+        if let payload = en.payload {
           worklist.pushIfNotVisited(payload)
         }
       default:

SwiftCompilerSources/Sources/SIL/Value.swift

@@ -25,10 +25,13 @@ public protocol Value : AnyObject, CustomStringConvertible {
   var definingInstruction: Instruction? { get }
 
   /// The block where the value is defined.
-  ///
-  /// It's not legal to get the definingBlock of an `Undef` value.
   var parentBlock: BasicBlock { get }
 
+  /// The function where the value lives in.
+  ///
+  /// It's not legal to get the parentFunction of an instruction in a global initializer.
+  var parentFunction: Function { get }
+
   /// True if the value has a trivial type.
   var hasTrivialType: Bool { get }
 
@@ -113,6 +116,7 @@ extension Value {
 
   public var uses: UseList { UseList(bridged.getFirstUse()) }
 
+  // Default implementation for all values which have a parent block, like instructions and arguments.
   public var parentFunction: Function { parentBlock.parentFunction }
 
   public var type: Type { bridged.getType().type }
@@ -206,8 +210,11 @@ extension BridgedValue {
 public final class Undef : Value {
   public var definingInstruction: Instruction? { nil }
 
+  public var parentFunction: Function { bridged.SILUndef_getParentFunction().function }
+
   public var parentBlock: BasicBlock {
-    fatalError("undef has no defining block")
+    // By convention, undefs are considered to be defined at the entry of the function.
+    parentFunction.entryBlock
   }
 
   /// Undef has not parent function, therefore the default `hasTrivialType` does not work.
@@ -221,9 +228,12 @@ public final class Undef : Value {
 
 final class PlaceholderValue : Value {
   public var definingInstruction: Instruction? { nil }
+
   public var parentBlock: BasicBlock {
     fatalError("PlaceholderValue has no defining block")
   }
+
+  public var parentFunction: Function { bridged.PlaceholderValue_getParentFunction().function }
 }
 
 extension OptionalBridgedValue {

benchmark/scripts/Template.swift

@@ -1,8 +1,8 @@
-//===--- {name}.swift -------------------------------------------===//
+//===--- {name}.swift {padding}---===//
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2021 Apple Inc. and the Swift project authors
+// Copyright (c) {year} Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -12,7 +12,7 @@
 
 import TestsUtils
 
-public let {name} = [
+public let benchmarks = [
   BenchmarkInfo(name: "{name}", runFunction: run_{name}, tags: [.validation, .api]),
 ]
 

benchmark/scripts/create_benchmark.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 
 import argparse
+import datetime
 import os
 import re
 
@@ -46,18 +47,22 @@ def create_benchmark_file(name):
     and places it in the `single-source` directory.
     """
 
+    file_text = ""
     template_path = create_relative_path("Template.swift")
-    benchmark_template = ""
     with open(template_path, "r") as f:
-        benchmark_template = "".join(f.readlines())
+        file_text = "".join(f.readlines())
 
-    # fill in template with benchmark name.
-    formatted_template = benchmark_template.format(name=name)
+    # fill in missing template details
+    file_text = file_text.format(
+        name=name,
+        padding="-" * (56 - len(name)),
+        year=datetime.date.today().year
+    )
 
-    relative_path = create_relative_path("../single-source/")
-    source_file_path = os.path.join(relative_path, name + ".swift")
-    with open(source_file_path, "w") as f:
-        f.write(formatted_template)
+    file_path_prefix = create_relative_path("../single-source/")
+    file_path = os.path.join(file_path_prefix, name + ".swift")
+    with open(file_path, "w") as f:
+        f.write(file_text)
 
 
 def add_import_benchmark(name):
@@ -119,9 +124,9 @@ def add_register_benchmark(name):
 
     file_new_contents = insert_line_alphabetically(
         name,
-        "registerBenchmark(" + name + ")\n",
+        "register(" + name + ".benchmarks)\n",
         file_contents,
-        r"registerBenchmark\(([a-zA-Z]+)\)",
+        r"register\(([a-zA-Z]+)\.benchmarks\)",
     )
     with open(relative_path, "w") as f:
         for line in file_new_contents: