[ty] Refactor frozen dataclass diagnostic

Author: thejchap

crates/ty_python_semantic/resources/mdtest/dataclasses.md

@@ -369,14 +369,14 @@ To do
 
 ### `frozen`
 
-If true (the default is False), assigning to fields will generate a diagnostic. If `__setattr__()` or
-`__delattr__()` is defined in the class, we should emit a diagnostic.
+If true (the default is False), assigning to fields will generate a diagnostic. If `__setattr__()`
+or `__delattr__()` is defined in the class, we should emit a diagnostic.
 
 ```py
 from dataclasses import dataclass
 
 @dataclass(frozen=True)
-class Frozen:
+class MyFrozenClass:
     x: int
 
     # TODO: Emit a diagnostic here
@@ -385,10 +385,23 @@ class Frozen:
     # TODO: Emit a diagnostic here
     def __delattr__(self, name: str) -> None: ...
 
-frozen = Frozen(1)
+frozen = MyFrozenClass(1)
 frozen.x = 2  # error: [invalid-assignment]
 ```
 
+When attempting to mutate an unresolved attribute on a frozen dataclass, only `unresolved-attribute`
+is emitted:
+
+```py
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class MyFrozenClass: ...
+
+frozen = MyFrozenClass()
+frozen.x = 2  # error: [unresolved-attribute]
+```
+
 ### `match_args`
 
 To do

crates/ty_python_semantic/src/types/infer.rs

@@ -2924,24 +2924,16 @@ impl<'db> TypeInferenceBuilder<'db> {
             | Type::TypeVar(..)
             | Type::AlwaysTruthy
             | Type::AlwaysFalsy => {
-                if let Type::NominalInstance(instance) = object_ty {
-                    let dataclass_params = match instance.class() {
+                let dataclass_params = match object_ty {
+                    Type::NominalInstance(instance) => match instance.class() {
                         ClassType::NonGeneric(cls) => cls.dataclass_params(self.db()),
                         ClassType::Generic(_) => None,
-                    };
-                    let frozen = dataclass_params
-                        .is_some_and(|params| params.contains(DataclassParams::FROZEN));
-                    if frozen && emit_diagnostics {
-                        if let Some(builder) = self.context.report_lint(&INVALID_ASSIGNMENT, target)
-                        {
-                            builder.into_diagnostic(format_args!(
-                                "Property `{attribute}` defined in `{ty}` is read-only",
-                                ty = object_ty.display(self.db()),
-                            ));
-                        }
-                    }
-                }
-                match object_ty.class_member(db, attribute.into()) {
+                    },
+                    _ => None,
+                };
+                let ro =
+                    dataclass_params.is_some_and(|params| params.contains(DataclassParams::FROZEN));
+                let assignable_if_rw = match object_ty.class_member(db, attribute.into()) {
                     meta_attr @ SymbolAndQualifiers { .. } if meta_attr.is_class_var() => {
                         if emit_diagnostics {
                             if let Some(builder) =
@@ -3092,7 +3084,16 @@ impl<'db> TypeInferenceBuilder<'db> {
                             }
                         }
                     }
+                };
+                if (assignable_if_rw && ro) && emit_diagnostics {
+                    if let Some(builder) = self.context.report_lint(&INVALID_ASSIGNMENT, target) {
+                        builder.into_diagnostic(format_args!(
+                            "Property `{attribute}` defined in `{ty}` is read-only",
+                            ty = object_ty.display(self.db()),
+                        ));
+                    }
                 }
+                assignable_if_rw && !ro
             }
 
             Type::ClassLiteral(..) | Type::GenericAlias(..) | Type::SubclassOf(..) => {