gh-153044: Note the flag-context invariant of the complement rule

Unicode \w and ascii \W overlap, so a category and its complement are
only disjoint within one flag context; this holds because the walk
never compares atoms across a flag-scoping boundary.  Add tests pinning
that (?a:\w+)\W and \w+(?a:\W) are not possessified, while \w+\W and
(?a:\w+\W) are.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: serhiy-storchaka

Lib/re/_optimizer.py

@@ -644,7 +644,10 @@ def _disjoint(atom, other, flags):
     ca = _as_single_category(*atom)
     if ca is not None:
         cb = _as_single_category(*other)
-        # a category and its complement are disjoint whatever they mean
+        # A category and its complement are disjoint whatever they mean --
+        # but only within one flag context (unicode \w and ascii \W
+        # overlap), which holds because the walk never compares atoms
+        # across a flag-scoping boundary.
         if cb is not None and cb == CH_NEGATE[ca]:
             return True
     if not (flags & SRE_FLAG_LOCALE):

Lib/test/test_re.py

@@ -3102,6 +3102,7 @@ def is_possessive(self, pattern, flags=0):
         # a category and its complement are disjoint whatever they mean
         (r'\p{Lu}+\P{Lu}', 0), (r'\P{Cased}+\p{Cased}', 0),
         (r'\p{Lu}+\P{Lu}', re.I), (r'\d+\D', 0),
+        (r'\w+\W', 0), (r'(?a:\w+\W)', 0),
     ])
     def test_possessified(self, pattern, flags):
         self.assertTrue(self.is_possessive(pattern, flags))
@@ -3113,6 +3114,8 @@ def test_possessified(self, pattern, flags):
         (r'a+\b', 0), (r'a+\B', 0),                     # word boundary
         (r'a+(?=a)', 0), (r'a+(?!b)', 0),               # lookaround
         (r'(?i:a)+A', 0), (r'a+(?i:A)', 0),             # scoped flags
+        # not complement pairs: unicode \w and ascii \W overlap (e.g. é)
+        (r'(?a:\w+)\W', 0), (r'\w+(?a:\W)', 0),
         (b'a+B', re.L | re.I),                          # runtime locale folding
         (r'a+?b', 0),                                   # lazy
         (r'[a-z--b]+c', 0), (r'[\w--\d]+\w', 0),       # follower in the set