Merge branch 'main' into silence-envvars

Author: lorentey

.gitignore

@@ -47,6 +47,9 @@ docs/_build
 .cache
 .clangd
 
+# SwiftPM
+.build
+
 #==============================================================================#
 # Ignore CMake temporary files
 #==============================================================================#
@@ -59,6 +62,7 @@ CMakeFiles
 #==============================================================================#
 compile_commands.json
 
+#==============================================================================#
 # Ignore generated GYB files until we fix the workaround on Windows
 #==============================================================================#
 8

CHANGELOG.md

@@ -5,9 +5,120 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 
 ## Swift 5.7
 
+* [SE-0326][]:
+
+  It's now possible to infer parameter and result types from the body of a multi-statement
+  closure. The distinction between single- and multi-statement closures has been removed.
+
+  Use of closures becomes less cumbersome by removing the need to constantly specify explicit
+  closure types which sometimes could be pretty large e.g. when there are multiple parameters
+  or a complex tuple result type.
+
+  For example:
+
+  ```swift
+  func map<T>(fn: (Int) -> T) -> T {
+    return fn(42)
+  }
+
+  func computeResult<U: BinaryInteger>(_: U) -> U { /* processing */ }
+
+  let _ = map {
+    if let $0 < 0 {
+       // do some processing
+    }
+
+    return computeResult($0)
+  }
+  ```
+
+  The result type of `map` can now be inferred from the body of the trailing closure
+  passed as an argument.
+
+* [SE-0345][]:
+
+  It is now possible to unwrap optional variables with a shorthand syntax that
+  shadows the existing declaration. For example, the following:
+  
+  ```swift
+  let foo: String? = "hello world"
+  
+  if let foo {
+    print(foo) // prints "hello world"
+  }
+  ```
+  
+  is equivalent to:
+  
+  ```swift
+  let foo: String? = "hello world"
+  
+  if let foo = foo {
+    print(foo) // prints "hello world"
+  }
+  ```
+
+* [SE-0340][]:
+
+  It is now possible to make declarations unavailable from use in asynchronous
+  contexts with the `@available(*, noasync)` attribute.
+
+  This is to protect the consumers of an API against undefined behavior that can
+  occur when the API uses thread-local storage, or encourages using thread-local
+  storage, across suspension points, or protect developers against holding locks
+  across suspension points which may lead to undefined behavior, priority
+  inversions, or deadlocks.
+
+* [SE-0343][]:
+
+Top-level scripts support asynchronous calls.
+
+Using an `await` by calling an asynchronous function or accessing an isolated
+variable transitions the top-level to an asynchronous context. As an
+asynchronous context, top-level variables are `@MainActor`-isolated and the
+top-level is run on the `@MainActor`.
+
+Note that the transition affects function overload resolution and starts an
+implicit run loop to drive the concurrency machinery.
+
+Unmodified scripts are not affected by this change unless `-warn-concurrency` is
+passed to the compiler invocation. With `-warn-concurrency`, variables in the
+top-level are isolated to the main actor and the top-level context is isolated
+to the main actor, but is not an asynchronous context.
+
+* [SE-0336][]:
+
+It is now possible to declare `distributed actor` and `distributed func`s inside of them.
+
+Distributed actors provide stronger isolation guarantees than "local" actors, and enable additional checks to be made on return types and parameters of distributed methods, e.g. checking if they conform to `Codable`. Distributed methods can be called on "remote" references of distributed actors, turning those invocations into remote procedure calls, by means of pluggable and user extensible distributed actor system implementations. 
+
+Swift does not provide any specific distributed actor system by itself, however, packages in the ecosystem fulfil the role of providing those implementations.
+
+```swift
+distributed actor Greeter { 
+  var greetingsSent = 0
+  
+  distributed func greet(name: String) -> String {
+    greetingsSent += 1
+    return "Hello, \(name)!"
+  }
+}
+
+func talkTo(greeter: Greeter) async throws {
+  // isolation of distributed actors is stronger, it is impossible to refer to
+  // any stored properties of distributed actors from outside of them:
+  greeter.greetingsSent // distributed actor-isolated property 'name' can not be accessed from a non-isolated context
+  
+  // remote calls are implicitly throwing and async, 
+  // to account for the potential networking involved:
+  let greeting = try await greeter.greet(name: "Alice")
+  print(greeting) // Hello, Alice!
+}
+```
+
 * The compiler now emits a warning when a non-final class conforms to a protocol that imposes a same-type requirement between `Self` and an associated type. This is because such a requirement makes the conformance unsound for subclasses.
 
