Update type_ordering.rs

* exclude ordering of nested unions (which cannot exist in DNF) as unreachable codes
* try to avoid performance degradation in ordering of intersections

Author: mtshiba

crates/red_knot_python_semantic/src/types/type_ordering.rs

@@ -269,37 +269,31 @@ pub(super) fn union_elements_ordering<'db>(
         (Type::Dynamic(_), _) => Ordering::Less,
         (_, Type::Dynamic(_)) => Ordering::Greater,
 
-        (Type::Union(left), Type::Union(right)) => {
-            if left.elements(db).len() != right.elements(db).len() {
-                return left.elements(db).len().cmp(&right.elements(db).len());
-            }
-            // Lexicographically compare the elements of the two unions.
-            for (left, right) in left.elements(db).iter().zip(right.elements(db)) {
-                let ordering = union_elements_ordering(left, right, db);
-                if ordering != Ordering::Equal {
-                    return ordering;
-                }
-            }
-            Ordering::Equal
+        (Type::Union(_), Type::Union(_)) => {
+            unreachable!("our type representation does not permit nested unions");
         }
         (Type::Union(_), _) => Ordering::Less,
         (_, Type::Union(_)) => Ordering::Greater,
 
         (Type::Intersection(left), Type::Intersection(right)) => {
             // Lexicographically compare the elements of the two intersections.
-            if left.positive(db).len() != right.positive(db).len() {
-                return left.positive(db).len().cmp(&right.positive(db).len());
+            let left_positive = left.positive(db);
+            let right_positive = right.positive(db);
+            if left_positive.len() != right_positive.len() {
+                return left_positive.len().cmp(&right_positive.len());
             }
-            if left.negative(db).len() != right.negative(db).len() {
-                return left.negative(db).len().cmp(&right.negative(db).len());
+            let left_negative = left.negative(db);
+            let right_negative = right.negative(db);
+            if left_negative.len() != right_negative.len() {
+                return left_negative.len().cmp(&right_negative.len());
             }
-            for (left, right) in left.positive(db).iter().zip(right.positive(db)) {
+            for (left, right) in left_positive.iter().zip(right_positive) {
                 let ordering = union_elements_ordering(left, right, db);
                 if ordering != Ordering::Equal {
                     return ordering;
                 }
             }
-            for (left, right) in left.negative(db).iter().zip(right.negative(db)) {
+            for (left, right) in left_negative.iter().zip(right_negative) {
                 let ordering = union_elements_ordering(left, right, db);
                 if ordering != Ordering::Equal {
                     return ordering;