Reusing variable name in different scopes

[takeda]

I saw that there is a similar bug around redefining a variable, but I believe this one is slightly different problem, here is the code:

#! /usr/bin/env python

from typing import Dict, List, Union

def main(arg):
	# type: (bool) -> Union[Dict[str, str], List[str]]

	if arg:
		var = list()
		var.append('something')
	else:
		var = dict()
		var['key'] = 'something'

	return var


if __name__ == '__main__':
	main(True)

The variable var while it uses the same name, it is technically a different variable, but mypy 0.630 is complaining about it:

$ ../py37/bin/mypy --python-executable ../py27/bin/python test.py
test.py:12: error: Incompatible types in assignment (expression has type "Dict[<nothing>, <nothing>]", variable has type "List[str]")
test.py:13: error: No overload variant of "__setitem__" of "list" matches argument types "str", "str"
test.py:13: note: Possible overload variants:
test.py:13: note:     def __setitem__(self, int, str) -> None
test.py:13: note:     def __setitem__(self, slice, Iterable[str]) -> None

Ideally it should have no problem with it and at the point where there is return statement it should just do an union so the type would be Union[Dict[str, str], List[str]]

[ilevkivskyi]

OK, let us keep this open, although it is just another aspect of a known problem. @JukkaL is currently exploring possible solutions.

[gvanrossum]

it is technically a different variable

I beg to differ. In your example, at least, it looks like a single variable, because return var references it. (I would agree that you could argue it's two variables if that return weren't there.)

[takeda]

The error is still showing up even if I set return to None.

[takeda]

If I try to treat it as a single variable, and try to define an unified type like this:

                var = list() # type: Union[Dict[str, str], List[str]]

I get this error:

test.py:10: error: Item "Dict[str, str]" of "Union[Dict[str, str], List[str]]" has no attribute "append"

It feels that as far as type checker is concerned it probably would be easier to treat them as two different variables and then do Union at the end of the control block.

I found this pattern in code that works with JSON data if that helps.

[JukkaL]

The feature I'm working on won't support this use case yet, though it would be nice if mypy would support this better. Maybe we need to revisit #2008 at some point.

Here's a workaround that works right now using Python 3.6+ syntax:

    ...
    var: Union[Dict[str, str], List[str]]
    if arg:
        var = list()
        var.append('something')
    else:
        var = dict()
        var['key'] = 'something'
    return var