[flake8-pyi] Implement PYI026

crates/ruff/resources/test/fixtures/flake8_pyi/PYI026.py

@@ -0,0 +1,18 @@
+import typing
+from typing import TypeAlias, Literal, Any
+
+NewAny = Any
+OptinalStr = typing.Optional[str]
+Foo = Literal["foo"]
+IntOrStr = int | str
+AliasNone = None
+
+NewAny: typing.TypeAlias = Any
+OptinalStr: TypeAlias = typing.Optional[str]
+Foo: typing.TypeAlias = Literal["foo"]
+IntOrStr: TypeAlias = int | str
+AliasNone: typing.TypeAlias = None
+
+# these are ok
+VarAlias = str
+AliasFoo = Foo

crates/ruff/resources/test/fixtures/flake8_pyi/PYI026.pyi

@@ -0,0 +1,18 @@
+import typing
+from typing import TypeAlias, Literal, Any
+
+NewAny = Any
+OptinalStr = typing.Optional[str]
+Foo = Literal["foo"]
+IntOrStr = int | str
+AliasNone = None
+
+NewAny: typing.TypeAlias = Any
+OptinalStr: TypeAlias = typing.Optional[str]
+Foo: typing.TypeAlias = Literal["foo"]
+IntOrStr: TypeAlias = int | str
+AliasNone: typing.TypeAlias = None
+
+# these are ok
+VarAlias = str
+AliasFoo = Foo

crates/ruff/src/checkers/ast/mod.rs

@@ -1549,6 +1549,7 @@ where
                         Rule::UnprefixedTypeParam,
                         Rule::AssignmentDefaultInStub,
                         Rule::UnannotatedAssignmentInStub,
+                        Rule::TypeAliasCheck,
                     ]) {
                         // Ignore assignments in function bodies; those are covered by other rules.
                         if !self
@@ -1567,6 +1568,9 @@ where
                                     self, targets, value,
                                 );
                             }
+                            if self.enabled(Rule::TypeAliasCheck) {
+                                flake8_pyi::rules::type_alias_check(self, value, targets);
+                            }
                         }
                     }
                 }

crates/ruff/src/codes.rs

@@ -633,6 +633,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Flake8Pyi, "021") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::DocstringInStub),
         (Flake8Pyi, "024") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::CollectionsNamedTuple),
         (Flake8Pyi, "025") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::UnaliasedCollectionsAbcSetImport),
+        (Flake8Pyi, "026") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::TypeAliasCheck),
         (Flake8Pyi, "029") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::StrOrReprDefinedInStub),
         (Flake8Pyi, "030") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::UnnecessaryLiteralUnion),
         (Flake8Pyi, "032") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::AnyEqNeAnnotation),

crates/ruff/src/rules/flake8_pyi/mod.rs

