diff --git a/crates/ty_python_semantic/src/types.rs b/crates/ty_python_semantic/src/types.rs
index af8eca4263..4f3c97e3f0 100644
--- a/crates/ty_python_semantic/src/types.rs
+++ b/crates/ty_python_semantic/src/types.rs
@@ -259,12 +259,6 @@ pub(crate) type NormalizedVisitor<'db> = TypeTransformer<'db, Normalized>;
 #[derive(Debug)]
 pub(crate) struct Normalized;
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub(crate) enum OnlyReorder {
-    No,
-    Yes,
-}
-
 /// How a generic type has been specialized.
 ///
 /// This matters only if there is at least one invariant type parameter.
@@ -569,18 +563,11 @@ impl<'db> PropertyInstanceType<'db> {
         Self::new(db, getter, setter)
     }
 
-    fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         Self::new(
             db,
-            self.getter(db)
-                .map(|ty| ty.normalized_impl(db, only_reorder, visitor)),
-            self.setter(db)
-                .map(|ty| ty.normalized_impl(db, only_reorder, visitor)),
+            self.getter(db).map(|ty| ty.normalized_impl(db, visitor)),
+            self.setter(db).map(|ty| ty.normalized_impl(db, visitor)),
         )
     }
 
@@ -1579,75 +1566,56 @@ impl<'db> Type<'db> {
     /// - Converts class-based typeddicts into synthesized typeddicts
     #[must_use]
     pub(crate) fn normalized(self, db: &'db dyn Db) -> Self {
-        self.normalized_impl(db, OnlyReorder::No, &NormalizedVisitor::default())
-    }
-
-    /// Ensures that all union and intersection elements in this type are in a canonical ordering,
-    /// but performs no other normalizations.
-    #[must_use]
-    pub(crate) fn canonically_ordered(self, db: &'db dyn Db) -> Self {
-        self.normalized_impl(db, OnlyReorder::Yes, &NormalizedVisitor::default())
+        self.normalized_impl(db, &NormalizedVisitor::default())
     }
 
     #[must_use]
-    pub(crate) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         match self {
-            Type::Union(union) => {
-                visitor.visit(self, || union.normalized_impl(db, only_reorder, visitor))
-            }
+            Type::Union(union) => visitor.visit(self, || union.normalized_impl(db, visitor)),
             Type::Intersection(intersection) => visitor.visit(self, || {
-                Type::Intersection(intersection.normalized_impl(db, only_reorder, visitor))
+                Type::Intersection(intersection.normalized_impl(db, visitor))
             }),
             Type::Callable(callable) => visitor.visit(self, || {
-                Type::Callable(callable.normalized_impl(db, only_reorder, visitor))
+                Type::Callable(callable.normalized_impl(db, visitor))
             }),
             Type::ProtocolInstance(protocol) => {
-                visitor.visit(self, || protocol.normalized_impl(db, only_reorder, visitor))
+                visitor.visit(self, || protocol.normalized_impl(db, visitor))
             }
             Type::NominalInstance(instance) => {
-                visitor.visit(self, || instance.normalized_impl(db, only_reorder, visitor))
+                visitor.visit(self, || instance.normalized_impl(db, visitor))
             }
             Type::FunctionLiteral(function) => visitor.visit(self, || {
-                Type::FunctionLiteral(function.normalized_impl(db, only_reorder, visitor))
+                Type::FunctionLiteral(function.normalized_impl(db, visitor))
             }),
             Type::PropertyInstance(property) => visitor.visit(self, || {
-                Type::PropertyInstance(property.normalized_impl(db, only_reorder, visitor))
+                Type::PropertyInstance(property.normalized_impl(db, visitor))
             }),
             Type::KnownBoundMethod(method_kind) => visitor.visit(self, || {
-                Type::KnownBoundMethod(method_kind.normalized_impl(db, only_reorder, visitor))
+                Type::KnownBoundMethod(method_kind.normalized_impl(db, visitor))
             }),
             Type::BoundMethod(method) => visitor.visit(self, || {
-                Type::BoundMethod(method.normalized_impl(db, only_reorder, visitor))
+                Type::BoundMethod(method.normalized_impl(db, visitor))
             }),
             Type::BoundSuper(bound_super) => visitor.visit(self, || {
-                Type::BoundSuper(bound_super.normalized_impl(db, only_reorder, visitor))
+                Type::BoundSuper(bound_super.normalized_impl(db, visitor))
             }),
             Type::GenericAlias(generic) => visitor.visit(self, || {
-                Type::GenericAlias(generic.normalized_impl(db, only_reorder, visitor))
+                Type::GenericAlias(generic.normalized_impl(db, visitor))
             }),
             Type::SubclassOf(subclass_of) => visitor.visit(self, || {
-                Type::SubclassOf(subclass_of.normalized_impl(db, only_reorder, visitor))
+                Type::SubclassOf(subclass_of.normalized_impl(db, visitor))
             }),
             Type::TypeVar(bound_typevar) => visitor.visit(self, || {
-                Type::TypeVar(bound_typevar.normalized_impl(db, only_reorder, visitor))
+                Type::TypeVar(bound_typevar.normalized_impl(db, visitor))
             }),
             Type::KnownInstance(known_instance) => visitor.visit(self, || {
-                Type::KnownInstance(known_instance.normalized_impl(db, only_reorder, visitor))
+                Type::KnownInstance(known_instance.normalized_impl(db, visitor))
             }),
             Type::TypeIs(type_is) => visitor.visit(self, || {
-                type_is.with_type(
-                    db,
-                    type_is
-                        .return_type(db)
-                        .normalized_impl(db, only_reorder, visitor),
-                )
+                type_is.with_type(db, type_is.return_type(db).normalized_impl(db, visitor))
             }),
-            Type::Dynamic(dynamic) => Type::Dynamic(dynamic.normalized(only_reorder)),
+            Type::Dynamic(dynamic) => Type::Dynamic(dynamic.normalized()),
             Type::EnumLiteral(enum_literal)
                 if is_single_member_enum(db, enum_literal.enum_class(db)) =>
             {
@@ -1655,18 +1623,16 @@ impl<'db> Type<'db> {
                 enum_literal.enum_class_instance(db)
             }
             Type::TypedDict(typed_dict) => visitor.visit(self, || {
-                Type::TypedDict(typed_dict.normalized_impl(db, only_reorder, visitor))
+                Type::TypedDict(typed_dict.normalized_impl(db, visitor))
             }),
-            Type::TypeAlias(alias) => {
-                alias
-                    .value_type(db)
-                    .normalized_impl(db, only_reorder, visitor)
+            Type::TypeAlias(alias) => alias.value_type(db).normalized_impl(db, visitor),
+            Type::NewTypeInstance(newtype) => {
+                visitor.visit(self, || {
+                    Type::NewTypeInstance(newtype.map_base_class_type(db, |class_type| {
+                        class_type.normalized_impl(db, visitor)
+                    }))
+                })
             }
-            Type::NewTypeInstance(newtype) => visitor.visit(self, || {
-                Type::NewTypeInstance(newtype.map_base_class_type(db, |class_type| {
-                    class_type.normalized_impl(db, only_reorder, visitor)
-                }))
-            }),
             Type::LiteralString
             | Type::AlwaysFalsy
             | Type::AlwaysTruthy
@@ -8970,45 +8936,31 @@ impl<'db> VarianceInferable<'db> for KnownInstanceType<'db> {
 }
 
 impl<'db> KnownInstanceType<'db> {
-    fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         match self {
             Self::SubscriptedProtocol(context) => {
-                Self::SubscriptedProtocol(context.normalized_impl(db, only_reorder, visitor))
+                Self::SubscriptedProtocol(context.normalized_impl(db, visitor))
             }
             Self::SubscriptedGeneric(context) => {
-                Self::SubscriptedGeneric(context.normalized_impl(db, only_reorder, visitor))
-            }
-            Self::TypeVar(typevar) => {
-                Self::TypeVar(typevar.normalized_impl(db, only_reorder, visitor))
+                Self::SubscriptedGeneric(context.normalized_impl(db, visitor))
             }
+            Self::TypeVar(typevar) => Self::TypeVar(typevar.normalized_impl(db, visitor)),
             Self::TypeAliasType(type_alias) => {
-                Self::TypeAliasType(type_alias.normalized_impl(db, only_reorder, visitor))
-            }
-            Self::Field(field) => Self::Field(field.normalized_impl(db, only_reorder, visitor)),
-            Self::UnionType(instance) => {
-                Self::UnionType(instance.normalized_impl(db, only_reorder, visitor))
-            }
-            Self::Literal(ty) => Self::Literal(ty.normalized_impl(db, only_reorder, visitor)),
-            Self::Annotated(ty) => Self::Annotated(ty.normalized_impl(db, only_reorder, visitor)),
-            Self::TypeGenericAlias(ty) => {
-                Self::TypeGenericAlias(ty.normalized_impl(db, only_reorder, visitor))
-            }
-            Self::Callable(callable) => {
-                Self::Callable(callable.normalized_impl(db, only_reorder, visitor))
+                Self::TypeAliasType(type_alias.normalized_impl(db, visitor))
             }
+            Self::Field(field) => Self::Field(field.normalized_impl(db, visitor)),
+            Self::UnionType(instance) => Self::UnionType(instance.normalized_impl(db, visitor)),
+            Self::Literal(ty) => Self::Literal(ty.normalized_impl(db, visitor)),
+            Self::Annotated(ty) => Self::Annotated(ty.normalized_impl(db, visitor)),
+            Self::TypeGenericAlias(ty) => Self::TypeGenericAlias(ty.normalized_impl(db, visitor)),
+            Self::Callable(callable) => Self::Callable(callable.normalized_impl(db, visitor)),
             Self::LiteralStringAlias(ty) => {
-                Self::LiteralStringAlias(ty.normalized_impl(db, only_reorder, visitor))
-            }
-            Self::NewType(newtype) => {
-                Self::NewType(newtype.map_base_class_type(db, |class_type| {
-                    class_type.normalized_impl(db, only_reorder, visitor)
-                }))
+                Self::LiteralStringAlias(ty.normalized_impl(db, visitor))
             }
+            Self::NewType(newtype) => Self::NewType(
+                newtype
+                    .map_base_class_type(db, |class_type| class_type.normalized_impl(db, visitor)),
+            ),
             Self::Deprecated(_)
             | Self::ConstraintSet(_)
             | Self::GenericContext(_)
@@ -9164,8 +9116,8 @@ pub enum DynamicType<'db> {
 }
 
 impl DynamicType<'_> {
-    fn normalized(self, only_reorder: OnlyReorder) -> Self {
-        if only_reorder == OnlyReorder::Yes || matches!(self, Self::Divergent(_)) {
+    fn normalized(self) -> Self {
+        if matches!(self, Self::Divergent(_)) {
             self
         } else {
             Self::Any
@@ -9537,16 +9489,11 @@ pub struct FieldInstance<'db> {
 impl get_size2::GetSize for FieldInstance<'_> {}
 
 impl<'db> FieldInstance<'db> {
-    pub(crate) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         FieldInstance::new(
             db,
             self.default_type(db)
-                .map(|ty| ty.normalized_impl(db, only_reorder, visitor)),
+                .map(|ty| ty.normalized_impl(db, visitor)),
             self.init(db),
             self.kw_only(db),
             self.alias(db),
@@ -9785,41 +9732,28 @@ impl<'db> TypeVarInstance<'db> {
         })
     }
 
-    pub(crate) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         Self::new(
             db,
             self.identity(db),
             self._bound_or_constraints(db)
                 .and_then(|bound_or_constraints| match bound_or_constraints {
-                    TypeVarBoundOrConstraintsEvaluation::Eager(bound_or_constraints) => Some(
-                        bound_or_constraints
-                            .normalized_impl(db, only_reorder, visitor)
-                            .into(),
-                    ),
+                    TypeVarBoundOrConstraintsEvaluation::Eager(bound_or_constraints) => {
+                        Some(bound_or_constraints.normalized_impl(db, visitor).into())
+                    }
                     TypeVarBoundOrConstraintsEvaluation::LazyUpperBound => self
                         .lazy_bound(db)
-                        .map(|bound| bound.normalized_impl(db, only_reorder, visitor).into()),
-                    TypeVarBoundOrConstraintsEvaluation::LazyConstraints => {
-                        self.lazy_constraints(db).map(|constraints| {
-                            constraints
-                                .normalized_impl(db, only_reorder, visitor)
-                                .into()
-                        })
-                    }
+                        .map(|bound| bound.normalized_impl(db, visitor).into()),
+                    TypeVarBoundOrConstraintsEvaluation::LazyConstraints => self
+                        .lazy_constraints(db)
+                        .map(|constraints| constraints.normalized_impl(db, visitor).into()),
                 }),
             self.explicit_variance(db),
             self._default(db).and_then(|default| match default {
-                TypeVarDefaultEvaluation::Eager(ty) => {
-                    Some(ty.normalized_impl(db, only_reorder, visitor).into())
-                }
+                TypeVarDefaultEvaluation::Eager(ty) => Some(ty.normalized_impl(db, visitor).into()),
                 TypeVarDefaultEvaluation::Lazy => self
                     .lazy_default(db)
-                    .map(|ty| ty.normalized_impl(db, only_reorder, visitor).into()),
+                    .map(|ty| ty.normalized_impl(db, visitor).into()),
             }),
         )
     }
@@ -10526,15 +10460,10 @@ impl<'db> BoundTypeVarInstance<'db> {
         })
     }
 
-    pub(crate) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         Self::new(
             db,
-            self.typevar(db).normalized_impl(db, only_reorder, visitor),
+            self.typevar(db).normalized_impl(db, visitor),
             self.binding_context(db),
             self.paramspec_attr(db),
         )
@@ -10696,16 +10625,11 @@ impl<'db> TypeVarConstraints<'db> {
         }
     }
 
-    fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         let normalized = self
             .elements(db)
             .iter()
-            .map(|ty| ty.normalized_impl(db, only_reorder, visitor))
+            .map(|ty| ty.normalized_impl(db, visitor))
             .collect::<Box<_>>();
         TypeVarConstraints::new(db, normalized)
     }
@@ -10745,22 +10669,13 @@ fn walk_type_var_bounds<'db, V: visitor::TypeVisitor<'db> + ?Sized>(
 }
 
 impl<'db> TypeVarBoundOrConstraints<'db> {
-    fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         match self {
-            TypeVarBoundOrConstraints::UpperBound(bound) => TypeVarBoundOrConstraints::UpperBound(
-                bound.normalized_impl(db, only_reorder, visitor),
-            ),
+            TypeVarBoundOrConstraints::UpperBound(bound) => {
+                TypeVarBoundOrConstraints::UpperBound(bound.normalized_impl(db, visitor))
+            }
             TypeVarBoundOrConstraints::Constraints(constraints) => {
-                TypeVarBoundOrConstraints::Constraints(constraints.normalized_impl(
-                    db,
-                    only_reorder,
-                    visitor,
-                ))
+                TypeVarBoundOrConstraints::Constraints(constraints.normalized_impl(db, visitor))
             }
         }
     }
@@ -10940,22 +10855,17 @@ impl<'db> UnionTypeInstance<'db> {
         }
     }
 
-    pub(crate) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         let value_expr_types = self._value_expr_types(db).as_ref().map(|types| {
             types
                 .iter()
-                .map(|ty| ty.normalized_impl(db, only_reorder, visitor))
+                .map(|ty| ty.normalized_impl(db, visitor))
                 .collect::<Box<_>>()
         });
         let union_type = self
             .union_type(db)
             .clone()
-            .map(|ty| ty.normalized_impl(db, only_reorder, visitor));
+            .map(|ty| ty.normalized_impl(db, visitor));
 
         Self::new(db, value_expr_types, union_type)
     }
@@ -11012,16 +10922,8 @@ pub struct InternedType<'db> {
 impl get_size2::GetSize for InternedType<'_> {}
 
 impl<'db> InternedType<'db> {
-    pub(crate) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
-        InternedType::new(
-            db,
-            self.inner(db).normalized_impl(db, only_reorder, visitor),
-        )
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
+        InternedType::new(db, self.inner(db).normalized_impl(db, visitor))
     }
 
     fn recursive_type_normalized_impl(
@@ -12343,17 +12245,11 @@ impl<'db> BoundMethodType<'db> {
         )
     }
 
-    fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         Self::new(
             db,
-            self.function(db).normalized_impl(db, only_reorder, visitor),
-            self.self_instance(db)
-                .normalized_impl(db, only_reorder, visitor),
+            self.function(db).normalized_impl(db, visitor),
+            self.self_instance(db).normalized_impl(db, visitor),
         )
     }
 
