BUG: fix DatetimeIndex union across DST without disabling range fast path

Author: antznette1

pandas/core/indexes/datetimelike.py

@@ -541,14 +541,7 @@ def _as_range_index(self) -> RangeIndex:
         return RangeIndex(rng)
 
     def _can_range_setop(self, other) -> bool:
-        # Only allow range-based setops when both objects are tick-based AND
-        # not timezone-aware. For tz-aware DatetimeIndex, constant i8 stepping
-        # does not hold across DST transitions in local time, so avoid range path.
-        if not (isinstance(self.freq, Tick) and isinstance(other.freq, Tick)):
-            return False
-        self_tz = getattr(self.dtype, "tz", None)
-        other_tz = getattr(other.dtype, "tz", None)
-        return self_tz is None and other_tz is None
+        return isinstance(self.freq, Tick) and isinstance(other.freq, Tick)
 
     def _wrap_range_setop(self, other, res_i8) -> Self:
         new_freq = None
@@ -724,6 +717,35 @@ def _union(self, other, sort):
         assert isinstance(other, type(self))
         assert self.dtype == other.dtype
 
+        # For tz-aware DatetimeIndex, perform union in UTC to avoid
+        # local-time irregularities across DST transitions, then convert back.
+        tz = getattr(self.dtype, "tz", None)
+        if tz is not None:
+            other_tz = getattr(other.dtype, "tz", None)
+            if (
+                other_tz == tz
+                and isinstance(self._data, DatetimeArray)
+                and isinstance(other._data, DatetimeArray)
+            ):
+                left_utc_naive = self._data.tz_convert("UTC").tz_localize(None)
+                right_utc_naive = other._data.tz_convert("UTC").tz_localize(None)
+                left_naive = type(self)._simple_new(left_utc_naive, name=self.name)
+                right_naive = type(other)._simple_new(right_utc_naive, name=other.name)
+                res_naive = super(type(left_naive), left_naive)._union(
+                    right_naive, sort
+                )
+
+                if isinstance(res_naive, DatetimeArray):
+                    base_arr = res_naive
+                    name = self.name
+                else:
+                    base_arr = cast(DatetimeArray, res_naive._data)
+                    name = res_naive.name
+
+                res_arr = base_arr.tz_localize("UTC").tz_convert(tz)
+                res = type(self)._simple_new(res_arr, name=name)
+                return res._with_freq("infer")
+
         if self._can_range_setop(other):
             return self._range_union(other, sort=sort)
 
@@ -733,39 +755,6 @@ def _union(self, other, sort):
             #  that result.freq == self.freq
             return result
         else:
-            # For tz-aware DatetimeIndex, perform union in UTC to avoid
-            # local-time irregularities across DST transitions, then convert back.
-            tz = getattr(self.dtype, "tz", None)
-            other_tz = getattr(other.dtype, "tz", None)
-            if tz is not None and tz == other_tz:
-                # Narrow to DatetimeArray to access tz_convert without mypy errors
-                if isinstance(self._data, DatetimeArray) and isinstance(
-                    other._data, DatetimeArray
-                ):
-                    # Convert both to UTC, then drop tz to avoid re-entering
-                    # tz-aware path
-                    left_utc_naive = self._data.tz_convert("UTC").tz_localize(None)
-                    right_utc_naive = other._data.tz_convert("UTC").tz_localize(None)
-                    left_naive = type(self)._simple_new(left_utc_naive, name=self.name)
-                    right_naive = type(other)._simple_new(
-                        right_utc_naive, name=other.name
-                    )
-                    # Perform base union on tz-naive indices to avoid DST complications
-                    res_naive = super(type(left_naive), left_naive)._union(
-                        right_naive, sort
-                    )
-                    # Localize back to UTC and then convert to original tz
-                    if isinstance(res_naive, DatetimeArray):
-                        base_arr = res_naive
-                        name = self.name
-                    else:
-                        base_arr = cast(DatetimeArray, res_naive._data)
-                        name = res_naive.name
-                    res_arr = base_arr.tz_localize("UTC").tz_convert(tz)
-                    res = type(self)._simple_new(res_arr, name=name)
-                    return res._with_freq("infer")
-                # Defensive fallback if types are unexpected
-                return super()._union(other, sort)
             return super()._union(other, sort)._with_freq("infer")
 
     # --------------------------------------------------------------------