Merge branch 'apple:main' into fix-it-for-repeated-any-or-some-in-composition

Author: moritzdietsche

CHANGELOG.md

@@ -330,7 +330,7 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 
 * [SE-0328][]:
 
-  Opaque types (expressed with 'some') can now be used in structural positions
+  Opaque types (expressed with `some`) can now be used in structural positions
   within a result type, including having multiple opaque types in the same
   result. For example:
 
@@ -942,7 +942,7 @@ Swift 5.5
   }
   ```
 
-* The 'lazy' keyword now works in local contexts, making the following valid:
+* The `lazy` keyword now works in local contexts, making the following valid:
 
   ```swift
   func test(useIt: Bool) {
@@ -2901,7 +2901,7 @@ Swift 3.0
 
 * [SE-0101][]:
 
- The functions `sizeof()`, `strideof()`, and `alignof()` have been removed.
+  The functions `sizeof()`, `strideof()`, and `alignof()` have been removed.
   Memory layout properties for a type `T` are now spelled
   `MemoryLayout<T>.size`, `MemoryLayout<T>.stride`, and
   `MemoryLayout<T>.alignment`, respectively.
@@ -2943,7 +2943,7 @@ Swift 3.0
 
 * [SE-0124][]:
 
- Initializers on `Int` and `UInt` that accept an `ObjectIdentifier` must now use an explicit `bitPattern` label.
+  Initializers on `Int` and `UInt` that accept an `ObjectIdentifier` must now use an explicit `bitPattern` label.
 
   ```swift
   let x: ObjectIdentifier = ...
@@ -3199,7 +3199,7 @@ using the `.dynamicType` member to retrieve the type of an expression should mig
     didFailToRegisterForRemoteNotificationsWithError error: NSError)
   ```
 
- Now it accepts an `Error` argument:
+  Now it accepts an `Error` argument:
 
   ```swift
   optional func application(_ application: UIApplication,
@@ -3422,7 +3422,7 @@ using the `.dynamicType` member to retrieve the type of an expression should mig
   foo/* comment */! // no longer works
   ```
 
- Parse errors resulting from this change can be resolved by moving the comment outside the expression.
+  Parse errors resulting from this change can be resolved by moving the comment outside the expression.
 
 * [SE-0031][]:
 
@@ -3483,7 +3483,7 @@ using the `.dynamicType` member to retrieve the type of an expression should mig
   Attributes change from using `=` in parameters lists
   to using `:`, aligning with function call syntax.
 
-  ```
+  ```swift
   // before
   @available(*, unavailable, renamed="MyRenamedProtocol")
 
@@ -3524,13 +3524,13 @@ using the `.dynamicType` member to retrieve the type of an expression should mig
 
   Curried function syntax (with successive parenthesized groups of arguments) is removed, and now produces a compile-time error. Use chained functional return types instead.
 
-```
-// Before
-public func project(function f: FunctionType)(p0: CGPoint, p1: CGPoint)(x: CGFloat) -> CGPoint
+  ```swift
+  // Before
+  public func project(function f: FunctionType)(p0: CGPoint, p1: CGPoint)(x: CGFloat) -> CGPoint
 
-// After
-public func project(function f: FunctionType) -> (p0: CGPoint, p1: CGPoint) -> (x: CGFloat) -> CGPoint
-```
+  // After
+  public func project(function f: FunctionType) -> (p0: CGPoint, p1: CGPoint) -> (x: CGFloat) -> CGPoint
+  ```
 
 * Generic signatures can now contain superclass requirements with generic parameter types, for example:
 
@@ -4877,11 +4877,15 @@ Swift 1.2
 * The `@autoclosure` attribute is now an attribute on a parameter, not an
   attribute on the parameter's type.
 
-  Where before you might have used:
+  Where before you might have used
 
   ```swift
   func assert(predicate : @autoclosure () -> Bool) {...}
-  you now write this as:
+  ```
+
+  you now write this as
+
+  ```swift
   func assert(@autoclosure predicate : () -> Bool) {...}
   ```
 
@@ -4923,7 +4927,11 @@ Swift 1.2
       // redeclares Objective-C method
       //'setProperty:'
   }
