[BUG] Redeclaring variable in pure python mode is not raising error

Describe the bug

Redeclaring variable in pure python mode is behaving not consistently with cython code. E.g. in cython following code raises error:

def foo():
    cdef float a = 3.0
    cdef int a = 1
    print(a)

Error compiling Cython file:
------------------------------------------------------------
...
# cdef int a = 1
# cdef int a = 2.0

def foo():
    cdef float a = 3.0
    cdef int a = 1
             ^
------------------------------------------------------------

bug.pyx:8:13: 'a' redeclared

Code to reproduce the behaviour:

def foo():
    a: cython.float = 3.0
    a: cython.int = 1
    print(a)

$ python
Python 3.9.12 (main, May  8 2022, 18:05:13)
[Clang 12.0.0 (clang-1200.0.32.29)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import bug
>>> bug.foo()
1.0
>>>

Expected behaviour

There are two possible solutions:

1. compiling code will fail with error as in cython code
2. code prints value 1

Environment

OS: macOS Python version 3.9.12 Cython version master

Additional context

No response

[scoder]

I think it is better if cython will be more strict than python -> not allowing redeclaring variables rather then generating code which behaves in a way that user does not expect.

I and probably others always thought of cython as some kind of superset of python, is it a good reson to break this? It feels like cython always tries to follow the idea if it’s like that in python, we do it the same way

PEP 526 has this to say on the matter:

Duplicate type annotations will be ignored. However, static type checkers
may issue a warning for annotations of the same variable by a different type:

a: int
a: str  # Static type checker may or may not warn about this.

So, in Python, this is a warning at best.

However, when you run Cython on typed code, you are not just saying, “please compile this Python code for me”, you are also explicitly enabling static typing. I think that explicit step of a user from “run this Python code with type annotations ignored at runtime” to “compile this Python code with static typing” is enough of a reason to let Cython reject contradicting type declarations with a compile error. This should not just be a warning, even if Cython does not completely understand the annotation yet.

If we encounter conflicting type annotations in user code, it seems more likely (to me) that it’s a bug than intention. Intuitively, if you want different types for a variable, then why do you use the same variable name in the first place? The differently typed cases are probably really referring to different things that are worth having different names.

[matusvalo]

I personally prefer @scoder solution.