[swift/main] Merge performance improvements into swift/main

Package.swift

@@ -11,7 +11,11 @@ let availabilityDefinition = PackageDescription.SwiftSetting.unsafeFlags([
     "-Xfrontend",
     "-define-availability",
     "-Xfrontend",
-    "SwiftStdlib 5.8:macOS 9999, iOS 9999, watchOS 9999, tvOS 9999",
+    "SwiftStdlib 5.8:macOS 13.3, iOS 16.4, watchOS 9.4, tvOS 16.4",
+    "-Xfrontend",
+    "-define-availability",
+    "-Xfrontend",
+    "SwiftStdlib 5.9:macOS 9999, iOS 9999, watchOS 9999, tvOS 9999",
 ])
 
 /// Swift settings for building a private stdlib-like module that is to be used
@@ -128,7 +132,8 @@ let package = Package(
                 .product(name: "ArgumentParser", package: "swift-argument-parser"),
                 "_RegexParser",
                 "_StringProcessing"
-            ]),
+            ],
+            swiftSettings: [availabilityDefinition]),
         .executableTarget(
             name: "RegexBenchmark",
             dependencies: [

Sources/RegexTester/RegexTester.swift

@@ -14,7 +14,7 @@ import _RegexParser
 import _StringProcessing
 
 @main
-@available(macOS 9999, *)
+@available(SwiftStdlib 5.8, *)
 struct RegexTester: ParsableCommand {
   typealias MatchFunctionType = (String) throws -> Regex<AnyRegexOutput>.Match?
 

Sources/_RegexParser/Regex/AST/MatchingOptions.swift

@@ -44,7 +44,7 @@ extension AST {
 
       // Swift-only default possessive quantifier
       case possessiveByDefault      // t.b.d.
-
+      
       // NSRegularExpression compatibility special-case
       case nsreCompatibleDot        // no AST representation
     }

Sources/_StringProcessing/Algorithms/Algorithms/Trim.swift

@@ -81,13 +81,11 @@ extension RangeReplaceableCollection {
 // MARK: Fixed pattern algorithms
 
 extension Collection where Element: Equatable {
-  /// Returns a new collection of the same type by removing initial elements
-  /// that satisfy the given predicate from the start.
-  /// - Parameter predicate: A closure that takes an element of the sequence
-  /// as its argument and returns a Boolean value indicating whether the
-  /// element should be removed from the collection.
+  /// Returns a new collection of the same type by removing `prefix` from the start
+  /// of the collection.
+  /// - Parameter prefix: The collection to remove from this collection.
   /// - Returns: A collection containing the elements of the collection that are
-  ///  not removed by `predicate`.
+  ///  not removed by `prefix`.
   @available(SwiftStdlib 5.7, *)
   public func trimmingPrefix<Prefix: Sequence>(
     _ prefix: Prefix
@@ -97,11 +95,8 @@ extension Collection where Element: Equatable {
 }
 
 extension Collection where SubSequence == Self, Element: Equatable {
-  /// Removes the initial elements that satisfy the given predicate from the
-  /// start of the sequence.
-  /// - Parameter predicate: A closure that takes an element of the sequence
-  /// as its argument and returns a Boolean value indicating whether the
-  /// element should be removed from the collection.
+  /// Removes `prefix` from the start of the collection.
+  /// - Parameter prefix: The collection to remove from this collection.
   @available(SwiftStdlib 5.7, *)
   public mutating func trimPrefix<Prefix: Sequence>(
     _ prefix: Prefix
@@ -111,11 +106,8 @@ extension Collection where SubSequence == Self, Element: Equatable {
 }
 
 extension RangeReplaceableCollection where Element: Equatable {
-  /// Removes the initial elements that satisfy the given predicate from the
-  /// start of the sequence.
-  /// - Parameter predicate: A closure that takes an element of the sequence
-  /// as its argument and returns a Boolean value indicating whether the
-  /// element should be removed from the collection.
+  /// Removes `prefix` from the start of the collection.
+  /// - Parameter prefix: The collection to remove from this collection.
   @available(SwiftStdlib 5.7, *)
   public mutating func trimPrefix<Prefix: Sequence>(
     _ prefix: Prefix
@@ -127,11 +119,11 @@ extension RangeReplaceableCollection where Element: Equatable {
 // MARK: Regex algorithms
 
 extension BidirectionalCollection where SubSequence == Substring {
-  /// Returns a new collection of the same type by removing `prefix` from the
-  /// start.
-  /// - Parameter prefix: The collection to remove from this collection.
+  /// Returns a new collection of the same type by removing the initial elements
+  /// that matches the given regex.
+  /// - Parameter regex: The regex to remove from this collection.
   /// - Returns: A collection containing the elements that does not match
-  /// `prefix` from the start.
+  /// `regex` from the start.
   @_disfavoredOverload
   @available(SwiftStdlib 5.7, *)
   public func trimmingPrefix(_ regex: some RegexComponent) -> SubSequence {

Sources/_StringProcessing/ByteCodeGen.swift

@@ -465,16 +465,16 @@ fileprivate extension Compiler.ByteCodeGen {
     assert(high != 0)
     assert((0...(high ?? Int.max)).contains(low))
 
-    let extraTrips: Int?
+    let maxExtraTrips: Int?
     if let h = high {
-      extraTrips = h - low
+      maxExtraTrips = h - low
     } else {
-      extraTrips = nil
+      maxExtraTrips = nil
     }
     let minTrips = low
-    assert((extraTrips ?? 1) >= 0)
+    assert((maxExtraTrips ?? 1) >= 0)
 
-    if tryEmitFastQuant(child, updatedKind, minTrips, extraTrips) {
+    if tryEmitFastQuant(child, updatedKind, minTrips, maxExtraTrips) {
       return
     }
 
@@ -492,19 +492,19 @@ fileprivate extension Compiler.ByteCodeGen {
           decrement %minTrips and fallthrough
 
       loop-body:
-        <if can't guarantee forward progress && extraTrips = nil>:
+        <if can't guarantee forward progress && maxExtraTrips = nil>:
           mov currentPosition %pos
         evaluate the subexpression
-        <if can't guarantee forward progress && extraTrips = nil>:
+        <if can't guarantee forward progress && maxExtraTrips = nil>:
           if %pos is currentPosition:
             goto exit
         goto min-trip-count control block
 
       exit-policy control block:
-        if %extraTrips is zero:
+        if %maxExtraTrips is zero:
           goto exit
         else:
-          decrement %extraTrips and fallthrough
+          decrement %maxExtraTrips and fallthrough
 
         <if eager>:
           save exit and goto loop-body
@@ -531,12 +531,12 @@ fileprivate extension Compiler.ByteCodeGen {
           /* fallthrough */
     """
 
-    // Specialization based on `extraTrips` for 0 or unbounded
+    // Specialization based on `maxExtraTrips` for 0 or unbounded
     _ = """
       exit-policy control block:
-        <if extraTrips == 0>:
+        <if maxExtraTrips == 0>:
           goto exit
-        <if extraTrips == .unbounded>:
+        <if maxExtraTrips == .unbounded>:
           /* fallthrough */
     """
 
@@ -569,12 +569,12 @@ fileprivate extension Compiler.ByteCodeGen {
       minTripsReg = nil
     }
 
-    let extraTripsReg: IntRegister?
-    if (extraTrips ?? 0) > 0 {
-      extraTripsReg = builder.makeIntRegister(
-        initialValue: extraTrips!)
+    let maxExtraTripsReg: IntRegister?
+    if (maxExtraTrips ?? 0) > 0 {
+      maxExtraTripsReg = builder.makeIntRegister(
+        initialValue: maxExtraTrips!)
     } else {
-      extraTripsReg = nil
+      maxExtraTripsReg = nil
     }
 
     // Set up a dummy save point for possessive to update
@@ -606,7 +606,7 @@ fileprivate extension Compiler.ByteCodeGen {
     let startPosition: PositionRegister?
     let emitPositionChecking =
       (!optimizationsEnabled || !child.guaranteesForwardProgress) &&
-      extraTrips == nil
+      maxExtraTrips == nil
 
     if emitPositionChecking {
       startPosition = builder.makePositionRegister()
@@ -616,7 +616,7 @@ fileprivate extension Compiler.ByteCodeGen {
     }
     try emitNode(child)
     if emitPositionChecking {
-      // in all quantifier cases, no matter what minTrips or extraTrips is,
+      // in all quantifier cases, no matter what minTrips or maxExtraTrips is,
       // if we have a successful non-advancing match, branch to exit because it
       // can match an arbitrary number of times
       builder.buildCondBranch(to: exit, ifSamePositionAs: startPosition!)
@@ -629,20 +629,20 @@ fileprivate extension Compiler.ByteCodeGen {
     }
 
     // exit-policy:
-    //   condBranch(to: exit, ifZeroElseDecrement: %extraTrips)
+    //   condBranch(to: exit, ifZeroElseDecrement: %maxExtraTrips)
     //   <eager: split(to: loop, saving: exit)>
     //   <possesive:
     //     clearSavePoint
     //     split(to: loop, saving: exit)>
     //   <reluctant: save(restoringAt: loop)
     builder.label(exitPolicy)
-    switch extraTrips {
+    switch maxExtraTrips {
     case nil: break
     case 0:   builder.buildBranch(to: exit)
     default:
-      assert(extraTripsReg != nil, "logic inconsistency")
+      assert(maxExtraTripsReg != nil, "logic inconsistency")
       builder.buildCondBranch(
-        to: exit, ifZeroElseDecrement: extraTripsReg!)
+        to: exit, ifZeroElseDecrement: maxExtraTripsReg!)
     }
 
     switch updatedKind {
@@ -672,12 +672,12 @@ fileprivate extension Compiler.ByteCodeGen {
     _ child: DSLTree.Node,
     _ kind: AST.Quantification.Kind,
     _ minTrips: Int,
-    _ extraTrips: Int?
+    _ maxExtraTrips: Int?
   ) -> Bool {
     let isScalarSemantics = options.semanticLevel == .unicodeScalar
     guard optimizationsEnabled
             && minTrips <= QuantifyPayload.maxStorableTrips
-            && extraTrips ?? 0 <= QuantifyPayload.maxStorableTrips
+            && maxExtraTrips ?? 0 <= QuantifyPayload.maxStorableTrips
             && kind != .reluctant else {
       return false
     }
@@ -687,7 +687,7 @@ fileprivate extension Compiler.ByteCodeGen {
       guard let bitset = ccc.asAsciiBitset(options) else {
         return false
       }
-      builder.buildQuantify(bitset: bitset, kind, minTrips, extraTrips, isScalarSemantics: isScalarSemantics)
+      builder.buildQuantify(bitset: bitset, kind, minTrips, maxExtraTrips, isScalarSemantics: isScalarSemantics)
 
     case .atom(let atom):
       switch atom {
@@ -696,17 +696,17 @@ fileprivate extension Compiler.ByteCodeGen {
         guard let val = c._singleScalarAsciiValue else {
           return false
         }
-        builder.buildQuantify(asciiChar: val, kind, minTrips, extraTrips, isScalarSemantics: isScalarSemantics)
+        builder.buildQuantify(asciiChar: val, kind, minTrips, maxExtraTrips, isScalarSemantics: isScalarSemantics)
 
       case .any:
         builder.buildQuantifyAny(
-          matchesNewlines: true, kind, minTrips, extraTrips, isScalarSemantics: isScalarSemantics)
+          matchesNewlines: true, kind, minTrips, maxExtraTrips, isScalarSemantics: isScalarSemantics)
       case .anyNonNewline:
         builder.buildQuantifyAny(
-          matchesNewlines: false, kind, minTrips, extraTrips, isScalarSemantics: isScalarSemantics)
+          matchesNewlines: false, kind, minTrips, maxExtraTrips, isScalarSemantics: isScalarSemantics)
       case .dot:
         builder.buildQuantifyAny(
-          matchesNewlines: options.dotMatchesNewline, kind, minTrips, extraTrips, isScalarSemantics: isScalarSemantics)
+          matchesNewlines: options.dotMatchesNewline, kind, minTrips, maxExtraTrips, isScalarSemantics: isScalarSemantics)
 
       case .characterClass(let cc):
         // Custom character class that consumes a single grapheme
@@ -715,19 +715,19 @@ fileprivate extension Compiler.ByteCodeGen {
           model: model,
           kind,
           minTrips,
-          extraTrips,
+          maxExtraTrips,
           isScalarSemantics: isScalarSemantics)
       default:
         return false
       }
     case .convertedRegexLiteral(let node, _):
-      return tryEmitFastQuant(node, kind, minTrips, extraTrips)
+      return tryEmitFastQuant(node, kind, minTrips, maxExtraTrips)
     case .nonCapturingGroup(let groupKind, let node):
       // .nonCapture nonCapturingGroups are ignored during compilation
       guard groupKind.ast == .nonCapture else {
         return false
       }
-      return tryEmitFastQuant(node, kind, minTrips, extraTrips)
+      return tryEmitFastQuant(node, kind, minTrips, maxExtraTrips)
     default:
       return false
     }