simplify atomic group handling

not sure what I was thinking before it was over complicated a lot

src/__snapshots__/redos-detector.test.ts.snap

@@ -292511,51 +292511,9 @@ exports[`RedosDetector isSafe cases /a+a{0,3}$/ 4`] = `"Regex is safe. There cou
 
 exports[`RedosDetector isSafe cases /a?(?=(a{0,1}))\\1$/ 1`] = `null`;
 
-exports[`RedosDetector isSafe cases /a?(?=(a{0,1}))\\1$/ 2`] = `
-Object {
-  "infinite": false,
-  "value": 1,
-}
-`;
-
-exports[`RedosDetector isSafe cases /a?(?=(a{0,1}))\\1$/ 3`] = `
-Array [
-  Object {
-    "trail": Array [
-      Object {
-        "a": Object {
-          "backreferenceStack": Array [],
-          "node": Object {
-            "end": Object {
-              "offset": 1,
-            },
-            "source": "a",
-            "start": Object {
-              "offset": 0,
-            },
-          },
-          "quantifierIterations": "removed",
-        },
-        "b": Object {
-          "backreferenceStack": Array [],
-          "node": Object {
-            "end": Object {
-              "offset": 18,
-            },
-            "source": "a",
-            "start": Object {
-              "offset": 17,
-            },
-          },
-          "quantifierIterations": "removed",
-        },
-      },
-    ],
-  },
-]
-`;
+exports[`RedosDetector isSafe cases /a?(?=(a{0,1}))\\1$/ 2`] = `Array []`;
 
-exports[`RedosDetector isSafe cases /a?(?=(a{0,1}))\\1$/ 4`] = `"Regex is safe. There could be at most 1 backtrack."`;
+exports[`RedosDetector isSafe cases /a?(?=(a{0,1}))\\1$/ 3`] = `"Regex is safe."`;
 
 exports[`RedosDetector isSafe cases /a?(?=a?)$/ 1`] = `null`;
 

src/character-groups.ts

@@ -1,5 +1,5 @@
 import { intersectRanges, OurRange } from './our-range';
-import { mergeSets, subtractSets } from './set';
+import { mergeSets, subtractSets } from './sets';
 
 export type MutableCharacterGroups = {
   characterClassEscapes: Set<string>;

src/checker-reader.ts

@@ -1,3 +1,4 @@
+import { areSetsEqual, setsOverlap } from './sets';
 import {
   AstNode,
   CharacterClass,
@@ -28,15 +29,11 @@ import {
   characterReaderLevel2TypeSplit,
   CharacterReaderLevel2Value,
 } from './character-reader/character-reader-level-2';
-import { atomicGroupsToSynchronisationCheckerKeys } from './atomic-groups-to-synchronisation-checker-keys';
 import { BackReferenceStack } from './character-reader/character-reader-level-1';
-import { Groups } from './nodes/group';
 import { InfiniteLoopTracker } from './infinite-loop-tracker';
 import { last } from './arrays';
 import { MyFeatures } from './parse';
-import { setsOverlap } from './set';
 import { SidesEqualChecker } from './sides-equal-checker';
-import { synchronisationCheck } from './synchronisation-checker';
 
 export type CheckerInput = Readonly<{
   atomicGroupOffsets: ReadonlySet<number>;
@@ -350,34 +347,20 @@ export function* buildCheckerReader(input: CheckerInput): CheckerReader {
         return;
       }
 
-      const syncResult = synchronisationCheck(
-        atomicGroupsInSync,
-        atomicGroupsToSynchronisationCheckerKeys({
-          atomicGroupOffsets: input.atomicGroupOffsets,
-          leftGroupsNow: leftValue.groups,
-          leftPreceedingGroups: leftValue.preceedingZeroWidthEntries.reduce<
-            Groups[]
-          >(
-            (acc, entry) =>
-              entry.type === 'groups' ? [...acc, entry.groups] : acc,
-            []
-          ),
-          rightGroupsNow: rightValue.groups,
-          rightPreceedingGroups: rightValue.preceedingZeroWidthEntries.reduce<
-            Groups[]
-          >(
-            (acc, entry) =>
-              entry.type === 'groups' ? [...acc, entry.groups] : acc,
-            []
-          ),
-        })
+      const leftAtomicGroups = new Set(
+        [...leftValue.groups.keys()].filter((group) =>
+          input.atomicGroupOffsets.has(group.range[0])
+        )
       );
-
-      if (syncResult.type === 'goneOutOfSync') {
+      const rightAtomicGroups = new Set(
+        [...rightValue.groups.keys()].filter((group) =>
+          input.atomicGroupOffsets.has(group.range[0])
+        )
+      );
+      if (!areSetsEqual(leftAtomicGroups, rightAtomicGroups)) {
         dispose();
         return;
       }
-      atomicGroupsInSync = syncResult.keysInSync;
 
       const newEntry: TrailEntry = {
         intersection,

src/redos-detector.test.ts

@@ -403,7 +403,7 @@ describe('RedosDetector', () => {
         [/(?=(a{0,1}))\1a?$/, true],
         [/(?=(a?))\1a?$/, true],
         [/(?=(a?b))\1a?$/, true],
-        [/a?(?=(a{0,1}))\1$/, false],
+        [/a?(?=(a{0,1}))\1$/, true],
         [/(?=(a?a?))\1a$/, false],
 
         // atomic group workaround not detected because group not entire lookahead

src/sets.test.ts

@@ -0,0 +1,55 @@
+import { areSetsEqual, mergeSets, setsOverlap, subtractSets } from './sets';
+
+describe('Sets', () => {
+  describe('areSetsEqual', () => {
+    it('works', () => {
+      expect(areSetsEqual(new Set(), new Set())).toBe(true);
+      expect(areSetsEqual(new Set([1]), new Set([]))).toBe(false);
+      expect(areSetsEqual(new Set([]), new Set([1]))).toBe(false);
+      expect(areSetsEqual(new Set([1]), new Set([1]))).toBe(true);
+      expect(areSetsEqual(new Set([1, 2]), new Set([1, 3]))).toBe(false);
+      expect(areSetsEqual(new Set([2, 1]), new Set([1, 2]))).toBe(true);
+    });
+  });
+
+  describe('mergeSets', () => {
+    it('works', () => {
+      expect([...mergeSets(new Set(), new Set())]).toStrictEqual([]);
+      expect([...mergeSets(new Set([1]), new Set([2]))].sort()).toStrictEqual([
+        1, 2,
+      ]);
+      expect(
+        [...mergeSets(new Set([1, 2]), new Set([2]))].sort()
+      ).toStrictEqual([1, 2]);
+      expect(
+        [...mergeSets(new Set([1, 2]), new Set([2, 3]))].sort()
+      ).toStrictEqual([1, 2, 3]);
+    });
+  });
+
+  describe('subtractSets', () => {
+    it('works', () => {
+      expect([...subtractSets(new Set(), new Set())]).toStrictEqual([]);
+      expect(
+        [...subtractSets(new Set([1]), new Set([2]))].sort()
+      ).toStrictEqual([1]);
+      expect(
+        [...subtractSets(new Set([1, 2]), new Set([2]))].sort()
+      ).toStrictEqual([1]);
+      expect(
+        [...subtractSets(new Set([1, 2]), new Set([2, 3]))].sort()
+      ).toStrictEqual([1]);
+    });
+  });
+
+  describe('setsOverlap', () => {
+    it('works', () => {
+      expect(setsOverlap(new Set(), new Set())).toBe(false);
+      expect(setsOverlap(new Set([1]), new Set([]))).toBe(false);
+      expect(setsOverlap(new Set([]), new Set([1]))).toBe(false);
+      expect(setsOverlap(new Set([1]), new Set([1]))).toBe(true);
+      expect(setsOverlap(new Set([1, 2]), new Set([1, 3]))).toBe(true);
+      expect(setsOverlap(new Set([2, 1]), new Set([1, 2]))).toBe(true);
+    });
+  });
+});

src/set.ts → src/sets.ts

@@ -1,3 +1,11 @@
+export function areSetsEqual<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): boolean {
+  if (a.size !== b.size) return false;
+  for (const entry of a) {
+    if (!b.has(entry)) return false;
+  }
+  return true;
+}
+
 export function mergeSets<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): Set<T> {
   return new Set([...a, ...b]);
 }