Merge main 2023-01-05

CMakeLists.txt

@@ -460,6 +460,7 @@ set(COMPATIBILITY_MINIMUM_DEPLOYMENT_VERSION_OSX "10.9")
 set(COMPATIBILITY_MINIMUM_DEPLOYMENT_VERSION_IOS "7.0")
 set(COMPATIBILITY_MINIMUM_DEPLOYMENT_VERSION_TVOS "9.0")
 set(COMPATIBILITY_MINIMUM_DEPLOYMENT_VERSION_WATCHOS "2.0")
+set(COMPATIBILITY_MINIMUM_DEPLOYMENT_VERSION_MACCATALYST "13.1")
 
 #
 # User-configurable debugging options.
@@ -590,6 +591,13 @@ option(SWIFT_THREADING_PACKAGE
    Valid package names are 'pthreads', 'darwin', 'linux', 'win32', 'c11', 'none'
    or the empty string for the SDK default.")
 
+option(SWIFT_ENABLE_MACCATALYST
+  "Build the Standard Library and overlays with MacCatalyst support"
+  FALSE)
+
+set(SWIFT_DARWIN_DEPLOYMENT_VERSION_MACCATALYST "14.5" CACHE STRING
+  "Minimum deployment target version for macCatalyst")
+
 #
 # End of user-configurable options.
 #

README.md

@@ -37,6 +37,7 @@ to track the status of our builds, please refer to our [GitHub Actions page](htt
 | **CentOS 7** | x86_64 |[![Build Status](https://ci.swift.org/job/oss-swift-package-centos-7/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-centos-7)|
 | **Amazon Linux 2** | x86_64 |[![Build Status](https://ci.swift.org/job/oss-swift-package-amazon-linux-2/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-amazon-linux-2)|
 | **Amazon Linux 2** | AArch64 |[![Build Status](https://ci.swift.org/job/oss-swift-package-amazon-linux-2-aarch64/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-amazon-linux-2-aarch64)|
+| **Universal Base Image 9** | x86_64 |[![Build Status](https://ci.swift.org/job/oss-swift-package-ubi-9/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-ubi-9)|
 
 **Swift Community-Hosted CI Platforms**
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -98,6 +98,11 @@ private struct CollectedEffects {
       addDestroyEffects(of: inst.operands[0].value)
 
     case let da as DestroyAddrInst:
+      // A destroy_addr also involves a read from the address. It's equivalent to a `%x = load [take]` and `destroy_value %x`.
+      addEffects(.read, to: da.operand)
+      // Conceptually, it's also a write, because the stored value is not available anymore after the destroy
+      addEffects(.write, to: da.operand)
+
       addDestroyEffects(of: da.operand)
 
     case let copy as CopyAddrInst:
@@ -108,12 +113,16 @@ private struct CollectedEffects {
         addEffects(.copy, to: copy.source)
       }
       if !copy.isInitializationOfDest {
+        // Like for destroy_addr, the destroy also involves a read.
+        addEffects(.read, to: copy.destination)
         addDestroyEffects(of: copy.destination)
       }
 
     case let store as StoreInst:
       addEffects(.write, to: store.destination)
       if store.destinationOwnership == .assign {
+        // Like for destroy_addr, the destroy also involves a read.
+        addEffects(.read, to: store.destination)
         addDestroyEffects(of: store.destination)
       }
 
@@ -433,7 +442,8 @@ private struct ArgumentEscapingWalker : ValueDefUseWalker, AddressDefUseWalker {
       return .continueWalk
 
     // Warning: all instruction listed here, must also be handled in `CollectedEffects.addInstructionEffects`
-    case is StoreInst, is StoreWeakInst, is StoreUnownedInst, is ApplySite, is DestroyAddrInst:
+    case is StoreInst, is StoreWeakInst, is StoreUnownedInst, is ApplySite, is DestroyAddrInst,
+         is DebugValueInst:
       return .continueWalk
 
     default:

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -810,7 +810,10 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
         switch effect.kind {
         case .escapingToReturn(let toPath, let exclusive):
           if exclusive && path.projectionPath.matches(pattern: toPath) {
-            let arg = apply.arguments[effect.argumentIndex]
+            guard let callerArgIdx = apply.callerArgIndex(calleeArgIndex: effect.argumentIndex) else {
+              return .abortWalk
+            }
+            let arg = apply.arguments[callerArgIdx]
 
             let p = Path(projectionPath: effect.pathPattern, followStores: path.followStores, knownType: nil)
             if walkUp(addressOrValue: arg, path: p) == .abortWalk {

benchmark/CMakeLists.txt

@@ -179,6 +179,7 @@ set(SWIFT_BENCH_MODULES
     single-source/StrToInt
     single-source/StringBuilder
     single-source/StringComparison
+    single-source/StringDistance
     single-source/StringEdits
     single-source/StringEnum
     single-source/StringInterpolation

benchmark/single-source/StringDistance.swift

@@ -0,0 +1,204 @@
+//===--- StringEdits.swift ------------------------------------------------===//
+//
+// 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 TestsUtils
+
+public let benchmarks: [BenchmarkInfo] = [
+  BenchmarkInfo(
+    name: "StringDistance.characters.mixed",
+    runFunction: { n in
+      run_characters(string: mixedString, ranges: mixedRanges, n: n)
+    },
+    tags: [.api, .String],
+    setUpFunction: { blackHole(mixedRanges) }),
+  BenchmarkInfo(
+    name: "StringDistance.scalars.mixed",
+    runFunction: { n in
+      run_scalars(string: mixedString, ranges: mixedRanges, n: n)
+    },
+    tags: [.api, .String],
+    setUpFunction: { blackHole(mixedRanges) }),
+  BenchmarkInfo(
+    name: "StringDistance.utf16.mixed",
+    runFunction: { n in
+      run_utf16(string: mixedString, ranges: mixedRanges, n: n)
+    },
+    tags: [.api, .String],
+    setUpFunction: { blackHole(mixedRanges) }),
+  BenchmarkInfo(
+    name: "StringDistance.utf8.mixed",
+    runFunction: { n in
+      run_utf8(string: mixedString, ranges: mixedRanges, n: n)
+    },
+    tags: [.api, .String],
+    setUpFunction: { blackHole(mixedRanges) }),
+  BenchmarkInfo(
+    name: "StringDistance.characters.ascii",
+    runFunction: { n in
+      run_characters(string: asciiString, ranges: asciiRanges, n: n)
+    },
+    tags: [.api, .String],
+    setUpFunction: { blackHole(asciiRanges) }),
+  BenchmarkInfo(
+    name: "StringDistance.scalars.ascii",
+    runFunction: { n in
+      run_scalars(string: asciiString, ranges: asciiRanges, n: n)
+    },
+    tags: [.api, .String],
+    setUpFunction: { blackHole(asciiRanges) }),
+  BenchmarkInfo(
+    name: "StringDistance.utf16.ascii",
+    runFunction: { n in
+      run_utf16(string: asciiString, ranges: asciiRanges, n: n)
+    },
+    tags: [.api, .String],
+    setUpFunction: { blackHole(asciiRanges) }),
+  BenchmarkInfo(
+    name: "StringDistance.utf8.ascii",
+    runFunction: { n in
+      run_utf8(string: asciiString, ranges: asciiRanges, n: n)
+    },
+    tags: [.api, .String],
+    setUpFunction: { blackHole(asciiRanges) }),
+]
+
+
+let mixedString = #"""
+    The powerful programming language that is also easy to learn.
+    손쉽게 학습할 수 있는 강력한 프로그래밍 언어.
+    🪙 A 🥞 short 🍰 piece 🫘 of 🌰 text 👨‍👨‍👧‍👧 with 👨‍👩‍👦 some 🚶🏽 emoji 🇺🇸🇨🇦 characters 🧈
+    some🔩times 🛺 placed 🎣 in 🥌 the 🆘 mid🔀dle 🇦🇶or🏁 around 🏳️‍🌈 a 🍇 w🍑o🥒r🥨d
+    Unicode is such fun!
+    U̷n̷i̷c̷o̴d̴e̷ ̶i̸s̷ ̸s̵u̵c̸h̷ ̸f̵u̷n̴!̵
+    U̴̡̲͋̾n̵̻̳͌ì̶̠̕c̴̭̈͘ǫ̷̯͋̊d̸͖̩̈̈́ḛ̴́ ̴̟͎͐̈i̴̦̓s̴̜̱͘ ̶̲̮̚s̶̙̞͘u̵͕̯̎̽c̵̛͕̜̓h̶̘̍̽ ̸̜̞̿f̵̤̽ṷ̴͇̎͘ń̷͓̒!̷͍̾̚
+    U̷̢̢̧̨̼̬̰̪͓̞̠͔̗̼̙͕͕̭̻̗̮̮̥̣͉̫͉̬̲̺͍̺͊̂ͅ\#
+    n̶̨̢̨̯͓̹̝̲̣̖̞̼̺̬̤̝̊̌́̑̋̋͜͝ͅ\#
+    ḭ̸̦̺̺͉̳͎́͑\#
+    c̵̛̘̥̮̙̥̟̘̝͙̤̮͉͔̭̺̺̅̀̽̒̽̏̊̆͒͌̂͌̌̓̈́̐̔̿̂͑͠͝͝ͅ\#
+    ö̶̱̠̱̤̙͚͖̳̜̰̹̖̣̻͎͉̞̫̬̯͕̝͔̝̟̘͔̙̪̭̲́̆̂͑̌͂̉̀̓́̏̎̋͗͛͆̌̽͌̄̎̚͝͝͝͝ͅ\#
+    d̶̨̨̡̡͙̟͉̱̗̝͙͍̮͍̘̮͔͑\#
+    e̶̢͕̦̜͔̘̘̝͈̪̖̺̥̺̹͉͎͈̫̯̯̻͑͑̿̽͂̀̽͋́̎̈́̈̿͆̿̒̈́̽̔̇͐͛̀̓͆̏̾̀̌̈́̆̽̕ͅ
+    """#
+
+let mixedRanges = (
+  generateRanges(for: mixedString, by: 1)
+  + generateRanges(for: mixedString, by: 2)
+  + generateRanges(for: mixedString, by: 4)
+  + generateRanges(for: mixedString, by: 8)
+  + generateRanges(for: mixedString, by: 16)
+  + generateRanges(for: mixedString, by: 32)
+  + generateRanges(for: mixedString, by: 64)
+  + generateRanges(for: mixedString, by: 128)
+  + generateRanges(for: mixedString, by: 256)
+  + generateRanges(for: mixedString, by: 512))
+
+let _asciiString = #"""
+  Swift is a high-performance system programming language.  It has a clean
+  and modern syntax, offers seamless access to existing C and Objective-C code
+  and frameworks, and is memory safe by default.
+
+  Although inspired by Objective-C and many other languages, Swift is not itself
+  a C-derived language. As a complete and independent language, Swift packages
+  core features like flow control, data structures, and functions, with
+  high-level constructs like objects, protocols, closures, and generics. Swift
+  embraces modules, eliminating the need for headers and the code duplication
+  they entail.
+
+  Swift toolchains are created using the script
+  [build-toolchain](https://github.com/apple/swift/blob/main/utils/build-toolchain).
+  This script is used by swift.org's CI to produce snapshots and can allow for
+  one to locally reproduce such builds for development or distribution purposes.
+  A typical invocation looks like the following:
+
+  ```
+    $ ./swift/utils/build-toolchain $BUNDLE_PREFIX
+  ```
+
+  where ``$BUNDLE_PREFIX`` is a string that will be prepended to the build date
+  to give the bundle identifier of the toolchain's ``Info.plist``. For instance,
+  if ``$BUNDLE_PREFIX`` was ``com.example``, the toolchain produced will have
+  the bundle identifier ``com.example.YYYYMMDD``. It will be created in the
+  directory you run the script with a filename of the form:
+  ``swift-LOCAL-YYYY-MM-DD-a-osx.tar.gz``.
+  """#
+let asciiString = String(repeating: _asciiString, count: 10)
+
+let asciiRanges = (
+  generateRanges(for: asciiString, by: 1)
+  + generateRanges(for: asciiString, by: 2)
+  + generateRanges(for: asciiString, by: 4)
+  + generateRanges(for: asciiString, by: 8)
+  + generateRanges(for: asciiString, by: 16)
+  + generateRanges(for: asciiString, by: 32)
+  + generateRanges(for: asciiString, by: 64)
+  + generateRanges(for: asciiString, by: 128)
+  + generateRanges(for: asciiString, by: 256)
+  + generateRanges(for: asciiString, by: 512))
+
+func generateRanges(for string: String, by step: Int) -> [Range<String.Index>] {
+  var remaining = step
+  var i = string.startIndex
+  var last = i
+
+  var ranges: [Range<String.Index>] = []
+  while i < string.endIndex {
+    string.unicodeScalars.formIndex(after: &i)
+    remaining -= 1
+    if remaining == 0 {
+      ranges.append(last ..< i)
+      remaining = step
+      last = i
+    }
+  }
+  ranges.append(last ..< i)
+  return ranges
+}
+
+func run_characters(string: String, ranges: [Range<String.Index>], n: Int) {
+  var c = 0
+  for _ in 0 ..< n {
+    for r in ranges {
+      c += string.distance(from: r.lowerBound, to: r.upperBound)
+    }
+  }
+  blackHole(c)
+}
+
+func run_scalars(string: String, ranges: [Range<String.Index>], n: Int) {
+  var c = 0
+  for _ in 0 ..< n {
+    for r in ranges {
+      c += string.unicodeScalars.distance(from: r.lowerBound, to: r.upperBound)
+    }
+  }
+  blackHole(c)
+}
+
+func run_utf16(string: String, ranges: [Range<String.Index>], n: Int) {
+  var c = 0
+  for _ in 0 ..< n {
+    for r in ranges {
+      c += string.utf16.distance(from: r.lowerBound, to: r.upperBound)
+    }
+  }
+  blackHole(c)
+}
+
+func run_utf8(string: String, ranges: [Range<String.Index>], n: Int) {
+  var c = 0
+  for _ in 0 ..< n {
+    for r in ranges {
+      c += string.utf8.distance(from: r.lowerBound, to: r.upperBound)
+    }
+  }
+  blackHole(c)
+}

benchmark/utils/main.swift

@@ -178,6 +178,7 @@ import StrComplexWalk
 import StrToInt
 import StringBuilder
 import StringComparison
+import StringDistance
 import StringEdits
 import StringEnum
 import StringInterpolation
@@ -362,9 +363,10 @@ register(StaticArray.benchmarks)
 register(StrComplexWalk.benchmarks)
 register(StrToInt.benchmarks)
 register(StringBuilder.benchmarks)
+register(StringComparison.benchmarks)
+register(StringDistance.benchmarks)
 register(StringEdits.benchmarks)
 register(StringEnum.benchmarks)
-register(StringComparison.benchmarks)
 register(StringInterpolation.benchmarks)
 register(StringMatch.benchmarks)
 register(StringRemoveDupes.benchmarks)

docs/CppInteroperability/CppInteroperabilityManifesto.md

@@ -67,7 +67,7 @@ Assumptions:
     + [Function templates: calls with generic type parameters](#function-templates-calls-with-generic-type-parameters)
     + [Function templates: importing as real generic functions](#function-templates-importing-as-real-generic-functions)
     + [Class templates](#class-templates)
-    + [Class templates: importing instantiation behind typedef](#class-templates-importing-instantiation-behind-typedef)
+    + [Class templates: importing full class template instantiations](#class-templates-importing-full-class-template-instantiations)
     + [Class templates: importing specific specializations](#class-templates-importing-specific-specializations)
     + [Class templates: using with generic type parameters](#class-templates-using-with-generic-type-parameters)
     + [Class templates: using in generic code through a synthesized protocol](#class-templates-using-in-generic-code-through-a-synthesized-protocol)
@@ -184,7 +184,7 @@ that pick different sides, forcing the user to choose.
 
 Swift/C++ interoperability builds on top of the Swift/C interoperability, so it
 helps to be familiar with [Swift's strategy for importing C
-modules](HowSwiftImportsCAPIs.md).
+modules](../HowSwiftImportsCAPIs.md).
 
 # Importing C++ APIs into Swift