Adds TypeAlias annotation, where possible

[sobolevn]

This is more an experiment to see if newly added TypeAlias in our own code is supported.

Refs #11305

[sobolevn]

Looks like it does not work out of the box. Some more work is required.
@hauntsaninja, maybe you will be interested in looking into failing logs.

[hauntsaninja]

Thanks for doing this, will take a look later. I suspect at least some of the confusion might just be from clobbering mypy.nodes.TypeAlias

mypy/mypy/nodes.py

Lines 2877 to 2878 in c22beb4

	class TypeAlias(SymbolNode):

[JelleZijlstra]

This file also imports mypy.nodes.TypeAlias (line 25)

[JelleZijlstra]

This one too (line 34)

[sobolevn]

Thanks! Now TypeAlias from typing_extensions is always called _TypeAlias

[JelleZijlstra]

@hauntsaninja is right. I wonder why flake8 doesn't catch this.

[sobolevn]

Looks like the CI is stuck. Reopening to retrigger it.

[hauntsaninja]

Hooray, looks like it's passing tests.

I'd recommend using _TypeAlias in every file, not just ones that we have mypy.nodes.TypeAlias in. Actually, thinking about it, I think the clearest thing to do is just use the fully qualified typing_extensions.TypeAlias everywhere in mypy. There aren't too many of these, so the extra verbosity is probably worth it.

I think we'll also need to change the minimum version of typing_extensions we require.

[sobolevn]

I'd recommend using _TypeAlias in every file, not just ones that we have mypy.nodes.TypeAlias in.

I've already done this 🎉

I think the clearest thing to do is just use the fully qualified typing_extensions.TypeAlias everywhere in mypy.

I cannot agree with this, sorry! This is way too verbose. Imagine this:

import typing_extensions

TypeParameterChecker: typing_extensions.TypeAlias = Callable[[Type, Type, int], bool]

Current solution:

from typing_extensions import TypeAlias as _TypeAlias

TypeParameterChecker: _TypeAlias = Callable[[Type, Type, int], bool]

Looks and reads much better! 😎
Moreover, we won't have to duplicate typing_extensions import, in case some other names like from typing_extensions import Final are also used.

[hauntsaninja]

Suggested change

	ReporterClasses: TypeAlias = Dict[str, Tuple[Callable[['Reports', str], 'AbstractReporter'], bool]]
	ReporterClasses: _TypeAlias = Dict[str, Tuple[Callable[['Reports', str], 'AbstractReporter'], bool]]

[hauntsaninja]

Suggested change

	SavedScope: TypeAlias = Tuple[str, Optional[TypeInfo], Optional[FuncBase]]
	SavedScope: _TypeAlias = Tuple[str, Optional[TypeInfo], Optional[FuncBase]]

[hauntsaninja]

Suggested change

	SubtypeRelationship: TypeAlias = Tuple[Instance, Instance]
	SubtypeRelationship: _TypeAlias = Tuple[Instance, Instance]

[hauntsaninja]

Suggested change

	SubtypeKind: TypeAlias = Tuple[bool, ...]
	SubtypeKind: _TypeAlias = Tuple[bool, ...]

[hauntsaninja]

Suggested change

	SubtypeCache: TypeAlias = Dict[TypeInfo, Dict[SubtypeKind, Set[SubtypeRelationship]]]
	SubtypeCache: _TypeAlias = Dict[TypeInfo, Dict[SubtypeKind, Set[SubtypeRelationship]]]

[JelleZijlstra]

What if we rename mypy.nodes.TypeAlias instead?

[hauntsaninja]

We already have both a TypeAlias and a TypeAliasType + might be a breaking change for plugins. I'm open to it, but I'm struggling to come up with names that work. Maybe we should just rewrite all of mypy in TypeScript? ;-)
I think I still like the verbose option the best, but don't feel strongly enough about it to push for it since Nikita disagrees.

[sobolevn]

Thanks! I've missed a couple. Now it should be ready!

Maybe we should just rewrite all of mypy in TypeScript? ;-)

I am planning to do it in Rust 😉

[hauntsaninja]

Thank you!