@@ -12563,16 +12459,10 @@ impl<'db> CallableType<'db> {
     /// Return a "normalized" version of this `Callable` type.
     ///
     /// See [`Type::normalized`] for more details.
-    fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         CallableType::new(
             db,
-            self.signatures(db)
-                .normalized_impl(db, only_reorder, visitor),
+            self.signatures(db).normalized_impl(db, visitor),
             self.kind(db),
         )
     }
@@ -12998,40 +12888,19 @@ impl<'db> KnownBoundMethodType<'db> {
         }
     }
 
-    fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         match self {
             KnownBoundMethodType::FunctionTypeDunderGet(function) => {
-                KnownBoundMethodType::FunctionTypeDunderGet(function.normalized_impl(
-                    db,
-                    only_reorder,
-                    visitor,
-                ))
+                KnownBoundMethodType::FunctionTypeDunderGet(function.normalized_impl(db, visitor))
             }
             KnownBoundMethodType::FunctionTypeDunderCall(function) => {
-                KnownBoundMethodType::FunctionTypeDunderCall(function.normalized_impl(
-                    db,
-                    only_reorder,
-                    visitor,
-                ))
+                KnownBoundMethodType::FunctionTypeDunderCall(function.normalized_impl(db, visitor))
             }
             KnownBoundMethodType::PropertyDunderGet(property) => {
-                KnownBoundMethodType::PropertyDunderGet(property.normalized_impl(
-                    db,
-                    only_reorder,
-                    visitor,
-                ))
+                KnownBoundMethodType::PropertyDunderGet(property.normalized_impl(db, visitor))
             }
             KnownBoundMethodType::PropertyDunderSet(property) => {
-                KnownBoundMethodType::PropertyDunderSet(property.normalized_impl(
-                    db,
-                    only_reorder,
-                    visitor,
-                ))
+                KnownBoundMethodType::PropertyDunderSet(property.normalized_impl(db, visitor))
             }
             KnownBoundMethodType::StrStartswith(_)
             | KnownBoundMethodType::ConstraintSetRange
@@ -13665,12 +13534,7 @@ impl<'db> PEP695TypeAliasType<'db> {
             })
     }
 
