Rename any -> dot

Explicitly disambiguate the fact we're talking
about `.`, which does not match newlines unless in
single line mode.

Author: hamishknight

Sources/RegexBuilder/CharacterClass.swift

@@ -42,7 +42,7 @@ extension CharacterClass {
 @available(SwiftStdlib 5.7, *)
 extension RegexComponent where Self == CharacterClass {
   public static var any: CharacterClass {
-    .init(DSLTree.CustomCharacterClass(members: [.atom(.any)]))
+    .init(DSLTree.CustomCharacterClass(members: [.atom(.dot)]))
   }
 
   public static var anyGraphemeCluster: CharacterClass {

Sources/_RegexParser/Regex/AST/Atom.swift

@@ -60,7 +60,7 @@ extension AST {
       case namedCharacter(String)
 
       /// .
-      case any
+      case dot
 
       /// ^
       case startOfLine
@@ -104,7 +104,7 @@ extension AST.Atom {
     case .callout(let v):               return v
     case .backtrackingDirective(let v): return v
     case .changeMatchingOptions(let v): return v
-    case .any:                          return nil
+    case .dot:                          return nil
     case .startOfLine:                  return nil
     case .endOfLine:                    return nil
     case .invalid:                      return nil
@@ -806,7 +806,7 @@ extension AST.Atom {
       // the AST? Or defer for the matching engine?
       return nil
 
-    case .scalarSequence, .property, .any, .startOfLine, .endOfLine,
+    case .scalarSequence, .property, .dot, .startOfLine, .endOfLine,
         .backreference, .subpattern, .callout, .backtrackingDirective,
         .changeMatchingOptions, .invalid:
       return nil
@@ -858,7 +858,7 @@ extension AST.Atom {
     case .keyboardMetaControl(let x):
       return "\\M-\\C-\(x)"
 
-    case .property, .escaped, .any, .startOfLine, .endOfLine,
+    case .property, .escaped, .dot, .startOfLine, .endOfLine,
         .backreference, .subpattern, .namedCharacter, .callout,
         .backtrackingDirective, .changeMatchingOptions, .invalid:
       return nil

Sources/_RegexParser/Regex/Parse/LexicalAnalysis.swift

@@ -2073,7 +2073,7 @@ extension Parser {
         p.unreachable("Should have lexed a group or group-like atom")
 
       // (sometimes) special metacharacters
-      case ".": return customCC ? .char(".") : .any
+      case ".": return customCC ? .char(".") : .dot
       case "^": return customCC ? .char("^") : .startOfLine
       case "$": return customCC ? .char("$") : .endOfLine
 

Sources/_RegexParser/Regex/Parse/Sema.swift

@@ -221,7 +221,7 @@ extension RegexValidator {
   ) {
     switch esc {
     case .resetStartOfMatch, .singleDataUnit, .trueAnychar,
-        // '\N' needs to be emitted using 'emitAny'.
+        // '\N' needs to be emitted using 'emitDot'.
         .notNewline:
       error(.unsupported("'\\\(esc.character)'"), at: loc)
 
@@ -288,7 +288,7 @@ extension RegexValidator {
               at: atom.location)
       }
 
-    case .char, .scalar, .startOfLine, .endOfLine, .any:
+    case .char, .scalar, .startOfLine, .endOfLine, .dot:
       break
 
     case .invalid:

Sources/_RegexParser/Regex/Printing/DumpAST.swift

@@ -153,7 +153,7 @@ extension AST.Atom {
     case .keyboardControl, .keyboardMeta, .keyboardMetaControl:
       fatalError("TODO")
 
-    case .any:         return "."
+    case .dot:         return "."
     case .startOfLine: return "^"
     case .endOfLine:   return "$"
 

Sources/_StringProcessing/ByteCodeGen.swift

@@ -55,8 +55,8 @@ fileprivate extension Compiler.ByteCodeGen {
       }
     }
     switch a {
-    case .any:
-      emitAny()
+    case .dot:
+      emitDot()
 
     case let .char(c):
       try emitCharacter(c)
@@ -282,7 +282,7 @@ fileprivate extension Compiler.ByteCodeGen {
     }
   }
 
-  mutating func emitAny() {
+  mutating func emitDot() {
     switch (options.semanticLevel, options.dotMatchesNewline) {
     case (.graphemeCluster, true):
       builder.buildAdvance(1)
@@ -758,9 +758,9 @@ fileprivate extension Compiler.ByteCodeGen {
       try emitQuantification(amt.ast, kind, child)
 
     case let .customCharacterClass(ccc):
-      if ccc.containsAny {
+      if ccc.containsDot {
         if !ccc.isInverted {
-          emitAny()
+          emitDot()
         } else {
           throw Unsupported("Inverted any")
         }

Sources/_StringProcessing/ConsumerInterface.swift

@@ -111,7 +111,7 @@ extension DSLTree.Atom {
           : $0 == s
       }
 
-    case .any:
+    case .dot:
       // FIXME: Should this be a total ordering?
       if opts.semanticLevel == .graphemeCluster {
         return { input, bounds in
@@ -264,10 +264,10 @@ extension AST.Atom {
     case let .namedCharacter(name):
       return consumeName(name, opts: opts)
 
-    case .any:
+    case .dot:
       assertionFailure(
         "Should have been handled by tree conversion")
-      fatalError(".atom(.any) is handled in emitAny")
+      fatalError(".atom(.dot) is handled in emitDot")
 
     case .startOfLine, .endOfLine:
       // handled in emitAssertion

Sources/_StringProcessing/PrintAsPattern.swift

@@ -895,7 +895,8 @@ extension AST.Atom {
     case .namedCharacter:
       return (" /* TODO: named character */", false)
 
-    case .any:
+    case .dot:
+      // FIXME: This is wrong, the DSL doesn't have an equivalent to .dot.
       return (".any", true)
 
     case .startOfLine, .endOfLine:
@@ -950,7 +951,7 @@ extension AST.Atom {
     case .namedCharacter(let n):
       return "\\N{\(n)}"
 
-    case .any:
+    case .dot:
       return "."
 
     case .startOfLine, .endOfLine:
@@ -1099,7 +1100,8 @@ extension DSLTree.Atom {
     _ printer: inout PrettyPrinter
   ) -> (String, canBeWrapped: Bool)? {
     switch self {
-    case .any:
+    case .dot:
+      // FIXME: This is wrong, the DSL doesn't have an equivalent to .dot.
       return (".any", true)
 
     case let .char(c):
@@ -1141,7 +1143,7 @@ extension DSLTree.Atom {
 
   var _regexBase: String {
     switch self {
-    case .any:
+    case .dot:
       return "."
 
     case let .char(c):

Sources/_StringProcessing/Regex/ASTConversion.swift

@@ -217,7 +217,7 @@ extension AST.Atom {
     switch self.kind {
     case let .char(c):                    return .char(c)
     case let .scalar(s):                  return .char(Character(s.value))
-    case .any:                            return .any
+    case .dot:                            return .dot
     case let .backreference(r):           return .backreference(.init(ast: r))
     case let .changeMatchingOptions(seq): return .changeMatchingOptions(.init(ast: seq))
 

Sources/_StringProcessing/Regex/DSLTree.swift

@@ -117,11 +117,11 @@ extension DSLTree {
     var members: [Member]
     var isInverted: Bool
 
-    var containsAny: Bool {
+    var containsDot: Bool {
       members.contains { member in
         switch member {
-        case .atom(.any): return true
-        case .custom(let ccc): return ccc.containsAny
+        case .atom(.dot): return true
+        case .custom(let ccc): return ccc.containsDot
         default:
           return false
         }
@@ -245,7 +245,10 @@ extension DSLTree {
   public enum Atom {
     case char(Character)
     case scalar(Unicode.Scalar)
-    case any
+
+    /// The DSL representation of '.' in a regex literal. This does not match
+    /// newlines unless single line mode is enabled.
+    case dot
 
     case assertion(_AST.AssertionKind)
     case backreference(_AST.Reference)
@@ -857,7 +860,7 @@ extension DSLTree.Atom {
     switch self {
     case .changeMatchingOptions, .assertion:
       return false
-    case .char, .scalar, .any, .backreference, .symbolicReference, .unconverted:
+    case .char, .scalar, .dot, .backreference, .symbolicReference, .unconverted:
       return true
     }
   }