GeezerVison

run_analysis keeps a Python set for every basic block, and a new one for every op whose gen/kill sets aren't empty. In large functions these sets have thousands of items, so the data-flow analyses take O(ops * values) time and memory. The must-defined and borrowed-arguments analyses are the worst, since a must analysis starts every block from a copy of the full universe. This makes the refcount transform very slow for large functions, such as generated code or long module top levels.

This PR represents the sets as int bit masks:

• BitIndex assigns a bit position to each value an analysis sees.
• The worklist algorithm works on masks, so union, intersection and difference are integer operations. Since ints are immutable, an op whose gen/kill sets are empty shares the previous result, as before.
• The gen/kill masks of each op are computed once, instead of running the visitor again in the op-level pass.
• The results are BitSet objects that implement collections.abc.Set, so the code using the results only needed annotation changes (set[Value] -> AbstractSet[Value] in refcount.py).
• analyze_live_regs, analyze_borrowed_arguments and analyze_must_defined_regs take an optional index. The refcount transform shares one index between the three, because it combines their results (e.g. live - live - borrowed after a branch); with a shared index these operations are integer operations too. With different indexes, BitSet still works and, like set, iterates over the smaller operand.
• Reflected operations (set - bitset, set & bitset, set | bitset) return a real set, since typeshed says the result is a set and compiled code checks this. find_always_defined_attributes relies on it.

Benchmark

A function with n statements of this form:

    a{i} = xs[{i % 7}] + {i}
    if a{i}:
        t = a{i}

Each analysis timed separately, then insert_ref_count_opcodes (interpreted). Max RSS is for the whole process:

Liveness is a bit slower, because live sets are small and a mask grows with the number of values. It is still a small part of the total.

On ordinary code, compiling mypy/checker.py, mypy/checkexpr.py, mypy/semanal.py and mypy/messages.py with the analysis and transform modules compiled by mypyc:

Testing

• The generated C for those four modules is identical to master, both with interpreted and compiled analysis modules, and the IR for the benchmark functions is identical.
• The full mypyc test suite passes interpreted. The IR, refcount, exceptions, always-defined, spill and run tests also pass with dataflow.py and its users compiled by mypyc.
• New mypyc/test/test_bitset.py covers BitSet operations: same index, different index, mixed with set, and the types the reflected operations return.

This is independent of #22425 (which removes temporaries from the must-defined universe). The two merge without conflicts and help in different ways: #22425 makes the sets smaller, this PR makes each item cost a bit instead of a hash table entry.