[dataclass_transform] support subclass/metaclass-based transforms (#14657)

Support dataclass_transforms that use inheritance or metaclasses rather
than decorators. This only needs plumbing changes so that we can get the
correct metadata for a given class and trigger the dataclasses transform
plugin; logic should otherwise remain the same.

The code changes here are a little invasive because of how the
dataclasses plugin handles it's "reason" (ie, the AST node that
triggered the plugin). Currently it takes a `ClassDefContext` where
`reason: Expression`, but in the case of inheritance/metaclass-based
transforms, it makes more sense for the class definition itself to be
the reason (since the parent class and keyword args are supplied in the
class definition itself). To accommodate for this, I refactored the
`DataclassTransformer` class to take a `reason: Expression | Statement`
while leaving the plugin API itself alone. This mostly involved updating
the identifiers used throughout the class.

Author: wesleywright

Diff for: mypy/nodes.py

@@ -2830,6 +2830,7 @@ class is generic then it will be a type constructor of higher kind.
         "type_var_tuple_prefix",
         "type_var_tuple_suffix",
         "self_type",
+        "dataclass_transform_spec",
     )
 
     _fullname: str  # Fully qualified name
@@ -2977,6 +2978,9 @@ class is generic then it will be a type constructor of higher kind.
     # Shared type variable for typing.Self in this class (if used, otherwise None).
     self_type: mypy.types.TypeVarType | None
 
+    # Added if the corresponding class is directly decorated with `typing.dataclass_transform`
+    dataclass_transform_spec: DataclassTransformSpec | None
+
     FLAGS: Final = [
         "is_abstract",
         "is_enum",
@@ -3032,6 +3036,7 @@ def __init__(self, names: SymbolTable, defn: ClassDef, module_name: str) -> None
         self.is_intersection = False
         self.metadata = {}
         self.self_type = None
+        self.dataclass_transform_spec = None
 
     def add_type_vars(self) -> None:
         self.has_type_var_tuple_type = False
@@ -3251,6 +3256,11 @@ def serialize(self) -> JsonDict:
             "slots": list(sorted(self.slots)) if self.slots is not None else None,
             "deletable_attributes": self.deletable_attributes,
             "self_type": self.self_type.serialize() if self.self_type is not None else None,
+            "dataclass_transform_spec": (
+                self.dataclass_transform_spec.serialize()
+                if self.dataclass_transform_spec is not None
+                else None
+            ),
         }
         return data
 
@@ -3314,6 +3324,10 @@ def deserialize(cls, data: JsonDict) -> TypeInfo:
         set_flags(ti, data["flags"])
         st = data["self_type"]
         ti.self_type = mypy.types.TypeVarType.deserialize(st) if st is not None else None
+        if data.get("dataclass_transform_spec") is not None:
+            ti.dataclass_transform_spec = DataclassTransformSpec.deserialize(
+                data["dataclass_transform_spec"]
+            )
         return ti