Merge pull request #4398 from swiftwasm/katei/merge-main-2022-04-01

Merge main 2022-04-01

Author: kateinoigakukun

CHANGELOG.md

@@ -5,6 +5,29 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 
 ## Swift 5.7
 
+* [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 +9118,7 @@ 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>
 
 [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,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
 )

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/RangeDumper.swift

@@ -0,0 +1,98 @@
+//===--- RangeDumper.swift - Dumps escape information ----------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 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
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+
+let rangeDumper = FunctionPass(name: "dump-ranges", {
+  (function: Function, context: PassContext) in
+
+  var begin: Instruction?
+  var ends = Stack<Instruction>(context)
+  defer { ends.deinitialize() }
+  var interiors = Stack<Instruction>(context)
+  defer { interiors.deinitialize() }
+  var ins = Stack<Instruction>(context)
+  defer { ins.deinitialize() }
+  var outs = Stack<Instruction>(context)
+  defer { outs.deinitialize() }
+
+  for block in function.blocks {
+    for inst in block.instructions {
+      if let sli = inst as? StringLiteralInst {
+        switch sli.string {
+          case "begin":
+            precondition(begin == nil, "more than one begin instruction")
+            begin = sli
+          case "end":
+            ends.append(sli)
+          case "interior":
+            interiors.append(sli)
+          case "inside":
+            ins.append(sli)
+          case "outside":
+            outs.append(sli)
+          default:
+            break
+        }
+      }
+    }
+  }
+  
+  guard let begin = begin else { return }
+  
+  var instRange = InstructionRange(begin: begin, context)
+  defer { instRange.deinitialize() }
+
+  instRange.insert(contentsOf: ends)
+  instRange.insert(contentsOf: interiors)
+
+  print("Instruction range in \(function.name):")
+  print(instRange)
+  print("Block range in \(function.name):")
+  print(instRange.blockRange)
+  print("End function \(function.name)\n")
+
+  verify(instRange.blockRange, context)
+  
+  for i in ins {
+    precondition(instRange.contains(i))
+    precondition(instRange.inclusiveRangeContains(i))
+  }
+  for e in ends {
+    precondition(!instRange.contains(e))
+    precondition(instRange.inclusiveRangeContains(e))
+  }
+  for o in outs {
+    precondition(!instRange.contains(o))
+    precondition(!instRange.inclusiveRangeContains(o))
+  }
+})
+
+private func verify(_ blockRange: BasicBlockRange, _ context: PassContext) {
+  var inRange = BasicBlockSet(context)
+  defer { inRange.deinitialize() }
+  for b in blockRange.range {
+    inRange.insert(b)
+  }
+
+  var inInclusiveRange = BasicBlockSet(context)
+  defer { inInclusiveRange.deinitialize() }
+  for b in blockRange.inclusiveRange {
+    inInclusiveRange.insert(b)
+  }
+
+  for b in blockRange.begin.function.blocks {
+    precondition(blockRange.contains(b) == inRange.contains(b))
+    precondition(blockRange.inclusiveRangeContains(b) == inInclusiveRange.contains(b))
+  }
+}
+