review comments

Author: AlexWaygood

crates/ty_python_semantic/resources/mdtest/dataclasses/post_init.md

@@ -17,28 +17,23 @@ class Empty2:
     def __post_init__(self) -> None: ...  # fine
 
 @dataclass
-class Empty2:
+class Empty3:
     # The returned value is discarded,
     # so arbitrary return annotations are allowed
     def __post_init__(self) -> int:
         return 42
 
-@dataclass
-class Empty3:
-    def __post_init__(self, *args): ...  # fine
-
 @dataclass
 class Empty4:
-    def __post_init__(self, **kwargs): ...  # fine
+    def __post_init__(self, *args): ...  # fine
 
 @dataclass
 class Empty5:
-    def __post_init__(self, *args, **kargs): ...  # fine
+    def __post_init__(self, **kwargs): ...  # fine
 
 @dataclass
 class Empty6:
-    # error: [invalid-dataclass]
-    def __post_init__(self, required_argument: int): ...
+    def __post_init__(self, *args, **kargs): ...  # fine
 
 @dataclass
 class Empty7:
@@ -88,9 +83,9 @@ class HasInitVarDifferentParameterName:
     x: InitVar[int]
 
     # because arguments are always passed in positionally
-    # to `__post_init__` methods, we allow the parameters to
-    # have arbitrary names as long as they are annotated with
-    # the right type. So this is fine:
+    # to `__post_init__` methods, we allow a parameter to
+    # have an arbitrary name as long as it is inferred has
+    # having a compatible type. So this is fine:
     def __post_init__(self, xx) -> None: ...
 
 @dataclass

crates/ty_python_semantic/src/types/overrides.rs

@@ -542,59 +542,63 @@ fn check_post_init_signature<'db>(
 ) {
     let db = context.db();
 
-    if configuration.check_invalid_dataclasses()
-        && member.name == "__post_init__"
-        && let Some((static_class, spec)) = class.static_class_literal(db)
-    {
-        let init_var_fields = static_class
-            .fields(db, spec, policy)
-            .iter()
-            .filter(|(_, field)| {
-                matches!(
-                    field.kind,
-                    FieldKind::Dataclass {
-                        init_only: true,
-                        ..
-                    }
-                )
-            });
-
-        let first_parameter = Parameter::positional_only(Some(Name::new_static("self")))
-            .with_annotated_type(Type::instance(db, class));
+    if !configuration.check_invalid_dataclasses() {
+        return;
+    }
+    if member.name != "__post_init__" {
+        return;
+    }
+    let Some((static_class, spec)) = class.static_class_literal(db) else {
+        return;
+    };
 
-        let following_parameters = init_var_fields.map(|(name, field)| {
-            Parameter::positional_only(Some(name.clone())).with_annotated_type(field.declared_ty)
+    let init_var_fields = static_class
+        .fields(db, spec, policy)
+        .iter()
+        .filter(|(_, field)| {
+            matches!(
+                field.kind,
+                FieldKind::Dataclass {
+                    init_only: true,
+                    ..
+                }
+            )
         });
 
-        let parameters = Parameters::new(
-            db,
-            std::iter::once(first_parameter).chain(following_parameters),
-        );
+    let first_parameter = Parameter::positional_only(Some(Name::new_static("self")))
+        .with_annotated_type(Type::instance(db, class));
 
-        let expected_signature =
-            CallableType::single(db, Signature::new(parameters, Type::object()));
+    let following_parameters = init_var_fields.map(|(name, field)| {
+        Parameter::positional_only(Some(name.clone())).with_annotated_type(field.declared_ty)
+    });
 
-        if member
-            .ty
-            .is_assignable_to(db, Type::Callable(expected_signature))
-        {
-            return;
-        }
+    let parameters = Parameters::new(
+        db,
+        std::iter::chain([first_parameter], following_parameters),
+    );
 
-        let Some(builder) = context.report_lint(
-            &INVALID_DATACLASS,
-            definition.focus_range(db, context.module()),
-        ) else {
-            return;
-        };
+    let expected_signature = CallableType::single(db, Signature::new(parameters, Type::object()));
 
-        let mut diagnostic = builder.into_diagnostic(format_args!(
-            "Invalid `__post_init__` signature for dataclass `{}`",
-            class.name(db)
-        ));
-        diagnostic.info(
-            "`__post_init__` methods must accept all `InitVar` fields \
-            as positional-only parameters",
-        );
+    if member
+        .ty
+        .is_assignable_to(db, Type::Callable(expected_signature))
+    {
+        return;
     }
+
+    let Some(builder) = context.report_lint(
+        &INVALID_DATACLASS,
+        definition.focus_range(db, context.module()),
+    ) else {
+        return;
+    };
+
+    let mut diagnostic = builder.into_diagnostic(format_args!(
+        "Invalid `__post_init__` signature for dataclass `{}`",
+        class.name(db)
+    ));
+    diagnostic.info(
+        "`__post_init__` methods must accept all `InitVar` fields \
+            as positional-only parameters",
+    );
 }