Implement configuration options runtime-evaluated-decorators and runtime-evaluated-baseclasses for flake8-type-checking (#3292)

crates/ruff/resources/test/fixtures/flake8_type_checking/runtime_evaluated_baseclasses_1.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import pathlib
+from typing import TYPE_CHECKING
+
+import pydantic
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    import datetime  # TCH004
+    from array import array  # TCH004
+
+    import pandas  # TCH004
+    import pyproj
+
+
+class A(pydantic.BaseModel):
+    x: datetime.datetime
+
+
+class B(BaseModel):
+    x: pandas.DataFrame
+
+
+class C(BaseModel):
+    x: pathlib.Path
+
+
+class E:
+    pass
+
+
+class F(E):
+    x: pyproj.Transformer
+
+
+class G(BaseModel):
+    x: array

crates/ruff/resources/test/fixtures/flake8_type_checking/runtime_evaluated_baseclasses_2.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import geopandas as gpd  # TCH002
+import pydantic
+import pyproj  # TCH002
+from pydantic import BaseModel
+
+import numpy
+
+
+class A(BaseModel):
+    x: pandas.DataFrame
+
+
+class B(pydantic.BaseModel):
+    x: numpy.ndarray
+
+
+class C:
+    pass
+
+
+class D(C):
+    x: pyproj.Transformer
+
+
+class E(C):
+    x: gpd.GeoDataFrame

crates/ruff/resources/test/fixtures/flake8_type_checking/runtime_evaluated_baseclasses_3.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import datetime
+import pathlib
+from uuid import UUID  # TCH003
+
+import pydantic
+from pydantic import BaseModel
+
+
+class A(pydantic.BaseModel):
+    x: datetime.datetime
+
+
+class B(BaseModel):
+    x: pathlib.Path
+
+
+class C:
+    pass
+
+
+class D(C):
+    x: UUID

crates/ruff/resources/test/fixtures/flake8_type_checking/runtime_evaluated_decorators_1.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import pathlib
+from typing import TYPE_CHECKING
+
+import attrs
+from attrs import frozen
+
+import numpy
+
+if TYPE_CHECKING:
+    import datetime  # TCH004
+    from array import array  # TCH004
+
+    import pandas  # TCH004
+    import pyproj
+
+
+@attrs.define(auto_attribs=True)
+class A:
+    x: datetime.datetime
+
+
+@attrs.define
+class B:
+    x: pandas.DataFrame
+
+
+@frozen(auto_attribs=True)
+class C:
+    x: pathlib.Path
+
+
+@frozen
+class D:
+    x: array
+
+
+@dataclass
+class E:
+    x: pyproj.Transformer
+
+
+@attrs.define
+class F:
+    x: numpy.ndarray

crates/ruff/resources/test/fixtures/flake8_type_checking/runtime_evaluated_decorators_2.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import attrs
+import pandas
+import pyproj
+from attrs import frozen
+
+import numpy  # TCH002
+
+
+@attrs.define(auto_attribs=True)
+class A:
+    x: pyproj.Transformer
+
+
+@attrs.define
+class B:
+    x: pandas.DataFrame
+
+
+@frozen
+class C:
+    x: pandas.DataFrame
+
+
+@dataclass
+class D:
+    x: numpy.ndarray

crates/ruff/resources/test/fixtures/flake8_type_checking/runtime_evaluated_decorators_3.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import datetime
+from array import array
+from dataclasses import dataclass
+from uuid import UUID  # TCH003
+
+import attrs
+from attrs import frozen
+
+
+@attrs.define(auto_attribs=True)
+class A:
+    x: datetime.datetime
+
+
+@frozen
+class B:
+    x: array
+
+
+@dataclass
+class C:
+    x: UUID

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

@@ -185,7 +185,6 @@ where
                 }
             }
         }
