Merge branch 'apple:main' into main

Author: classicvalues

.gitignore

@@ -1,3 +1,5 @@
+.DS_Store
+
 # Xcode
 #
 # gitignore contributors: remember to update Global/Xcode.gitignore, Objective-C.gitignore & Swift.gitignore

Package.swift

@@ -16,9 +16,6 @@ let package = Package(
         .library(
             name: "_MatchingEngine",
             targets: ["_MatchingEngine"]),
-        .library(
-            name: "_Unicode",
-            targets: ["_Unicode"]),
         .executable(
             name: "VariadicsGenerator",
             targets: ["VariadicsGenerator"])
@@ -31,31 +28,33 @@ let package = Package(
         // Targets can depend on other targets in this package, and on products in packages which this package depends on.
         .target(
             name: "_MatchingEngine",
-            dependencies: [/*"_Unicode"*/],
+            dependencies: [],
             swiftSettings: [
                 .unsafeFlags(["-enable-library-evolution"])
             ]),
         .testTarget(
             name: "MatchingEngineTests",
-            dependencies: ["_MatchingEngine"]),
+            dependencies: [
+              "_MatchingEngine", "_StringProcessing"]),
+        .target(
+            name: "_CUnicode",
+            dependencies: []),
         .target(
             name: "_StringProcessing",
-            dependencies: ["_MatchingEngine"],
+            dependencies: ["_MatchingEngine", "_CUnicode"],
             swiftSettings: [
-                .unsafeFlags(["-enable-library-evolution"])
+                .unsafeFlags(["-enable-library-evolution"]),
+                .unsafeFlags(["-Xfrontend", "-enable-experimental-pairwise-build-block"])
             ]),
-        .target(
-            name: "_Unicode",
-            dependencies: []),
         .testTarget(
             name: "RegexTests",
-            dependencies: ["_StringProcessing"]),
+            dependencies: ["_StringProcessing"],
+            swiftSettings: [
+                .unsafeFlags(["-Xfrontend", "-enable-experimental-pairwise-build-block"])
+            ]),
         .target(
             name: "Prototypes",
-            dependencies: ["_MatchingEngine"]),
-        .testTarget(
-          name: "UnicodeTests",
-          dependencies: ["_Unicode"]),
+            dependencies: ["_MatchingEngine", "_StringProcessing"]),
 
         // MARK: Scripts
         .executableTarget(
@@ -74,7 +73,10 @@ let package = Package(
         // MARK: Exercises
         .target(
           name: "Exercises",
-          dependencies: ["_MatchingEngine", "Prototypes", "_StringProcessing"]),
+          dependencies: ["_MatchingEngine", "Prototypes", "_StringProcessing"],
+          swiftSettings: [
+              .unsafeFlags(["-Xfrontend", "-enable-experimental-pairwise-build-block"])
+          ]),
         .testTarget(
           name: "ExercisesTests",
           dependencies: ["Exercises"]),

README.md

@@ -1,8 +1,11 @@
-# MatchingEngine
+# Declarative String Processing for Swift
 
 An early experimental general-purpose pattern matching engine for Swift.
 
 See [Declarative String Processing Overview][decl-string]
 
 [decl-string]: Documentation/DeclarativeStringProcessing.md
 
+## Requirements
+
+- [Swift Trunk Development Snapshot](https://www.swift.org/download/#snapshots) DEVELOPMENT-SNAPSHOT-2022-02-03 or later.

Sources/Exercises/Participants/PEGParticipant.swift

@@ -40,7 +40,7 @@ private func graphemeBreakPropertyData(forLine line: String) -> GraphemeBreakEnt
   let program = PEG.Program(start: "Entry", environment: ["Entry": entry])
 
   let vm = program.compile(for: String.self)
-  let engine = program.transpile(for: String.self)
+  let engine = try! program.transpile()
   _ = (vm, engine)
 
   fatalError("Unsupported")

Sources/Exercises/Participants/RegexParticipant.swift

@@ -46,7 +46,7 @@ struct RegexLiteralParticipant: Participant {
 // MARK: - Regex literal
 
 private func extractFromCaptures(
-  _ match: Tuple4<Substring, Substring, Substring?, Substring>
+  _ match: (Substring, Substring, Substring?, Substring)
 ) -> GraphemeBreakEntry? {
   guard let lowerScalar = Unicode.Scalar(hex: match.1),
         let upperScalar = match.2.map(Unicode.Scalar.init(hex:)) ?? lowerScalar,
@@ -61,7 +61,7 @@ private func extractFromCaptures(
 private func graphemeBreakPropertyData<RP: RegexProtocol>(
   forLine line: String,
   using regex: RP
-) -> GraphemeBreakEntry? where RP.Match == Tuple4<Substring, Substring, Substring?, Substring> {
+) -> GraphemeBreakEntry? where RP.Match == (Substring, Substring, Substring?, Substring) {
   line.match(regex).map(\.match).flatMap(extractFromCaptures)
 }
 
@@ -71,7 +71,7 @@ private func graphemeBreakPropertyDataLiteral(
   return graphemeBreakPropertyData(
     forLine: line,
     using: r(#"([0-9A-F]+)(?:\.\.([0-9A-F]+))?\s+;\s+(\w+).*"#,
-             matching: Tuple4<Substring, Substring, Substring?, Substring>.self))
+             matching: (Substring, Substring, Substring?, Substring).self))
 }
 
 // MARK: - Builder DSL
@@ -80,18 +80,18 @@ private func graphemeBreakPropertyData(
   forLine line: String
 ) -> GraphemeBreakEntry? {
   line.match {
-    OneOrMore(.hexDigit).tryCapture(Unicode.Scalar.init(hex:))
-    Optionally {
+    tryCapture(oneOrMore(.hexDigit)) { Unicode.Scalar(hex: $0) }
+    optionally {
       ".."
-      OneOrMore(.hexDigit).tryCapture(Unicode.Scalar.init(hex:))
+      tryCapture(oneOrMore(.hexDigit)) { Unicode.Scalar(hex: $0) }
     }
-    OneOrMore(.whitespace)
+    oneOrMore(.whitespace)
     ";"
-    OneOrMore(.whitespace)
-    OneOrMore(.word).tryCapture(Unicode.GraphemeBreakProperty.init)
-    Repeat(.any)
+    oneOrMore(.whitespace)
+    tryCapture(oneOrMore(.word)) { Unicode.GraphemeBreakProperty($0) }
+    zeroOrMore(.any)
   }.map {
-    let (_, lower, upper, property) = $0.match.tuple
+    let (_, lower, upper, property) = $0.match
     return GraphemeBreakEntry(lower...(upper ?? lower), property)
   }
 }

Sources/PatternConverter/PatternConverter.swift

@@ -30,6 +30,12 @@ struct PatternConverter: ParsableCommand {
   @Flag(help: "Whether to show canonical regex literal")
   var showCanonical: Bool = false
 
+  @Flag(help: "Whether to show capture structure")
+  var showCaptureStructure: Bool = false
+
+  @Flag(help: "Whether to skip result builder DSL")
+  var skipDSL: Bool = false
+
   @Option(help: "Limit (from top-down) the conversion levels")
   var topDownConversionLimit: Int?
 
@@ -65,12 +71,21 @@ struct PatternConverter: ParsableCommand {
       print()
     }
 
+    if showCaptureStructure {
+      print("Capture structure:")
+      print()
+      print(ast.captureStructure)
+      print()
+    }
+
     print()
-    let render = ast.renderAsPattern(
-      maxTopDownLevels: topDownConversionLimit,
-      minBottomUpLevels: bottomUpConversionLimit
-    )
-    print(render)
+    if !skipDSL {
+      let render = ast.renderAsBuilderDSL(
+        maxTopDownLevels: topDownConversionLimit,
+        minBottomUpLevels: bottomUpConversionLimit
+      )
+      print(render)
+    }
 
     return
   }

Sources/Prototypes/PEG/PEGCode.swift

@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import _MatchingEngine
+import _StringProcessing
 
 extension PEG.VM {
   struct Code {

Sources/Prototypes/PEG/PEGCompile.swift

@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import _MatchingEngine
+import _StringProcessing
 
 extension PEG.VM {
   typealias InIndex = Input.Index

Sources/Prototypes/PEG/PEGCore.swift

@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import _MatchingEngine
+import _StringProcessing
 let emitComments = true
 
 struct PEGCore<

Sources/Prototypes/PEG/PEGTranspile.swift

@@ -10,12 +10,13 @@
 //===----------------------------------------------------------------------===//
 
 import _MatchingEngine
+import _StringProcessing
 
-extension PEG.VM {
-  typealias MEProgram = _MatchingEngine.Program<Input>
-  func transpile() -> MEProgram {
-    typealias Builder = MEProgram.Builder
-    var builder = MEProgram.Builder()
+extension PEG.VM where Input == String {
+  typealias MEProg = MEProgram<String>
+  func transpile() throws -> MEProg {
+    typealias Builder = MEProg.Builder
+    var builder = MEProg.Builder()
 
     // Address token info
     //
@@ -106,14 +107,13 @@ extension PEG.VM {
       }
     }
 
-    return builder.assemble()
+    return try builder.assemble()
   }
 }
 
-extension PEG.Program {
-  public func transpile<Input: Collection>(
-    for input: Input.Type = Input.self
-  ) -> Engine<Input> where Input.Element == Element {
-    Engine(compile(for: input).vm.transpile())
+extension PEG.Program where Element == Character {
+  public func transpile(
+  ) throws -> Engine<String> {
+    try Engine(compile(for: String.self).vm.transpile())
   }
 }