+  ```
+
   Similar checking applies to accidental overrides in the Objective-C runtime:
+
+  ```swift
   class B : NSObject {
   func method(arg: String) { }     // note: overridden declaration
       // here has type '(String) -> ()'
@@ -4934,7 +4942,11 @@ Swift 1.2
       // selector 'method:' has incompatible
       // type '([String]) -> ()'
   }
+  ```
+
   as well as protocol conformances:
+
+  ```swift
   class MyDelegate : NSObject, NSURLSessionDelegate {
   func URLSession(session: NSURLSession, didBecomeInvalidWithError:
       Bool){ } // error: Objective-C method 'URLSession:didBecomeInvalidWithError:'
@@ -5022,13 +5034,17 @@ Swift 1.2
   that used `unsafeBitCast` as a workaround for this issue can be written to
   use the raw value initializer.
 
-  For example:
+  For example,
 
   ```swift
   let animationCurve =
     unsafeBitCast(userInfo[UIKeyboardAnimationCurveUserInfoKey].integerValue,
     UIViewAnimationCurve.self)
-  can now be written instead as:
+  ```
+
+  can now be written instead as
+
+  ```swift
   let animationCurve = UIViewAnimationCurve(rawValue:
     userInfo[UIKeyboardAnimationCurveUserInfoKey].integerValue)!
   ```

CMakeLists.txt

@@ -179,7 +179,7 @@ set(SWIFT_ANALYZE_CODE_COVERAGE FALSE CACHE STRING
 # SWIFT_VERSION is deliberately /not/ cached so that an existing build directory
 # can be reused when a new version of Swift comes out (assuming the user hasn't
 # manually set it as part of their own CMake configuration).
-set(SWIFT_VERSION "5.7")
+set(SWIFT_VERSION "5.8")
 
 set(SWIFT_VENDOR "" CACHE STRING
     "The vendor name of the Swift compiler")

SwiftCompilerSources/.gitignore

@@ -0,0 +1 @@
+.swiftpm

SwiftCompilerSources/CMakeLists.txt

@@ -171,19 +171,16 @@ function(add_swift_compiler_modules_library name)
   endforeach()
 
   # Create a static library containing all module object files.
+  if (XCODE)
+    # Xcode does not compile libraries that contain only object files.
+    # Therefore, it fails to create the static library. As a workaround,
+    # we add an empty source file force_lib.c to the target.
+    set(all_obj_files force_lib.c ${all_obj_files})
+  endif()
   add_library(${name} STATIC ${all_obj_files})
   add_dependencies(${name} ${all_module_targets})
   set_target_properties(${name} PROPERTIES LINKER_LANGUAGE CXX)
   set_property(GLOBAL APPEND PROPERTY SWIFT_BUILDTREE_EXPORTS ${name})
-
-  # Xcode does not compile libraries that contain only object files.
-  # Therefore, it fails to create the static library. As a workaround,
-  # we add a dummy script phase to the target.
-  if (XCODE)
-    add_custom_command(TARGET ${name} POST_BUILD 
-      COMMAND ""
-      COMMENT "Dummy script phase to force building this target")
-  endif()
 endfunction()
 
 
@@ -267,25 +264,3 @@ else()
   endif()
 
 endif()
-
-# Configure 'SwiftCompilerModules' SwiftPM package. The 'Package.swift' will
-# be created at '${build_dir}/SwiftCompilerModulesPackage/Package.swift' and can
-# be built with 'swift-build'.
-# Note that this SwiftPM package itself is just for development purposes, and
-# is not actually used for the compiler building. 
-set(swiftcompiler_modules_package_directory
-    "${SWIFT_BINARY_DIR}/SwiftCompilerModulesPackage")
-configure_file(Package.swift.in
-  "${swiftcompiler_modules_package_directory}/Package.swift" @ONLY)
-# SwiftPM requires all sources are inside the directory of 'Package.swift'.
-# Create symlinks to the actual source directories.
-execute_process(COMMAND
-  "${CMAKE_COMMAND}" -E create_symlink
-  "${CMAKE_CURRENT_SOURCE_DIR}/Sources"
-  "${swiftcompiler_modules_package_directory}/Sources")
-if(SWIFT_BUILD_REGEX_PARSER_IN_COMPILER)
-  execute_process(COMMAND
-    "${CMAKE_COMMAND}" -E create_symlink
-    "${EXPERIMENTAL_STRING_PROCESSING_SOURCE_DIR}/Sources/_RegexParser"
-    "${swiftcompiler_modules_package_directory}/_RegexParser_Sources")
-endif()

SwiftCompilerSources/Package.swift.in renamed to SwiftCompilerSources/Package.swift

@@ -11,10 +11,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-// NOTE: This 'Package.swift.in' file is for CMake configure_file().
-// Generated 'Package.swift' can be found in
-// '${swift_build_dir}/SwiftCompilerSources/Package.swift'.
-
 import PackageDescription
 
 private extension Target {
@@ -23,9 +19,7 @@ private extension Target {
       "-Xfrontend", "-validate-tbd-against-ir=none",
       "-Xfrontend", "-enable-cxx-interop",
       // Bridging modules and headers
-      "-Xcc", "-I", "-Xcc", "@SWIFT_SOURCE_DIR@/include",
-      // Generated C headers
-      "-Xcc", "-I", "-Xcc", "@CMAKE_BINARY_DIR@/include",
+      "-Xcc", "-I", "-Xcc", "../include",
       "-cross-module-optimization"
     ]),
   ]

SwiftCompilerSources/Sources/Basic/Utils.swift

@@ -12,6 +12,30 @@
 
 @_exported import BasicBridging
 
+//===----------------------------------------------------------------------===//
+//                              StringRef
+//===----------------------------------------------------------------------===//
+
+public struct StringRef : CustomStringConvertible, CustomReflectable {
+  let _bridged : BridgedStringRef
+
+  public init(bridged: BridgedStringRef) { self._bridged = bridged }
+
+  public var string: String { _bridged.string }
+  public var description: String { string }
+  public var customMirror: Mirror { Mirror(self, children: []) }
+  
+  public static func ==(lhs: StringRef, rhs: StaticString) -> Bool {
+    let lhsBuffer = UnsafeBufferPointer<UInt8>(start: lhs._bridged.data, count: Int(lhs._bridged.length))
+    return rhs.withUTF8Buffer { (rhsBuffer: UnsafeBufferPointer<UInt8>) in
+      if lhsBuffer.count != rhsBuffer.count { return false }
+      return lhsBuffer.elementsEqual(rhsBuffer, by: ==)
+    }
+  }
+  
+  public static func !=(lhs: StringRef, rhs: StaticString) -> Bool { !(lhs == rhs) }
+}
+
 //===----------------------------------------------------------------------===//
 //                            Bridging Utilities
 //===----------------------------------------------------------------------===//

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AssumeSingleThreaded.swift

@@ -33,7 +33,7 @@ let assumeSingleThreadedPass = FunctionPass(
       for inst in block.instructions {
         guard let rcInst = inst as? RefCountingInst else { continue }
 
-        context.setAtomicity(of: rcInst, isAtomic: false)
+        rcInst.setAtomicity(isAtomic: false, context)
       }
     }
   }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/StackPromotion.swift

