Reject Generic and TypedDict

Author: charliermarsh

crates/ty_python_semantic/resources/mdtest/call/new_class.md

@@ -194,8 +194,8 @@ reveal_type(MyEnum)  # revealed: <class 'MyEnum'>
 
 ### Generic and TypedDict bases
 
-`type()` doesn't support `__mro_entries__`, so `Generic[T]` and `TypedDict` fail as bases for
-`type()`. `types.new_class()` handles `__mro_entries__` properly, so these are valid:
+Even though `types.new_class()` handles `__mro_entries__` at runtime, ty does not yet model the full
+typing semantics of dynamically-created generic classes or TypedDicts, so these bases are rejected:
 
 ```py
 import types
@@ -204,11 +204,11 @@ from typing_extensions import TypedDict
 
 T = TypeVar("T")
 
+# error: [invalid-base] "Invalid base for class created via `types.new_class()`"
 GenericClass = types.new_class("GenericClass", (Generic[T],))
-reveal_type(GenericClass)  # revealed: <class 'GenericClass'>
 
+# error: [invalid-base] "Invalid base for class created via `types.new_class()`"
 TypedDictClass = types.new_class("TypedDictClass", (TypedDict,))
-reveal_type(TypedDictClass)  # revealed: <class 'TypedDictClass'>
 ```
 
 ### `type[X]` bases

crates/ty_python_semantic/src/types/infer/builder.rs

@@ -3456,33 +3456,37 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
 
             // Check for special bases that are not allowed for dynamic classes.
             //
-            // `type()` doesn't support `__mro_entries__`, so Generic and TypedDict bases
-            // are invalid. `types.new_class()` handles `__mro_entries__` properly, so
-            // these are allowed.
+            // Generic and TypedDict bases rely on special typing semantics that ty cannot yet
+            // model for dynamically-created classes, so we reject them for both `type()` and
+            // `types.new_class()`.
             //
             // Protocol works with both, but ty can't yet represent a dynamically-created
             // protocol class, so we emit a warning.
             //
             // (`NamedTuple` is rejected earlier: `try_from_type` returns `None`
             // without a concrete subclass, so it's reported as an `InvalidBases` MRO error.)
             match class_base {
-                ClassBase::Generic | ClassBase::TypedDict if kind == DynamicClassKind::TypeCall => {
+                ClassBase::Generic | ClassBase::TypedDict => {
                     if let Some(builder) = self.context.report_lint(&INVALID_BASE, diagnostic_node)
                     {
-                        let mut diagnostic =
-                            builder.into_diagnostic("Invalid base for class created via `type()`");
+                        let mut diagnostic = builder.into_diagnostic(format_args!(
+                            "Invalid base for class created via `{fn_name}`"
+                        ));
                         diagnostic
                             .set_primary_message(format_args!("Has type `{}`", base.display(db)));
                         match class_base {
                             ClassBase::Generic => {
-                                diagnostic.info("Classes created via `type()` cannot be generic");
+                                diagnostic.info(format_args!(
+                                    "Classes created via `{fn_name}` cannot be generic"
+                                ));
                                 diagnostic.info(format_args!(
                                     "Consider using `class {name}(Generic[...]): ...` instead"
                                 ));
                             }
                             ClassBase::TypedDict => {
-                                diagnostic
-                                    .info("Classes created via `type()` cannot be TypedDicts");
+                                diagnostic.info(format_args!(
+                                    "Classes created via `{fn_name}` cannot be TypedDicts"
+                                ));
                                 diagnostic.info(format_args!(
                                     "Consider using `TypedDict(\"{name}\", {{}})` instead"
                                 ));
@@ -3491,9 +3495,6 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                         }
                     }
                 }
-                ClassBase::Generic | ClassBase::TypedDict => {
-                    // types.new_class() handles __mro_entries__, so these are valid.
-                }
                 ClassBase::Protocol => {
                     if let Some(builder) = self
                         .context