[flake8-type-checking] Adds implementation for TC007 and TC008

crates/ruff_linter/resources/test/fixtures/flake8_type_checking/TC007.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import Dict, TypeAlias, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Dict
+
+    from foo import Foo
+
+    OptStr: TypeAlias = str | None
+    Bar: TypeAlias = Foo[int]
+
+a: TypeAlias = int  # OK
+b: TypeAlias = Dict  # OK
+c: TypeAlias = Foo   # TC007
+d: TypeAlias = Foo | None  # TC007
+e: TypeAlias = OptStr   # TC007
+f: TypeAlias = Bar   # TC007
+g: TypeAlias = Foo | Bar  # TC007 x2
+h: TypeAlias = Foo[str]  # TC007
+i: TypeAlias = (Foo |  # TC007 x2 (fix removes comment currently)
+    Bar)
+
+type C = Foo   # OK
+type D = Foo | None  # OK
+type E = OptStr   # OK
+type F = Bar   # OK
+type G = Foo | Bar  # OK
+type H = Foo[str]  # OK
+type I = (Foo |  # OK 
+    Bar)

crates/ruff_linter/resources/test/fixtures/flake8_type_checking/TC008.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import TypeAlias, TYPE_CHECKING
+
+from foo import Foo
+
+if TYPE_CHECKING:
+    from typing import Dict
+
+    OptStr: TypeAlias = str | None
+    Bar: TypeAlias = Foo[int]
+else:
+    Bar = Foo
+
+a: TypeAlias = 'int'  # TC008
+b: TypeAlias = 'Dict'  # OK
+c: TypeAlias = 'Foo'   # TC008
+d: TypeAlias = 'Foo[str]'  # OK
+e: TypeAlias = 'Foo.bar'  # OK
+f: TypeAlias = 'Foo | None'  # TC008
+g: TypeAlias = 'OptStr'   # OK
+h: TypeAlias = 'Bar'   # TC008
+i: TypeAlias = Foo['str']   # TC008
+j: TypeAlias = 'Baz'   # OK
+k: TypeAlias = 'k | None'  # OK
+l: TypeAlias = 'int' | None  # TC008 (because TC010 is not enabled)
+m: TypeAlias = ('int'  # TC008
+    | None)
+n: TypeAlias = ('int'  # TC008 (fix removes comment currently)
+    ' | None')
+
+type B = 'Dict'  # TC008
+type D = 'Foo[str]'  # TC008
+type E = 'Foo.bar'  # TC008
+type G = 'OptStr'  # TC008
+type I = Foo['str']  # TC008
+type J = 'Baz'  # TC008
+type K = 'K | None'  # TC008
+type L = 'int' | None  # TC008 (because TC010 is not enabled)
+type M = ('int'  # TC008
+    | None)
+type N = ('int'  # TC008 (fix removes comment currently)
+    ' | None')
+
+
+class Baz:
+    a: TypeAlias = 'Baz'  # OK
+    type A = 'Baz'  # TC008
+
+    class Nested:
+        a: TypeAlias = 'Baz'  # OK
+        type A = 'Baz'  # TC008

crates/ruff_linter/resources/test/fixtures/flake8_type_checking/quote.py

@@ -101,3 +101,12 @@ def f():
 
     def test_annotated_non_typing_reference(user: Annotated[str, Depends(get_foo)]):
         pass
+
+
+def f():
+    from typing import TypeAlias, TYPE_CHECKING
+
+    if TYPE_CHECKING:
+        from pandas import DataFrame
+
+    x: TypeAlias = DataFrame | None

crates/ruff_linter/src/checkers/ast/analyze/bindings.rs

@@ -3,7 +3,9 @@ use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;
-use crate::rules::{flake8_import_conventions, flake8_pyi, pyflakes, pylint, ruff};
+use crate::rules::{
+    flake8_import_conventions, flake8_pyi, flake8_type_checking, pyflakes, pylint, ruff,
+};
 
 /// Run lint rules over the [`Binding`]s.
 pub(crate) fn bindings(checker: &mut Checker) {
@@ -15,6 +17,7 @@ pub(crate) fn bindings(checker: &mut Checker) {
         Rule::UnconventionalImportAlias,
         Rule::UnsortedDunderSlots,
         Rule::UnusedVariable,
+        Rule::UnquotedTypeAlias,
     ]) {
         return;
     }
@@ -72,6 +75,13 @@ pub(crate) fn bindings(checker: &mut Checker) {
                 checker.diagnostics.push(diagnostic);
             }
         }
