TypeAlias not conforming to PascalCase to throw invalid-name

[jamesbraza]

Current problem

Python typing.TypeAlias are an alias to a type (as we all know). Thus, I think TypeAlias should have to follow type naming conventions (e.g. PascalCase for classes, unless a primitive).

In other words, we should see TypeAlias really as not much different from a novel class in regards to naming conventions. I think pylint is the tool to help enforce this!

Desired solution

Please see the below code snippet

# pylint: disable=missing-module-docstring

from threading import Thread  # Placeholder class
from typing import TypeAlias

ThreadAlias: TypeAlias = Thread  # Say nothing here
THREAD_ALIAS: TypeAlias = Thread  # Throw invalid-name
# C0103: Type alias "THREAD_ALIAS" doesn't conform to PascalCase naming style (invalid-name)

To restate, I think pylint should error on CLASS_NAME_ALIAS with invalid-name.

Additional context

See the TypeAlias PEP: https://peps.python.org/pep-0613/#error-messaging

They use ClassName, not CLASS_NAME.

[cdce8p]

I agree. TypeAlias names should be PascalCase. We could even argue that its good practice to suffix them with Type (although I wouldn't enforce that). The difficulty will be detecting that a variable is actually a type alias. That's only really possible with the TypeAlias annotation. Maybe a few other common cases could be handled too, without the explicit TypeAlias: Union or Callable.

@DanielNoord Would you like to take a look at this one? I suspect it will be quite similar to the name check for TypeVars.

[DanielNoord]

Based on previous experiences I think narrowing down the tests are very important here. An initial draft:

"""Test cases for invalid-name for TypeAlias with default settings"""
# pylint: disable=too-few-public-methods,line-too-long

from typing import Callable, TypeAlias, Union

# PascalCase names
GoodName: TypeAlias = int
_GoodName: TypeAlias = int
__GoodName: TypeAlias = int
AnotherGoodName = Union[int, str]
AlsoGoodName = Callable

# Non-PascalCase names
BADName: TypeAlias = int # [invalid-name]
BadNAME: TypeAlias = int  # [invalid-name]
badName: TypeAlias = int  # [invalid-name]
BADNAMEType: TypeAlias = int # [invalid-name]
ANOTHERBADNAME = Union[int,str] # [invalid-name]
AlsoBADNAME = Callable  # [invalid-name]

Please tell me if you have any test cases that are missing.

[cdce8p]

Based on previous experiences I think narrowing down the tests are very important here. An initial draft:
[...]
Please tell me if you have any test cases that are missing.

👍🏻 That's about what I had in mind. Maybe we can make also make sure that the name isn't suffixed with just T as to not mistake it with a TypeVar.

BadNameT: TypeAlias = int  # [invalid-name]

I'll also test the PR against Home Assistant once it's ready, just to make sure we don't miss anything else.

[jamesbraza]

Thank you all for adding color! @DanielNoord I agree with all your GoodNames .

I would like to include two more bad names:

• BAD_NAME/_BAD_NAME/__BAD_NAME: (implying it's some constant, not a type alias)
• TBadName: can also be confused with TypeVar

[DanielNoord]

I have decided to leave Callable out because of the following example:

do_something: Callable[[], int]

def do_something() -> int:
    return 1

Submitting the PR in a couple of minutes. Let me know if you want me to re-add it.