Move MatchingEngine out of the _MatchingEngine module

Author: milseman

Package.swift

@@ -34,7 +34,8 @@ let package = Package(
             ]),
         .testTarget(
             name: "MatchingEngineTests",
-            dependencies: ["_MatchingEngine"]),
+            dependencies: [
+              "_MatchingEngine", "_StringProcessing"]),
         .target(
             name: "_StringProcessing",
             dependencies: ["_MatchingEngine"],
@@ -50,7 +51,7 @@ let package = Package(
             ]),
         .target(
             name: "Prototypes",
-            dependencies: ["_MatchingEngine"]),
+            dependencies: ["_MatchingEngine", "_StringProcessing"]),
 
         // MARK: Scripts
         .executableTarget(

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 = try! program.transpile(for: String.self)
+  let engine = try! program.transpile()
   _ = (vm, engine)
 
   fatalError("Unsupported")

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() throws -> 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
     //
@@ -110,10 +111,9 @@ extension PEG.VM {
   }
 }
 
-extension PEG.Program {
-  public func transpile<Input: Collection>(
-    for input: Input.Type = Input.self
-  ) throws -> Engine<Input> where Input.Element == Element {
-    try 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())
   }
 }

Sources/Prototypes/PEG/PEGVM.swift

@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import _MatchingEngine
+import _StringProcessing
 
 extension PEG {
 

Sources/Prototypes/PEG/Printing.swift

@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import _MatchingEngine
+import _StringProcessing
 
 extension PEGCore.Instruction: InstructionProtocol {
   var operandPC: InstructionAddress? { self.pc }

Sources/_StringProcessing/ByteCodeGen.swift

@@ -3,10 +3,10 @@ import _MatchingEngine
 extension Compiler {
   struct ByteCodeGen {
     var options: MatchingOptions
-    var builder = _MatchingEngine.Program<String>.Builder()
+    var builder = Program.Builder()
 
     mutating func finish(
-    ) throws -> _MatchingEngine.Program<String> {
+    ) throws -> Program {
       builder.buildAccept()
       return try builder.assemble()
     }

Sources/_StringProcessing/Compiler.swift

@@ -11,11 +11,6 @@
 
 import _MatchingEngine
 
-struct RegexProgram {
-  typealias Program = _MatchingEngine.Program<String>
-  var program: Program
-}
-
 class Compiler {
   let tree: DSLTree
 
@@ -30,12 +25,12 @@ class Compiler {
     self.tree = tree
   }
 
-  __consuming func emit() throws -> RegexProgram {
+  __consuming func emit() throws -> Program {
     // TODO: Handle global options
     var codegen = ByteCodeGen(options: options)
     try codegen.emitNode(tree.root)
     let program = try codegen.finish()
-    return RegexProgram(program: program)
+    return program
   }
 }
 

Sources/_StringProcessing/ConsumerInterface.swift

@@ -18,7 +18,7 @@ extension DSLTree.Node {
   /// the front of an input range
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction? {
+  ) throws -> MEProgram<String>.ConsumeFunction? {
     switch self {
     case .atom(let a):
       return try a.generateConsumer(opts)
@@ -55,7 +55,7 @@ extension DSLTree.Atom {
   // unnecessary...
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction? {
+  ) throws -> MEProgram<String>.ConsumeFunction? {
     switch self {
 
     case let .char(c):
@@ -112,7 +112,7 @@ extension AST.Atom {
 
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction? {
+  ) throws -> MEProgram<String>.ConsumeFunction? {
     // TODO: Wean ourselves off of this type...
     if let cc = self.characterClass?.withMatchLevel(
       opts.matchLevel
@@ -171,7 +171,7 @@ extension AST.Atom {
 extension DSLTree.CustomCharacterClass.Member {
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction {
+  ) throws -> MEProgram<String>.ConsumeFunction {
     switch self {
     case let .atom(a):
       guard let c = try a.generateConsumer(opts) else {
@@ -256,7 +256,7 @@ extension DSLTree.CustomCharacterClass.Member {
 extension AST.CustomCharacterClass.Member {
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction {
+  ) throws -> MEProgram<String>.ConsumeFunction {
     switch self {
     case .custom(let ccc):
       return try ccc.generateConsumer(opts)
@@ -351,7 +351,7 @@ extension AST.CustomCharacterClass.Member {
 extension DSLTree.CustomCharacterClass {
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction {
+  ) throws -> MEProgram<String>.ConsumeFunction {
     // NOTE: Easy way to implement, obviously not performant
     let consumers = try members.map {
       try $0.generateConsumer(opts)
@@ -374,7 +374,7 @@ extension DSLTree.CustomCharacterClass {
 extension AST.CustomCharacterClass {
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction {
+  ) throws -> MEProgram<String>.ConsumeFunction {
     // NOTE: Easy way to implement, obviously not performant
     let consumers = try strippingTriviaShallow.members.map {
       try $0.generateConsumer(opts)
@@ -397,22 +397,22 @@ extension AST.CustomCharacterClass {
 // NOTE: Conveniences, though not most performant
 private func consumeScalarGC(
   _ gc: Unicode.GeneralCategory
-) -> Program<String>.ConsumeFunction {
+) -> MEProgram<String>.ConsumeFunction {
   consumeScalar { gc == $0.properties.generalCategory }
 }
 private func consumeScalarGCs(
   _ gcs: [Unicode.GeneralCategory]
-) -> Program<String>.ConsumeFunction {
+) -> MEProgram<String>.ConsumeFunction {
   consumeScalar { gcs.contains($0.properties.generalCategory) }
 }
 private func consumeScalarProp(
   _ p: @escaping (Unicode.Scalar.Properties) -> Bool
-) -> Program<String>.ConsumeFunction {
+) -> MEProgram<String>.ConsumeFunction {
   consumeScalar { p($0.properties) }
 }
 func consumeScalar(
   _ p: @escaping (Unicode.Scalar) -> Bool
-) -> Program<String>.ConsumeFunction {
+) -> MEProgram<String>.ConsumeFunction {
   { input, bounds in
     // TODO: bounds check?
     let curIdx = bounds.lowerBound
@@ -427,11 +427,11 @@ func consumeScalar(
 extension AST.Atom.CharacterProperty {
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction {
+  ) throws -> MEProgram<String>.ConsumeFunction {
     // Handle inversion for us, albeit not efficiently
     func invert(
-      _ p: @escaping Program<String>.ConsumeFunction
-    ) -> Program<String>.ConsumeFunction {
+      _ p: @escaping MEProgram<String>.ConsumeFunction
+    ) -> MEProgram<String>.ConsumeFunction {
       return { input, bounds in
         if p(input, bounds) != nil { return nil }
         // TODO: semantic level
@@ -444,7 +444,7 @@ extension AST.Atom.CharacterProperty {
     // FIXME: Below is largely scalar based, for convenience,
     // but we want a comprehensive treatment to semantic mode
     // switching.
-    let preInversion: Program<String>.ConsumeFunction =
+    let preInversion: MEProgram<String>.ConsumeFunction =
     try {
       switch kind {
         // TODO: is this modeled differently?
@@ -498,7 +498,7 @@ extension Unicode.BinaryProperty {
   // FIXME: Semantic level, vet for precise defs
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction {
+  ) throws -> MEProgram<String>.ConsumeFunction {
     switch self {
 
     case .asciiHexDigit:
@@ -664,7 +664,7 @@ extension Unicode.POSIXProperty {
   // FIXME: Semantic level, vet for precise defs
   func generateConsumer(
     _ opts: MatchingOptions
-  ) -> Program<String>.ConsumeFunction {
+  ) -> MEProgram<String>.ConsumeFunction {
     // FIXME: semantic levels, modes, etc
     switch self {
     case .alnum:
@@ -710,7 +710,7 @@ extension Unicode.ExtendedGeneralCategory {
   // FIXME: Semantic level
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction {
+  ) throws -> MEProgram<String>.ConsumeFunction {
     switch self {
     case .letter:
       return consumeScalarGCs([

Sources/_MatchingEngine/Engine/Backtracking.swift renamed to Sources/_StringProcessing/Engine/Backtracking.swift

@@ -34,7 +34,7 @@ extension Engine where Input == String {
   public func consume(
     _ input: Input,
     in range: Range<Input.Index>,
-    matchMode: MatchMode = .prefix
+    matchMode: MatchMode = .partialFromFront
   ) -> (Input.Index, CaptureList)? {
     if enableTracing {
       print("Consume: \(input)")

Sources/_MatchingEngine/Engine/Consume.swift renamed to Sources/_StringProcessing/Engine/Consume.swift

@@ -13,7 +13,7 @@
 // But, we can play around with this.
 public struct Engine<Input: BidirectionalCollection> where Input.Element: Hashable {
 
-  var program: Program<Input>
+  var program: MEProgram<Input>
 
   // TODO: Pre-allocated register banks
 
@@ -25,7 +25,7 @@ public struct Engine<Input: BidirectionalCollection> where Input.Element: Hashab
   }
 
   public init(
-    _ program: Program<Input>,
+    _ program: MEProgram<Input>,
     enableTracing: Bool? = nil
   ) {
     var program = program