Merge branch 'main' into ewilde/async-main-resolution

Author: etcwilde

CHANGELOG.md

@@ -5,6 +5,59 @@ _**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
@@ -9095,6 +9148,8 @@ Swift 1.0
 [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>

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,15 @@ let package = Package(
           "-cross-module-optimization"
         ])]),
     .target(
-      name: "ExperimentalRegex",
+      name: "_RegexParser",
       dependencies: [],
       swiftSettings: [SwiftSetting.unsafeFlags([
           "-I", "../include/swift",
           "-cross-module-optimization"
         ])]),
     .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()
   }
 }

SwiftCompilerSources/Sources/Optimizer/DataStructures/InstructionRange.swift

@@ -12,7 +12,7 @@
 
 import SIL
 
-/// A range of basic blocks.
+/// A range of instructions.
 ///
 /// The `InstructionRange` defines a range from a dominating "begin" instruction to one or more "end" instructions.
 /// The range is "exclusive", which means that the "end" instructions are not part of the range.
@@ -60,6 +60,13 @@ struct InstructionRange : CustomStringConvertible, CustomReflectable {
     blockRange.insert(inst.block)
   }
 
+  /// Insert a sequence of potential end instructions.
+  mutating func insert<S: Sequence>(contentsOf other: S) where S.Element == Instruction {
+    for inst in other {
+      insert(inst)
+    }
+  }
+
   /// Returns true if the exclusive range contains `inst`.
   func contains(_ inst: Instruction) -> Bool {
     let block = inst.block
@@ -99,7 +106,7 @@ struct InstructionRange : CustomStringConvertible, CustomReflectable {
 
   /// Returns the exit instructions.
   var exits: LazyMapSequence<LazySequence<FlattenSequence<
-                               LazyMapSequence<Stack<BasicBlock>,
+                               LazyMapSequence<LazyFilterSequence<Stack<BasicBlock>>,
                                                LazyFilterSequence<SuccessorArray>>>>,
                              Instruction> {
     blockRange.exits.lazy.map { $0.instructions.first! }
@@ -116,21 +123,20 @@ struct InstructionRange : CustomStringConvertible, CustomReflectable {
           let isInterior = include
           include = true
           return isInterior
-          
         }
         return false
       }
     }
   }
 
   var description: String {
-    """
-    begin:    \(begin)
-    range:      \(blockRange.range)
-    ends:     \(ends.map { $0.description }.joined(separator: "\n          "))
-    exits:    \(exits.map { $0.description }.joined(separator: "\n          "))
-    interiors:\(interiors.map { $0.description }.joined(separator: "\n          "))
-    """
+    return (isValid ? "" : "<invalid>\n") +
+      """
+      begin:    \(begin)
+      ends:     \(ends.map { $0.description }.joined(separator: "\n          "))
+      exits:    \(exits.map { $0.description }.joined(separator: "\n          "))
+      interiors:\(interiors.map { $0.description }.joined(separator: "\n          "))
+      """
   }
 
   var customMirror: Mirror { Mirror(self, children: []) }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CMakeLists.txt

@@ -10,6 +10,7 @@ swift_compiler_sources(Optimizer
   AssumeSingleThreaded.swift
   SILPrinter.swift
   MergeCondFails.swift
+  RangeDumper.swift
   ReleaseDevirtualizer.swift
   RunUnitTests.swift
 )