Add Type::KnownInstance

Author: AlexWaygood

crates/ty_python_semantic/src/symbol.rs

@@ -1131,7 +1131,7 @@ fn widen_type_for_undeclared_public_symbol<'db>(
     // such.
     let is_known_instance = inferred
         .ignore_possibly_unbound()
-        .is_some_and(|ty| matches!(ty, Type::KnownInstance(_)));
+        .is_some_and(|ty| matches!(ty, Type::SpecialForm(_) | Type::KnownInstance(_)));
 
     if is_considered_non_modifiable || is_known_instance {
         inferred

crates/ty_python_semantic/src/types.rs

@@ -21,8 +21,8 @@ use crate::types::generics::{Specialization, SpecializationBuilder, Specializati
 use crate::types::signatures::{Parameter, ParameterForm};
 use crate::types::{
     BoundMethodType, DataclassParams, DataclassTransformerParams, FunctionDecorators, FunctionType,
-    KnownClass, KnownFunction, MethodWrapperKind, PropertyInstanceType, SpecialForm, TupleType,
-    TypeMapping, UnionType, WrapperDescriptorKind, todo_type,
+    KnownClass, KnownFunction, KnownInstanceType, MethodWrapperKind, PropertyInstanceType,
+    SpecialFormType, TupleType, TypeMapping, UnionType, WrapperDescriptorKind, todo_type,
 };
 use ruff_db::diagnostic::{Annotation, Diagnostic, Severity, SubDiagnostic};
 use ruff_python_ast as ast;
@@ -314,7 +314,9 @@ impl<'db> Bindings<'db> {
                             }
                             [
                                 Some(Type::PropertyInstance(property)),
-                                Some(Type::KnownInstance(SpecialForm::TypeAliasType(type_alias))),
+                                Some(Type::KnownInstance(KnownInstanceType::TypeAliasType(
+                                    type_alias,
+                                ))),
                                 ..,
                             ] if property.getter(db).is_some_and(|getter| {
                                 getter
@@ -327,7 +329,7 @@ impl<'db> Bindings<'db> {
                             }
                             [
                                 Some(Type::PropertyInstance(property)),
-                                Some(Type::KnownInstance(SpecialForm::TypeVar(typevar))),
+                                Some(Type::KnownInstance(KnownInstanceType::TypeVar(typevar))),
                                 ..,
                             ] => {
                                 match property
@@ -913,7 +915,7 @@ impl<'db> Bindings<'db> {
                         _ => {}
                     },
 
-                    Type::KnownInstance(SpecialForm::TypedDict) => {
+                    Type::SpecialForm(SpecialFormType::TypedDict) => {
                         overload.set_return_type(todo_type!("TypedDict"));
                     }
 

crates/ty_python_semantic/src/types/call/bind.rs

@@ -11,8 +11,8 @@ use crate::semantic_index::definition::Definition;
 use crate::types::generics::{GenericContext, Specialization};
 use crate::types::signatures::{Parameter, Parameters};
 use crate::types::{
-    CallableType, DataclassParams, DataclassTransformerParams, Signature, SpecialForm, TypeMapping,
-    TypeVarInstance,
+    CallableType, DataclassParams, DataclassTransformerParams, KnownInstanceType, Signature,
+    TypeMapping, TypeVarInstance,
 };
 use crate::{
     Db, FxOrderSet, KnownModule, Program,
@@ -593,7 +593,8 @@ impl<'db> ClassLiteral<'db> {
     pub(crate) fn legacy_generic_context(self, db: &'db dyn Db) -> Option<GenericContext<'db>> {
         self.explicit_bases(db).iter().find_map(|base| match base {
             Type::KnownInstance(
-                SpecialForm::Generic(generic_context) | SpecialForm::Protocol(generic_context),
+                KnownInstanceType::Generic(generic_context)
+                | KnownInstanceType::Protocol(generic_context),
             ) => *generic_context,
             _ => None,
         })
@@ -746,7 +747,7 @@ impl<'db> ClassLiteral<'db> {
                     .iter()
                     .rev()
                     .take(3)
-                    .any(|base| matches!(base, Type::KnownInstance(SpecialForm::Protocol(_))))
+                    .any(|base| matches!(base, Type::KnownInstance(KnownInstanceType::Protocol(_))))
             })
     }
 

crates/ty_python_semantic/src/types/class.rs

@@ -1,8 +1,8 @@
 use crate::Db;
 use crate::types::generics::Specialization;
 use crate::types::{
-    ClassType, DynamicType, KnownClass, MroError, MroIterator, SpecialForm, Type, TypeMapping,
-    todo_type,
+    ClassType, DynamicType, KnownClass, KnownInstanceType, MroError, MroIterator, SpecialFormType,
+    Type, TypeMapping, todo_type,
 };
 
 /// Enumeration of the possible kinds of types we allow in class bases.
@@ -147,66 +147,78 @@ impl<'db> ClassBase<'db> {
             | Type::ProtocolInstance(_)
             | Type::AlwaysFalsy
             | Type::AlwaysTruthy => None,
+
             Type::KnownInstance(known_instance) => match known_instance {
-                SpecialForm::TypeVar(_)
-                | SpecialForm::TypeAliasType(_)
-                | SpecialForm::Annotated
-                | SpecialForm::Literal
-                | SpecialForm::LiteralString
-                | SpecialForm::Union
-                | SpecialForm::NoReturn
-                | SpecialForm::Never
-                | SpecialForm::Final
-                | SpecialForm::NotRequired
-                | SpecialForm::TypeGuard
-                | SpecialForm::TypeIs
-                | SpecialForm::TypingSelf
-                | SpecialForm::Unpack
-                | SpecialForm::ClassVar
-                | SpecialForm::Concatenate
-                | SpecialForm::Required
-                | SpecialForm::TypeAlias
-                | SpecialForm::ReadOnly
-                | SpecialForm::Optional
-                | SpecialForm::Not
-                | SpecialForm::Intersection
-                | SpecialForm::TypeOf
-                | SpecialForm::CallableTypeOf
-                | SpecialForm::AlwaysTruthy
-                | SpecialForm::AlwaysFalsy => None,
-                SpecialForm::Unknown => Some(Self::unknown()),
+                KnownInstanceType::Generic(_) => Some(Self::Generic),
+                KnownInstanceType::Protocol(_) => Some(Self::Protocol),
+                KnownInstanceType::TypeAliasType(_) | KnownInstanceType::TypeVar(_) => None,
+            },
+
+            Type::SpecialForm(special_form) => match special_form {
+                SpecialFormType::Annotated
+                | SpecialFormType::Literal
+                | SpecialFormType::LiteralString
+                | SpecialFormType::Union
+                | SpecialFormType::NoReturn
+                | SpecialFormType::Never
+                | SpecialFormType::Final
+                | SpecialFormType::NotRequired
+                | SpecialFormType::TypeGuard
+                | SpecialFormType::TypeIs
+                | SpecialFormType::TypingSelf
+                | SpecialFormType::Unpack
+                | SpecialFormType::ClassVar
+                | SpecialFormType::Concatenate
+                | SpecialFormType::Required
+                | SpecialFormType::TypeAlias
+                | SpecialFormType::ReadOnly
+                | SpecialFormType::Optional
+                | SpecialFormType::Not
+                | SpecialFormType::Intersection
+                | SpecialFormType::TypeOf
+                | SpecialFormType::CallableTypeOf
+                | SpecialFormType::AlwaysTruthy
+                | SpecialFormType::AlwaysFalsy => None,
+
+                SpecialFormType::Unknown => Some(Self::unknown()),
                 // TODO: Classes inheriting from `typing.Type` et al. also have `Generic` in their MRO
-                SpecialForm::Dict => Self::try_from_type(db, KnownClass::Dict.to_class_literal(db)),
-                SpecialForm::List => Self::try_from_type(db, KnownClass::List.to_class_literal(db)),
-                SpecialForm::Type => Self::try_from_type(db, KnownClass::Type.to_class_literal(db)),
-                SpecialForm::Tuple => {
+                SpecialFormType::Dict => {
+                    Self::try_from_type(db, KnownClass::Dict.to_class_literal(db))
+                }
+                SpecialFormType::List => {
+                    Self::try_from_type(db, KnownClass::List.to_class_literal(db))
+                }
+                SpecialFormType::Type => {
+                    Self::try_from_type(db, KnownClass::Type.to_class_literal(db))
+                }
+                SpecialFormType::Tuple => {
                     Self::try_from_type(db, KnownClass::Tuple.to_class_literal(db))
                 }
-                SpecialForm::Set => Self::try_from_type(db, KnownClass::Set.to_class_literal(db)),
-                SpecialForm::FrozenSet => {
+                SpecialFormType::Set => {
+                    Self::try_from_type(db, KnownClass::Set.to_class_literal(db))
+                }
+                SpecialFormType::FrozenSet => {
                     Self::try_from_type(db, KnownClass::FrozenSet.to_class_literal(db))
                 }
-                SpecialForm::ChainMap => {
+                SpecialFormType::ChainMap => {
                     Self::try_from_type(db, KnownClass::ChainMap.to_class_literal(db))
                 }
-                SpecialForm::Counter => {
+                SpecialFormType::Counter => {
                     Self::try_from_type(db, KnownClass::Counter.to_class_literal(db))
                 }
-                SpecialForm::DefaultDict => {
+                SpecialFormType::DefaultDict => {
                     Self::try_from_type(db, KnownClass::DefaultDict.to_class_literal(db))
                 }
-                SpecialForm::Deque => {
+                SpecialFormType::Deque => {
                     Self::try_from_type(db, KnownClass::Deque.to_class_literal(db))
                 }
-                SpecialForm::OrderedDict => {
+                SpecialFormType::OrderedDict => {
                     Self::try_from_type(db, KnownClass::OrderedDict.to_class_literal(db))
                 }
-                SpecialForm::TypedDict => Self::try_from_type(db, todo_type!("TypedDict")),
-                SpecialForm::Callable => {
+                SpecialFormType::TypedDict => Self::try_from_type(db, todo_type!("TypedDict")),
+                SpecialFormType::Callable => {
                     Self::try_from_type(db, todo_type!("Support for Callable as a base class"))
                 }
-                SpecialForm::Protocol(_) => Some(ClassBase::Protocol),
-                SpecialForm::Generic(_) => Some(ClassBase::Generic),
             },
         }
     }
@@ -280,8 +292,8 @@ impl<'db> From<ClassBase<'db>> for Type<'db> {
         match value {
             ClassBase::Dynamic(dynamic) => Type::Dynamic(dynamic),
             ClassBase::Class(class) => class.into(),
-            ClassBase::Protocol => Type::KnownInstance(SpecialForm::Protocol(None)),
-            ClassBase::Generic => Type::KnownInstance(SpecialForm::Generic(None)),
+            ClassBase::Protocol => Type::KnownInstance(KnownInstanceType::Protocol(None)),
+            ClassBase::Generic => Type::KnownInstance(KnownInstanceType::Generic(None)),
         }
     }
 }

crates/ty_python_semantic/src/types/class_base.rs

@@ -5,7 +5,6 @@ use super::{
     CallArgumentTypes, CallDunderError, ClassBase, ClassLiteral, KnownClass,
     add_inferred_python_version_hint_to_diagnostic,
 };
-use crate::db::Db;
 use crate::declare_lint;
 use crate::lint::{Level, LintRegistryBuilder, LintStatus};
 use crate::suppression::FileSuppressionId;
@@ -15,7 +14,7 @@ use crate::types::string_annotation::{
     IMPLICIT_CONCATENATED_STRING_TYPE_ANNOTATION, INVALID_SYNTAX_IN_FORWARD_ANNOTATION,
     RAW_STRING_TYPE_ANNOTATION,
 };
-use crate::types::{KnownFunction, SpecialForm, Type, protocol_class::ProtocolClassLiteral};
+use crate::types::{KnownFunction, SpecialFormType, Type, protocol_class::ProtocolClassLiteral};
 use itertools::Itertools;
 use ruff_db::diagnostic::{Annotation, Diagnostic, Severity, SubDiagnostic};
 use ruff_python_ast::{self as ast, AnyNodeRef};
@@ -1823,7 +1822,6 @@ pub(crate) fn report_base_with_incompatible_slots(context: &InferContext, node:
 }
 
 pub(crate) fn report_invalid_arguments_to_annotated(
-    db: &dyn Db,
     context: &InferContext,
     subscript: &ast::ExprSubscript,
 ) {
@@ -1833,7 +1831,7 @@ pub(crate) fn report_invalid_arguments_to_annotated(
     builder.into_diagnostic(format_args!(
         "Special form `{}` expected at least 2 arguments \
          (one type and at least one metadata element)",
-        SpecialForm::Annotated.repr(db)
+        SpecialFormType::Annotated
     ));
 }
 
@@ -1873,7 +1871,6 @@ pub(crate) fn report_bad_argument_to_get_protocol_members(
 }
 
 pub(crate) fn report_invalid_arguments_to_callable(
-    db: &dyn Db,
     context: &InferContext,
     subscript: &ast::ExprSubscript,
 ) {
@@ -1882,7 +1879,7 @@ pub(crate) fn report_invalid_arguments_to_callable(
     };
     builder.into_diagnostic(format_args!(
         "Special form `{}` expected exactly two arguments (parameter types and return type)",
-        SpecialForm::Callable.repr(db)
+        SpecialFormType::Callable
     ));
 }
 

crates/ty_python_semantic/src/types/diagnostic.rs

@@ -110,6 +110,7 @@ impl Display for DisplayRepresentation<'_> {
                 SubclassOfInner::Class(class) => write!(f, "type[{}]", class.name(self.db)),
                 SubclassOfInner::Dynamic(dynamic) => write!(f, "type[{dynamic}]"),
             },
+            Type::SpecialForm(special_form) => special_form.fmt(f),
             Type::KnownInstance(known_instance) => known_instance.repr(self.db).fmt(f),
             Type::FunctionLiteral(function) => {
                 let signature = function.signature(self.db);

crates/ty_python_semantic/src/types/display.rs

@@ -9,8 +9,8 @@ use crate::types::class_base::ClassBase;
 use crate::types::instance::{NominalInstanceType, Protocol, ProtocolInstanceType};
 use crate::types::signatures::{Parameter, Parameters, Signature};
 use crate::types::{
-    SpecialForm, Type, TypeMapping, TypeVarBoundOrConstraints, TypeVarInstance, TypeVarVariance,
-    UnionType, declaration_type, todo_type,
+    KnownInstanceType, Type, TypeMapping, TypeVarBoundOrConstraints, TypeVarInstance,
+    TypeVarVariance, UnionType, declaration_type, todo_type,
 };
 use crate::{Db, FxOrderSet};
 
@@ -51,7 +51,7 @@ impl<'db> GenericContext<'db> {
         match type_param_node {
             ast::TypeParam::TypeVar(node) => {
                 let definition = index.expect_single_definition(node);
-                let Type::KnownInstance(SpecialForm::TypeVar(typevar)) =
+                let Type::KnownInstance(KnownInstanceType::TypeVar(typevar)) =
                     declaration_type(db, definition).inner_type()
                 else {
                     return None;