"""Что PEP 709 изменил, чего не изменил — и почему «вынести метод» подорожало.

ТРИ ВОПРОСА, НА КОТОРЫЕ ОТВЕЧАЕТ ЭТОТ СКРИПТ.

  1. ЧТО ИЗМЕНИЛОСЬ В 3.12. PEP 709 встроил списковые, словарные и
     множественные включения в вызывающий код: отдельного объекта кода у них
     больше нет. Видно по `co_consts` и по отсутствию `MAKE_FUNCTION`.

  2. ЧЕГО ОН НЕ ИЗМЕНИЛ. Область видимости. PEP говорит, что изоляция
     переменных сохраняется — теперь через сохранение и восстановление на
     стеке вместо вызова функции. Проверяется не байт-кодом, а `scope.py`:
     на всех четырёх версиях включение в теле класса даёт один и тот же
     `NameError`.

  3. ПОЧЕМУ ПРИЁМ «ВЫНЕСТИ МЕТОД В ЛОКАЛЬНУЮ» БОЛЬШЕ НЕ ПОМОГАЕТ. Совет
     старый и когда-то был верен. Замер (`cost.py`) даёт обратный знак около
     десяти процентов, и объяснение — здесь: инструкций в теле цикла ровно
     столько же, но вызов идёт другим путём.
"""
import dis
import sys

print("PY", sys.version.split()[0])


def rule(title):
    print()
    print(title)
    print("-" * len(title))


def opnames(code):
    return [i.opname for i in dis.get_instructions(code)]


# ------------------------------------------------ 1. что изменил PEP 709
rule("1. Встраивание включений (PEP 709, 3.12)")

CASES = [
    ("списковое включение", "x = [i for i in src]"),
    ("словарное включение", "x = {i: i for i in src}"),
    ("множественное включение", "x = {i for i in src}"),
    ("генераторное выражение", "x = (i for i in src)"),
]
for label, src in CASES:
    code = compile(src, "<bench>", "exec")
    names = opnames(code)
    has_make = "MAKE_FUNCTION" in names
    nested = [c for c in code.co_consts if hasattr(c, "co_name")]
    print(
        f"  {label:<26} MAKE_FUNCTION: {'есть' if has_make else 'нет ':<5}"
        f"  вложенный объект кода: {nested[0].co_name if nested else 'нет'}"
    )

print()
print("  Генераторное выражение PEP 709 не касается — у него отдельная функция")
print("  и отдельный кадр остались. Три остальных встроены.")


# ------------------------------------- 3. почему «вынести метод» дороже
rule("2. Почему «вынести метод в локальную» стало дороже")


def by_loop(src, f):
    out = []
    for x in src:
        out.append(f(x))
    return out


def by_loop_hoisted(src, f):
    out = []
    append = out.append
    for x in src:
        append(f(x))
    return out


def loop_body(fn):
    """Инструкции между FOR_ITER и JUMP_BACKWARD — то, что исполняется на
    каждом элементе. Всё остальное отрабатывает один раз и в счёт не идёт."""
    names = opnames(fn)
    start = names.index("FOR_ITER") + 1
    end = names.index("JUMP_BACKWARD")
    return names[start:end]


for fn in (by_loop, by_loop_hoisted):
    body = loop_body(fn)
    print(f"  {fn.__name__:<18} {len(body)} инструкций в теле цикла")
    print(f"  {'':<18} {' '.join(body)}")

print()
n_plain = len(loop_body(by_loop))
n_hoist = len(loop_body(by_loop_hoisted))
print(f"  Инструкций в теле цикла поровну — {n_plain} и {n_hoist}. Разница не в")
print("  количестве, а в том, ЧТО стоит на месте вызова.")
print()
print("  `out.append(...)` компилируется в LOAD_ATTR с установленным младшим")
print("  битом аргумента. Документация dis описывает эту форму так: «if")
print("  STACK[-1] has a method with the correct name, the bytecode pushes the")
print("  unbound method and STACK[-1]. STACK[-1] will be used as the first")
print("  argument (self) by CALL». То есть self кладётся на стек здесь же, и")
print("  объекта связанного метода не возникает вовсе.")
print()
print("  `append(...)` через локальную переменную — обычный вызов обычного")
print("  объекта: PUSH_NULL плюс вызов уже связанного метода, которому self")
print("  придётся подставить самому, на каждом вызове.")
print()
print("  Замер (cost.py) даёт разницу около десяти процентов не в пользу")
print("  «оптимизации». Совет вынести метод в локальную пришёл из времён, когда")
print("  поиск атрибута был непредсказуемо дорогим; с тех пор подешевел он, а")
print("  не альтернатива ему.")