Create slice object while unmarshaling instead of runtime as a constant

[kumaraditya303]

Take the following code as example:

def func():
    a = [1,2]
    return a[::-1]

It creates the following bytecode:

  2           0 RESUME                   0

  3           2 LOAD_CONST               1 (1)
              4 LOAD_CONST               2 (2)
              6 BUILD_LIST               2
              8 STORE_FAST               0 (a)

  4          10 LOAD_FAST                0 (a)
             12 LOAD_CONST               0 (None)
             14 LOAD_CONST               0 (None)
             16 LOAD_CONST               3 (-1)
             18 BUILD_SLICE              3
             20 BINARY_SUBSCR
             30 RETURN_VALUE

The slice object is created and destroyed almost immediately, although there is a slice cache on the interpreter state but still it is inefficient. Ideally we want this bytecode for slice objects with integers only:

  2           0 RESUME                   0

  3           2 LOAD_CONST               1 (1)
              4 LOAD_CONST               2 (2)
              6 BUILD_LIST               2
              8 STORE_FAST               0 (a)

  4          10 LOAD_FAST                0 (a)
             12 LOAD_CONST               2 slice(None, None, -1)
             XX BINARY_SUBSCR
             XX RETURN_VALUE

Since slice is not hashable it can marshalled as a tuple of len 3 and since all the indices of slice are integers it will be hashable. It will help in deepfreeze too.

[JelleZijlstra]

See also https://bugs.python.org/issue42454

[markshannon]

and #319