-For example, Swift 5.6 would allow the following code, which at runtime would construct an instanec of `C` and not `SubC` as expected:
+For example, Swift 5.6 would allow the following code, which at runtime would construct an instance of `C` and not `SubC` as expected:
 
   ```swift
   protocol P {
@@ -49,7 +160,7 @@ For example, Swift 5.6 would allow the following code, which at runtime would co
 
 * [SE-0341][]:
 
-  Opaque types can now be used in the parameters of functions and subscripts, wher they provide a shorthand syntax for the introduction of a generic parameter. For example, the following:
+  Opaque types can now be used in the parameters of functions and subscripts, when they provide a shorthand syntax for the introduction of a generic parameter. For example, the following:
 
   ```swift
   func horizontal(_ v1: some View, _ v2: some View) -> some View {
@@ -9034,6 +9145,11 @@ Swift 1.0
 [SE-0337]: <https://github.com/apple/swift-evolution/blob/main/proposals/0337-support-incremental-migration-to-concurrency-checking.md>
 [SE-0335]: <https://github.com/apple/swift-evolution/blob/main/proposals/0335-existential-any.md>
 [SE-0341]: <https://github.com/apple/swift-evolution/blob/main/proposals/0341-opaque-parameters.md>
+[SE-0336]: <https://github.com/apple/swift-evolution/blob/main/proposals/0336-distributed-actor-isolation.md>
+[SE-0343]: <https://github.com/apple/swift-evolution/blob/main/proposals/0343-top-level-concurrency.md>
+[SE-0340]: <https://github.com/apple/swift-evolution/blob/main/proposals/0340-swift-noasync.md>
+[SE-0345]: <https://github.com/apple/swift-evolution/blob/main/proposals/0345-if-let-shorthand.md>
+[SE-0326]: <https://github.com/apple/swift-evolution/blob/main/proposals/0326-extending-multi-statement-closure-inference.md>
 
 [SR-75]: <https://bugs.swift.org/browse/SR-75>
 [SR-106]: <https://bugs.swift.org/browse/SR-106>

CMakeLists.txt

@@ -327,9 +327,15 @@ option(SWIFT_EMBED_BITCODE_SECTION_HIDE_SYMBOLS
   "If non-empty, when embedding the LLVM bitcode binary sections into the relevant binaries, pass in -bitcode_hide_symbols. Does nothing if SWIFT_EMBED_BITCODE_SECTION is set to false."
   FALSE)
 
+if("${SWIFT_HOST_VARIANT_SDK}" MATCHES "(OSX|IOS*|TVOS*|WATCHOS*)")
+  set(SWIFT_RUNTIME_CRASH_REPORTER_CLIENT_default TRUE)
+else()
+  set(SWIFT_RUNTIME_CRASH_REPORTER_CLIENT_default FALSE)
+endif()
+
 option(SWIFT_RUNTIME_CRASH_REPORTER_CLIENT
     "Whether to enable CrashReporter integration"
-    FALSE)
+    "${SWIFT_RUNTIME_CRASH_REPORTER_CLIENT_default}")
 
 set(SWIFT_DARWIN_XCRUN_TOOLCHAIN "XcodeDefault" CACHE STRING
     "The name of the toolchain to pass to 'xcrun'")

SwiftCompilerSources/Package.swift

@@ -11,7 +11,7 @@ let package = Package(
     .library(
       name: "Swift",
       type: .static,
-      targets: ["SIL", "Optimizer", "ExperimentalRegex"]),
+      targets: ["SIL", "Optimizer", "_RegexParser"]),
   ],
   dependencies: [
   ],
