micro-optimisations

Author: AlexWaygood

crates/ty_python_semantic/src/types.rs

@@ -3539,11 +3539,11 @@ impl<'db> Type<'db> {
                 }
             },
 
-            Type::NominalInstance(instance) => match instance.class.known(db) {
-                Some(KnownClass::Tuple) => try_dunder_bool()?,
-                Some(known_class) => known_class.bool(),
-                None => try_dunder_bool()?,
-            },
+            Type::NominalInstance(NominalInstanceType { class, .. }) => class
+                .known(db)
+                .and_then(KnownClass::bool)
+                .map(Ok)
+                .unwrap_or_else(try_dunder_bool)?,
 
             Type::ProtocolInstance(_) => try_dunder_bool()?,
 

crates/ty_python_semantic/src/types/class.rs

@@ -3173,7 +3173,10 @@ impl KnownClass {
 
     /// Determine whether instances of this class are always truthy, always falsy,
     /// or have an ambiguous truthiness.
-    pub(crate) const fn bool(self) -> Truthiness {
+    ///
+    /// Returns `None` for `KnownClass::Tuple`, since the truthiness of a tuple
+    /// depends on its spec.
+    pub(crate) const fn bool(self) -> Option<Truthiness> {
         match self {
             // N.B. It's only generally safe to infer `Truthiness::AlwaysTrue` for a `KnownClass`
             // variant if the class's `__bool__` method always returns the same thing *and* the
@@ -3199,9 +3202,9 @@ impl KnownClass {
             | Self::GeneratorType
             | Self::AsyncGeneratorType
             | Self::MethodWrapperType
-            | Self::CoroutineType => Truthiness::AlwaysTrue,
+            | Self::CoroutineType => Some(Truthiness::AlwaysTrue),
 
-            Self::NoneType => Truthiness::AlwaysFalse,
+            Self::NoneType => Some(Truthiness::AlwaysFalse),
 
             Self::Any
             | Self::BaseException
@@ -3218,7 +3221,6 @@ impl KnownClass {
             | Self::StdlibAlias
             | Self::SupportsIndex
             | Self::Set
-            | Self::Tuple
             | Self::Int
             | Self::Type
             | Self::Bytes
@@ -3257,7 +3259,9 @@ impl KnownClass {
             | Self::KwOnly
             | Self::InitVar
             | Self::NamedTupleFallback
-            | Self::TypedDictFallback => Truthiness::Ambiguous,
+            | Self::TypedDictFallback => Some(Truthiness::Ambiguous),
+
+            Self::Tuple => None,
         }
     }
 
@@ -4023,16 +4027,18 @@ impl KnownClass {
         }
     }
 
-    /// Return true if all instances of this `KnownClass` compare equal.
-    pub(super) const fn is_single_valued(self) -> bool {
+    /// Returns `Some(true)` if all instances of this `KnownClass` compare equal.
+    /// Returns `None` for `KnownClass::Tuple`, since whether or not a tuple type
+    /// is single-valued depends on the tuple spec.
+    pub(super) const fn is_single_valued(self) -> Option<bool> {
         match self {
             Self::NoneType
             | Self::NoDefaultType
             | Self::VersionInfo
             | Self::EllipsisType
             | Self::TypeAliasType
             | Self::UnionType
-            | Self::NotImplementedType => true,
+            | Self::NotImplementedType => Some(true),
 
             Self::Any
             | Self::Bool
@@ -4045,7 +4051,6 @@ impl KnownClass {
             | Self::Complex
             | Self::Str
             | Self::List
-            | Self::Tuple
             | Self::Set
             | Self::FrozenSet
             | Self::Dict
@@ -4097,7 +4102,9 @@ impl KnownClass {
             | Self::Iterable
             | Self::Iterator
             | Self::NamedTupleFallback
-            | Self::TypedDictFallback => false,
+            | Self::TypedDictFallback => Some(false),
+
+            Self::Tuple => None,
         }
     }
 

crates/ty_python_semantic/src/types/generics.rs

@@ -263,7 +263,7 @@ impl<'db> GenericContext<'db> {
 
     pub(crate) fn default_specialization(self, db: &'db dyn Db) -> Specialization<'db> {
         let partial = self.specialize_partial(db, &vec![None; self.variables(db).len()]);
-        if matches!(self.known_class(db), Some(KnownClass::Tuple)) {
+        if self.known_class(db) == Some(KnownClass::Tuple) {
             Specialization::new(
                 db,
                 self,

crates/ty_python_semantic/src/types/instance.rs

@@ -161,13 +161,10 @@ impl<'db> NominalInstanceType<'db> {
     }
 
     pub(super) fn is_single_valued(self, db: &'db dyn Db) -> bool {
-        if let Some(tuple_spec) = self.class.tuple_spec(db) {
-            return tuple_spec.is_single_valued(db);
-        }
-
         self.class
             .known(db)
-            .map(KnownClass::is_single_valued)
+            .and_then(KnownClass::is_single_valued)
+            .or_else(|| Some(self.class.tuple_spec(db)?.is_single_valued(db)))
             .unwrap_or_else(|| is_single_member_enum(db, self.class.class_literal(db).0))
     }