Can we write a test for this? I can't think of one.

We can write something stable, then if it deopts the test fails:

class A:
    @property
    def foo(s): pass

a = A()

def f():
    a.foo

for _ in range(8):
    f()
# dissassemble f and inspect that LOAD_ATTR_PROPERTY is inside
for _ in range(x):
    f()
    # dissassemble f and inspect that LOAD_ATTR_PROPERTY is still inside in every single iteration, else fail

Can we write a test for this?
I can't think of one.

In general, I think we should probably have better testing that isn't as heavy as the stuff in test_dis.py. The stuff in test_opcache is good for testing regressions in behavior, but not useful for catching things like this.

It shouldn't be too hard to set up a simple test harness that's able to assert that an opcode in co_code maps to another opcode at the same position in _co_code_adaptive after a specific number of calls. That would be capable of testing that simple, specific optimizations and deoptimizations work without lots of ongoing maintenance every time we change the bytecode.

We could even extend it check cache values, so that we're confident that things like exponential backoff keep working as expected.