+        if checker.enabled(Rule::UnquotedTypeAlias) {
+            if let Some(diagnostics) =
+                flake8_type_checking::rules::unquoted_type_alias(checker, binding)
+            {
+                checker.diagnostics.extend(diagnostics);
+            }
+        }
         if checker.enabled(Rule::UnsortedDunderSlots) {
             if let Some(diagnostic) = ruff::rules::sort_dunder_slots(checker, binding) {
                 checker.diagnostics.push(diagnostic);

crates/ruff_linter/src/checkers/ast/analyze/deferred_scopes.rs

@@ -52,6 +52,8 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
     // Identify any valid runtime imports. If a module is imported at runtime, and
     // used at runtime, then by default, we avoid flagging any other
     // imports from that model as typing-only.
+    // FIXME: This does not seem quite right, if only TC004 is enabled
+    //        then we don't need to collect the runtime imports
     let enforce_typing_imports = !checker.source_type.is_stub()
         && checker.any_enabled(&[
             Rule::RuntimeImportInTypeCheckingBlock,
@@ -375,6 +377,8 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
         }
 
         if matches!(scope.kind, ScopeKind::Function(_) | ScopeKind::Module) {
+            // FIXME: This does not seem quite right, if only TC004 is enabled
+            //        then we don't need to collect the runtime imports
             if enforce_typing_imports {
                 let runtime_imports: Vec<&Binding> = checker
                     .semantic

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

@@ -888,9 +888,7 @@ impl<'a> Visitor<'a> for Checker<'a> {
                 if let Some(type_params) = type_params {
                     self.visit_type_params(type_params);
                 }
-                self.visit
-                    .type_param_definitions
-                    .push((value, self.semantic.snapshot()));
+                self.visit_deferred_type_alias_value(value);
                 self.semantic.pop_scope();
                 self.visit_expr(name);
             }
@@ -961,7 +959,7 @@ impl<'a> Visitor<'a> for Checker<'a> {
 
                 if let Some(expr) = value {
                     if self.semantic.match_typing_expr(annotation, "TypeAlias") {
-                        self.visit_type_definition(expr);
+                        self.visit_annotated_type_alias_value(expr);
                     } else {
                         self.visit_expr(expr);
                     }
@@ -1855,6 +1853,45 @@ impl<'a> Checker<'a> {
         self.semantic.flags = snapshot;
     }
 
+    /// Visit an [`Expr`], and treat it as the value expression
+    /// of a [PEP 613] type alias.
+    ///
+    /// For example:
+    /// ```python
+    /// from typing import TypeAlias
+    ///
+    /// OptStr: TypeAlias = str | None  # We're visiting the RHS
+    /// ```
+    ///
+    /// [PEP 613]: https://peps.python.org/pep-0613/
+    fn visit_annotated_type_alias_value(&mut self, expr: &'a Expr) {
+        let snapshot = self.semantic.flags;
+        self.semantic.flags |= SemanticModelFlags::ANNOTATED_TYPE_ALIAS;
+        self.visit_type_definition(expr);
+        self.semantic.flags = snapshot;
+    }
+
+    /// Visit an [`Expr`], and treat it as the value expression
+    /// of a [PEP 695] type alias.
+    ///
+    /// For example:
+    /// ```python
+    /// type OptStr = str | None  # We're visiting the RHS
+    /// ```
+    ///
+    /// [PEP 695]: https://peps.python.org/pep-0695/#generic-type-alias
+    fn visit_deferred_type_alias_value(&mut self, expr: &'a Expr) {
+        let snapshot = self.semantic.flags;
+        // even though we don't visit these nodes immediately we need to
+        // modify the semantic flags before we push the expression and its
+        // corresponding semantic snapshot
+        self.semantic.flags |= SemanticModelFlags::DEFERRED_TYPE_ALIAS;
+        self.visit
+            .type_param_definitions
+            .push((expr, self.semantic.snapshot()));
+        self.semantic.flags = snapshot;
+    }
+
     /// Visit an [`Expr`], and treat it as a type definition.
     fn visit_type_definition(&mut self, expr: &'a Expr) {
         if self.semantic.in_no_type_check() {
@@ -2017,6 +2054,21 @@ impl<'a> Checker<'a> {
             flags.insert(BindingFlags::UNPACKED_ASSIGNMENT);
         }
 
+        match parent {
+            Stmt::TypeAlias(_) => flags.insert(BindingFlags::DEFERRED_TYPE_ALIAS),
+            Stmt::AnnAssign(ast::StmtAnnAssign { annotation, .. }) => {
+                // TODO: It is a bit unfortunate that we do this check twice
+                //       maybe we should change how we visit this statement
+                //       so the semantic flag for the type alias sticks around
+                //       until after we've handled this store, so we can check
+                //       the flag instead of duplicating this check
+                if self.semantic.match_typing_expr(annotation, "TypeAlias") {
+                    flags.insert(BindingFlags::ANNOTATED_TYPE_ALIAS);
+                }
+            }
+            _ => {}
+        }
+
         let scope = self.semantic.current_scope();
 
         if scope.kind.is_module()
@@ -2272,7 +2324,17 @@ impl<'a> Checker<'a> {
 
                     self.semantic.flags |=
                         SemanticModelFlags::TYPE_DEFINITION | type_definition_flag;
-                    self.visit_expr(parsed_annotation.expression());
+                    let parsed_expr = parsed_annotation.expression();
+                    self.visit_expr(parsed_expr);
+                    if self.semantic.in_type_alias_value() {
+                        if self.enabled(Rule::QuotedTypeAlias) {
+                            flake8_type_checking::rules::quoted_type_alias(
+                                self,
+                                parsed_expr,
+                                string_expr,
+                            );
+                        }
+                    }
                     self.parsed_type_annotation = None;
                 } else {
                     if self.enabled(Rule::ForwardAnnotationSyntaxError) {

crates/ruff_linter/src/codes.rs

@@ -858,6 +858,8 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Flake8TypeChecking, "004") => (RuleGroup::Stable, rules::flake8_type_checking::rules::RuntimeImportInTypeCheckingBlock),
         (Flake8TypeChecking, "005") => (RuleGroup::Stable, rules::flake8_type_checking::rules::EmptyTypeCheckingBlock),
         (Flake8TypeChecking, "006") => (RuleGroup::Preview, rules::flake8_type_checking::rules::RuntimeCastValue),
+        (Flake8TypeChecking, "007") => (RuleGroup::Preview, rules::flake8_type_checking::rules::UnquotedTypeAlias),
+        (Flake8TypeChecking, "008") => (RuleGroup::Preview, rules::flake8_type_checking::rules::QuotedTypeAlias),
         (Flake8TypeChecking, "010") => (RuleGroup::Stable, rules::flake8_type_checking::rules::RuntimeStringUnion),
 
         // tryceratops

crates/ruff_linter/src/rules/flake8_type_checking/mod.rs

@@ -63,6 +63,23 @@ mod tests {
         Ok(())
     }
 
+    // we test these rules as a pair, since they're opposites of one another
+    // so we want to make sure their fixes are not going around in circles.
+    #[test_case(Rule::UnquotedTypeAlias, Path::new("TC007.py"))]
+    #[test_case(Rule::QuotedTypeAlias, Path::new("TC008.py"))]
+    fn type_alias_rules(rule_code: Rule, path: &Path) -> Result<()> {
+        let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
+        let diagnostics = test_path(
+            Path::new("flake8_type_checking").join(path).as_path(),
+            &settings::LinterSettings::for_rules(vec![
+                Rule::UnquotedTypeAlias,
+                Rule::QuotedTypeAlias,
+            ]),
+        )?;
+        assert_messages!(snapshot, diagnostics);
+        Ok(())
+    }
+
     #[test_case(Rule::RuntimeImportInTypeCheckingBlock, Path::new("quote.py"))]
     #[test_case(Rule::TypingOnlyThirdPartyImport, Path::new("quote.py"))]
     #[test_case(Rule::RuntimeImportInTypeCheckingBlock, Path::new("quote2.py"))]
@@ -431,6 +448,29 @@ mod tests {
     ",
         "multiple_modules_different_types"
     )]
+    #[test_case(
+        r"
+        from __future__ import annotations
+
+        from typing import TYPE_CHECKING, TypeAlias
+        if TYPE_CHECKING:
+            from foo import Foo  # TC004
+
+        a: TypeAlias = Foo | None  # OK
+    ",
+        "tc004_precedence_over_tc007"
+    )]
+    #[test_case(
+        r"
+        from __future__ import annotations
+
+        from typing import TypeAlias
+
+        a: TypeAlias = 'int | None'  # TC008
+        b: TypeAlias = 'int' | None  # TC010
+    ",
+        "tc010_precedence_over_tc008"
+    )]
     fn contents(contents: &str, snapshot: &str) {
         let diagnostics = test_snippet(
             contents,

crates/ruff_linter/src/rules/flake8_type_checking/rules/mod.rs

@@ -2,10 +2,12 @@ pub(crate) use empty_type_checking_block::*;
 pub(crate) use runtime_cast_value::*;
 pub(crate) use runtime_import_in_type_checking_block::*;
 pub(crate) use runtime_string_union::*;
+pub(crate) use type_alias_quotes::*;
 pub(crate) use typing_only_runtime_import::*;
 
 mod empty_type_checking_block;
 mod runtime_cast_value;
 mod runtime_import_in_type_checking_block;
 mod runtime_string_union;
+mod type_alias_quotes;
 mod typing_only_runtime_import;

crates/ruff_linter/src/rules/flake8_type_checking/rules/runtime_import_in_type_checking_block.rs

@@ -151,6 +151,14 @@ pub(crate) fn runtime_import_in_type_checking_block(
             } else {
                 // Determine whether the member should be fixed by moving the import out of the
                 // type-checking block, or by quoting its references.
+                // TODO: We should check `reference.in_annotated_type_alias()`
+                //       as well to match the behavior of the flake8 plugin
+                //       although maybe the best way forward is to add an
+                //       additional setting to configure whether quoting
+                //       or moving the import is preferred for type aliases
+                //       since some people will consistently use their
+                //       type aliases at runtimes, while others won't, so
+                //       the best solution is unclear.
                 if checker.settings.flake8_type_checking.quote_annotations
                     && binding.references().all(|reference_id| {
                         let reference = checker.semantic().reference(reference_id);

crates/ruff_linter/src/rules/flake8_type_checking/rules/runtime_string_union.rs

@@ -51,7 +51,7 @@ impl Violation for RuntimeStringUnion {
     }
 }
 
-/// TC006
+/// TC010
 pub(crate) fn runtime_string_union(checker: &mut Checker, expr: &Expr) {
     if !checker.semantic().in_type_definition() {
         return;