@@ -207,7 +207,8 @@ private extension EscapeInfo {
     var dominatingBlock = value.block
 
     _ = isEscaping(object: value, visitUse: { op, _, _ in
-        if let defBlock = op.value.definingBlock, defBlock.dominates(dominatingBlock, domTree) {
+        let defBlock = op.value.definingBlock
+        if defBlock.dominates(dominatingBlock, domTree) {
           dominatingBlock = defBlock
         }
         return .continueWalking
@@ -230,25 +231,25 @@ private extension EscapeInfo {
         outerBlockRange.insert(user.block)
 
         let val = op.value
-        if let defBlock = val.definingBlock {
-          // Also insert the operand's definition. Otherwise we would miss allocation
-          // instructions (for which the `visitUse` closure is not called).
-          outerBlockRange.insert(defBlock)
-          
-          // We need to explicitly add predecessor blocks of phi-arguments becaues they
-          // are not necesesarily visited by `EscapeInfo.walkDown`.
-          // This is important for the special case where there is a back-edge from the
-          // inner range to the inner rage's begin-block:
-          //
-          //   bb0:                      // <- need to be in the outer range
-          //     br bb1(%some_init_val)
-          //   bb1(%arg):
-          //     %k = alloc_ref $Klass   // innerInstRange.begin
-          //     cond_br bb2, bb1(%k)    // back-edge to bb1 == innerInstRange.blockRange.begin
-          //
-          if val is BlockArgument {
-            outerBlockRange.insert(contentsOf: defBlock.predecessors)
-          }
+        let defBlock = val.definingBlock
+
+        // Also insert the operand's definition. Otherwise we would miss allocation
+        // instructions (for which the `visitUse` closure is not called).
+        outerBlockRange.insert(defBlock)
+        
+        // We need to explicitly add predecessor blocks of phi-arguments becaues they
+        // are not necesesarily visited by `EscapeInfo.walkDown`.
+        // This is important for the special case where there is a back-edge from the
+        // inner range to the inner rage's begin-block:
+        //
+        //   bb0:                      // <- need to be in the outer range
+        //     br bb1(%some_init_val)
+        //   bb1(%arg):
+        //     %k = alloc_ref $Klass   // innerInstRange.begin
+        //     cond_br bb2, bb1(%k)    // back-edge to bb1 == innerInstRange.blockRange.begin
+        //
+        if val is BlockArgument {
+          outerBlockRange.insert(contentsOf: defBlock.predecessors)
         }
         return .continueWalking
       })

SwiftCompilerSources/Sources/Optimizer/InstructionPasses/SimplifyBeginCOWMutation.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import Basic
 import SIL
 
 /// Simplify begin_cow_mutation instructions.
@@ -66,7 +67,7 @@ private func optimizeEmptySingleton(_ beginCOW: BeginCOWMutationInst,
   }
   let builder = Builder(at: beginCOW, location: beginCOW.location, context)
   let zero = builder.createIntegerLiteral(0, type: beginCOW.uniquenessResult.type);
-  context.replaceAllUses(of: beginCOW.uniquenessResult, with: zero)
+  beginCOW.uniquenessResult.uses.replaceAll(with: zero, context)
 }
 
 private func isEmptyCOWSingleton(_ value: Value) -> Bool {
@@ -102,7 +103,7 @@ private func optimizeEmptyBeginEndPair(_ beginCOW: BeginCOWMutationInst,
 
   for use in buffer.nonDebugUses {
     let endCOW = use.instruction as! EndCOWMutationInst
-    context.replaceAllUses(of: endCOW, with: beginCOW.operand)
+    endCOW.uses.replaceAll(with: beginCOW.operand, context)
     context.erase(instruction: endCOW)
   }
   context.erase(instruction: beginCOW, .includingDebugUses)
@@ -121,7 +122,7 @@ private func optimizeEmptyEndBeginPair(_ beginCOW: BeginCOWMutationInst,
     return false
   }
 
-  context.replaceAllUses(of: beginCOW.bufferResult, with: endCOW.operand)
+  beginCOW.bufferResult.uses.replaceAll(with: endCOW.operand, context)
   context.erase(instruction: beginCOW, .includingDebugUses)
   context.erase(instruction: endCOW, .includingDebugUses)
   return true

SwiftCompilerSources/Sources/Optimizer/InstructionPasses/SimplifyStrongRetainRelease.swift

@@ -59,7 +59,7 @@ let simplifyStrongReleasePass = InstructionPass<StrongReleaseInst>(
   // release of the class, squish the conversion.
   if let ier = op as? InitExistentialRefInst {
     if ier.uses.isSingleUse {
-      context.setOperand(of: release, at: 0, to: ier.operand)
+      release.setOperand(at: 0, to: ier.operand, context)
       context.erase(instruction: ier)
       return
     }