Simple AST level Optimization that would have ~1.5-2.5% gains for certain tests

[GanerCodes]

Feature or enhancement

Proposal:

If we collapse statements of the form:

X = expr
X = expr that immediately and only once references X (i.e. X.a or X().y+2)

we can compose the RHS of the first line into the second line, i.e.
X = y() ; X = X.k()**2 ⟶ X = y().k()**2

Test (Ryzen 7 3800X, locked to 1 core, Python 3.13.3, no FT/JIT) sees f2 being ~2% faster than f1

import timeit

class B:
    def __init__(self):
        self.c = 42
class A:
    def __init__(self):
        self.b = B()

def f1():
    a = A()
    return a.b.c

def f2():
    a = A()
    a = a.b
    return a.c

number = 100_000_000
for _ in range(25):
    t1 = timeit.timeit('f1()', globals=globals(), number=number)
    t2 = timeit.timeit('f2()', globals=globals(), number=number)
    print(f'{t1:.9f} {t2:.9f} ⇒ {(t2/t1-1)*100:.9f}%')

We observe the slightly larger bytecode output (68 vs 64 instr):

Has this already been discussed elsewhere?

I don't think

[Fidget-Spinner]

Sadly, I think this would break debuggers that stop at the first line and expect to introspect the value of x?

[GanerCodes]

Sadly, I think this would break debuggers that stop at the first line and expect to introspect the value of x?

good catch; although I don't avoiding optimizations for debugging purposes is a good idea; so ideally this would get toggled using one of the optimization level flags

[Fidget-Spinner]

If you're interested in such optimizations, a safer place to do them is in the JIT compiler, not the AST.

[ZeroIntensity]

It would also break frame introspection: accessing f_locals or locals() would miss the variable. For example:

import inspect

class A:
    def foo(self):
        assert self == inspect.currentframe().f_back.f_locals["a"]
        return "bar"

a = A()
assert a.foo() == "bar"  # This cannot be safely optimized to A().foo() == "bar"

[Fidget-Spinner]

Closing because it's not feasible to do in the AST.