Handle atoms as things to be wrapped

oops

Author: Azoy

Sources/_StringProcessing/PrintAsPattern.swift

@@ -193,7 +193,11 @@ extension PrettyPrinter {
       }
 
       if let pattern = a._patternBase(&self) {
-        print(pattern)
+        if pattern.canBeWrapped {
+          print("One(\(pattern.0))")
+        } else {
+          print(pattern.0)
+        }
       }
 
     case .trivia:
@@ -387,9 +391,9 @@ extension PrettyPrinter {
       if let lhs = lhs._patternBase(&self), let rhs = rhs._patternBase(&self) {
         indent()
         output("(")
-        output(lhs)
+        output(lhs.0)
         output("...")
-        output(rhs)
+        output(rhs.0)
         output(")")
       }
 
@@ -1029,33 +1033,35 @@ extension DSLTree.CustomCharacterClass {
 }
 
 extension DSLTree.Atom {
-  func _patternBase(_ printer: inout PrettyPrinter) -> String? {
+  func _patternBase(
+    _ printer: inout PrettyPrinter
+  ) -> (String, canBeWrapped: Bool)? {
     switch self {
     case .any:
-      return ".any"
+      return (".any", true)
 
     case let .char(c):
-      return String(c)._quoted
+      return (String(c)._quoted, false)
 
     case let .scalar(s):
       let hex = String(s.value, radix: 16, uppercase: true)
-      return "\\u{\(hex)}"._quoted
+      return ("\\u{\(hex)}"._quoted, false)
 
     case let .unconverted(a):
       if a.ast.isUnprintableAtom {
-        return "#/\(a.ast._regexBase)/#"
+        return ("#/\(a.ast._regexBase)/#", false)
       } else {
-        return a.ast._dslBase.0
+        return a.ast._dslBase
       }
 
     case .assertion(let a):
-      return a.ast._patternBase
+      return (a.ast._patternBase, false)
 
     case .backreference(_):
-      return "/* TOOD: backreferences */"
+      return ("/* TOOD: backreferences */", false)
 
     case .symbolicReference:
-      return "/* TOOD: symbolic references */"
+      return ("/* TOOD: symbolic references */", false)
 
     case .changeMatchingOptions(let matchingOptions):
       for add in matchingOptions.ast.adding {