Adds `TypeAlias` annotation, where possible #11321

sobolevn · 2021-10-12T22:34:59Z

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

sobolevn · 2021-10-12T22:38:34Z

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 · 2021-10-12T23:01:43Z

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 · 2021-10-12T23:56:33Z

mypy/checker.py

@@ -8,7 +8,7 @@
    Any, Dict, Set, List, cast, Tuple, TypeVar, Union, Optional, NamedTuple, Iterator,
    Iterable, Sequence, Mapping, Generic, AbstractSet, Callable
 )
-from typing_extensions import Final
+from typing_extensions import Final, TypeAlias


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

JelleZijlstra · 2021-10-12T23:57:10Z

mypy/checkexpr.py

@@ -7,7 +7,7 @@
 from typing import (
    Any, cast, Dict, Set, List, Tuple, Callable, Union, Optional, Sequence, Iterator
 )
-from typing_extensions import ClassVar, Final, overload
+from typing_extensions import ClassVar, Final, overload, TypeAlias


This one too (line 34)

Thanks! Now TypeAlias from typing_extensions is always called _TypeAlias

JelleZijlstra · 2021-10-12T23:57:57Z

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

sobolevn · 2021-10-13T07:45:49Z

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 · 2021-10-13T08:20:51Z

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 · 2021-10-13T17:39:25Z

mypy/report.py

@@ -45,7 +45,7 @@
    ]
 )

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


Suggested change

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

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

hauntsaninja · 2021-10-13T17:39:33Z

mypy/scope.py


 from mypy.backports import nullcontext
 from mypy.nodes import TypeInfo, FuncBase


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


Suggested change

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

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

hauntsaninja · 2021-10-13T17:39:47Z

mypy/typestate.py


 from mypy.nodes import TypeInfo
 from mypy.types import Instance, TypeAliasType, get_proper_type, Type
 from mypy.server.trigger import make_trigger
 from mypy import state

 # Represents that the 'left' instance is a subtype of the 'right' instance
-SubtypeRelationship = Tuple[Instance, Instance]
+SubtypeRelationship: TypeAlias = Tuple[Instance, Instance]


Suggested change

SubtypeRelationship: TypeAlias = Tuple[Instance, Instance]

SubtypeRelationship: _TypeAlias = Tuple[Instance, Instance]

hauntsaninja · 2021-10-13T17:39:54Z

mypy/typestate.py


 # A tuple encoding the specific conditions under which we performed the subtype check.
 # (e.g. did we want a proper subtype? A regular subtype while ignoring variance?)
-SubtypeKind = Tuple[bool, ...]
+SubtypeKind: TypeAlias = Tuple[bool, ...]


Suggested change

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

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

hauntsaninja · 2021-10-13T17:40:00Z

mypy/typestate.py


 # A cache that keeps track of whether the given TypeInfo is a part of a particular
 # subtype relationship
-SubtypeCache = Dict[TypeInfo, Dict[SubtypeKind, Set[SubtypeRelationship]]]
+SubtypeCache: TypeAlias = Dict[TypeInfo, Dict[SubtypeKind, Set[SubtypeRelationship]]]


Suggested change

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

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

JelleZijlstra · 2021-10-13T18:09:22Z

What if we rename mypy.nodes.TypeAlias instead?

hauntsaninja · 2021-10-13T18:24:49Z

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 · 2021-10-13T19:58:29Z

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 · 2021-10-14T04:36:55Z

Thank you!

Adds TypeAlias annotation, where possible

877f8f3

sobolevn marked this pull request as draft October 12, 2021 22:38

JelleZijlstra reviewed Oct 12, 2021

View reviewed changes

Aliases TypeAlias as _TypeAlias

7a1b9cc

sobolevn marked this pull request as ready for review October 13, 2021 07:30

sobolevn closed this Oct 13, 2021

sobolevn reopened this Oct 13, 2021

hauntsaninja reviewed Oct 13, 2021

View reviewed changes

sobolevn closed this Oct 13, 2021

sobolevn reopened this Oct 13, 2021

hauntsaninja reviewed Oct 13, 2021

View reviewed changes

Fixes TypeAlias import

a32ae01

Fixes TypeAlias import

84075a9

hauntsaninja merged commit f497645 into python:master Oct 14, 2021

tushar-deepsource pushed a commit to DeepSourceCorp/mypy that referenced this pull request Jan 20, 2022

Add TypeAlias annotations to mypy code (python#11321)

9c34c98

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Adds `TypeAlias` annotation, where possible #11321

Adds `TypeAlias` annotation, where possible #11321

sobolevn commented Oct 12, 2021

sobolevn commented Oct 12, 2021

hauntsaninja commented Oct 12, 2021

JelleZijlstra Oct 12, 2021

JelleZijlstra Oct 12, 2021

sobolevn Oct 13, 2021

JelleZijlstra commented Oct 12, 2021

sobolevn commented Oct 13, 2021

hauntsaninja left a comment

sobolevn commented Oct 13, 2021

hauntsaninja Oct 13, 2021

hauntsaninja Oct 13, 2021

hauntsaninja Oct 13, 2021

hauntsaninja Oct 13, 2021

hauntsaninja Oct 13, 2021

JelleZijlstra commented Oct 13, 2021

hauntsaninja commented Oct 13, 2021 •

edited

Loading

sobolevn commented Oct 13, 2021 •

edited

Loading

hauntsaninja commented Oct 14, 2021

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

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

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

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

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

Adds TypeAlias annotation, where possible #11321

Adds TypeAlias annotation, where possible #11321

Conversation

sobolevn commented Oct 12, 2021

sobolevn commented Oct 12, 2021

hauntsaninja commented Oct 12, 2021

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

JelleZijlstra commented Oct 12, 2021

sobolevn commented Oct 13, 2021

hauntsaninja left a comment

Choose a reason for hiding this comment

sobolevn commented Oct 13, 2021

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

JelleZijlstra commented Oct 13, 2021

hauntsaninja commented Oct 13, 2021 • edited Loading

sobolevn commented Oct 13, 2021 • edited Loading

hauntsaninja commented Oct 14, 2021

Adds `TypeAlias` annotation, where possible #11321

Adds `TypeAlias` annotation, where possible #11321

hauntsaninja commented Oct 13, 2021 •

edited

Loading

sobolevn commented Oct 13, 2021 •

edited

Loading