[ty] Move Salsa caching "down a layer" in tuple.rs

Author: AlexWaygood

crates/ty_python_semantic/src/types.rs

@@ -2,7 +2,6 @@ use infer::nearest_enclosing_class;
 use itertools::{Either, Itertools};
 use ruff_db::parsed::parsed_module;
 
-use std::borrow::Cow;
 use std::slice::Iter;
 
 use bitflags::bitflags;
@@ -687,7 +686,7 @@ impl<'db> Type<'db> {
     ///
     /// I.e., for the type `tuple[int, str]`, this will return the tuple spec `[int, str]`.
     /// For a subclass of `tuple[int, str]`, it will return the same tuple spec.
-    fn tuple_instance_spec(&self, db: &'db dyn Db) -> Option<Cow<'db, TupleSpec<'db>>> {
+    fn tuple_instance_spec(&self, db: &'db dyn Db) -> Option<TupleSpec<'db>> {
         self.into_nominal_instance()
             .and_then(|instance| instance.tuple_spec(db))
     }
@@ -702,9 +701,9 @@ impl<'db> Type<'db> {
     ///
     /// I.e., for the type `tuple[int, str]`, this will return the tuple spec `[int, str]`.
     /// But for a subclass of `tuple[int, str]`, it will return `None`.
-    fn exact_tuple_instance_spec(&self, db: &'db dyn Db) -> Option<Cow<'db, TupleSpec<'db>>> {
+    fn exact_tuple_instance_spec(&self) -> Option<TupleSpec<'db>> {
         self.into_nominal_instance()
-            .and_then(|instance| instance.own_tuple_spec(db))
+            .and_then(|instance| instance.own_tuple_spec())
     }
 
     /// Returns the materialization of this type depending on the given `variance`.
@@ -4622,9 +4621,9 @@ impl<'db> Type<'db> {
     ///
     /// This method should only be used outside of type checking because it omits any errors.
     /// For type checking, use [`try_iterate`](Self::try_iterate) instead.
-    fn iterate(self, db: &'db dyn Db) -> Cow<'db, TupleSpec<'db>> {
+    fn iterate(self, db: &'db dyn Db) -> TupleSpec<'db> {
         self.try_iterate(db)
-            .unwrap_or_else(|err| Cow::Owned(TupleSpec::homogeneous(err.fallback_element_type(db))))
+            .unwrap_or_else(|err| TupleSpec::homogeneous(db, err.fallback_element_type(db)))
     }
 
     /// Given the type of an object that is iterated over in some way,
@@ -4635,15 +4634,15 @@ impl<'db> Type<'db> {
     /// ```python
     /// y(*x)
     /// ```
-    fn try_iterate(self, db: &'db dyn Db) -> Result<Cow<'db, TupleSpec<'db>>, IterationError<'db>> {
+    fn try_iterate(self, db: &'db dyn Db) -> Result<TupleSpec<'db>, IterationError<'db>> {
         self.try_iterate_with_mode(db, EvaluationMode::Sync)
     }
 
     fn try_iterate_with_mode(
         self,
         db: &'db dyn Db,
         mode: EvaluationMode,
-    ) -> Result<Cow<'db, TupleSpec<'db>>, IterationError<'db>> {
+    ) -> Result<TupleSpec<'db>, IterationError<'db>> {
         if mode.is_async() {
             let try_call_dunder_anext_on_iterator = |iterator: Type<'db>| {
                 iterator
@@ -4657,7 +4656,7 @@ impl<'db> Type<'db> {
                 Ok(dunder_aiter_bindings) => {
                     let iterator = dunder_aiter_bindings.return_type(db);
                     match try_call_dunder_anext_on_iterator(iterator) {
-                        Ok(result) => Ok(Cow::Owned(TupleSpec::homogeneous(result))),
+                        Ok(result) => Ok(TupleSpec::homogeneous(db, result)),
                         Err(dunder_anext_error) => {
                             Err(IterationError::IterReturnsInvalidIterator {
                                 iterator,
@@ -4702,27 +4701,28 @@ impl<'db> Type<'db> {
                 }
             }
             Type::GenericAlias(alias) if alias.origin(db).is_tuple(db) => {
-                return Ok(Cow::Owned(TupleSpec::homogeneous(todo_type!(
-                    "*tuple[] annotations"
-                ))));
+                return Ok(TupleSpec::homogeneous(
+                    db,
+                    todo_type!("*tuple[] annotations"),
+                ));
             }
             Type::StringLiteral(string_literal_ty) => {
                 // We could go further and deconstruct to an array of `StringLiteral`
                 // with each individual character, instead of just an array of
                 // `LiteralString`, but there would be a cost and it's not clear that
                 // it's worth it.
-                return Ok(Cow::Owned(TupleSpec::from_elements(std::iter::repeat_n(
-                    Type::LiteralString,
-                    string_literal_ty.python_len(db),
-                ))));
+                return Ok(TupleSpec::heterogeneous(
+                    db,
+                    std::iter::repeat_n(Type::LiteralString, string_literal_ty.python_len(db)),
+                ));
             }
             Type::Never => {
                 // The dunder logic below would have us return `tuple[Never, ...]`, which eagerly
                 // simplifies to `tuple[()]`. That will will cause us to emit false positives if we
                 // index into the tuple. Using `tuple[Unknown, ...]` avoids these false positives.
                 // TODO: Consider removing this special case, and instead hide the indexing
                 // diagnostic in unreachable code.
-                return Ok(Cow::Owned(TupleSpec::homogeneous(Type::unknown())));
+                return Ok(TupleSpec::homogeneous(db, Type::unknown()));
             }
             _ => {}
         }
@@ -4751,7 +4751,7 @@ impl<'db> Type<'db> {
                 // `__iter__` is definitely bound and calling it succeeds.
                 // See what calling `__next__` on the object returned by `__iter__` gives us...
                 try_call_dunder_next_on_iterator(iterator)
-                    .map(|ty| Cow::Owned(TupleSpec::homogeneous(ty)))
+                    .map(|ty| TupleSpec::homogeneous(db, ty))
                     .map_err(
                         |dunder_next_error| IterationError::IterReturnsInvalidIterator {
                             iterator,
@@ -4776,10 +4776,13 @@ impl<'db> Type<'db> {
                                 // and the type returned by the `__getitem__` method.
                                 //
                                 // No diagnostic is emitted; iteration will always succeed!
-                                Cow::Owned(TupleSpec::homogeneous(UnionType::from_elements(
+                                TupleSpec::homogeneous(
                                     db,
-                                    [dunder_next_return, dunder_getitem_return_type],
-                                )))
+                                    UnionType::from_elements(
+                                        db,
+                                        [dunder_next_return, dunder_getitem_return_type],
+                                    ),
+                                )
                             })
                             .map_err(|dunder_getitem_error| {
                                 IterationError::PossiblyUnboundIterAndGetitemError {
@@ -4806,7 +4809,7 @@ impl<'db> Type<'db> {
 
             // There's no `__iter__` method. Try `__getitem__` instead...
             Err(CallDunderError::MethodNotAvailable) => try_call_dunder_getitem()
-                .map(|ty| Cow::Owned(TupleSpec::homogeneous(ty)))
+                .map(|ty| TupleSpec::homogeneous(db, ty))
                 .map_err(
                     |dunder_getitem_error| IterationError::UnboundIterAndGetitemError {
                         dunder_getitem_error,

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

@@ -53,7 +53,7 @@ impl<'a, 'db> CallArguments<'a, 'db> {
                         let ty = infer_argument_type(arg, value);
                         let length = ty
                             .try_iterate(db)
-                            .map(|tuple| tuple.len())
+                            .map(|tuple| tuple.len(db))
                             .unwrap_or(TupleLength::unknown());
                         (Argument::Variadic(length), Some(ty))
                     }
@@ -225,7 +225,7 @@ fn expand_type<'db>(db: &'db dyn Db, ty: Type<'db>) -> Option<Vec<Type<'db>>> {
 
             // If the class is a fixed-length tuple subtype, we expand it to its elements.
             if let Some(spec) = instance.tuple_spec(db) {
-                return match &*spec {
+                return match spec.inner(db) {
                     Tuple::Fixed(fixed_length_tuple) => {
                         let expanded = fixed_length_tuple
                             .all_elements()
@@ -237,7 +237,7 @@ fn expand_type<'db>(db: &'db dyn Db, ty: Type<'db>) -> Option<Vec<Type<'db>>> {
                                 }
                             })
                             .multi_cartesian_product()
-                            .map(|types| Type::tuple(TupleType::from_elements(db, types)))
+                            .map(|types| Type::tuple(TupleType::heterogeneous(db, types)))
                             .collect::<Vec<_>>();
 
                         if expanded.len() == 1 {

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

@@ -3,7 +3,6 @@
 //! [signatures][crate::types::signatures], we have to handle the fact that the callable might be a
 //! union of types, each of which might contain multiple overloads.
 
-use std::borrow::Cow;
 use std::collections::HashSet;
 use std::fmt;
 
@@ -1034,10 +1033,8 @@ impl<'db> Bindings<'db> {
                                     );
                                     continue;
                                 };
-                                overload.set_return_type(Type::tuple(TupleType::new(
-                                    db,
-                                    tuple_spec.as_ref(),
-                                )));
+                                overload
+                                    .set_return_type(Type::tuple(TupleType::new(db, tuple_spec)));
                             }
                         }
 
@@ -2151,9 +2148,9 @@ impl<'a, 'db> ArgumentTypeChecker<'a, 'db> {
             // arbitrary number of `Unknown`s at the end, so that if the expanded value has a
             // smaller arity than the unexpanded value, we still have enough values to assign to
             // the already matched parameters.
-            let argument_types = match argument_types.as_ref() {
+            let argument_types = match argument_types.inner(self.db) {
                 Tuple::Fixed(_) => {
-                    Cow::Owned(argument_types.concat(self.db, &Tuple::homogeneous(Type::unknown())))
+                    argument_types.concat(self.db, &Tuple::homogeneous(Type::unknown()))
                 }
                 Tuple::Variable(_) => argument_types,
             };
@@ -2173,13 +2170,13 @@ impl<'a, 'db> ArgumentTypeChecker<'a, 'db> {
 
             // Check the types by zipping through the splatted argument types and their matched
             // parameters.
-            for (argument_type, parameter_index) in (argument_types.all_elements())
+            for (argument_type, parameter_index) in (argument_types.all_elements(self.db))
                 .zip(&self.argument_matches[argument_index].parameters)
             {
                 self.check_argument_type(
                     adjusted_argument_index,
                     argument,
-                    *argument_type,
+                    argument_type,
                     *parameter_index,
                 );
             }

crates/ty_python_semantic/src/types/class.rs

@@ -20,7 +20,7 @@ use crate::types::function::{DataclassTransformerParams, KnownFunction};
 use crate::types::generics::{GenericContext, Specialization, walk_specialization};
 use crate::types::infer::nearest_enclosing_class;
 use crate::types::signatures::{CallableSignature, Parameter, Parameters, Signature};
-use crate::types::tuple::TupleSpec;
+use crate::types::tuple::Tuple;
 use crate::types::{
     BareTypeAliasType, Binding, BoundSuperError, BoundSuperType, CallableType, DataclassParams,
     DeprecatedInstance, KnownInstanceType, StringLiteralType, TypeAliasType, TypeMapping,
@@ -661,7 +661,7 @@ impl<'db> ClassType<'db> {
             "__len__" if class_literal.is_tuple(db) => {
                 let return_type = specialization
                     .and_then(|spec| spec.tuple(db))
-                    .and_then(|tuple| tuple.len().into_fixed_length())
+                    .and_then(|tuple| tuple.len(db).into_fixed_length())
                     .and_then(|len| i64::try_from(len).ok())
                     .map(Type::IntLiteral)
                     .unwrap_or_else(|| KnownClass::Int.to_instance(db));
@@ -672,7 +672,7 @@ impl<'db> ClassType<'db> {
             "__bool__" if class_literal.is_tuple(db) => {
                 let return_type = specialization
                     .and_then(|spec| spec.tuple(db))
-                    .map(|tuple| tuple.truthiness().into_type(db))
+                    .map(|tuple| tuple.truthiness(db).into_type(db))
                     .unwrap_or_else(|| KnownClass::Bool.to_instance(db));
 
                 synthesize_simple_tuple_method(return_type)
@@ -685,13 +685,13 @@ impl<'db> ClassType<'db> {
                         let mut element_type_to_indices: FxIndexMap<Type<'db>, Vec<i64>> =
                             FxIndexMap::default();
 
-                        match tuple {
+                        match tuple.inner(db) {
                             // E.g. for `tuple[int, str]`, we will generate the following overloads:
                             //
                             //    __getitem__(self, index: Literal[0, -2], /) -> int
                             //    __getitem__(self, index: Literal[1, -1], /) -> str
                             //
-                            TupleSpec::Fixed(fixed_length_tuple) => {
+                            Tuple::Fixed(fixed_length_tuple) => {
                                 let tuple_length = fixed_length_tuple.len();
 
                                 for (index, ty) in fixed_length_tuple.elements().enumerate() {
@@ -714,7 +714,7 @@ impl<'db> ClassType<'db> {
                             //    __getitem__(self, index: Literal[-2], /) -> bytes
                             //    __getitem__(self, index: Literal[-3], /) -> float | str
                             //
-                            TupleSpec::Variable(variable_length_tuple) => {
+                            Tuple::Variable(variable_length_tuple) => {
                                 for (index, ty) in variable_length_tuple.prefix.iter().enumerate() {
                                     if let Ok(index) = i64::try_from(index) {
                                         element_type_to_indices.entry(*ty).or_default().push(index);
@@ -778,7 +778,7 @@ impl<'db> ClassType<'db> {
                         }
 
                         let all_elements_unioned =
-                            UnionType::from_elements(db, tuple.all_elements());
+                            UnionType::from_elements(db, tuple.all_elements(db));
 
                         let mut overload_signatures =
                             Vec::with_capacity(element_type_to_indices.len().saturating_add(2));
@@ -850,15 +850,15 @@ impl<'db> ClassType<'db> {
                     Some(tuple) => {
                         // TODO: Once we support PEP 646 annotations for `*args` parameters, we can
                         // use the tuple itself as the argument type.
-                        let tuple_len = tuple.len();
+                        let tuple_len = tuple.len(db);
 
                         if tuple_len.minimum() == 0 && tuple_len.maximum().is_none() {
                             // If the tuple has no length restrictions,
                             // any iterable is allowed as long as the iterable has the correct element type.
-                            let mut tuple_elements = tuple.all_elements();
+                            let mut tuple_elements = tuple.all_elements(db);
                             iterable_parameter = iterable_parameter.with_annotated_type(
                                 KnownClass::Iterable
-                                    .to_specialized_instance(db, [*tuple_elements.next().unwrap()]),
+                                    .to_specialized_instance(db, [tuple_elements.next().unwrap()]),
                             );
                             assert_eq!(
                                 tuple_elements.next(),
@@ -884,7 +884,7 @@ impl<'db> ClassType<'db> {
                 // - a zero-length tuple
                 // - an unspecialized tuple
                 // - a tuple with no minimum length
-                if tuple.is_none_or(|tuple| tuple.len().minimum() == 0) {
+                if tuple.is_none_or(|tuple| tuple.len(db).minimum() == 0) {
                     iterable_parameter =
                         iterable_parameter.with_default_type(Type::empty_tuple(db));
                 }
@@ -4707,7 +4707,7 @@ impl SlotsKind {
             // __slots__ = ("a", "b")
             Type::NominalInstance(nominal) => match nominal
                 .tuple_spec(db)
-                .and_then(|spec| spec.len().into_fixed_length())
+                .and_then(|spec| spec.len(db).into_fixed_length())
             {
                 Some(0) => Self::Empty,
                 Some(_) => Self::NotEmpty,

crates/ty_python_semantic/src/types/display.rs

@@ -12,7 +12,7 @@ use crate::types::class::{ClassLiteral, ClassType, GenericAlias};
 use crate::types::function::{FunctionType, OverloadLiteral};
 use crate::types::generics::{GenericContext, Specialization};
 use crate::types::signatures::{CallableSignature, Parameter, Parameters, Signature};
-use crate::types::tuple::TupleSpec;
+use crate::types::tuple::{Tuple, TupleSpec};
 use crate::types::{
     BoundTypeVarInstance, CallableType, IntersectionType, KnownClass, MethodWrapperKind, Protocol,
     StringLiteralType, SubclassOfInner, Type, TypeVarBoundOrConstraints, TypeVarInstance,
@@ -263,8 +263,8 @@ pub(crate) struct DisplayTuple<'db> {
 impl Display for DisplayTuple<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.write_str("tuple[")?;
-        match self.tuple {
-            TupleSpec::Fixed(tuple) => {
+        match self.tuple.inner(self.db) {
+            Tuple::Fixed(tuple) => {
                 let elements = tuple.elements_slice();
                 if elements.is_empty() {
                     f.write_str("()")?;
@@ -287,7 +287,7 @@ impl Display for DisplayTuple<'_> {
             // above only an S is included only if there's a suffix; anything about both a P and an
             // S is included if there is either a prefix or a suffix. The initial `tuple[` and
             // trailing `]` are printed elsewhere. The `yyy, ...` is printed no matter what.)
-            TupleSpec::Variable(tuple) => {
+            Tuple::Variable(tuple) => {
                 if !tuple.prefix.is_empty() {
                     tuple.prefix.display(self.db).fmt(f)?;
                     f.write_str(", ")?;