Address Copilot review comments on PR #62

- fastparser.py: replace the shared matching/meanings cache dicts
  instead of clearing them in place when the size cap is hit; in-flight
  parse jobs in other threads hold references to the current dicts,
  which keeps the CFFI buffers that the C++ core points into alive
  until those jobs complete (avoiding a potential use-after-free)
- eparser.h/.cpp: make the parity mismatch counter a relaxed atomic,
  consistent with the other counters, since it is incremented from
  within concurrent parses
- CLAUDE.md: update stale guidance - mypy is now clean and runs as a
  CI gate on non-PyPy jobs

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: vthorsteinsson

CLAUDE.md

@@ -29,8 +29,8 @@ uv run pytest test/test_parse.py::test_long_parse
 # Lint (CI runs this)
 uv run ruff check src/reynir
 
-# Type check (config in pyproject.toml [tool.mypy]; carries a handful of
-# known pre-existing errors, so it is not a CI gate)
+# Type check (config in pyproject.toml [tool.mypy]; runs as a CI gate
+# on non-PyPy jobs, so it must stay clean)
 uv run mypy src/reynir
 ```
 

src/reynir/eparser.cpp

@@ -1102,7 +1102,7 @@ void Parser::setMatchingTable(const BYTE* pSpecs, UINT nSpecs,
    this->m_nSpecs = 0;
    this->m_pMeaningsFunc = NULL;
    this->m_bParity = bParity;
-   this->m_nParityMismatches = 0;
+   this->m_nParityMismatches.store(0, std::memory_order_relaxed);
    memset(&this->m_masks, 0, sizeof(MatchMasks));
    if (!pSpecs || !nSpecs || !fpMeanings || !pMasks)
       return;

src/reynir/eparser.h

@@ -422,7 +422,9 @@ class Parser {
    MeaningsFunc m_pMeaningsFunc;
    MatchMasks m_masks;
    BOOL m_bParity;             // Parity checking mode
-   UINT m_nParityMismatches;
+   // Atomic (like the diagnostic allocation counters), since it is
+   // incremented from within concurrent parses
+   std::atomic<UINT> m_nParityMismatches;
 
    void push(UINT nHandle, State*, Column*, State*&, StateChunk*);
 
@@ -466,9 +468,9 @@ class Parser {
    BOOL parityMode(void) const
       { return this->m_bParity; }
    void countParityMismatch(void)
-      { this->m_nParityMismatches++; }
+      { this->m_nParityMismatches.fetch_add(1, std::memory_order_relaxed); }
    UINT getParityMismatches(void) const
-      { return this->m_nParityMismatches; }
+      { return this->m_nParityMismatches.load(std::memory_order_relaxed); }
 
    // Evaluate a native token/terminal match
    static BOOL evalMatch(const TerminalSpec*, const BYTE* pTokenRec, const MatchMasks&);

src/reynir/fastparser.py

@@ -881,11 +881,15 @@ def go(self, tokens: Iterable[Tok], *, root: Optional[str] = None) -> Node:
         result: Optional[Node] = None
 
         if len(self._matching_cache) > self._MAX_MATCHING_CACHE_SIZE:
-            # The matching cache has grown too large: clear it.
+            # The matching cache has grown too large: discard it.
             # The cost is only that subsequent parses need to re-match
             # tokens against terminals as they are encountered again.
-            self._matching_cache.clear()
-            self._meanings_cache.clear()
+            # Note: the dicts are replaced, not cleared in place. Parse
+            # jobs that may be in flight in other threads hold references
+            # to the current dicts, which keeps the CFFI buffers that the
+            # C++ core points into alive until those jobs complete.
+            self._matching_cache = dict()
+            self._meanings_cache = dict()
 
         # Use the context manager protocol to guarantee that the parse job
         # handle will be properly deleted even if an exception is thrown