-
         // Pre-visit.
         match &stmt.node {
             StmtKind::Global { names } => {
@@ -2086,11 +2085,30 @@ where
                 // If we're in a class or module scope, then the annotation needs to be
                 // available at runtime.
                 // See: https://docs.python.org/3/reference/simple_stmts.html#annotated-assignment-statements
-                let runtime_annotation = !self.ctx.annotations_future_enabled
-                    && matches!(
+                let runtime_annotation = if self.ctx.annotations_future_enabled {
+                    if matches!(self.ctx.current_scope().kind, ScopeKind::Class(..)) {
+                        let baseclasses = &self
+                            .settings
+                            .flake8_type_checking
+                            .runtime_evaluated_baseclasses;
+                        let decorators = &self
+                            .settings
+                            .flake8_type_checking
+                            .runtime_evaluated_decorators;
+                        flake8_type_checking::helpers::runtime_evaluated(
+                            &self.ctx,
+                            baseclasses,
+                            decorators,
+                        )
+                    } else {
+                        false
+                    }
+                } else {
+                    matches!(
                         self.ctx.current_scope().kind,
                         ScopeKind::Class(..) | ScopeKind::Module
-                    );
+                    )
+                };
 
                 if runtime_annotation {
                     visit_type_definition!(self, annotation);
@@ -5490,7 +5508,6 @@ pub fn check_ast(
     } else {
         python_ast
     };
-
     // Iterate over the AST.
     checker.visit_body(python_ast);
 

crates/ruff/src/rules/flake8_type_checking/helpers.rs

@@ -1,7 +1,9 @@
 use num_traits::Zero;
 use rustpython_parser::ast::{Constant, Expr, ExprKind};
 
-use crate::ast::types::{Binding, BindingKind, ExecutionContext};
+use crate::ast::context::Context;
+use crate::ast::helpers::{map_callable, to_call_path};
+use crate::ast::types::{Binding, BindingKind, ExecutionContext, ScopeKind};
 use crate::checkers::ast::Checker;
 
 /// Return `true` if [`Expr`] is a guard for a type-checking block.
@@ -54,3 +56,53 @@ pub const fn is_valid_runtime_import(binding: &Binding) -> bool {
         false
     }
 }
+
+pub fn runtime_evaluated(
+    context: &Context,
+    base_classes: &[String],
+    decorators: &[String],
+) -> bool {
+    if !base_classes.is_empty() {
+        if runtime_evaluated_baseclass(context, base_classes) {
+            return true;
+        }
+    }
+    if !decorators.is_empty() {
+        if runtime_evaluated_decorators(context, decorators) {
+            return true;
+        }
+    }
+    false
+}
+
+fn runtime_evaluated_baseclass(context: &Context, base_classes: &[String]) -> bool {
+    if let ScopeKind::Class(class_def) = &context.current_scope().kind {
+        for base in class_def.bases.iter() {
+            if let Some(call_path) = context.resolve_call_path(base) {
+                if base_classes
+                    .iter()
+                    .any(|base_class| to_call_path(base_class) == call_path)
+                {
+                    return true;
+                }
+            }
+        }
+    }
+    false
+}
+
+fn runtime_evaluated_decorators(context: &Context, decorators: &[String]) -> bool {
+    if let ScopeKind::Class(class_def) = &context.current_scope().kind {
+        for decorator in class_def.decorator_list.iter() {
+            if let Some(call_path) = context.resolve_call_path(map_callable(decorator)) {
+                if decorators
+                    .iter()
+                    .any(|decorator| to_call_path(decorator) == call_path)
+                {
+                    return true;
+                }
+            }
+        }
+    }
+    false
+}

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

@@ -76,4 +76,45 @@ mod tests {
         assert_yaml_snapshot!(diagnostics);
         Ok(())
     }
+
+    #[test_case(Rule::RuntimeImportInTypeCheckingBlock, Path::new("runtime_evaluated_baseclasses_1.py"); "runtime_evaluated_baseclasses_1")]
+    #[test_case(Rule::TypingOnlyThirdPartyImport, Path::new("runtime_evaluated_baseclasses_2.py"); "runtime_evaluated_baseclasses_2")]
+    #[test_case(Rule::TypingOnlyStandardLibraryImport, Path::new("runtime_evaluated_baseclasses_3.py"); "runtime_evaluated_baseclasses_3")]
+    fn runtime_evaluated_baseclasses(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::Settings {
+                flake8_type_checking: super::settings::Settings {
+                    runtime_evaluated_baseclasses: vec!["pydantic.BaseModel".to_string()],
+                    ..Default::default()
+                },
+                ..settings::Settings::for_rule(rule_code)
+            },
+        )?;
+        assert_yaml_snapshot!(snapshot, diagnostics);
+        Ok(())
+    }
+
+    #[test_case(Rule::RuntimeImportInTypeCheckingBlock, Path::new("runtime_evaluated_decorators_1.py"); "runtime_evaluated_decorators_1")]
+    #[test_case(Rule::TypingOnlyThirdPartyImport, Path::new("runtime_evaluated_decorators_2.py"); "runtime_evaluated_decorators_2")]
+    #[test_case(Rule::TypingOnlyStandardLibraryImport, Path::new("runtime_evaluated_decorators_3.py"); "runtime_evaluated_decorators_3")]
+    fn runtime_evaluated_decorators(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::Settings {
+                flake8_type_checking: super::settings::Settings {
+                    runtime_evaluated_decorators: vec![
+                        "attrs.define".to_string(),
+                        "attrs.frozen".to_string(),
+                    ],
+                    ..Default::default()
+                },
+                ..settings::Settings::for_rule(rule_code)
+            },
+        )?;
+        assert_yaml_snapshot!(snapshot, diagnostics);
+        Ok(())
+    }
 }

