Rename hasImplicitScope -> isIsolated

Author: hamishknight

Sources/_MatchingEngine/Regex/AST/Group.swift

@@ -54,10 +54,9 @@ extension AST {
       case atomicScriptRun
 
       // (?iJmnsUxxxDPSWy{..}-iJmnsUxxxDPSW:)
-      // If hasImplicitScope is true, it was written as e.g (?i), and implicitly
-      // forms a group containing all the following elements of the current
-      // group.
-      case changeMatchingOptions(MatchingOptionSequence, hasImplicitScope: Bool)
+      // Isolated options are written as e.g (?i), and implicitly form a group
+      // containing all the following elements of the current group.
+      case changeMatchingOptions(MatchingOptionSequence, isIsolated: Bool)
 
       // NOTE: Comments appear to be groups, but are not parsed
       // the same. They parse more like quotes, so are not
@@ -74,16 +73,16 @@ extension AST.Group.Kind {
     }
   }
 
-  /// Whether this is a group with an implicit scope, e.g matching options
-  /// written as (?i) implicitly become parent groups for the rest of the
-  /// elements in the current group:
+  /// Whether this is a group with an implicit scope, e.g isolated matching
+  /// options implicitly become parent groups for the rest of the elements in
+  /// the current group:
   ///
   ///      (a(?i)bc)de -> (a(?i:bc))de
   ///
   public var hasImplicitScope: Bool {
     switch self {
-    case .changeMatchingOptions(_, let hasImplicitScope):
-      return hasImplicitScope
+    case .changeMatchingOptions(_, let isIsolated):
+      return isIsolated
     default:
       return false
     }

Sources/_MatchingEngine/Regex/Parse/LexicalAnalysis.swift

@@ -602,7 +602,7 @@ extension Source {
         // Matching option changing group (?iJmnsUxxxDPSWy{..}-iJmnsUxxxDPSW:).
         if let seq = try src.lexMatchingOptionSequence() {
           if src.tryEat(":") {
-            return .changeMatchingOptions(seq, hasImplicitScope: false)
+            return .changeMatchingOptions(seq, isIsolated: false)
           }
           // If this isn't start of an explicit group, we should have an
           // implicit group that covers the remaining elements of the current
@@ -611,7 +611,7 @@ extension Source {
           // also does it across alternations, which will require additional
           // handling.
           try src.expect(")")
-          return .changeMatchingOptions(seq, hasImplicitScope: true)
+          return .changeMatchingOptions(seq, isIsolated: true)
         }
 
         guard let next = src.peek() else {

Sources/_MatchingEngine/Regex/Printing/DumpAST.swift

@@ -120,8 +120,8 @@ extension AST.Group.Kind: _ASTPrintable {
     case .nonAtomicLookbehind:   return "nonAtomicLookbehind"
     case .scriptRun:             return "scriptRun"
     case .atomicScriptRun:       return "atomicScriptRun"
-    case .changeMatchingOptions(let seq, let hasImplicitScope):
-      return "changeMatchingOptions<\(seq), \(hasImplicitScope)>"
+    case .changeMatchingOptions(let seq, let isIsolated):
+      return "changeMatchingOptions<\(seq), \(isIsolated)>"
     }
   }
 }

Sources/_StringProcessing/ASTBuilder.swift

@@ -90,9 +90,9 @@ public func atomicScriptRun(_ child: AST) -> AST {
   group(.atomicScriptRun, child)
 }
 func changeMatchingOptions(
-  _ seq: AST.MatchingOptionSequence, hasImplicitScope: Bool, _ child: AST
+  _ seq: AST.MatchingOptionSequence, isIsolated: Bool, _ child: AST
 ) -> AST {
-  group(.changeMatchingOptions(seq, hasImplicitScope: hasImplicitScope), child)
+  group(.changeMatchingOptions(seq, isIsolated: isIsolated), child)
 }
 
 func matchingOptions(

Tests/RegexTests/ParseTests.swift

@@ -475,74 +475,74 @@ extension RegexTests {
 
     // Matching option changing groups.
     parseTest("(?-)", changeMatchingOptions(
-      matchingOptions(), hasImplicitScope: true, empty())
+      matchingOptions(), isIsolated: true, empty())
     )
     parseTest("(?i)", changeMatchingOptions(
       matchingOptions(adding: .caseInsensitive),
-      hasImplicitScope: true, empty())
+      isIsolated: true, empty())
     )
     parseTest("(?m)", changeMatchingOptions(
       matchingOptions(adding: .multiline),
-      hasImplicitScope: true, empty())
+      isIsolated: true, empty())
     )
     parseTest("(?x)", changeMatchingOptions(
       matchingOptions(adding: .extended),
-      hasImplicitScope: true, empty())
+      isIsolated: true, empty())
     )
     parseTest("(?xx)", changeMatchingOptions(
       matchingOptions(adding: .extraExtended),
-      hasImplicitScope: true, empty())
+      isIsolated: true, empty())
     )
     parseTest("(?xxx)", changeMatchingOptions(
       matchingOptions(adding: .extraExtended, .extended),
-      hasImplicitScope: true, empty())
+      isIsolated: true, empty())
     )
     parseTest("(?-i)", changeMatchingOptions(
       matchingOptions(removing: .caseInsensitive),
-      hasImplicitScope: true, empty())
+      isIsolated: true, empty())
     )
     parseTest("(?i-s)", changeMatchingOptions(
       matchingOptions(adding: .caseInsensitive, removing: .singleLine),
-      hasImplicitScope: true, empty())
+      isIsolated: true, empty())
     )
     parseTest("(?i-is)", changeMatchingOptions(
       matchingOptions(adding: .caseInsensitive,
                       removing: .caseInsensitive, .singleLine),
-      hasImplicitScope: true, empty())
+      isIsolated: true, empty())
     )
 
     parseTest("(?:)", nonCapture(empty()))
     parseTest("(?-:)", changeMatchingOptions(
-      matchingOptions(), hasImplicitScope: false, empty())
+      matchingOptions(), isIsolated: false, empty())
     )
     parseTest("(?i:)", changeMatchingOptions(
       matchingOptions(adding: .caseInsensitive),
-      hasImplicitScope: false, empty())
+      isIsolated: false, empty())
     )
     parseTest("(?-i:)", changeMatchingOptions(
       matchingOptions(removing: .caseInsensitive),
-      hasImplicitScope: false, empty())
+      isIsolated: false, empty())
     )
 
     parseTest("(?^)", changeMatchingOptions(
       unsetMatchingOptions(),
-      hasImplicitScope: true, empty())
+      isIsolated: true, empty())
     )
     parseTest("(?^:)", changeMatchingOptions(
       unsetMatchingOptions(),
-      hasImplicitScope: false, empty())
+      isIsolated: false, empty())
     )
     parseTest("(?^ims:)", changeMatchingOptions(
       unsetMatchingOptions(adding: .caseInsensitive, .multiline, .singleLine),
-      hasImplicitScope: false, empty())
+      isIsolated: false, empty())
     )
     parseTest("(?^J:)", changeMatchingOptions(
       unsetMatchingOptions(adding: .allowDuplicateGroupNames),
-      hasImplicitScope: false, empty())
+      isIsolated: false, empty())
     )
     parseTest("(?^y{w}:)", changeMatchingOptions(
       unsetMatchingOptions(adding: .textSegmentWordMode),
-      hasImplicitScope: false, empty())
+      isIsolated: false, empty())
     )
 
     let allOptions: [AST.MatchingOption.Kind] = [
@@ -557,44 +557,44 @@ extension RegexTests {
         adding: allOptions,
         removing: allOptions.dropLast(2)
       ),
-      hasImplicitScope: true, empty())
+      isIsolated: true, empty())
     )
     parseTest("(?iJmnsUxxxwDPSWy{g}y{w}-iJmnsUxxxwDPSW:)", changeMatchingOptions(
       matchingOptions(
         adding: allOptions,
         removing: allOptions.dropLast(2)
       ),
-      hasImplicitScope: false, empty())
+      isIsolated: false, empty())
     )
 
     parseTest(
       "a(b(?i)c)d", concat("a", capture(concat("b", changeMatchingOptions(
         matchingOptions(adding: .caseInsensitive),
-        hasImplicitScope: true, "c"))), "d"),
+        isIsolated: true, "c"))), "d"),
       captures: .atom()
     )
     parseTest(
       "(a(?i)b(c)d)", capture(concat("a", changeMatchingOptions(
         matchingOptions(adding: .caseInsensitive),
-        hasImplicitScope: true, concat("b", capture("c"), "d")))),
+        isIsolated: true, concat("b", capture("c"), "d")))),
       captures: .tuple(.atom(), .atom())
     )
     parseTest(
       "(a(?i)b(?#hello)c)", capture(concat("a", changeMatchingOptions(
         matchingOptions(adding: .caseInsensitive),
-        hasImplicitScope: true, concat("b", "c")))),
+        isIsolated: true, concat("b", "c")))),
       captures: .atom()
     )
 
     // TODO: This is Oniguruma's behavior, but PCRE treats it as:
     //     ab(?i:c)|(?i:def)|(?i:gh)
     // instead. We ought to have a mode to emulate that.
     parseTest("ab(?i)c|def|gh", concat("a", "b", changeMatchingOptions(
-      matchingOptions(adding: .caseInsensitive), hasImplicitScope: true,
+      matchingOptions(adding: .caseInsensitive), isIsolated: true,
       alt("c", concat("d", "e", "f"), concat("g", "h")))))
 
     parseTest("(a|b(?i)c|d)", capture(alt("a", concat("b", changeMatchingOptions(
-      matchingOptions(adding: .caseInsensitive), hasImplicitScope: true,
+      matchingOptions(adding: .caseInsensitive), isIsolated: true,
       alt("c", "d"))))),
       captures: .atom())