[ty] Support typing.TypeAliasType

Author: sharkdp

crates/ty_project/tests/check.rs

@@ -294,4 +294,8 @@ impl SourceOrderVisitor<'_> for PullTypesVisitor<'_> {
 
 /// Whether or not the .py/.pyi version of this file is expected to fail
 #[rustfmt::skip]
-const KNOWN_FAILURES: &[(&str, bool, bool)] = &[];
+const KNOWN_FAILURES: &[(&str, bool, bool)] = &[
+    // Fails with too-many-cycle-iterations due to a self-referential
+    // type alias, see https://github.com/astral-sh/ty/issues/256
+    ("crates/ruff_linter/resources/test/fixtures/pyflakes/F401_34.py", true, true),
+];

crates/ty_python_semantic/resources/mdtest/pep695_type_aliases.md

@@ -87,3 +87,40 @@ type TypeAliasType2 = TypeOf[Alias2]
 static_assert(not is_equivalent_to(TypeAliasType1, TypeAliasType2))
 static_assert(is_disjoint_from(TypeAliasType1, TypeAliasType2))
 ```
+
+## Direct use of `TypeAliasType`
+
+`TypeAliasType` can also be used directly. This is useful for versions of Python prior to 3.12.
+
+```toml
+[environment]
+python-version = "3.9"
+```
+
+### Basic example
+
+```py
+from typing_extensions import TypeAliasType, Union
+
+IntOrStr = TypeAliasType("IntOrStr", Union[int, str])
+
+reveal_type(IntOrStr)  # revealed: typing.TypeAliasType
+
+reveal_type(IntOrStr.__name__)  # revealed: Literal["IntOrStr"]
+
+def f(x: IntOrStr) -> None:
+    reveal_type(x)  # revealed: int | str
+```
+
+### Generic example
+
+```py
+from typing_extensions import TypeAliasType, TypeVar
+
+T = TypeVar("T")
+
+IntAnd = TypeAliasType("IntAndT", tuple[int, T], type_params=(T,))
+
+def f(x: IntAnd[str]) -> None:
+    reveal_type(x)  # revealed: @Todo(Generic PEP-695 type alias)
+```

crates/ty_python_semantic/src/types.rs

@@ -4012,6 +4012,45 @@ impl<'db> Type<'db> {
                     Signatures::single(signature)
                 }
 
+                Some(KnownClass::TypeAliasType) => {
+                    // ```py
+                    // def __new__(
+                    //     cls,
+                    //     name: str,
+                    //     value: Any,
+                    //     *,
+                    //     type_params: tuple[TypeVar | ParamSpec | TypeVarTuple, ...] = ()
+                    // ) -> Self: ...
+                    // ```
+                    let signature = CallableSignature::single(
+                        self,
+                        Signature::new(
+                            Parameters::new([
+                                Parameter::positional_or_keyword(Name::new_static("name"))
+                                    .with_annotated_type(KnownClass::Str.to_instance(db)),
+                                Parameter::positional_or_keyword(Name::new_static("value"))
+                                    .with_annotated_type(Type::any())
+                                    .type_form(),
+                                Parameter::keyword_only(Name::new_static("type_params"))
+                                    .with_annotated_type(KnownClass::Tuple.to_specialized_instance(
+                                        db,
+                                        [UnionType::from_elements(
+                                            db,
+                                            [
+                                                KnownClass::TypeVar.to_instance(db),
+                                                KnownClass::ParamSpec.to_instance(db),
+                                                KnownClass::TypeVarTuple.to_instance(db),
+                                            ],
+                                        )],
+                                    ))
+                                    .with_default_type(TupleType::empty(db)),
+                            ]),
+                            None,
+                        ),
+                    );
+                    Signatures::single(signature)
+                }
+
                 Some(KnownClass::Property) => {
                     let getter_signature = Signature::new(
                         Parameters::new([
@@ -5318,7 +5357,7 @@ impl<'db> Type<'db> {
                     Some(TypeDefinition::TypeVar(var.definition(db)))
                 }
                 KnownInstanceType::TypeAliasType(type_alias) => {
-                    Some(TypeDefinition::TypeAlias(type_alias.definition(db)))
+                    type_alias.definition(db).map(TypeDefinition::TypeAlias)
                 }
                 _ => None,
             },
@@ -7467,15 +7506,15 @@ impl<'db> ModuleLiteralType<'db> {
 }
 
 #[salsa::interned(debug)]
-pub struct TypeAliasType<'db> {
+pub struct PEP695TypeAliasType<'db> {
     #[returns(ref)]
     pub name: ast::name::Name,
 
     rhs_scope: ScopeId<'db>,
 }
 
 #[salsa::tracked]
-impl<'db> TypeAliasType<'db> {
+impl<'db> PEP695TypeAliasType<'db> {
     pub(crate) fn definition(self, db: &'db dyn Db) -> Definition<'db> {
         let scope = self.rhs_scope(db);
         let type_alias_stmt_node = scope.node(db).expect_type_alias();
@@ -7492,6 +7531,42 @@ impl<'db> TypeAliasType<'db> {
     }
 }
 
+#[salsa::interned(debug)]
+pub struct BareTypeAliasType<'db> {
+    #[returns(ref)]
+    pub name: String,
+    pub value: Type<'db>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, salsa::Update)]
+pub enum TypeAliasType<'db> {
+    PEP695(PEP695TypeAliasType<'db>),
+    Bare(BareTypeAliasType<'db>),
+}
+
+impl<'db> TypeAliasType<'db> {
+    pub(crate) fn name(self, db: &'db dyn Db) -> &'db str {
+        match self {
+            TypeAliasType::PEP695(type_alias) => type_alias.name(db),
+            TypeAliasType::Bare(type_alias) => type_alias.name(db).as_str(),
+        }
+    }
+
+    pub(crate) fn definition(self, db: &'db dyn Db) -> Option<Definition<'db>> {
+        match self {
+            TypeAliasType::PEP695(type_alias) => Some(type_alias.definition(db)),
+            TypeAliasType::Bare(_) => None,
+        }
+    }
+
+    pub(crate) fn value_type(self, db: &'db dyn Db) -> Type<'db> {
+        match self {
+            TypeAliasType::PEP695(type_alias) => type_alias.value_type(db),
+            TypeAliasType::Bare(type_alias) => type_alias.value(db),
+        }
+    }
+}
+
 /// Either the explicit `metaclass=` keyword of the class, or the inferred metaclass of one of its base classes.
 #[derive(Debug, Clone, PartialEq, Eq, salsa::Update)]
 pub(super) struct MetaclassCandidate<'db> {
@@ -8004,6 +8079,10 @@ impl<'db> TupleType<'db> {
             .to_specialized_instance(db, [UnionType::from_elements(db, self.elements(db))])
     }
 
+    pub(crate) fn empty(db: &'db dyn Db) -> Type<'db> {
+        Type::Tuple(TupleType::new(db, Box::<[Type<'db>]>::from([])))
+    }
+
     pub(crate) fn from_elements<T: Into<Type<'db>>>(
         db: &'db dyn Db,
         types: impl IntoIterator<Item = T>,

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

@@ -20,9 +20,10 @@ use crate::types::diagnostic::{
 use crate::types::generics::{Specialization, SpecializationBuilder, SpecializationError};
 use crate::types::signatures::{Parameter, ParameterForm};
 use crate::types::{
-    BoundMethodType, DataclassParams, DataclassTransformerParams, FunctionDecorators, FunctionType,
-    KnownClass, KnownFunction, KnownInstanceType, MethodWrapperKind, PropertyInstanceType,
-    TupleType, UnionType, WrapperDescriptorKind, todo_type,
+    BareTypeAliasType, BoundMethodType, DataclassParams, DataclassTransformerParams,
+    FunctionDecorators, FunctionType, KnownClass, KnownFunction, KnownInstanceType,
+    MethodWrapperKind, PropertyInstanceType, TupleType, TypeAliasType, UnionType,
+    WrapperDescriptorKind, todo_type,
 };
 use ruff_db::diagnostic::{Annotation, Diagnostic, Severity, SubDiagnostic};
 use ruff_python_ast as ast;
@@ -908,6 +909,19 @@ impl<'db> Bindings<'db> {
                             }
                         }
 
+                        Some(KnownClass::TypeAliasType) => {
+                            if let [Some(name), Some(value), ..] = overload.parameter_types() {
+                                // TODO: emit a diagnostic if the name is not a string literal
+                                if let Some(name) = name.into_string_literal() {
+                                    overload.set_return_type(Type::KnownInstance(
+                                        KnownInstanceType::TypeAliasType(TypeAliasType::Bare(
+                                            BareTypeAliasType::new(db, name.value(db), value),
+                                        )),
+                                    ));
+                                }
+                            }
+                        }
+
                         _ => {}
                     },
 

crates/ty_python_semantic/src/types/infer.rs

@@ -86,11 +86,11 @@ use crate::types::{
     CallDunderError, CallableSignature, CallableType, ClassLiteral, ClassType, DataclassParams,
     DynamicType, FunctionDecorators, FunctionType, GenericAlias, IntersectionBuilder,
     IntersectionType, KnownClass, KnownFunction, KnownInstanceType, MemberLookupPolicy,
-    MetaclassCandidate, Parameter, ParameterForm, Parameters, Signature, Signatures,
-    StringLiteralType, SubclassOfType, Symbol, SymbolAndQualifiers, Truthiness, TupleType, Type,
-    TypeAliasType, TypeAndQualifiers, TypeArrayDisplay, TypeQualifiers, TypeVarBoundOrConstraints,
-    TypeVarInstance, TypeVarKind, TypeVarVariance, UnionBuilder, UnionType, binding_type,
-    todo_type,
+    MetaclassCandidate, PEP695TypeAliasType, Parameter, ParameterForm, Parameters, Signature,
+    Signatures, StringLiteralType, SubclassOfType, Symbol, SymbolAndQualifiers, Truthiness,
+    TupleType, Type, TypeAliasType, TypeAndQualifiers, TypeArrayDisplay, TypeQualifiers,
+    TypeVarBoundOrConstraints, TypeVarInstance, TypeVarKind, TypeVarVariance, UnionBuilder,
+    UnionType, binding_type, todo_type,
 };
 use crate::unpack::{Unpack, UnpackPosition};
 use crate::util::subscript::{PyIndex, PySlice};
@@ -2374,12 +2374,13 @@ impl<'db> TypeInferenceBuilder<'db> {
             .node_scope(NodeWithScopeRef::TypeAlias(type_alias))
             .to_scope_id(self.db(), self.file());
 
-        let type_alias_ty =
-            Type::KnownInstance(KnownInstanceType::TypeAliasType(TypeAliasType::new(
+        let type_alias_ty = Type::KnownInstance(KnownInstanceType::TypeAliasType(
+            TypeAliasType::PEP695(PEP695TypeAliasType::new(
                 self.db(),
                 &type_alias.name.as_name_expr().unwrap().id,
                 rhs_scope,
-            )));
+            )),
+        ));
 
         self.add_declaration_with_binding(
             type_alias.into(),
@@ -4860,6 +4861,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                         | KnownClass::Super
                         | KnownClass::TypeVar
                         | KnownClass::NamedTuple
+                        | KnownClass::TypeAliasType
                 )
             )
             // temporary special-casing for all subclasses of `enum.Enum`