crates/ruff/src/rules/flake8_type_checking/settings.rs

@@ -34,12 +34,34 @@ pub struct Options {
     /// Exempt certain modules from needing to be moved into type-checking
     /// blocks.
     pub exempt_modules: Option<Vec<String>>,
+    #[option(
+        default = "[]",
+        value_type = "list[str]",
+        example = r#"
+            runtime-evaluated-baseclasses = ["pydantic.BaseModel"]
+        "#
+    )]
+    /// Exempt classes that list any of the enumerated classes as a base class
+    /// from needing to be moved into type-checking blocks.
+    pub runtime_evaluated_baseclasses: Option<Vec<String>>,
+    #[option(
+        default = "[]",
+        value_type = "list[str]",
+        example = r#"
+            runtime-evaluated-decorators = ["attrs.define", "attrs.frozen"]
+        "#
+    )]
+    /// Exempt classes decorated with any of the enumerated decorators from
+    /// needing to be moved into type-checking blocks.
+    pub runtime_evaluated_decorators: Option<Vec<String>>,
 }
 
 #[derive(Debug, CacheKey)]
 pub struct Settings {
     pub strict: bool,
     pub exempt_modules: Vec<String>,
+    pub runtime_evaluated_baseclasses: Vec<String>,
+    pub runtime_evaluated_decorators: Vec<String>,
 }
 
 impl Default for Settings {
@@ -47,6 +69,8 @@ impl Default for Settings {
         Self {
             strict: false,
             exempt_modules: vec!["typing".to_string()],
+            runtime_evaluated_baseclasses: vec![],
+            runtime_evaluated_decorators: vec![],
         }
     }
 }
@@ -58,6 +82,10 @@ impl From<Options> for Settings {
             exempt_modules: options
                 .exempt_modules
                 .unwrap_or_else(|| vec!["typing".to_string()]),
+            runtime_evaluated_baseclasses: options
+                .runtime_evaluated_baseclasses
+                .unwrap_or_default(),
+            runtime_evaluated_decorators: options.runtime_evaluated_decorators.unwrap_or_default(),
         }
     }
 }
@@ -67,6 +95,8 @@ impl From<Settings> for Options {
         Self {
             strict: Some(settings.strict),
             exempt_modules: Some(settings.exempt_modules),
+            runtime_evaluated_baseclasses: Some(settings.runtime_evaluated_baseclasses),
+            runtime_evaluated_decorators: Some(settings.runtime_evaluated_decorators),
         }
     }
 }

crates/ruff/src/rules/flake8_type_checking/snapshots/ruff__rules__flake8_type_checking__tests__runtime-import-in-type-checking-block_runtime_evaluated_baseclasses_1.py.snap

@@ -0,0 +1,38 @@
+---
+source: crates/ruff/src/rules/flake8_type_checking/mod.rs
+expression: diagnostics
+---
+- kind:
+    RuntimeImportInTypeCheckingBlock:
+      full_name: datetime
+  location:
+    row: 10
+    column: 11
+  end_location:
+    row: 10
+    column: 19
+  fix: ~
+  parent: ~
+- kind:
+    RuntimeImportInTypeCheckingBlock:
+      full_name: array.array
+  location:
+    row: 11
+    column: 22
+  end_location:
+    row: 11
+    column: 27
+  fix: ~
+  parent: ~
+- kind:
+    RuntimeImportInTypeCheckingBlock:
+      full_name: pandas
+  location:
+    row: 13
+    column: 11
+  end_location:
+    row: 13
+    column: 17
+  fix: ~
+  parent: ~
+

