Need type annotation for predefined dict generic (3.9)

[ultrabear]

Bug Report
mypy errors on defining a variable to a python 3.9 dict whose type signature has been previously stored in a variable

To Reproduce
Using mypy bug.py --strict
Error stems from disallow untyped generics, I think

Block = dict[str, str]

def main() -> Block:

    out = Block()  # error: Need type annotation for "out" (hint: "out: Dict[<type>, <type>] = ...")

    return out

if __name__ == "__main__":
    main()

Expected Behavior

Mypy should be able to read the type information stored in Block and read it as that type being init, as it can read the type information for a return signature

Actual Behavior
mypy raises a untyped generic error that out needs a type annotation:
error: Need type annotation for "out" (hint: "out: Dict[<type>, <type>] = ...")

Your Environment

• Mypy version used: 0.910
• Mypy command-line flags: --strict
• Mypy configuration options from mypy.ini (and other config files): none present.
• Python version used: 3.9.6
• Operating system and version: Linux 5.10

[hi-ogawa]

EDIT: Actually var-annotated error code is enabled by default (i.e. without --strict option).

I'm starting to take a look at this issue and I made an example of my own. Interestingly, there doesn't seem a problem for list.

• ex11093/test3.py

from typing import Dict, List

D1 = dict[str, str]
D2 = Dict[str, str]
x1 = D1()
x2 = D2()
x3 = dict[str, str]()

L1 = list[str]
L2 = List[str]
y1 = L1()
y2 = L2()
y3 = list[str]()

• command

$ mypy --show-error-codes ex11093/test3.py 
ex11093/test3.py:5: error: Need type annotation for "x1" (hint: "x1: Dict[<type>, <type>] = ...")  [var-annotated]
ex11093/test3.py:6: error: Need type annotation for "x2" (hint: "x2: Dict[<type>, <type>] = ...")  [var-annotated]
Found 2 errors in 1 file (checked 1 source file)

---

UPDATE (1):
This issue might be partially due to SemanticAnalyzer.translate_dict_call where this kind of translation doesn't happen for list builtin.

mypy/mypy/semanal.py

Line 3813 in 4927396

def translate_dict_call(self, call: CallExpr) -> Optional[DictExpr]:

Not sure yet but this translation is to support TypedDict construction like this? I commented out translate_dict_call and the first test failure I got is this.

mypy/test-data/unit/check-typeddict.test

Lines 14 to 17 in 4927396

	[case testCanCreateTypedDictInstanceWithDictCall]
	from mypy_extensions import TypedDict
	Point = TypedDict('Point', {'x': int, 'y': int})
	p = Point(dict(x=42, y=1337))

Looking at PEP589, it seems it actually doesn't allow such construction of TypedDict https://github.com/python/peps/blob/master/pep-0589.rst?plain=1#L210-L212

It can be used as a callable object with keyword arguments corresponding to the TypedDict items. Non-keyword arguments are not allowed.

---

UPDATE (2):
The reason why Dict[str, str]() works is that such expression actually won't get translated by translate_dict_call due to its AST:

CallExpr:2(
  TypeApplication:2(
    NameExpr(Dict [typing.Dict])
    Types(
      builtins.str
      builtins.str))
  Args())

[AlexWaygood]

I've removed the "topic-585" label as I can reproduce this with typing.Dict as well as builtins.dict

[vsego]

Two years later, and this is still an issue:

from typing import TypeAlias


T_foo: TypeAlias = dict[str, int]


foo = T_foo()

Any progress with it?