[red-knot] Three-argument type-calls take 'str' as the first argument

Author: sharkdp

crates/red_knot_python_semantic/resources/mdtest/call/builtins.md

@@ -26,7 +26,11 @@ reveal_type(type(1))  # revealed: Literal[int]
 But a three-argument call to type creates a dynamic instance of the `type` class:
 
 ```py
+class Base: ...
+
 reveal_type(type("Foo", (), {}))  # revealed: type
+
+reveal_type(type("Foo", (Base,), {"attr": 1}))  # revealed: type
 ```
 
 Other numbers of arguments are invalid
@@ -38,3 +42,21 @@ type("Foo", ())
 # error: [no-matching-overload] "No overload of class `type` matches arguments"
 type("Foo", (), {}, weird_other_arg=42)
 ```
+
+The following calls are also invalid, due to incorrect argument types:
+
+```py
+class Base: ...
+
+# error: [no-matching-overload] "No overload of class `type` matches arguments"
+type(b"Foo", (), {})
+
+# TODO: this should be an error
+type("Foo", str, {})
+
+# TODO: this should be an error
+type("Foo", (1, 2), {})
+
+# TODO: this should be an error
+type("Foo", (Base,), {b"attr": 1})
+```

crates/red_knot_python_semantic/resources/mdtest/narrow/type.md

@@ -76,6 +76,9 @@ No narrowing should occur if `type` is used to dynamically create a class:
 
 ```py
 def _(x: str | int):
+    # The following diagnostic is valid, since the three-argument form of `type`
+    # can only be called with `str` as the first argument.
+    # error: [no-matching-overload] "No overload of class `type` matches arguments"
     if type(x, (), {}) is str:
         reveal_type(x)  # revealed: str | int
     else:

crates/red_knot_python_semantic/src/types.rs

@@ -2893,11 +2893,13 @@ impl<'db> Type<'db> {
                             ),
                             Signature::new(
                                 Parameters::new([
-                                    Parameter::positional_only(Some(Name::new_static("o")))
-                                        .with_annotated_type(Type::any()),
+                                    Parameter::positional_only(Some(Name::new_static("name")))
+                                        .with_annotated_type(KnownClass::Str.to_instance(db)),
                                     Parameter::positional_only(Some(Name::new_static("bases")))
+                                        // TODO: Should be tuple[type, ...] once we have support for homogenous tuples
                                         .with_annotated_type(Type::any()),
                                     Parameter::positional_only(Some(Name::new_static("dict")))
+                                        // TODO: Should be `dict[str, Any]` once we have support for generics
                                         .with_annotated_type(Type::any()),
                                 ]),
                                 Some(KnownClass::Type.to_instance(db)),