"""Что интерпретатор делает на вызове — по байт-коду, а не по описанию.

ЗАЧЕМ ЭТОТ СКРИПТ. `cost.py` показывает, что `o.m()` стоит почти столько же,
сколько вызов обычной функции, хотя «должен» стоить дороже: по модели данных
`o.m` — это обращение к дескриптору, который создаёт объект связанного метода,
и только потом вызов. Здесь видно, почему числа получаются другими: объект
связанного метода на этом пути не создаётся вовсе. Его отсутствие — не
рассуждение, а наблюдаемый факт: в разобранном байт-коде стоит пара инструкций,
устроенная именно так.

ЧТО ЗДЕСЬ ПРЕДЪЯВЛЯЕТСЯ.

1. Какую специализацию интерпретатор выбрал после прогрева для каждой формы
   вызова. Видно через `dis.dis(..., adaptive=True)`.
2. Что `o.m` и `o.m()` — разные пути, а не «второе есть первое плюс скобки».
3. Что документации на выбранные опкоды нет: строк `CALL_PY_EXACT_ARGS` и
   `LOAD_ATTR_METHOD_WITH_VALUES` нет в `Doc/library/dis.rst`. Скрипт проверяет
   это по установленной документации, если она есть, и говорит прямо, когда
   проверить нечем.

ЧТО ЗДЕСЬ НЕ МЕРЯЕТСЯ. Время. Байт-код — свойство кода, его между версиями
сравнивать можно; время между версиями не сравнивается вовсе.

ЗАПУСК:

    for v in 3.12 3.13 3.14; do python$v bench/calls/shapes.py; done
"""

import dis
import io
import platform
import sys

WARMUP = 200


SRC = '''
class C:
    def m(self, x): return x
    @staticmethod
    def s(x): return x
    @classmethod
    def c(cls, x): return x

def plain(x): return x

def call_function(n):
    t = 0
    for _ in range(n):
        t = plain(t)
    return t

def call_method(n, o):
    t = 0
    for _ in range(n):
        t = o.m(t)
    return t

def call_prebound(n, bound):
    t = 0
    for _ in range(n):
        t = bound(t)
    return t

def call_static(n):
    t = 0
    for _ in range(n):
        t = C.s(t)
    return t

def call_classmethod(n):
    t = 0
    for _ in range(n):
        t = C.c(t)
    return t

def call_builtin(n, data):
    t = 0
    for _ in range(n):
        t = len(data)
    return t

def just_lookup(n, o):
    t = None
    for _ in range(n):
        t = o.m
    return t
'''


def opcodes(fn) -> list[str]:
    """Инструкции ТЕЛА ЦИКЛА — от FOR_ITER до прыжка назад.

    Брать весь разбор нельзя: у каждой функции в заголовке стоит свой вызов
    `range(n)`, и его LOAD_GLOBAL с CALL попадали бы в каждую строку таблицы,
    одинаковые и бессмысленные. Интересует ровно то, что повторяется.
    """
    body: list[str] = []
    inside = False
    for ins in dis.get_instructions(fn, adaptive=True):
        name = ins.opname
        if name.startswith("FOR_ITER"):
            inside = True
            continue
        if name.startswith("JUMP_BACKWARD"):
            inside = False
            continue
        if inside and name.startswith(("CALL", "LOAD_ATTR", "LOAD_GLOBAL")):
            body.append(name)
    return body


def head(n: int, title: str) -> None:
    line = f"{n}. {title}"
    print(f"\n{line}\n{'-' * len(line)}")


def main() -> None:
    print(f"Python {platform.python_version()}")
    print(f"Сборка: {sys.version.split('[')[-1].rstrip('] ')}")
    print("\nЗдесь разбирается байт-код — свойство кода, а не время.")

    ns: dict = {}
    exec(SRC, ns)  # noqa: S102 — код свой, не из ввода
    obj = ns["C"]()
    data = [1, 2, 3]
    ns["call_function"](WARMUP)
    ns["call_method"](WARMUP, obj)
    ns["call_prebound"](WARMUP, obj.m)
    ns["call_static"](WARMUP)
    ns["call_classmethod"](WARMUP)
    ns["call_builtin"](WARMUP, data)
    ns["just_lookup"](WARMUP, obj)

    head(1, "ЧТО ВЫБРАЛ ИНТЕРПРЕТАТОР ПОСЛЕ ПРОГРЕВА")
    print(f"  Каждая форма прогрета {WARMUP} вызовами, затем разобрана.")
    print("  форма вызова                инструкции после специализации")
    rows = [
        ("plain(t)", "call_function"),
        ("o.m(t)", "call_method"),
        ("bound(t)", "call_prebound"),
        ("C.s(t)", "call_static"),
        ("C.c(t)", "call_classmethod"),
        ("len(data)", "call_builtin"),
        ("o.m  — только чтение", "just_lookup"),
    ]
    seen = {}
    for label, name in rows:
        ops = opcodes(ns[name])
        seen[label] = ops
        print(f"  {label:<27s} {' + '.join(ops)}")

    head(2, "ЧТЕНИЕ АТРИБУТА И ВЫЗОВ МЕТОДА — РАЗНЫЕ ПУТИ")
    print("  o.m   без вызова:  " + " + ".join(seen["o.m  — только чтение"]))
    print("  o.m(t) с вызовом:  " + " + ".join(seen["o.m(t)"]))
    print("\n  Инструкция чтения РАЗНАЯ. Во втором случае интерпретатор знает,")
    print("  что сразу за чтением стоит вызов, и кладёт на стек функцию и")
    print("  экземпляр по отдельности — объект связанного метода не создаётся.")
    print("  Отсюда и число из cost.py: o.m() почти не дороже вызова функции.")

    head(3, "ТО ЖЕ САМОЕ, ПРОВЕРЕННОЕ ЧЕРЕЗ ОБЪЕКТЫ")
    print(f"  type(o.m)                         {type(obj.m).__name__}")
    print(f"  o.m is o.m                        {obj.m is obj.m}")
    print(f"  o.m == o.m                        {obj.m == obj.m}")
    print(f"  o.m.__func__ is C.__dict__['m']    {obj.m.__func__ is ns['C'].__dict__['m']}")
    print("\n  Каждое чтение o.m создаёт НОВЫЙ объект: два подряд не тождественны.")
    print("  Именно этой работы и нет на пути вызова через точку.")

    head(4, "ЕСТЬ ЛИ У ЭТИХ ОПКОДОВ ДОКУМЕНТАЦИЯ")
    names = sorted({op for ops in seen.values() for op in ops})
    documented = set(dis.opmap)
    print("  опкод                            есть в dis.opmap (то есть в языке)")
    for name in names:
        print(f"  {name:<32s} {'да' if name in documented else 'НЕТ — только специализация'}")
    print("\n  dis.opmap перечисляет инструкции, у которых есть имя в модуле dis.")
    print("  Специализаций там нет: они видны только через adaptive=True и в")
    print("  Doc/library/dis.rst не описаны. Опираться на них в коде нельзя —")
    print("  это деталь реализации, которая меняется между выпусками.")


main()