@@ -26,15 +26,22 @@ let package = Package(
           "-cross-module-optimization"
         ])]),
     .target(
-      name: "ExperimentalRegex",
+      name: "_RegexParser",
       dependencies: [],
-      swiftSettings: [SwiftSetting.unsafeFlags([
+      swiftSettings: [
+        .unsafeFlags([
           "-I", "../include/swift",
-          "-cross-module-optimization"
+          "-cross-module-optimization",
+        ]),
+        // Workaround until `_RegexParser` is imported as implementation-only
+        // by `_StringProcessing`.
+        .unsafeFlags([
+          "-Xfrontend",
+          "-disable-implicit-string-processing-module-import"
         ])]),
     .target(
       name: "Optimizer",
-      dependencies: ["SIL", "ExperimentalRegex"],
+      dependencies: ["SIL", "_RegexParser"],
       swiftSettings: [SwiftSetting.unsafeFlags([
           "-I", "../include/swift",
           "-cross-module-optimization"

SwiftCompilerSources/Sources/CMakeLists.txt

@@ -11,7 +11,7 @@
 add_subdirectory(Basic)
 add_subdirectory(AST)
 if(SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING)
-  add_subdirectory(ExperimentalRegex)
+  add_subdirectory(_RegexParser)
 endif()
 add_subdirectory(SIL)
 add_subdirectory(Optimizer)

SwiftCompilerSources/Sources/Optimizer/CMakeLists.txt

@@ -9,7 +9,7 @@
 set(dependencies)
 list(APPEND dependencies Basic SIL)
 if(SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING)
-  list(APPEND dependencies ExperimentalRegex)
+  list(APPEND dependencies _RegexParser)
 endif()
 
 add_swift_compiler_module(Optimizer DEPENDS ${dependencies})

SwiftCompilerSources/Sources/Optimizer/DataStructures/BasicBlockRange.swift

@@ -51,47 +51,62 @@ struct BasicBlockRange : CustomStringConvertible, CustomReflectable {
   /// The dominating begin block.
   let begin: BasicBlock
 
-  /// The exclusive range, i.e. not containing the end blocks.
-  private(set) var range: Stack<BasicBlock>
+  /// The inclusive range, i.e. the exclusive range plus the end blocks.
+  private(set) var inclusiveRange: Stack<BasicBlock>
 
+  /// The exclusive range, i.e. not containing the end blocks.
+  var range: LazyFilterSequence<Stack<BasicBlock>> {
+    inclusiveRange.lazy.filter { contains($0) }
+  }
+
   /// All inserted blocks.
   private(set) var inserted: Stack<BasicBlock>
 
-  private var insertedSet: BasicBlockSet
+  private var wasInserted: BasicBlockSet
+  private var inExclusiveRange: BasicBlockSet
   private var worklist: BasicBlockWorklist
 
   init(begin: BasicBlock, _ context: PassContext) {
     self.begin = begin
-    self.range = Stack(context)
+    self.inclusiveRange = Stack(context)
     self.inserted = Stack(context)
-    self.insertedSet = BasicBlockSet(context)
+    self.wasInserted = BasicBlockSet(context)
+    self.inExclusiveRange = BasicBlockSet(context)
     self.worklist = BasicBlockWorklist(context)
+    worklist.pushIfNotVisited(begin)
   }
 
   /// Insert a potential end block.
   mutating func insert(_ block: BasicBlock) {
-    if !insertedSet.contains(block) {
-      insertedSet.insert(block)
+    if !wasInserted.contains(block) {
+      wasInserted.insert(block)
       inserted.append(block)
     }
-    if block != begin {
-      worklist.pushIfNotVisited(contentsOf: block.predecessors)
-
-      while let b = worklist.pop() {
-        range.append(b)
-        if b != begin {
-          worklist.pushIfNotVisited(contentsOf: b.predecessors)
+    worklist.pushIfNotVisited(block)
+    while let b = worklist.pop() {
+      inclusiveRange.append(b)
+      if b != begin {
+        for pred in b.predecessors {
+          worklist.pushIfNotVisited(pred)
+          inExclusiveRange.insert(pred)
         }
       }
     }
   }
 
+  /// Insert a sequence of potential end blocks.
+  mutating func insert<S: Sequence>(contentsOf other: S) where S.Element == BasicBlock {
+    for block in other {
+      insert(block)
+    }
+  }
+
   /// Returns true if the exclusive range contains `block`.
-  func contains(_ block: BasicBlock) -> Bool { worklist.hasBeenPushed(block) }
+  func contains(_ block: BasicBlock) -> Bool { inExclusiveRange.contains(block) }
 
   /// Returns true if the inclusive range contains `block`.
   func inclusiveRangeContains (_ block: BasicBlock) -> Bool {
-    contains(block) || insertedSet.contains(block)
+    worklist.hasBeenPushed(block)
   }
 
   /// Returns true if the range is valid and that's iff the begin block dominates all blocks of the range.
@@ -104,14 +119,14 @@ struct BasicBlockRange : CustomStringConvertible, CustomReflectable {
 
   /// Returns the end blocks.
   var ends: LazyFilterSequence<Stack<BasicBlock>> {
-    inserted.lazy.filter { !worklist.hasBeenPushed($0) }
+    inserted.lazy.filter { !contains($0) }
   }
 
   /// Returns the exit blocks.
   var exits: LazySequence<FlattenSequence<
-                    LazyMapSequence<Stack<BasicBlock>,
+                    LazyMapSequence<LazyFilterSequence<Stack<BasicBlock>>,
                                     LazyFilterSequence<SuccessorArray>>>> {
-    range.lazy.flatMap {
+    range.flatMap {
       $0.successors.lazy.filter {
         !inclusiveRangeContains($0) || $0 == begin
       }
@@ -124,22 +139,25 @@ struct BasicBlockRange : CustomStringConvertible, CustomReflectable {
   }
 
   var description: String {
-    """
-    begin:     \(begin.name)
-    range:     \(range)
-    ends:      \(ends)
-    exits:     \(exits)
-    interiors: \(interiors)
-    """
+    return (isValid ? "" : "<invalid>\n") +
+      """
+      begin:     \(begin.name)
+      range:     \(range)
+      inclrange: \(inclusiveRange)
+      ends:      \(ends)
+      exits:     \(exits)
+      interiors: \(interiors)
+      """
   }
 
   var customMirror: Mirror { Mirror(self, children: []) }
 
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
     worklist.deinitialize()
+    inExclusiveRange.deinitialize()
+    wasInserted.deinitialize()
     inserted.deinitialize()
-    insertedSet.deinitialize()
-    range.deinitialize()
+    inclusiveRange.deinitialize()
   }
 }