Synthesized __new__ method

Author: sharkdp

crates/red_knot_python_semantic/resources/mdtest/named_tuple.md

@@ -13,14 +13,36 @@ class Person(NamedTuple):
     name: str
     age: int | None = None
 
-alice = Person(1, "Alice", 42)  # error: [no-matching-overload]
-alice = Person(id=1, name="Alice", age=42)  # error: [no-matching-overload]
-bob = Person(2, "Bob")  # error: [no-matching-overload]
-bob = Person(id=2, name="Bob")  # error: [no-matching-overload]
-
-reveal_type(alice.id)  # revealed: @Todo(GenericAlias instance)
-reveal_type(alice.name)  # revealed: @Todo(GenericAlias instance)
-reveal_type(alice.age)  # revealed: int | None | @Todo(instance attribute on class with dynamic base)
+alice = Person(1, "Alice", 42)
+alice = Person(id=1, name="Alice", age=42)
+bob = Person(2, "Bob")
+bob = Person(id=2, name="Bob")
+
+reveal_type(alice.id)  # revealed: int
+reveal_type(alice.name)  # revealed: str
+reveal_type(alice.age)  # revealed: int | None
+
+# error: [missing-argument]
+Person(3)
+
+# error: [too-many-positional-arguments]
+Person(3, "Eve", 99, "extra")
+
+# error: [invalid-argument-type]
+Person(id="3", name="Eve")
+```
+
+Alternative functional syntax:
+
+```py
+Person2 = NamedTuple("Person", [("id", int), ("name", str)])
+alice2 = Person2(1, "Alice")
+
+# TODO: should be an error
+Person2(1)
+
+reveal_type(alice2.id)  # revealed: @Todo(GenericAlias instance)
+reveal_type(alice2.name)  # revealed: @Todo(GenericAlias instance)
 ```
 
 ## `collections.namedtuple`

crates/red_knot_python_semantic/resources/mdtest/namedtuple.md

@@ -108,23 +108,18 @@ enum DataclassFieldsPolicy {
 }
 
 impl DataclassFieldsPolicy {
-    fn matches<'db>(
-        self,
-        db: &'db dyn Db,
-        class: ClassLiteral<'db>,
-        specialization: Option<Specialization<'db>>,
-    ) -> bool {
+    fn matches<'db>(self, db: &'db dyn Db, class: ClassLiteral<'db>) -> bool {
         match self {
             Self::Dataclass => {
                 class.dataclass_params(db).is_some()
                     || class
                         .try_metaclass(db)
                         .is_ok_and(|(_, transformer_params)| transformer_params.is_some())
             }
-            Self::NamedTuple => KnownClass::NamedTuple
-                .to_class_literal(db)
-                .to_class_type(db)
-                .is_some_and(|named_tuple| class.is_subclass_of(db, specialization, named_tuple)),
+            Self::NamedTuple => class.explicit_bases(db).iter().any(|base| {
+                base.into_class_literal()
+                    .is_some_and(|c| c.is_known(db, KnownClass::NamedTuple))
+            }),
         }
     }
 }
@@ -1016,12 +1011,6 @@ impl<'db> ClassLiteral<'db> {
 
         if symbol.symbol.is_unbound() {
             if let Some(dataclass_member) = self.own_dataclass_member(db, specialization, name) {
-                eprintln!(
-                    "==> dataclass {} {} {}",
-                    Type::from(self).display(db),
-                    name,
-                    dataclass_member.display(db)
-                );
                 return Symbol::bound(dataclass_member).into();
             }
         }
@@ -1038,21 +1027,21 @@ impl<'db> ClassLiteral<'db> {
     ) -> Option<Type<'db>> {
         let params = self.dataclass_params(db);
         let has_dataclass_param = |param| params.is_some_and(|params| params.contains(param));
+        let field_policy = if has_dataclass_param(DataclassParams::INIT)
+            || self
+                .try_metaclass(db)
+                .is_ok_and(|(_, transformer_params)| transformer_params.is_some())
+        {
+            DataclassFieldsPolicy::Dataclass
+        } else if DataclassFieldsPolicy::NamedTuple.matches(db, self) {
+            DataclassFieldsPolicy::NamedTuple
+        } else {
+            return None;
+        };
 
-        match name {
-            "__init__" => {
-                let field_policy = if has_dataclass_param(DataclassParams::INIT)
-                    || self
-                        .try_metaclass(db)
-                        .is_ok_and(|(_, transformer_params)| transformer_params.is_some())
-                {
-                    DataclassFieldsPolicy::Dataclass
-                } else if DataclassFieldsPolicy::NamedTuple.matches(db, self, specialization) {
-                    DataclassFieldsPolicy::NamedTuple
-                } else {
-                    return None;
-                };
-
+        match (name, field_policy) {
+            ("__init__", DataclassFieldsPolicy::Dataclass)
+            | ("__new__", DataclassFieldsPolicy::NamedTuple) => {
                 let mut parameters = vec![];
 
                 for (name, (mut attr_ty, mut default_ty)) in
@@ -1118,12 +1107,20 @@ impl<'db> ClassLiteral<'db> {
                     parameters.push(parameter);
                 }
 
-                let init_signature =
-                    Signature::new(Parameters::new(parameters), Some(Type::none(db)));
+                if name == "__init__" {
+                    let init_signature =
+                        Signature::new(Parameters::new(parameters), Some(Type::none(db)));
 
-                Some(Type::Callable(CallableType::single(db, init_signature)))
+                    Some(Type::Callable(CallableType::single(db, init_signature)))
+                } else {
+                    parameters.insert(0, Parameter::positional_or_keyword(Name::new_static("cls")));
+                    let new_signature =
+                        Signature::new(Parameters::new(parameters), Some(Type::none(db)));
+
+                    Some(Type::Callable(CallableType::single(db, new_signature)))
+                }
             }
-            "__lt__" | "__le__" | "__gt__" | "__ge__" => {
+            ("__lt__" | "__le__" | "__gt__" | "__ge__", DataclassFieldsPolicy::Dataclass) => {
                 if !has_dataclass_param(DataclassParams::ORDER) {
                     return None;
                 }
@@ -1144,13 +1141,6 @@ impl<'db> ClassLiteral<'db> {
         }
     }
 
-    fn is_dataclass(self, db: &'db dyn Db) -> bool {
-        self.dataclass_params(db).is_some()
-            || self
-                .try_metaclass(db)
-                .is_ok_and(|(_, transformer_params)| transformer_params.is_some())
-    }
-
     /// Returns a list of all annotated attributes defined in this class, or any of its superclasses.
     ///
     /// See [`ClassLiteral::own_dataclass_fields`] for more details.
@@ -1165,7 +1155,7 @@ impl<'db> ClassLiteral<'db> {
             .filter_map(|superclass| {
                 if let Some(class) = superclass.into_class() {
                     let class_literal = class.class_literal(db).0;
-                    if field_policy.matches(db, class_literal, specialization) {
+                    if field_policy.matches(db, class_literal) {
                         Some(class_literal)
                     } else {
                         None
@@ -2113,6 +2103,7 @@ impl<'db> KnownClass {
             | Self::TypeVarTuple
             | Self::TypeAliasType
             | Self::NoDefaultType
+            | Self::NamedTuple
             | Self::NewType
             | Self::ChainMap
             | Self::Counter

crates/red_knot_python_semantic/src/types/class.rs

@@ -72,11 +72,15 @@ impl<'db> ClassBase<'db> {
     pub(super) fn try_from_type(db: &'db dyn Db, ty: Type<'db>) -> Option<Self> {
         match ty {
             Type::Dynamic(dynamic) => Some(Self::Dynamic(dynamic)),
-            Type::ClassLiteral(literal) => Some(if literal.is_known(db, KnownClass::Any) {
-                Self::Dynamic(DynamicType::Any)
-            } else {
-                Self::Class(literal.default_specialization(db))
-            }),
+            Type::ClassLiteral(literal) => {
+                if literal.is_known(db, KnownClass::Any) {
+                    Some(Self::Dynamic(DynamicType::Any))
+                } else if literal.is_known(db, KnownClass::NamedTuple) {
+                    Self::try_from_type(db, KnownClass::Tuple.to_class_literal(db))
+                } else {
+                    Some(Self::Class(literal.default_specialization(db)))
+                }
+            }
             Type::GenericAlias(generic) => Some(Self::Class(ClassType::Generic(generic))),
             Type::NominalInstance(instance)
                 if instance.class().is_known(db, KnownClass::GenericAlias) =>

crates/red_knot_python_semantic/src/types/class_base.rs

@@ -59,22 +59,13 @@ type KeyDiagnosticFields = (
     Severity,
 );
 
-static EXPECTED_TOMLLIB_DIAGNOSTICS: &[KeyDiagnosticFields] = &[
-    (
-        DiagnosticId::lint("no-matching-overload"),
-        Some("/src/tomllib/_parser.py"),
-        Some(2329..2358),
-        "No overload of bound method `__init__` matches arguments",
-        Severity::Error,
-    ),
-    (
-        DiagnosticId::lint("unused-ignore-comment"),
-        Some("/src/tomllib/_parser.py"),
-        Some(22299..22333),
-        "Unused blanket `type: ignore` directive",
-        Severity::Warning,
-    ),
-];
+static EXPECTED_TOMLLIB_DIAGNOSTICS: &[KeyDiagnosticFields] = &[(
+    DiagnosticId::lint("unused-ignore-comment"),
+    Some("/src/tomllib/_parser.py"),
+    Some(22299..22333),
+    "Unused blanket `type: ignore` directive",
+    Severity::Warning,
+)];
 
 fn tomllib_path(file: &TestFile) -> SystemPathBuf {
     SystemPathBuf::from("src").join(file.name())