Method call on imported definition differs inside of a list comprehension

[DinoV]

Bug report

Bug description:

import re
[x for x in [] if re.match(".*", x)]

vs:

import re
re.match(".*", x)

When you disassemble these you'll see the inlined one will be doing a LOAD_ATTR 3 (match + NULL|self) while the one outside of the comprehension will be doing a PUSH_NULL/CALL which is to disable the method call optimization on things which are likely not methods.

These should both have the same byte code. There's no perceivable code execution difference other than performance though.

CPython versions tested on:

3.12, CPython main branch

Operating systems tested on:

Linux

[Eclips4]

cc @carljm

[5Six]

Tried to reproduce the difference but seems to give me the same bytecode:

My code:

import re
import dis

code_comprehension = "[x for x in [] if re.match('.*', x)]"
print("List Comprehension Bytecode:")
dis.dis(code_comprehension)

code_standard = "re.match('.*', x)"
print("\nStandard Call Bytecode:")
dis.dis(code_standard)

Result (relevant bits):

       L2:     FOR_ITER                30 (to L5)
               STORE_FAST               0 (x)
               LOAD_NAME                0 (re)
               LOAD_ATTR                3 (match + NULL|self)
               LOAD_CONST               1 ('.*')
               LOAD_FAST                0 (x)
               CALL                     2
               TO_BOOL

  1           LOAD_NAME                0 (re)
              LOAD_ATTR                3 (match + NULL|self)
              LOAD_CONST               0 ('.*')
              LOAD_NAME                2 (x)
              CALL                     2
              RETURN_VALUE

(Sorry if I'm wrong or misunderstood something, a bit new to this)

[Eclips4]

Tried to reproduce the difference but seems to give me the same bytecode:

My code:

import re
import dis

code_comprehension = "[x for x in [] if re.match('.*', x)]"
print("List Comprehension Bytecode:")
dis.dis(code_comprehension)

code_standard = "re.match('.*', x)"
print("\nStandard Call Bytecode:")
dis.dis(code_standard)

Result (relevant bits):

       L2:     FOR_ITER                30 (to L5)
               STORE_FAST               0 (x)
               LOAD_NAME                0 (re)
               LOAD_ATTR                3 (match + NULL|self)
               LOAD_CONST               1 ('.*')
               LOAD_FAST                0 (x)
               CALL                     2
               TO_BOOL

  1           LOAD_NAME                0 (re)
              LOAD_ATTR                3 (match + NULL|self)
              LOAD_CONST               0 ('.*')
              LOAD_NAME                2 (x)
              CALL                     2
              RETURN_VALUE

(Sorry if I'm wrong or misunderstood something, a bit new to this)

You're missed import of re module :) With explicit import bytecode will differ slightly.
Try this:

import re
import dis

code_comprehension = "import re\n[x for x in [] if re.match('.*', x)]"
print("List Comprehension Bytecode:")
dis.dis(code_comprehension)

code_standard = "import re\nre.match('.*', x)"
print("\nStandard Call Bytecode:")
dis.dis(code_standard)

[carljm]

I'll put this on my list, but not sure when I can get to it.