convert some atoms

Author: milseman

Sources/_MatchingEngine/Regex/DSLTree.swift

@@ -23,6 +23,8 @@ extension DSLTree {
 
     case customCharacterClass(CustomCharacterClass)
 
+    case atom(Atom)
+
     /// Comments, non-semantic whitespace, etc
     // TODO: Do we want this? Could be interesting
     case trivia(String)
@@ -65,13 +67,22 @@ extension DSLTree {
 
 extension DSLTree {
   enum CustomCharacterClass {
-    // TODO: Still need to convert atoms
-    case members([AST.Atom])
+    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)
   }
+
+  enum Atom {
+    case char(Character)
+    case scalar(Unicode.Scalar)
+
+    case unconverted(AST.Atom)
+  }
 }
 
 // CollectionConsumer
@@ -119,7 +130,8 @@ extension DSLTree.Node {
 
     case .trivia, .empty, .stringLiteral, .regexLiteral,
         .consumer, .consumerValidator, .characterPredicate,
-        .customCharacterClass, .unconvertedRegexLiteral:
+        .customCharacterClass, .unconvertedRegexLiteral,
+        .atom:
       return []
     }
   }
@@ -230,14 +242,10 @@ extension AST {
         if let str = v.literalStringValue {
           return .stringLiteral(str)
         }
+        return .atom(v.dslTreeAtom)
 
-        // TODO: More conversions
-        return .unconvertedRegexLiteral(self)
-
-      case .customCharacterClass(_):
-
-        // TODO: More conversions
-        return .unconvertedRegexLiteral(self)
+      case let .customCharacterClass(ccc):
+        return .customCharacterClass(ccc.dslTreeClass)
 
       case .empty(_):
         return .empty
@@ -252,3 +260,46 @@ extension AST {
     return wrap(convert())
   }
 }
+
+extension AST.CustomCharacterClass {
+  var dslTreeClass: DSLTree.CustomCharacterClass {
+    func mapMember(
+      _ member: Member
+    ) -> DSLTree.CustomCharacterClass {
+      switch member {
+      case let .custom(ccc):
+        return ccc.dslTreeClass
+
+      case let .range(r):
+        return .range(
+          r.lhs.dslTreeAtom, r.rhs.dslTreeAtom)
+
+      case let .atom(a):
+        return .atom(a.dslTreeAtom)
+
+      case let .quote(q):
+        return .sequence(q.literal.map { .atom(.char($0)) })
+
+      case let .setOperation(lhs, op, rhs):
+        fatalError("TODO: set operations")
+      }
+    }
+
+    // TODO: Coalesce?
+    return .sequence(members.map(mapMember))
+  }
+}
+
+extension AST.Atom {
+  var dslTreeAtom: DSLTree.Atom {
+    if case let .scalar(s) = kind {
+      return .scalar(s)
+    }
+    if case let .char(c) = kind {
+      return .char(c)
+    }
+
+    // TODO: More conversions
+    return .unconverted(self)
+  }
+}

Sources/_MatchingEngine/Regex/Printing/PrintAsPattern.swift

@@ -93,6 +93,21 @@ extension PrettyPrinter {
         printer.printAsPattern(convertedFromAST: child)
       }
 
+    case let .atom(a):
+      switch a {
+      case let .char(c):
+        print(String(c)._quoted)
+
+      case let .scalar(s):
+        let hex = String(s.value, radix: 16, uppercase: true)
+        print("\\u{\(hex)}"._quoted)
+
+      case let .unconverted(a):
+        // TODO: is this always right?
+        // TODO: Convert built-in character classes
+        print(a._patternBase)
+      }
+
     case .trivia:
       // What should we do? Maybe keep comments, etc?
       print("")