-    fn normalized_impl(
-        self,
-        _db: &'db dyn Db,
-        _only_reorder: OnlyReorder,
-        _visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    fn normalized_impl(self, _db: &'db dyn Db, _visitor: &NormalizedVisitor<'db>) -> Self {
         self
     }
 }
@@ -13727,17 +13591,12 @@ fn walk_manual_pep_695_type_alias<'db, V: visitor::TypeVisitor<'db> + ?Sized>(
 }
 
 impl<'db> ManualPEP695TypeAliasType<'db> {
-    fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         Self::new(
             db,
             self.name(db),
             self.definition(db),
-            self.value(db).normalized_impl(db, only_reorder, visitor),
+            self.value(db).normalized_impl(db, visitor),
         )
     }
 
@@ -13782,18 +13641,13 @@ fn walk_type_alias_type<'db, V: visitor::TypeVisitor<'db> + ?Sized>(
 }
 
 impl<'db> TypeAliasType<'db> {
-    pub(crate) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         match self {
             TypeAliasType::PEP695(type_alias) => {
-                TypeAliasType::PEP695(type_alias.normalized_impl(db, only_reorder, visitor))
+                TypeAliasType::PEP695(type_alias.normalized_impl(db, visitor))
             }
             TypeAliasType::ManualPEP695(type_alias) => {
-                TypeAliasType::ManualPEP695(type_alias.normalized_impl(db, only_reorder, visitor))
+                TypeAliasType::ManualPEP695(type_alias.normalized_impl(db, visitor))
             }
         }
     }