crates/ruff/src/rules/flake8_type_checking/snapshots/ruff__rules__flake8_type_checking__tests__runtime-import-in-type-checking-block_runtime_evaluated_decorators_1.py.snap

@@ -0,0 +1,38 @@
+---
+source: crates/ruff/src/rules/flake8_type_checking/mod.rs
+expression: diagnostics
+---
+- kind:
+    RuntimeImportInTypeCheckingBlock:
+      full_name: datetime
+  location:
+    row: 12
+    column: 11
+  end_location:
+    row: 12
+    column: 19
+  fix: ~
+  parent: ~
+- kind:
+    RuntimeImportInTypeCheckingBlock:
+      full_name: array.array
+  location:
+    row: 13
+    column: 22
+  end_location:
+    row: 13
+    column: 27
+  fix: ~
+  parent: ~
+- kind:
+    RuntimeImportInTypeCheckingBlock:
+      full_name: pandas
+  location:
+    row: 15
+    column: 11
+  end_location:
+    row: 15
+    column: 17
+  fix: ~
+  parent: ~
+

crates/ruff/src/rules/flake8_type_checking/snapshots/ruff__rules__flake8_type_checking__tests__typing-only-standard-library-import_runtime_evaluated_baseclasses_3.py.snap

@@ -0,0 +1,16 @@
+---
+source: crates/ruff/src/rules/flake8_type_checking/mod.rs
+expression: diagnostics
+---
+- kind:
+    TypingOnlyStandardLibraryImport:
+      full_name: uuid.UUID
+  location:
+    row: 5
+    column: 17
+  end_location:
+    row: 5
+    column: 21
+  fix: ~
+  parent: ~
+

crates/ruff/src/rules/flake8_type_checking/snapshots/ruff__rules__flake8_type_checking__tests__typing-only-standard-library-import_runtime_evaluated_decorators_3.py.snap

@@ -0,0 +1,16 @@
+---
+source: crates/ruff/src/rules/flake8_type_checking/mod.rs
+expression: diagnostics
+---
+- kind:
+    TypingOnlyStandardLibraryImport:
+      full_name: uuid.UUID
+  location:
+    row: 6
+    column: 17
+  end_location:
+    row: 6
+    column: 21
+  fix: ~
+  parent: ~
+

crates/ruff/src/rules/flake8_type_checking/snapshots/ruff__rules__flake8_type_checking__tests__typing-only-third-party-import_runtime_evaluated_baseclasses_2.py.snap

@@ -0,0 +1,27 @@
+---
+source: crates/ruff/src/rules/flake8_type_checking/mod.rs
+expression: diagnostics
+---
+- kind:
+    TypingOnlyThirdPartyImport:
+      full_name: geopandas
+  location:
+    row: 3
+    column: 7
+  end_location:
+    row: 3
+    column: 23
+  fix: ~
+  parent: ~
+- kind:
+    TypingOnlyThirdPartyImport:
+      full_name: pyproj
+  location:
+    row: 5
+    column: 7
+  end_location:
+    row: 5
+    column: 13
+  fix: ~
+  parent: ~
+

crates/ruff/src/rules/flake8_type_checking/snapshots/ruff__rules__flake8_type_checking__tests__typing-only-third-party-import_runtime_evaluated_decorators_2.py.snap

@@ -0,0 +1,16 @@
+---
+source: crates/ruff/src/rules/flake8_type_checking/mod.rs
+expression: diagnostics
+---
+- kind:
+    TypingOnlyThirdPartyImport:
+      full_name: numpy
+  location:
+    row: 10
+    column: 7
+  end_location:
+    row: 10
+    column: 12
+  fix: ~
+  parent: ~
+

ruff.schema.json

@@ -908,6 +908,26 @@
             "type": "string"
           }
         },
+        "runtime-evaluated-baseclasses": {
+          "description": "Exempt classes that list any of the enumerated classes as a base class from needing to be moved into type-checking blocks.",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "type": "string"
+          }
+        },
+        "runtime-evaluated-decorators": {
+          "description": "Exempt classes decorated with any of the enumerated decorators from needing to be moved into type-checking blocks.",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "type": "string"
+          }
+        },
         "strict": {
           "description": "Enforce TC001, TC002, and TC003 rules even when valid runtime imports are present for the same module. See flake8-type-checking's [strict](https://github.com/snok/flake8-type-checking#strict) option.",
           "type": [