is this faster

Author: AlexWaygood

crates/red_knot_python_semantic/src/types.rs

@@ -811,29 +811,6 @@ impl<'db> Type<'db> {
         }
     }
 
-    /// Normalize the type `bool` -> `Literal[True, False]`.
-    ///
-    /// Using this method in various type-relational methods
-    /// ensures that the following invariants hold true:
-    ///
-    /// - bool ≡ Literal[True, False]
-    /// - bool | T ≡ Literal[True, False] | T
-    /// - bool <: Literal[True, False]
-    /// - bool | T <: Literal[True, False] | T
-    /// - Literal[True, False] <: bool
-    /// - Literal[True, False] | T <: bool | T
-    #[must_use]
-    pub fn with_normalized_bools(self, db: &'db dyn Db) -> Self {
-        match self {
-            Type::Instance(InstanceType { class }) if class.is_known(db, KnownClass::Bool) => {
-                Type::normalized_bool(db)
-            }
-            // TODO: decompose `LiteralString` into `Literal[""] | TruthyLiteralString`?
-            // We'd need to rename this method... --Alex
-            _ => self,
-        }
-    }
-
     /// Return a normalized version of `self` in which all unions and intersections are sorted
     /// according to a canonical order, no matter how "deeply" a union/intersection may be nested.
     #[must_use]
@@ -905,10 +882,11 @@ impl<'db> Type<'db> {
             (_, Type::Never) => false,
 
             (Type::Instance(InstanceType { class }), _) if class.is_known(db, KnownClass::Bool) => {
-                Type::normalized_bool(db).is_subtype_of(db, target)
+                Type::BooleanLiteral(true).is_subtype_of(db, target)
+                    && Type::BooleanLiteral(false).is_subtype_of(db, target)
             }
             (_, Type::Instance(InstanceType { class })) if class.is_known(db, KnownClass::Bool) => {
-                self.is_subtype_of(db, Type::normalized_bool(db))
+                self.is_boolean_literal()
             }
 
             (Type::Union(union), _) => union
@@ -1125,10 +1103,12 @@ impl<'db> Type<'db> {
             }
 
             (Type::Instance(InstanceType { class }), _) if class.is_known(db, KnownClass::Bool) => {
-                Type::normalized_bool(db).is_assignable_to(db, target)
+                Type::BooleanLiteral(true).is_assignable_to(db, target)
+                    && Type::BooleanLiteral(false).is_assignable_to(db, target)
             }
             (_, Type::Instance(InstanceType { class })) if class.is_known(db, KnownClass::Bool) => {
-                self.is_assignable_to(db, Type::normalized_bool(db))
+                self.is_assignable_to(db, Type::BooleanLiteral(true))
+                    || self.is_assignable_to(db, Type::BooleanLiteral(false))
             }
 
             // A union is assignable to a type T iff every element of the union is assignable to T.
@@ -2409,13 +2389,6 @@ impl<'db> Type<'db> {
         KnownClass::NoneType.to_instance(db)
     }
 
-    /// The type `Literal[True, False]`, which is exactly equivalent to `bool`
-    /// (and which `bool` is eagerly normalized to in several situations)
-    pub fn normalized_bool(db: &'db dyn Db) -> Type<'db> {
-        const LITERAL_BOOLS: [Type; 2] = [Type::BooleanLiteral(false), Type::BooleanLiteral(true)];
-        Type::Union(UnionType::new(db, Box::from(LITERAL_BOOLS)))
-    }
-
     /// Return the type of `tuple(sys.version_info)`.
     ///
     /// This is not exactly the type that `sys.version_info` has at runtime,

crates/red_knot_python_semantic/src/types/builder.rs

@@ -26,7 +26,7 @@
 //!     eliminate the supertype from the intersection).
 //!   * An intersection containing two non-overlapping types should simplify to [`Type::Never`].
 
-use crate::types::{IntersectionType, KnownClass, Type, UnionType};
+use crate::types::{InstanceType, IntersectionType, KnownClass, Type, UnionType};
 use crate::{Db, FxOrderSet};
 use smallvec::SmallVec;
 
@@ -45,7 +45,6 @@ impl<'db> UnionBuilder<'db> {
 
     /// Adds a type to this union.
     pub(crate) fn add(mut self, ty: Type<'db>) -> Self {
-        let ty = ty.with_normalized_bools(self.db);
         match ty {
             Type::Union(union) => {
                 let new_elements = union.elements(self.db);
@@ -55,6 +54,11 @@ impl<'db> UnionBuilder<'db> {
                 }
             }
             Type::Never => {}
+            Type::Instance(InstanceType { class }) if class.is_known(self.db, KnownClass::Bool) => {
+                self = self
+                    .add(Type::BooleanLiteral(true))
+                    .add(Type::BooleanLiteral(false));
+            }
             _ => {
                 let mut to_remove = SmallVec::<[usize; 2]>::new();
                 let ty_negated = ty.negate(self.db);
@@ -162,9 +166,20 @@ impl<'db> IntersectionBuilder<'db> {
         }
     }
 
+    fn elements_of_union(&self, ty: Type<'db>) -> Option<&'db [Type<'db>]> {
+        const BOOL_LITERALS: &[Type] = &[Type::BooleanLiteral(true), Type::BooleanLiteral(false)];
+
+        match ty {
+            Type::Union(union) => Some(union.elements(self.db)),
+            Type::Instance(InstanceType { class }) if class.is_known(self.db, KnownClass::Bool) => {
+                Some(BOOL_LITERALS)
+            }
+            _ => None,
+        }
+    }
+
     pub(crate) fn add_positive(mut self, ty: Type<'db>) -> Self {
-        let ty = ty.with_normalized_bools(self.db);
-        if let Type::Union(union) = ty {
+        if let Some(elements) = self.elements_of_union(ty) {
             // Distribute ourself over this union: for each union element, clone ourself and
             // intersect with that union element, then create a new union-of-intersections with all
             // of those sub-intersections in it. E.g. if `self` is a simple intersection `T1 & T2`
@@ -173,8 +188,7 @@ impl<'db> IntersectionBuilder<'db> {
             // (T2 & T4)`. If `self` is already a union-of-intersections `(T1 & T2) | (T3 & T4)`
             // and we add `T5 | T6` to it, that flattens all the way out to `(T1 & T2 & T5) | (T1 &
             // T2 & T6) | (T3 & T4 & T5) ...` -- you get the idea.
-            union
-                .elements(self.db)
+            elements
                 .iter()
                 .map(|elem| self.clone().add_positive(*elem))
                 .fold(IntersectionBuilder::empty(self.db), |mut builder, sub| {
@@ -194,10 +208,8 @@ impl<'db> IntersectionBuilder<'db> {
     pub(crate) fn add_negative(mut self, ty: Type<'db>) -> Self {
         // See comments above in `add_positive`; this is just the negated version.
 
-        let ty = ty.with_normalized_bools(self.db);
-
-        if let Type::Union(union) = ty {
-            for elem in union.elements(self.db) {
+        if let Some(elements) = self.elements_of_union(ty) {
+            for elem in elements {
                 self = self.add_negative(*elem);
             }
             self