@@ -87,6 +87,8 @@ mod tests {
     #[test_case(Rule::UnrecognizedVersionInfoCheck, Path::new("PYI003.pyi"))]
     #[test_case(Rule::WrongTupleLengthVersionComparison, Path::new("PYI005.py"))]
     #[test_case(Rule::WrongTupleLengthVersionComparison, Path::new("PYI005.pyi"))]
+    #[test_case(Rule::TypeAliasCheck, Path::new("PYI026.py"))]
+    #[test_case(Rule::TypeAliasCheck, Path::new("PYI026.pyi"))]
     fn rules(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", rule_code.noqa_code(), path.to_string_lossy());
         let diagnostics = test_path(

crates/ruff/src/rules/flake8_pyi/rules/simple_defaults.rs

@@ -97,6 +97,36 @@ impl Violation for UnassignedSpecialVariableInStub {
     }
 }
 
+/// ## What it does
+/// Checks for `typehint.TypeAlias` annotation in type aliases.
+///
+/// ## Why is this bad?
+/// It makes harder for someone reading the code to differentiate
+/// between a value assignment and a type alias.
+///
+/// ## Example
+/// ```python
+/// IntOrStr = int | str
+/// ```
+///
+/// Use instead:
+/// ```python
+/// IntOrStr: TypeAlias = int | str
+/// ```
+#[violation]
+pub struct TypeAliasCheck {
+    name: String,
+    value: String,
+}
+
+impl Violation for TypeAliasCheck {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        let TypeAliasCheck { name, value } = self;
+        format!("Use `typing.TypeAlias` for type aliases in `{name}`, e.g. \"{name}: typing.TypeAlias = {value}\"")
+    }
+}
+
 fn is_allowed_negated_math_attribute(call_path: &CallPath) -> bool {
     matches!(call_path.as_slice(), ["math", "inf" | "e" | "pi" | "tau"])
 }
@@ -399,9 +429,10 @@ pub(crate) fn argument_simple_defaults(checker: &mut Checker, arguments: &Argume
 
 /// PYI015
 pub(crate) fn assignment_default_in_stub(checker: &mut Checker, targets: &[Expr], value: &Expr) {
-    let [target] = targets else {
+    if targets.len() != 1 {
         return;
-    };
+    }
+    let target = &targets[0];
     if !target.is_name_expr() {
         return;
     }
@@ -470,9 +501,10 @@ pub(crate) fn unannotated_assignment_in_stub(
     targets: &[Expr],
     value: &Expr,
 ) {
-    let [target] = targets else {
+    if targets.len() != 1 {
         return;
-    };
+    }
+    let target = &targets[0];
     let Expr::Name(ast::ExprName { id, .. }) = target else {
         return;
     };
@@ -523,3 +555,36 @@ pub(crate) fn unassigned_special_variable_in_stub(
         stmt.range(),
     ));
 }
+
+/// PIY026
+pub(crate) fn type_alias_check(checker: &mut Checker, value: &Expr, targets: &[Expr]) {
+    let is_any = |expr: &Expr| {
+        let Expr::Name(ast::ExprName { id, .. }) = expr else {
+            return false;
+        };
+        id == "Any"
+    };
+
+    let target = &targets[0];
+    if is_special_assignment(target, checker.semantic()) {
+        return;
+    }
+    if matches!(value, Expr::Name(_)) && !is_any(value) {
+        return;
+    }
+    if !is_valid_pep_604_union(value) {
+        return;
+    }
+
+    let Expr::Name(ast::ExprName { id, .. }) = target else {
+            return;
+    };
+
+    checker.diagnostics.push(Diagnostic::new(
+        TypeAliasCheck {
+            name: id.to_string(),
+            value: checker.generator().expr(value),
+        },
+        target.range(),
+    ));
+}

crates/ruff/src/rules/flake8_pyi/snapshots/ruff__rules__flake8_pyi__tests__PYI026_PYI026.py.snap

@@ -0,0 +1,4 @@
+---
+source: crates/ruff/src/rules/flake8_pyi/mod.rs
+---
+

crates/ruff/src/rules/flake8_pyi/snapshots/ruff__rules__flake8_pyi__tests__PYI026_PYI026.pyi.snap

@@ -0,0 +1,52 @@
+---
+source: crates/ruff/src/rules/flake8_pyi/mod.rs
+---
+PYI026.pyi:4:1: PYI026 Use `typing.TypeAlias` for type aliases in `NewAny`, e.g. "NewAny: typing.TypeAlias = Any"
+  |
+2 | from typing import TypeAlias, Literal, Any
+3 | 
+4 | NewAny = Any
+  | ^^^^^^ PYI026
+5 | OptinalStr = typing.Optional[str]
+6 | Foo = Literal["foo"]
+  |
+
+PYI026.pyi:5:1: PYI026 Use `typing.TypeAlias` for type aliases in `OptinalStr`, e.g. "OptinalStr: typing.TypeAlias = typing.Optional[str]"
+  |
+4 | NewAny = Any
+5 | OptinalStr = typing.Optional[str]
+  | ^^^^^^^^^^ PYI026
+6 | Foo = Literal["foo"]
+7 | IntOrStr = int | str
+  |
+
+PYI026.pyi:6:1: PYI026 Use `typing.TypeAlias` for type aliases in `Foo`, e.g. "Foo: typing.TypeAlias = Literal["foo"]"
+  |
+4 | NewAny = Any
+5 | OptinalStr = typing.Optional[str]
+6 | Foo = Literal["foo"]
+  | ^^^ PYI026
+7 | IntOrStr = int | str
+8 | AliasNone = None
+  |
+
+PYI026.pyi:7:1: PYI026 Use `typing.TypeAlias` for type aliases in `IntOrStr`, e.g. "IntOrStr: typing.TypeAlias = int | str"
+  |
+5 | OptinalStr = typing.Optional[str]
+6 | Foo = Literal["foo"]
+7 | IntOrStr = int | str
+  | ^^^^^^^^ PYI026
+8 | AliasNone = None
+  |
+
+PYI026.pyi:8:1: PYI026 Use `typing.TypeAlias` for type aliases in `AliasNone`, e.g. "AliasNone: typing.TypeAlias = None"
+   |
+ 6 | Foo = Literal["foo"]
+ 7 | IntOrStr = int | str
+ 8 | AliasNone = None
+   | ^^^^^^^^^ PYI026
+ 9 | 
+10 | NewAny: typing.TypeAlias = Any
+   |
+
+