From 8b827c3c6c04307e728ca25fb75f53adfbda13dc Mon Sep 17 00:00:00 2001 From: Carl Meyer Date: Fri, 22 Aug 2025 07:40:29 -0700 Subject: [PATCH] [ty] rename BareTypeAliasType to ManualPEP695TypeAliasType (#20037) ## Summary Rename `TypeAliasType::Bare` to `TypeAliasType::ManualPEP695`, and `BareTypeAliasType` to `ManualPEP695TypeAliasType`. Why? Both existing variants of `TypeAliasType` are specific to features added in PEP 695 (which introduced both the `type` statement and `types.TypeAliasType`), so it doesn't make sense to name one with the name `PEP695` and not the other. A "bare" type alias, in my mind, is a legacy type alias like `IntOrStr = int | str`, which is "bare" in that there is nothing at all distinguishing it as a type alias. I will want to use the "bare" name for this variant, in a future PR. The renamed variant here describes a type alias created with `IntOrStr = types.TypeAliasType("IntOrStr", int | str)`, which is not "bare", it's just "manually" instantiated instead of using the `type` statement syntax sugar. (This is useful when using the `typing_extensions` backport of `TypeAliasType` on older Python versions.) ## Test Plan Pure rename, existing tests pass. --- crates/ty_python_semantic/src/types.rs | 28 +++++++++++--------- crates/ty_python_semantic/src/types/class.rs | 13 ++++----- 2 files changed, 22 insertions(+), 19 deletions(-) diff --git a/crates/ty_python_semantic/src/types.rs b/crates/ty_python_semantic/src/types.rs index f20412c073..a583560192 100644 --- a/crates/ty_python_semantic/src/types.rs +++ b/crates/ty_python_semantic/src/types.rs @@ -9231,12 +9231,14 @@ fn value_type_cycle_initial<'db>(_db: &'db dyn Db, _self: PEP695TypeAliasType<'d Type::Never } +/// A PEP 695 `types.TypeAliasType` created by manually calling the constructor. +/// /// # Ordering /// Ordering is based on the type alias's salsa-assigned id and not on its values. /// The id may change between runs, or when the alias was garbage collected and recreated. #[salsa::interned(debug, heap_size=ruff_memory_usage::heap_size)] #[derive(PartialOrd, Ord)] -pub struct BareTypeAliasType<'db> { +pub struct ManualPEP695TypeAliasType<'db> { #[returns(ref)] pub name: ast::name::Name, pub definition: Option>, @@ -9244,17 +9246,17 @@ pub struct BareTypeAliasType<'db> { } // The Salsa heap is tracked separately. -impl get_size2::GetSize for BareTypeAliasType<'_> {} +impl get_size2::GetSize for ManualPEP695TypeAliasType<'_> {} -fn walk_bare_type_alias<'db, V: visitor::TypeVisitor<'db> + ?Sized>( +fn walk_manual_pep_695_type_alias<'db, V: visitor::TypeVisitor<'db> + ?Sized>( db: &'db dyn Db, - type_alias: BareTypeAliasType<'db>, + type_alias: ManualPEP695TypeAliasType<'db>, visitor: &V, ) { visitor.visit_type(db, type_alias.value(db)); } -impl<'db> BareTypeAliasType<'db> { +impl<'db> ManualPEP695TypeAliasType<'db> { fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self { Self::new( db, @@ -9272,7 +9274,7 @@ pub enum TypeAliasType<'db> { /// A type alias defined using the PEP 695 `type` statement. PEP695(PEP695TypeAliasType<'db>), /// A type alias defined by manually instantiating the PEP 695 `types.TypeAliasType`. - Bare(BareTypeAliasType<'db>), + ManualPEP695(ManualPEP695TypeAliasType<'db>), } fn walk_type_alias_type<'db, V: visitor::TypeVisitor<'db> + ?Sized>( @@ -9284,8 +9286,8 @@ fn walk_type_alias_type<'db, V: visitor::TypeVisitor<'db> + ?Sized>( TypeAliasType::PEP695(type_alias) => { walk_pep_695_type_alias(db, type_alias, visitor); } - TypeAliasType::Bare(type_alias) => { - walk_bare_type_alias(db, type_alias, visitor); + TypeAliasType::ManualPEP695(type_alias) => { + walk_manual_pep_695_type_alias(db, type_alias, visitor); } } } @@ -9296,8 +9298,8 @@ impl<'db> TypeAliasType<'db> { TypeAliasType::PEP695(type_alias) => { TypeAliasType::PEP695(type_alias.normalized_impl(db, visitor)) } - TypeAliasType::Bare(type_alias) => { - TypeAliasType::Bare(type_alias.normalized_impl(db, visitor)) + TypeAliasType::ManualPEP695(type_alias) => { + TypeAliasType::ManualPEP695(type_alias.normalized_impl(db, visitor)) } } } @@ -9305,21 +9307,21 @@ 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), + TypeAliasType::ManualPEP695(type_alias) => type_alias.name(db), } } pub(crate) fn definition(self, db: &'db dyn Db) -> Option> { match self { TypeAliasType::PEP695(type_alias) => Some(type_alias.definition(db)), - TypeAliasType::Bare(type_alias) => type_alias.definition(db), + TypeAliasType::ManualPEP695(type_alias) => type_alias.definition(db), } } 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), + TypeAliasType::ManualPEP695(type_alias) => type_alias.value(db), } } } diff --git a/crates/ty_python_semantic/src/types/class.rs b/crates/ty_python_semantic/src/types/class.rs index 12a38594cb..1c736dfc4b 100644 --- a/crates/ty_python_semantic/src/types/class.rs +++ b/crates/ty_python_semantic/src/types/class.rs @@ -28,11 +28,12 @@ use crate::types::infer::nearest_enclosing_class; use crate::types::signatures::{CallableSignature, Parameter, Parameters, Signature}; use crate::types::tuple::{TupleSpec, TupleType}; use crate::types::{ - ApplyTypeMappingVisitor, BareTypeAliasType, Binding, BoundSuperError, BoundSuperType, - CallableType, DataclassParams, DeprecatedInstance, HasRelationToVisitor, IsEquivalentVisitor, - KnownInstanceType, NormalizedVisitor, PropertyInstanceType, StringLiteralType, TypeAliasType, - TypeMapping, TypeRelation, TypeVarBoundOrConstraints, TypeVarInstance, TypeVarKind, - VarianceInferable, declaration_type, infer_definition_types, todo_type, + ApplyTypeMappingVisitor, Binding, BoundSuperError, BoundSuperType, CallableType, + DataclassParams, DeprecatedInstance, HasRelationToVisitor, IsEquivalentVisitor, + KnownInstanceType, ManualPEP695TypeAliasType, NormalizedVisitor, PropertyInstanceType, + StringLiteralType, TypeAliasType, TypeMapping, TypeRelation, TypeVarBoundOrConstraints, + TypeVarInstance, TypeVarKind, VarianceInferable, declaration_type, infer_definition_types, + todo_type, }; use crate::{ Db, FxIndexMap, FxOrderSet, Program, @@ -4935,7 +4936,7 @@ impl KnownClass { return; }; overload.set_return_type(Type::KnownInstance(KnownInstanceType::TypeAliasType( - TypeAliasType::Bare(BareTypeAliasType::new( + TypeAliasType::ManualPEP695(ManualPEP695TypeAliasType::new( db, ast::name::Name::new(name.value(db)), containing_assignment,