Rough printing parity with what we had before

Author: milseman

Sources/_MatchingEngine/Regex/DSLTree.swift

@@ -66,15 +66,19 @@ extension DSLTree {
 }
 
 extension DSLTree {
-  enum CustomCharacterClass {
-    case atom(Atom)
-    case range(Atom, Atom)
-
-    indirect case sequence([Self])
-
-    indirect case intersection(Self, Self)
-    indirect case subtraction(Self, Self)
-    indirect case symmetricDifference(Self, Self)
+  struct CustomCharacterClass {
+    var members: [Member]
+    var isInverted: Bool
+
+    enum Member {
+      case atom(Atom)
+      case range(Atom, Atom)
+      case custom(CustomCharacterClass)
+
+      indirect case intersection(CustomCharacterClass, CustomCharacterClass)
+      indirect case subtraction(CustomCharacterClass, CustomCharacterClass)
+      indirect case symmetricDifference(CustomCharacterClass, CustomCharacterClass)
+    }
   }
 
   enum Atom {
@@ -263,12 +267,13 @@ extension AST {
 
 extension AST.CustomCharacterClass {
   var dslTreeClass: DSLTree.CustomCharacterClass {
-    func mapMember(
+    // TODO: Not quite 1-1
+    func convert(
       _ member: Member
-    ) -> DSLTree.CustomCharacterClass {
+    ) -> DSLTree.CustomCharacterClass.Member {
       switch member {
       case let .custom(ccc):
-        return ccc.dslTreeClass
+        return .custom(ccc.dslTreeClass)
 
       case let .range(r):
         return .range(
@@ -278,15 +283,33 @@ extension AST.CustomCharacterClass {
         return .atom(a.dslTreeAtom)
 
       case let .quote(q):
-        return .sequence(q.literal.map { .atom(.char($0)) })
+        // TODO: Probably should flatten instead of nest
+        return .custom(.init(
+          members: q.literal.map { .atom(.char($0)) },
+          isInverted: false))
 
       case let .setOperation(lhs, op, rhs):
-        fatalError("TODO: set operations")
+        let lhs = DSLTree.CustomCharacterClass(
+          members: lhs.map(convert),
+          isInverted: false)
+        let rhs = DSLTree.CustomCharacterClass(
+          members: rhs.map(convert),
+          isInverted: false)
+
+        switch op.value {
+        case .subtraction:
+          return .subtraction(lhs, rhs)
+        case .intersection:
+          return .intersection(lhs, rhs)
+        case .symmetricDifference:
+          return .symmetricDifference(lhs, rhs)
+        }
       }
     }
 
-    // TODO: Coalesce?
-    return .sequence(members.map(mapMember))
+    return .init(
+      members: members.map(convert),
+      isInverted: self.isInverted)
   }
 }
 

Sources/_MatchingEngine/Regex/Printing/PrintAsPattern.swift

@@ -130,8 +130,8 @@ extension PrettyPrinter {
       // label is a lie.
       printAsPattern(convertedFromAST: n)
 
-    case .customCharacterClass:
-      print("/* TODO: custom character class */")
+    case let .customCharacterClass(ccc):
+      printAsPattern(ccc)
 
     case .groupTransform:
       print("/* TODO: group transforms */")
@@ -146,38 +146,41 @@ extension PrettyPrinter {
   }
 
   // TODO: Some way to integrate this with conversion...
-  mutating func printAsPattern(_ ccc: AST.CustomCharacterClass) {
+  mutating func printAsPattern(
+    _ ccc: DSLTree.CustomCharacterClass
+  ) {
     let inv = ccc.isInverted ? "inverted: true" : ""
     printBlock("CharacterClass(\(inv))") { printer in
       ccc.members.forEach { printer.printAsPattern($0) }
     }
   }
 
   // TODO: Some way to integrate this with conversion...
-  mutating func printAsPattern(_ member: AST.CustomCharacterClass.Member) {
+  mutating func printAsPattern(
+    _ member: DSLTree.CustomCharacterClass.Member
+  ) {
     switch member {
-    case .custom(let ccc):
+    case let .custom(ccc):
       printAsPattern(ccc)
-    case .range(let r):
-      if let lhs = r.lhs.literalStringValue,
-         let rhs = r.rhs.literalStringValue {
+    case let .range(lhs, rhs):
+      if case let .char(lhs) = lhs,
+         case let .char(rhs) = rhs {
         indent()
-        output(lhs._quoted)
+        output(String(lhs)._quoted)
         output("...")
-        output(rhs._quoted)
+        output(String(rhs)._quoted)
         terminateLine()
       } else {
-        print("// TODO: Range \(r.lhs) to \(r.rhs)")
+        print("// TODO: Range \(lhs) to \(rhs)")
       }
-    case .atom(let a):
-      if let s = a.literalStringValue {
-        print(s._quoted)
+    case let .atom(a):
+      if case let .char(c) = a {
+        print(String(c)._quoted)
       } else {
-        print(a._patternBase)
+        print(" // TODO: Atom \(a) ")
       }
-    case .quote(let q):
-      print("// TODO: quote \(q.literal._quoted) in custom character classes (should we split it?)")
-    case .setOperation:
+
+    case .symmetricDifference, .intersection, .subtraction:
       print("// TODO: Set operation: \(member)")
     }
   }