@@ -14128,26 +13982,21 @@ impl<'db> UnionType<'db> {
     /// See [`Type::normalized`] for more details.
     #[must_use]
     pub(crate) fn normalized(self, db: &'db dyn Db) -> Type<'db> {
-        self.normalized_impl(db, OnlyReorder::No, &NormalizedVisitor::default())
+        self.normalized_impl(db, &NormalizedVisitor::default())
     }
 
     pub(crate) fn normalized_impl(
         self,
         db: &'db dyn Db,
-        only_reorder: OnlyReorder,
         visitor: &NormalizedVisitor<'db>,
     ) -> Type<'db> {
         self.elements(db)
             .iter()
-            .map(|ty| ty.normalized_impl(db, only_reorder, visitor))
+            .map(|ty| ty.normalized_impl(db, visitor))
             .fold(
-                if only_reorder == OnlyReorder::Yes {
-                    UnionBuilder::new(db).order_elements(true)
-                } else {
-                    UnionBuilder::new(db)
-                        .order_elements(true)
-                        .unpack_aliases(true)
-                },
+                UnionBuilder::new(db)
+                    .order_elements(true)
+                    .unpack_aliases(true),
                 UnionBuilder::add,
             )
             .recursively_defined(self.recursively_defined(db))
@@ -14326,24 +14175,18 @@ impl<'db> IntersectionType<'db> {
     /// See [`Type::normalized`] for more details.
     #[must_use]
     pub(crate) fn normalized(self, db: &'db dyn Db) -> Self {
-        self.normalized_impl(db, OnlyReorder::No, &NormalizedVisitor::default())
+        self.normalized_impl(db, &NormalizedVisitor::default())
     }
 
-    pub(crate) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         fn normalized_set<'db>(
             db: &'db dyn Db,
             elements: &FxOrderSet<Type<'db>>,
-            only_reorder: OnlyReorder,
             visitor: &NormalizedVisitor<'db>,
         ) -> FxOrderSet<Type<'db>> {
             let mut elements: FxOrderSet<Type<'db>> = elements
                 .iter()
-                .map(|ty| ty.normalized_impl(db, only_reorder, visitor))
+                .map(|ty| ty.normalized_impl(db, visitor))
                 .collect();
 
             elements.sort_unstable_by(|l, r| union_or_intersection_elements_ordering(db, l, r));
@@ -14352,8 +14195,8 @@ impl<'db> IntersectionType<'db> {
 
         IntersectionType::new(
             db,
-            normalized_set(db, self.positive(db), only_reorder, visitor),
-            normalized_set(db, self.negative(db), only_reorder, visitor),
+            normalized_set(db, self.positive(db), visitor),
+            normalized_set(db, self.negative(db), visitor),
         )
     }
 
diff --git a/crates/ty_python_semantic/src/types/bound_super.rs b/crates/ty_python_semantic/src/types/bound_super.rs
index 05366a4e64..cea3bc3e54 100644
--- a/crates/ty_python_semantic/src/types/bound_super.rs
+++ b/crates/ty_python_semantic/src/types/bound_super.rs
@@ -9,8 +9,8 @@ use crate::{
     place::{Place, PlaceAndQualifiers},
     types::{
         ClassBase, ClassType, DynamicType, IntersectionBuilder, KnownClass, MemberLookupPolicy,
-        NominalInstanceType, NormalizedVisitor, OnlyReorder, SpecialFormType, SubclassOfInner,
-        Type, TypeVarBoundOrConstraints, TypeVarInstance, UnionBuilder,
+        NominalInstanceType, NormalizedVisitor, SpecialFormType, SubclassOfInner, Type,
+        TypeVarBoundOrConstraints, TypeVarInstance, UnionBuilder,
         context::InferContext,
         diagnostic::{INVALID_SUPER_ARGUMENT, UNAVAILABLE_IMPLICIT_SUPER_ARGUMENTS},
         todo_type, visitor,
@@ -178,21 +178,14 @@ pub enum SuperOwnerKind<'db> {
 }
 
 impl<'db> SuperOwnerKind<'db> {
-    fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         match self {
-            SuperOwnerKind::Dynamic(dynamic) => {
-                SuperOwnerKind::Dynamic(dynamic.normalized(only_reorder))
-            }
+            SuperOwnerKind::Dynamic(dynamic) => SuperOwnerKind::Dynamic(dynamic.normalized()),
             SuperOwnerKind::Class(class) => {
-                SuperOwnerKind::Class(class.normalized_impl(db, only_reorder, visitor))
+                SuperOwnerKind::Class(class.normalized_impl(db, visitor))
             }
             SuperOwnerKind::Instance(instance) => instance
-                .normalized_impl(db, only_reorder, visitor)
+                .normalized_impl(db, visitor)
                 .as_nominal_instance()
                 .map(Self::Instance)
                 .unwrap_or(Self::Dynamic(DynamicType::Any)),
@@ -613,17 +606,11 @@ impl<'db> BoundSuperType<'db> {
         }
     }
 
-    pub(super) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(super) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         Self::new(
             db,
-            self.pivot_class(db)
-                .normalized_impl(db, only_reorder, visitor),
-            self.owner(db).normalized_impl(db, only_reorder, visitor),
+            self.pivot_class(db).normalized_impl(db, visitor),
+            self.owner(db).normalized_impl(db, visitor),
         )
     }
 
diff --git a/crates/ty_python_semantic/src/types/class.rs b/crates/ty_python_semantic/src/types/class.rs
index 491743392a..260728caa4 100644
--- a/crates/ty_python_semantic/src/types/class.rs
+++ b/crates/ty_python_semantic/src/types/class.rs
@@ -38,8 +38,8 @@ use crate::types::{
     CallableTypes, DATACLASS_FLAGS, DataclassFlags, DataclassParams, DeprecatedInstance,
     FindLegacyTypeVarsVisitor, HasRelationToVisitor, IsDisjointVisitor, IsEquivalentVisitor,
     KnownInstanceType, ManualPEP695TypeAliasType, MaterializationKind, NormalizedVisitor,
-    OnlyReorder, PropertyInstanceType, StringLiteralType, TypeAliasType, TypeContext, TypeMapping,
-    TypeRelation, TypedDictParams, UnionBuilder, VarianceInferable, binding_type, declaration_type,
+    PropertyInstanceType, StringLiteralType, TypeAliasType, TypeContext, TypeMapping, TypeRelation,
+    TypedDictParams, UnionBuilder, VarianceInferable, binding_type, declaration_type,
     determine_upper_bound,
 };
 use crate::{
@@ -274,17 +274,11 @@ pub(super) fn walk_generic_alias<'db, V: super::visitor::TypeVisitor<'db> + ?Siz
 impl get_size2::GetSize for GenericAlias<'_> {}
 
 impl<'db> GenericAlias<'db> {
-    pub(super) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(super) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         Self::new(
             db,
             self.origin(db),
-            self.specialization(db)
-                .normalized_impl(db, only_reorder, visitor),
+            self.specialization(db).normalized_impl(db, visitor),
         )
     }
 
@@ -448,17 +442,10 @@ impl<'db> ClassType<'db> {
         }
     }
 
-    pub(super) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(super) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         match self {
             Self::NonGeneric(_) => self,
-            Self::Generic(generic) => {
-                Self::Generic(generic.normalized_impl(db, only_reorder, visitor))
-            }
+            Self::Generic(generic) => Self::Generic(generic.normalized_impl(db, visitor)),
         }
     }
 
diff --git a/crates/ty_python_semantic/src/types/class_base.rs b/crates/ty_python_semantic/src/types/class_base.rs
index 3974074e85..26b490fa3b 100644
--- a/crates/ty_python_semantic/src/types/class_base.rs
+++ b/crates/ty_python_semantic/src/types/class_base.rs
@@ -4,8 +4,8 @@ use crate::types::generics::Specialization;
 use crate::types::tuple::TupleType;
 use crate::types::{
     ApplyTypeMappingVisitor, ClassLiteral, ClassType, DynamicType, KnownClass, KnownInstanceType,
-    MaterializationKind, MroError, MroIterator, NormalizedVisitor, OnlyReorder, SpecialFormType,
-    Type, TypeContext, TypeMapping, todo_type,
+    MaterializationKind, MroError, MroIterator, NormalizedVisitor, SpecialFormType, Type,
+    TypeContext, TypeMapping, todo_type,
 };
 
 /// Enumeration of the possible kinds of types we allow in class bases.
@@ -35,15 +35,10 @@ impl<'db> ClassBase<'db> {
         Self::Dynamic(DynamicType::Unknown)
     }
 
-    pub(crate) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         match self {
-            Self::Dynamic(dynamic) => Self::Dynamic(dynamic.normalized(only_reorder)),
-            Self::Class(class) => Self::Class(class.normalized_impl(db, only_reorder, visitor)),
+            Self::Dynamic(dynamic) => Self::Dynamic(dynamic.normalized()),
+            Self::Class(class) => Self::Class(class.normalized_impl(db, visitor)),
             Self::Protocol | Self::Generic | Self::TypedDict => self,
         }
     }
diff --git a/crates/ty_python_semantic/src/types/function.rs b/crates/ty_python_semantic/src/types/function.rs
index 89813bed7d..e727e6663b 100644
--- a/crates/ty_python_semantic/src/types/function.rs
+++ b/crates/ty_python_semantic/src/types/function.rs
@@ -83,9 +83,9 @@ use crate::types::{
     ApplyTypeMappingVisitor, BoundMethodType, BoundTypeVarInstance, CallableType, CallableTypeKind,
     ClassBase, ClassLiteral, ClassType, DeprecatedInstance, DynamicType, FindLegacyTypeVarsVisitor,
     HasRelationToVisitor, IsDisjointVisitor, IsEquivalentVisitor, KnownClass, KnownInstanceType,
-    NormalizedVisitor, OnlyReorder, SpecialFormType, SubclassOfInner, SubclassOfType, Truthiness,
-    Type, TypeContext, TypeMapping, TypeRelation, UnionBuilder, binding_type,
-    definition_expression_type, infer_definition_types, walk_signature,
+    NormalizedVisitor, SpecialFormType, SubclassOfInner, SubclassOfType, Truthiness, Type,
+    TypeContext, TypeMapping, TypeRelation, UnionBuilder, binding_type, definition_expression_type,
+    infer_definition_types, walk_signature,
 };
 use crate::{Db, FxOrderSet, ModuleName, resolve_module};
 
@@ -1156,22 +1156,17 @@ impl<'db> FunctionType<'db> {
     }
 
     pub(crate) fn normalized(self, db: &'db dyn Db) -> Self {
-        self.normalized_impl(db, OnlyReorder::No, &NormalizedVisitor::default())
+        self.normalized_impl(db, &NormalizedVisitor::default())
     }
 
-    pub(crate) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         let literal = self.literal(db);
         let updated_signature = self
             .updated_signature(db)
-            .map(|signature| signature.normalized_impl(db, only_reorder, visitor));
+            .map(|signature| signature.normalized_impl(db, visitor));
         let updated_last_definition_signature = self
             .updated_last_definition_signature(db)
-            .map(|signature| signature.normalized_impl(db, only_reorder, visitor));
+            .map(|signature| signature.normalized_impl(db, visitor));
         Self::new(
             db,
             literal,
diff --git a/crates/ty_python_semantic/src/types/generics.rs b/crates/ty_python_semantic/src/types/generics.rs
index 93c4a53fd8..71ddbb2e91 100644
--- a/crates/ty_python_semantic/src/types/generics.rs
+++ b/crates/ty_python_semantic/src/types/generics.rs
@@ -21,8 +21,8 @@ use crate::types::{
     ApplyTypeMappingVisitor, BindingContext, BoundTypeVarIdentity, BoundTypeVarInstance,
     ClassLiteral, FindLegacyTypeVarsVisitor, HasRelationToVisitor, IsDisjointVisitor,
     IsEquivalentVisitor, KnownClass, KnownInstanceType, MaterializationKind, NormalizedVisitor,
-    OnlyReorder, Type, TypeContext, TypeMapping, TypeRelation, TypeVarBoundOrConstraints,
-    TypeVarIdentity, TypeVarInstance, TypeVarKind, TypeVarVariance, UnionType, declaration_type,
+    Type, TypeContext, TypeMapping, TypeRelation, TypeVarBoundOrConstraints, TypeVarIdentity,
+    TypeVarInstance, TypeVarKind, TypeVarVariance, UnionType, declaration_type,
     walk_type_var_bounds,
 };
 use crate::{Db, FxOrderMap, FxOrderSet};
@@ -673,15 +673,10 @@ impl<'db> GenericContext<'db> {
         Specialization::new(db, self, self.fill_in_defaults(db, types), None, None)
     }
 
-    pub(crate) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         let variables = self
             .variables(db)
-            .map(|bound_typevar| bound_typevar.normalized_impl(db, only_reorder, visitor));
+            .map(|bound_typevar| bound_typevar.normalized_impl(db, visitor));
 
         Self::from_typevar_instances(db, variables)
     }
@@ -1118,23 +1113,16 @@ impl<'db> Specialization<'db> {
         Specialization::new(db, self.generic_context(db), types, None, None)
     }
 
-    pub(crate) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         let types: Box<[_]> = self
             .types(db)
             .iter()
-            .map(|ty| ty.normalized_impl(db, only_reorder, visitor))
+            .map(|ty| ty.normalized_impl(db, visitor))
             .collect();
         let tuple_inner = self
             .tuple_inner(db)
-            .and_then(|tuple| tuple.normalized_impl(db, only_reorder, visitor));
-        let context = self
-            .generic_context(db)
-            .normalized_impl(db, only_reorder, visitor);
+            .and_then(|tuple| tuple.normalized_impl(db, visitor));
+        let context = self.generic_context(db).normalized_impl(db, visitor);
         Self::new(
             db,
             context,
diff --git a/crates/ty_python_semantic/src/types/instance.rs b/crates/ty_python_semantic/src/types/instance.rs
index b012aacfb2..9e674065b9 100644
--- a/crates/ty_python_semantic/src/types/instance.rs
+++ b/crates/ty_python_semantic/src/types/instance.rs
@@ -14,8 +14,8 @@ use crate::types::protocol_class::{ProtocolClass, walk_protocol_interface};
 use crate::types::tuple::{TupleSpec, TupleType, walk_tuple_type};
 use crate::types::{
     ApplyTypeMappingVisitor, ClassBase, ClassLiteral, FindLegacyTypeVarsVisitor,
-    HasRelationToVisitor, IsDisjointVisitor, IsEquivalentVisitor, NormalizedVisitor, OnlyReorder,
-    TypeContext, TypeMapping, TypeRelation, VarianceInferable,
+    HasRelationToVisitor, IsDisjointVisitor, IsEquivalentVisitor, NormalizedVisitor, TypeContext,
+    TypeMapping, TypeRelation, VarianceInferable,
 };
 use crate::{Db, FxOrderSet};
 
@@ -117,7 +117,6 @@ impl<'db> Type<'db> {
             SynthesizedProtocolType::new(
                 db,
                 ProtocolInterface::with_property_members(db, members),
-                OnlyReorder::No,
                 &NormalizedVisitor::default(),
             ),
         ))
@@ -370,15 +369,14 @@ impl<'db> NominalInstanceType<'db> {
     pub(super) fn normalized_impl(
         self,
         db: &'db dyn Db,
-        only_reorder: OnlyReorder,
         visitor: &NormalizedVisitor<'db>,
     ) -> Type<'db> {
         match self.0 {
             NominalInstanceInner::ExactTuple(tuple) => {
-                Type::tuple(tuple.normalized_impl(db, only_reorder, visitor))
+                Type::tuple(tuple.normalized_impl(db, visitor))
             }
             NominalInstanceInner::NonTuple(class) => Type::NominalInstance(NominalInstanceType(
-                NominalInstanceInner::NonTuple(class.normalized_impl(db, only_reorder, visitor)),
+                NominalInstanceInner::NonTuple(class.normalized_impl(db, visitor)),
             )),
             NominalInstanceInner::Object => Type::object(),
         }
@@ -732,7 +730,7 @@ impl<'db> ProtocolInstanceType<'db> {
     ///
     /// See [`Type::normalized`] for more details.
     pub(super) fn normalized(self, db: &'db dyn Db) -> Type<'db> {
-        self.normalized_impl(db, OnlyReorder::No, &NormalizedVisitor::default())
+        self.normalized_impl(db, &NormalizedVisitor::default())
     }
 
     /// Return a "normalized" version of this `Protocol` type.
@@ -741,7 +739,6 @@ impl<'db> ProtocolInstanceType<'db> {
     pub(super) fn normalized_impl(
         self,
         db: &'db dyn Db,
-        only_reorder: OnlyReorder,
         visitor: &NormalizedVisitor<'db>,
     ) -> Type<'db> {
         if self.is_equivalent_to_object(db) {
@@ -749,7 +746,7 @@ impl<'db> ProtocolInstanceType<'db> {
         }
         match self.inner {
             Protocol::FromClass(_) => Type::ProtocolInstance(Self::synthesized(
-                SynthesizedProtocolType::new(db, self.inner.interface(db), only_reorder, visitor),
+                SynthesizedProtocolType::new(db, self.inner.interface(db), visitor),
             )),
             Protocol::Synthesized(_) => Type::ProtocolInstance(self),
         }
@@ -912,8 +909,7 @@ mod synthesized_protocol {
     use crate::types::protocol_class::ProtocolInterface;
     use crate::types::{
         ApplyTypeMappingVisitor, BoundTypeVarInstance, FindLegacyTypeVarsVisitor,
-        NormalizedVisitor, OnlyReorder, Type, TypeContext, TypeMapping, TypeVarVariance,
-        VarianceInferable,
+        NormalizedVisitor, Type, TypeContext, TypeMapping, TypeVarVariance, VarianceInferable,
     };
     use crate::{Db, FxOrderSet};
 
@@ -935,10 +931,9 @@ mod synthesized_protocol {
         pub(super) fn new(
             db: &'db dyn Db,
             interface: ProtocolInterface<'db>,
-            only_reorder: OnlyReorder,
             visitor: &NormalizedVisitor<'db>,
         ) -> Self {
-            Self(interface.normalized_impl(db, only_reorder, visitor))
+            Self(interface.normalized_impl(db, visitor))
         }
 
         pub(super) fn apply_type_mapping_impl<'a>(
diff --git a/crates/ty_python_semantic/src/types/protocol_class.rs b/crates/ty_python_semantic/src/types/protocol_class.rs
index 6b3185ab64..5d3719b8d9 100644
--- a/crates/ty_python_semantic/src/types/protocol_class.rs
+++ b/crates/ty_python_semantic/src/types/protocol_class.rs
@@ -15,8 +15,8 @@ use crate::{
         ApplyTypeMappingVisitor, BoundTypeVarInstance, CallableType, ClassBase, ClassLiteral,
         ClassType, FindLegacyTypeVarsVisitor, HasRelationToVisitor,
         InstanceFallbackShadowsNonDataDescriptor, IsDisjointVisitor, KnownFunction,
-        MemberLookupPolicy, NormalizedVisitor, OnlyReorder, PropertyInstanceType, Signature, Type,
-        TypeMapping, TypeQualifiers, TypeRelation, TypeVarVariance, VarianceInferable,
+        MemberLookupPolicy, NormalizedVisitor, PropertyInstanceType, Signature, Type, TypeMapping,
+        TypeQualifiers, TypeRelation, TypeVarVariance, VarianceInferable,
         constraints::{ConstraintSet, IteratorConstraintsExtension, OptionConstraintsExtension},
         context::InferContext,
         diagnostic::report_undeclared_protocol_member,
@@ -369,22 +369,12 @@ impl<'db> ProtocolInterface<'db> {
         })
     }
 
-    pub(super) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(super) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         Self::new(
             db,
             self.inner(db)
                 .iter()
-                .map(|(name, data)| {
-                    (
-                        name.clone(),
-                        data.normalized_impl(db, only_reorder, visitor),
-                    )
-                })
+                .map(|(name, data)| (name.clone(), data.normalized_impl(db, visitor)))
                 .collect::<BTreeMap<_, _>>(),
         )
     }
@@ -490,17 +480,12 @@ pub(super) struct ProtocolMemberData<'db> {
 
 impl<'db> ProtocolMemberData<'db> {
     fn normalized(&self, db: &'db dyn Db) -> Self {
-        self.normalized_impl(db, OnlyReorder::No, &NormalizedVisitor::default())
+        self.normalized_impl(db, &NormalizedVisitor::default())
     }
 
-    fn normalized_impl(
-        &self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    fn normalized_impl(&self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         Self {
-            kind: self.kind.normalized_impl(db, only_reorder, visitor),
+            kind: self.kind.normalized_impl(db, visitor),
             qualifiers: self.qualifiers,
         }
     }
@@ -608,21 +593,16 @@ enum ProtocolMemberKind<'db> {
 }
 
 impl<'db> ProtocolMemberKind<'db> {
-    fn normalized_impl(
-        &self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    fn normalized_impl(&self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         match self {
             ProtocolMemberKind::Method(callable) => {
-                ProtocolMemberKind::Method(callable.normalized_impl(db, only_reorder, visitor))
+                ProtocolMemberKind::Method(callable.normalized_impl(db, visitor))
             }
             ProtocolMemberKind::Property(property) => {
-                ProtocolMemberKind::Property(property.normalized_impl(db, only_reorder, visitor))
+                ProtocolMemberKind::Property(property.normalized_impl(db, visitor))
             }
             ProtocolMemberKind::Other(ty) => {
-                ProtocolMemberKind::Other(ty.normalized_impl(db, only_reorder, visitor))
+                ProtocolMemberKind::Other(ty.normalized_impl(db, visitor))
             }
         }
     }
diff --git a/crates/ty_python_semantic/src/types/signatures.rs b/crates/ty_python_semantic/src/types/signatures.rs
index ff70f573f4..42cf93775d 100644
--- a/crates/ty_python_semantic/src/types/signatures.rs
+++ b/crates/ty_python_semantic/src/types/signatures.rs
@@ -25,8 +25,8 @@ use crate::types::infer::{infer_deferred_types, infer_scope_types};
 use crate::types::{
     ApplyTypeMappingVisitor, BindingContext, BoundTypeVarInstance, CallableType, CallableTypeKind,
     FindLegacyTypeVarsVisitor, HasRelationToVisitor, IsDisjointVisitor, IsEquivalentVisitor,
-    KnownClass, MaterializationKind, NormalizedVisitor, OnlyReorder, ParamSpecAttrKind,
-    TypeContext, TypeMapping, TypeRelation, VarianceInferable, todo_type,
+    KnownClass, MaterializationKind, NormalizedVisitor, ParamSpecAttrKind, TypeContext,
+    TypeMapping, TypeRelation, VarianceInferable, todo_type,
 };
 use crate::{Db, FxOrderSet};
 use ruff_python_ast::{self as ast, name::Name};
@@ -107,13 +107,12 @@ impl<'db> CallableSignature<'db> {
     pub(crate) fn normalized_impl(
         &self,
         db: &'db dyn Db,
-        only_reorder: OnlyReorder,
         visitor: &NormalizedVisitor<'db>,
     ) -> Self {
         Self::from_overloads(
             self.overloads
                 .iter()
-                .map(|signature| signature.normalized_impl(db, only_reorder, visitor)),
+                .map(|signature| signature.normalized_impl(db, visitor)),
         )
     }
 
@@ -744,13 +743,12 @@ impl<'db> Signature<'db> {
     pub(crate) fn normalized_impl(
         &self,
         db: &'db dyn Db,
-        only_reorder: OnlyReorder,
         visitor: &NormalizedVisitor<'db>,
     ) -> Self {
         Self {
             generic_context: self
                 .generic_context
-                .map(|ctx| ctx.normalized_impl(db, only_reorder, visitor)),
+                .map(|ctx| ctx.normalized_impl(db, visitor)),
             // Discard the definition when normalizing, so that two equivalent signatures
             // with different `Definition`s share the same Salsa ID when normalized
             definition: None,
@@ -758,11 +756,11 @@ impl<'db> Signature<'db> {
                 db,
                 self.parameters
                     .iter()
-                    .map(|param| param.normalized_impl(db, only_reorder, visitor)),
+                    .map(|param| param.normalized_impl(db, visitor)),
             ),
             return_ty: self
                 .return_ty
-                .map(|return_ty| return_ty.normalized_impl(db, only_reorder, visitor)),
+                .map(|return_ty| return_ty.normalized_impl(db, visitor)),
         }
     }
 
@@ -2158,7 +2156,6 @@ impl<'db> Parameter<'db> {
     pub(crate) fn normalized_impl(
         &self,
         db: &'db dyn Db,
-        only_reorder: OnlyReorder,
         visitor: &NormalizedVisitor<'db>,
     ) -> Self {
         let Parameter {
@@ -2173,17 +2170,9 @@ impl<'db> Parameter<'db> {
         // with a dynamic type as its annotation. (We must use `Any` here as all dynamic types
         // normalize to `Any`.)
         let annotated_type = annotated_type
-            .map(|ty| ty.normalized_impl(db, only_reorder, visitor))
+            .map(|ty| ty.normalized_impl(db, visitor))
             .unwrap_or_else(Type::any);
 
-        let map_default_type = |ty: Type<'db>| {
-            if only_reorder == OnlyReorder::Yes {
-                ty.normalized_impl(db, only_reorder, visitor)
-            } else {
-                Type::Never
-            }
-        };
-
         // Ensure that parameter names are stripped from positional-only, variadic and keyword-variadic parameters.
         // Ensure that we only record whether a parameter *has* a default
         // (strip the precise *type* of the default from the parameter, replacing it with `Never`).
@@ -2193,17 +2182,17 @@ impl<'db> Parameter<'db> {
                 default_type,
             } => ParameterKind::PositionalOnly {
                 name: None,
-                default_type: default_type.map(map_default_type),
+                default_type: default_type.map(|_| Type::Never),
             },
             ParameterKind::PositionalOrKeyword { name, default_type } => {
                 ParameterKind::PositionalOrKeyword {
                     name: name.clone(),
-                    default_type: default_type.map(map_default_type),
+                    default_type: default_type.map(|_| Type::Never),
                 }
             }
             ParameterKind::KeywordOnly { name, default_type } => ParameterKind::KeywordOnly {
                 name: name.clone(),
-                default_type: default_type.map(map_default_type),
+                default_type: default_type.map(|_| Type::Never),
             },
             ParameterKind::Variadic { name: _ } => ParameterKind::Variadic {
                 name: Name::new_static("args"),
diff --git a/crates/ty_python_semantic/src/types/subclass_of.rs b/crates/ty_python_semantic/src/types/subclass_of.rs
index 1017ebd7d4..eb016199a5 100644
--- a/crates/ty_python_semantic/src/types/subclass_of.rs
+++ b/crates/ty_python_semantic/src/types/subclass_of.rs
@@ -7,8 +7,8 @@ use crate::types::variance::VarianceInferable;
 use crate::types::{
     ApplyTypeMappingVisitor, BoundTypeVarInstance, ClassType, DynamicType,
     FindLegacyTypeVarsVisitor, HasRelationToVisitor, IsDisjointVisitor, KnownClass,
-    MaterializationKind, MemberLookupPolicy, NormalizedVisitor, OnlyReorder, SpecialFormType, Type,
-    TypeContext, TypeMapping, TypeRelation, TypeVarBoundOrConstraints, TypedDictType, todo_type,
+    MaterializationKind, MemberLookupPolicy, NormalizedVisitor, SpecialFormType, Type, TypeContext,
+    TypeMapping, TypeRelation, TypeVarBoundOrConstraints, TypedDictType, todo_type,
 };
 use crate::{Db, FxOrderSet};
 
@@ -263,14 +263,9 @@ impl<'db> SubclassOfType<'db> {
         }
     }
 
-    pub(crate) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         Self {
-            subclass_of: self.subclass_of.normalized_impl(db, only_reorder, visitor),
+            subclass_of: self.subclass_of.normalized_impl(db, visitor),
         }
     }
 
@@ -439,17 +434,12 @@ impl<'db> SubclassOfInner<'db> {
         Self::TypeVar(bound_typevar)
     }
 
-    pub(crate) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         match self {
-            Self::Class(class) => Self::Class(class.normalized_impl(db, only_reorder, visitor)),
-            Self::Dynamic(dynamic) => Self::Dynamic(dynamic.normalized(only_reorder)),
+            Self::Class(class) => Self::Class(class.normalized_impl(db, visitor)),
+            Self::Dynamic(dynamic) => Self::Dynamic(dynamic.normalized()),
             Self::TypeVar(bound_typevar) => {
-                Self::TypeVar(bound_typevar.normalized_impl(db, only_reorder, visitor))
+                Self::TypeVar(bound_typevar.normalized_impl(db, visitor))
             }
         }
     }
diff --git a/crates/ty_python_semantic/src/types/tuple.rs b/crates/ty_python_semantic/src/types/tuple.rs
index 0d90faeba2..f0cc3bedc8 100644
--- a/crates/ty_python_semantic/src/types/tuple.rs
+++ b/crates/ty_python_semantic/src/types/tuple.rs
@@ -29,8 +29,8 @@ use crate::types::constraints::{ConstraintSet, IteratorConstraintsExtension};
 use crate::types::generics::InferableTypeVars;
 use crate::types::{
     ApplyTypeMappingVisitor, BoundTypeVarInstance, FindLegacyTypeVarsVisitor, HasRelationToVisitor,
-    IsDisjointVisitor, IsEquivalentVisitor, NormalizedVisitor, OnlyReorder, Type, TypeMapping,
-    TypeRelation, UnionBuilder, UnionType,
+    IsDisjointVisitor, IsEquivalentVisitor, NormalizedVisitor, Type, TypeMapping, TypeRelation,
+    UnionBuilder, UnionType,
 };
 use crate::types::{Truthiness, TypeContext};
 use crate::{Db, FxOrderSet, Program};
@@ -225,13 +225,9 @@ impl<'db> TupleType<'db> {
     pub(crate) fn normalized_impl(
         self,
         db: &'db dyn Db,
-        only_reorder: OnlyReorder,
         visitor: &NormalizedVisitor<'db>,
     ) -> Option<Self> {
-        TupleType::new(
-            db,
-            &self.tuple(db).normalized_impl(db, only_reorder, visitor),
-        )
+        TupleType::new(db, &self.tuple(db).normalized_impl(db, visitor))
     }
 
     pub(super) fn recursive_type_normalized_impl(
@@ -427,17 +423,8 @@ impl<'db> FixedLengthTuple<Type<'db>> {
     }
 
     #[must_use]
-    fn normalized_impl(
-        &self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
-        Self::from_elements(
-            self.0
-                .iter()
-                .map(|ty| ty.normalized_impl(db, only_reorder, visitor)),
-        )
+    fn normalized_impl(&self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
+        Self::from_elements(self.0.iter().map(|ty| ty.normalized_impl(db, visitor)))
     }
 
     fn recursive_type_normalized_impl(
@@ -815,21 +802,16 @@ impl<'db> VariableLengthTuple<Type<'db>> {
     }
 
     #[must_use]
-    fn normalized_impl(
-        &self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> TupleSpec<'db> {
+    fn normalized_impl(&self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> TupleSpec<'db> {
         let prefix = self
             .prenormalized_prefix_elements(db, None)
-            .map(|ty| ty.normalized_impl(db, only_reorder, visitor))
+            .map(|ty| ty.normalized_impl(db, visitor))
             .collect::<Box<_>>();
         let suffix = self
             .prenormalized_suffix_elements(db, None)
-            .map(|ty| ty.normalized_impl(db, only_reorder, visitor))
+            .map(|ty| ty.normalized_impl(db, visitor))
             .collect::<Box<_>>();
-        let variable = self.variable.normalized_impl(db, only_reorder, visitor);
+        let variable = self.variable.normalized_impl(db, visitor);
         TupleSpec::Variable(Self {
             prefix,
             variable,
@@ -1298,12 +1280,11 @@ impl<'db> Tuple<Type<'db>> {
     pub(crate) fn normalized_impl(
         &self,
         db: &'db dyn Db,
-        only_reorder: OnlyReorder,
         visitor: &NormalizedVisitor<'db>,
     ) -> Self {
         match self {
-            Tuple::Fixed(tuple) => Tuple::Fixed(tuple.normalized_impl(db, only_reorder, visitor)),
-            Tuple::Variable(tuple) => tuple.normalized_impl(db, only_reorder, visitor),
+            Tuple::Fixed(tuple) => Tuple::Fixed(tuple.normalized_impl(db, visitor)),
+            Tuple::Variable(tuple) => tuple.normalized_impl(db, visitor),
         }
     }
 
diff --git a/crates/ty_python_semantic/src/types/type_ordering.rs b/crates/ty_python_semantic/src/types/type_ordering.rs
index add1d600f6..c47720011c 100644
--- a/crates/ty_python_semantic/src/types/type_ordering.rs
+++ b/crates/ty_python_semantic/src/types/type_ordering.rs
@@ -29,13 +29,13 @@ pub(super) fn union_or_intersection_elements_ordering<'db>(
 ) -> Ordering {
     debug_assert_eq!(
         *left,
-        left.canonically_ordered(db),
-        "`left` must be canonically ordered before a meaningful ordering can be established"
+        left.normalized(db),
+        "`left` must be normalized before a meaningful ordering can be established"
     );
     debug_assert_eq!(
         *right,
-        right.canonically_ordered(db),
-        "`right` must be canonically ordered before a meaningful ordering can be established"
+        right.normalized(db),
+        "`right` must be normalized before a meaningful ordering can be established"
     );
 
     if left == right {
diff --git a/crates/ty_python_semantic/src/types/typed_dict.rs b/crates/ty_python_semantic/src/types/typed_dict.rs
index b2180f9dd6..dee49a3afe 100644
--- a/crates/ty_python_semantic/src/types/typed_dict.rs
+++ b/crates/ty_python_semantic/src/types/typed_dict.rs
@@ -21,8 +21,8 @@ use crate::types::class::FieldKind;
 use crate::types::constraints::{ConstraintSet, IteratorConstraintsExtension};
 use crate::types::generics::InferableTypeVars;
 use crate::types::{
-    HasRelationToVisitor, IsDisjointVisitor, IsEquivalentVisitor, NormalizedVisitor, OnlyReorder,
-    TypeContext, TypeRelation,
+    HasRelationToVisitor, IsDisjointVisitor, IsEquivalentVisitor, NormalizedVisitor, TypeContext,
+    TypeRelation,
 };
 
 use ordermap::OrderSet;
@@ -298,19 +298,14 @@ impl<'db> TypedDictType<'db> {
         }
     }
 
-    pub(crate) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         match self {
             TypedDictType::Class(_) => {
                 let synthesized = SynthesizedTypedDictType::new(db, self.items(db));
-                TypedDictType::Synthesized(synthesized.normalized_impl(db, only_reorder, visitor))
+                TypedDictType::Synthesized(synthesized.normalized_impl(db, visitor))
             }
             TypedDictType::Synthesized(synthesized) => {
-                TypedDictType::Synthesized(synthesized.normalized_impl(db, only_reorder, visitor))
+                TypedDictType::Synthesized(synthesized.normalized_impl(db, visitor))
             }
         }
     }
@@ -773,17 +768,12 @@ impl<'db> SynthesizedTypedDictType<'db> {
         SynthesizedTypedDictType::new(db, items)
     }
 
-    pub(crate) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         let items = self
             .items(db)
             .iter()
             .map(|(name, field)| {
-                let field = field.clone().normalized_impl(db, only_reorder, visitor);
+                let field = field.clone().normalized_impl(db, visitor);
                 (name.clone(), field)
             })
             .collect::<TypedDictSchema<'db>>();
@@ -855,14 +845,9 @@ impl<'db> TypedDictField<'db> {
         }
     }
 
-    pub(crate) fn normalized_impl(
-        self,
-        db: &'db dyn Db,
-        only_reorder: OnlyReorder,
-        visitor: &NormalizedVisitor<'db>,
-    ) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &NormalizedVisitor<'db>) -> Self {
         Self {
-            declared_ty: self.declared_ty.normalized_impl(db, only_reorder, visitor),
+            declared_ty: self.declared_ty.normalized_impl(db, visitor),
             flags: self.flags,
             // A normalized typed-dict field does not hold onto the original declaration,
             // since a normalized typed-dict is an abstract type where equality does not depend