From c05e499eea19f31261b42cf97a5d5e0b0b419429 Mon Sep 17 00:00:00 2001
From: Nate Cook <natecook@apple.com>
Date: Thu, 16 Oct 2025 10:52:22 -0500
Subject: [PATCH] Add a 'compile-once-test' subcommand

Adds a new subcommand to the RegexTester executable that demonstrates
the difference between using regex patterns in different locations:
- statically created
- local to a function, but outside a loop
- local to a function, inside a loop

The compiler currently does not hoist the regex out of the loop, so
it pays the parse/compile cost during every iteration.
---
 Sources/RegexTester/CompileOnceTest.swift | 119 ++++++++++++++++++++++
 Sources/RegexTester/Main.swift            |  24 +++++
 Sources/RegexTester/RegexTester.swift     |   7 +-
 3 files changed, 148 insertions(+), 2 deletions(-)
 create mode 100644 Sources/RegexTester/CompileOnceTest.swift
 create mode 100644 Sources/RegexTester/Main.swift

diff --git a/Sources/RegexTester/CompileOnceTest.swift b/Sources/RegexTester/CompileOnceTest.swift
new file mode 100644
index 000000000..56de4afd8
--- /dev/null
+++ b/Sources/RegexTester/CompileOnceTest.swift
@@ -0,0 +1,119 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2021-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
+//
+//===----------------------------------------------------------------------===//
+
+import ArgumentParser
+import _RegexParser
+import _StringProcessing
+import Foundation
+
+@available(SwiftStdlib 5.8, *)
+let litPattern = #/a+bcd(?:g*)ab+?c?de(?:(?:(?i:f)))hij|zzz++a|3|2|1/#
+@available(SwiftStdlib 5.8, *)
+let strPattern = try! Regex("a+bcd(?:g*)ab+?c?de(?:(?:(?i:f)))hij|zzz++a|3|2|1")
+
+@available(SwiftStdlib 5.8, *)
+struct CompileOnceTest: ParsableCommand {
+  static let litPattern = #/a+bcd(?:g*)ab+?c?de(?:(?:(?i:f)))hij|zzz++a|3|2|1/#
+  static let strPattern = try! Regex("a+bcd(?:g*)ab+?c?de(?:(?:(?i:f)))hij|zzz++a|3|2|1")
+  
+  var N: Int { 10_000 }
+  var testString = "zzzzzzzzza"
+
+  func globalLitPattern() -> TimeInterval {
+    let start = Date.now
+    for _ in 0..<N {
+      guard testString.contains(RegexTester.litPattern) else { return 0 }
+    }
+    return Date.now.timeIntervalSince(start)
+  }
+  
+  func globalStrPattern() -> TimeInterval {
+    let start = Date.now
+    for _ in 0..<N {
+      guard testString.contains(RegexTester.strPattern) else { return 0 }
+    }
+    return Date.now.timeIntervalSince(start)
+  }
+
+  func staticLitPattern() -> TimeInterval {
+    let start = Date.now
+    for _ in 0..<N {
+      guard testString.contains(Self.litPattern) else { return 0 }
+    }
+    return Date.now.timeIntervalSince(start)
+  }
+  
+  func staticStrPattern() -> TimeInterval {
+    let start = Date.now
+    for _ in 0..<N {
+      guard testString.contains(Self.strPattern) else { return 0 }
+    }
+    return Date.now.timeIntervalSince(start)
+  }
+
+  func outerLitPattern() -> TimeInterval {
+    let start = Date.now
+    let pattern = #/a+bcd(?:g*)ab+?c?de(?:(?:(?i:f)))hij|zzz++a|3|2|1/#
+    for _ in 0..<N {
+      guard testString.contains(pattern) else { return 0 }
+    }
+    return Date.now.timeIntervalSince(start)
+  }
+  
+  func outerStrPattern() -> TimeInterval {
+    let start = Date.now
+    let pattern = try! Regex("a+bcd(?:g*)ab+?c?de(?:(?:(?i:f)))hij|zzz++a|3|2|1")
+    for _ in 0..<N {
+      guard testString.contains(pattern) else { return 0 }
+    }
+    return Date.now.timeIntervalSince(start)
+  }
+
+  func innerLitPattern() -> TimeInterval {
+    let start = Date.now
+    for _ in 0..<N {
+      let pattern = #/a+bcd(?:g*)ab+?c?de(?:(?:(?i:f)))hij|zzz++a|3|2|1/#
+      guard testString.contains(pattern) else { return 0 }
+    }
+    return Date.now.timeIntervalSince(start)
+  }
+  
+  func innerStrPattern() -> TimeInterval {
+    let start = Date.now
+    for _ in 0..<N {
+      let pattern = try! Regex("a+bcd(?:g*)ab+?c?de(?:(?:(?i:f)))hij|zzz++a|3|2|1")
+      guard testString.contains(pattern) else { return 0 }
+    }
+    return Date.now.timeIntervalSince(start)
+  }
+
+  func run() throws {
+    let globalLit = globalLitPattern()
+    let globalStr = globalStrPattern()
+    let staticLit = staticLitPattern()
+    let staticStr = staticStrPattern()
+    let outerLit = outerLitPattern()
+    let outerStr = outerStrPattern()
+    let innerLit = innerLitPattern()
+    let innerStr = innerStrPattern()
+    
+    print("""
+      Global literal: \(globalLit)
+              string: \(globalStr)
+      Static literal: \(staticLit)
+              string: \(staticStr)
+       Outer literal: \(outerLit)
+              string: \(outerStr)
+       Inner literal: \(innerLit)
+              string: \(innerStr)
+      """)
+  }
+}
diff --git a/Sources/RegexTester/Main.swift b/Sources/RegexTester/Main.swift
new file mode 100644
index 000000000..aff4e7ef5
--- /dev/null
+++ b/Sources/RegexTester/Main.swift
@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2021-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
+//
+//===----------------------------------------------------------------------===//
+
+import ArgumentParser
+import _RegexParser
+import _StringProcessing
+
+@main
+@available(SwiftStdlib 5.8, *)
+struct Main: ParsableCommand {
+  static var configuration: CommandConfiguration {
+    .init(
+      subcommands: [Tester.self, CompileOnceTest.self],
+      defaultSubcommand: Tester.self)
+  }
+}
diff --git a/Sources/RegexTester/RegexTester.swift b/Sources/RegexTester/RegexTester.swift
index 052de667f..e8ed8d8f8 100644
--- a/Sources/RegexTester/RegexTester.swift
+++ b/Sources/RegexTester/RegexTester.swift
@@ -13,9 +13,12 @@ import ArgumentParser
 import _RegexParser
 import _StringProcessing
 
-@main
 @available(SwiftStdlib 5.8, *)
-struct RegexTester: ParsableCommand {
+struct Tester: ParsableCommand {
+  static var configuration: CommandConfiguration {
+    .init(subcommands: [CompileOnceTest.self])
+  }
+  
   typealias MatchFunctionType = (String) throws -> Regex<AnyRegexOutput>.Match?
 
   @Argument(help: "The regex pattern to test.")