REF: relocate _freq storage from DTA/TDA arrays to Index (GH#24566) (#65322)

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jbrockmendel

pandas/core/arrays/datetimes.py

@@ -547,9 +547,7 @@ def _generate_range(
 
         dt64_values = i8values.view(f"datetime64[{unit}]")
         dtype = tz_to_dtype(tz, unit=unit)
-        result = cls._simple_new(dt64_values, dtype=dtype)
-        result._freq = freq
-        return result
+        return cls._simple_new(dt64_values, dtype=dtype)
 
     # -----------------------------------------------------------------
     # DatetimeLike Interface

pandas/core/arrays/period.py

@@ -977,6 +977,23 @@ def to_timestamp(self, freq=None, how: str = "start") -> DatetimeArray:
         new_data = libperiod.periodarr_to_dt64arr(new_parr.asi8, base)
         dta = DatetimeArray._from_sequence(new_data, dtype=new_data.dtype)
         assert dta.unit == unit
+        return dta
+
+    def _to_timestamp_freq(
+        self, dta: DatetimeArray, target_freq, how: str
+    ) -> BaseOffset | None:
+        """
+        Determine the freq to stamp on the DatetimeArray returned by
+        ``self.to_timestamp(target_freq, how)``.
+
+        Called by ``PeriodIndex.to_timestamp`` so the array-level
+        ``to_timestamp`` can return a bare DatetimeArray.
+        """
+        how = libperiod.validate_end_alias(how)
+        if how == "E":
+            # For the "end" case, to_timestamp routes through arithmetic that
+            # does not preserve freq; match that behavior here.
+            return None
 
         if self.freq.rule_code == "B":
             # See if we can retain BDay instead of Day in cases where
@@ -985,22 +1002,23 @@ def to_timestamp(self, freq=None, how: str = "start") -> DatetimeArray:
             if len(diffs) == 1:
                 diff = diffs[0]
                 if diff == self.dtype._n:
-                    dta._freq = self.freq
+                    return self.freq
                 elif diff == 1:
-                    dta._freq = self.freq.base
+                    return self.freq.base
                 # TODO: other cases?
-            return dta
-        else:
-            dta._freq = to_offset(dta.inferred_freq)
-            if freq is not None:
-                freq = to_offset(freq)
-                if (
-                    isinstance(dta.freq, Day)
-                    and not isinstance(freq, Day)
-                    and Timedelta(freq) == Timedelta(days=dta.freq.n)
-                ):
-                    dta._freq = freq
-            return dta
+            return None
+
+        result_freq = to_offset(dta.inferred_freq)
+        if target_freq is not None:
+            # match the normalization applied in to_timestamp
+            target_freq = Period._maybe_convert_freq(target_freq)
+            if (
+                isinstance(result_freq, Day)
+                and not isinstance(target_freq, Day)
+                and Timedelta(target_freq) == Timedelta(days=result_freq.n)
+            ):
+                result_freq = target_freq
+        return result_freq
 
     # --------------------------------------------------------------------
 

pandas/core/arrays/timedeltas.py

@@ -307,9 +307,7 @@ def _generate_range(
             index = index[:-1]
 
         td64values = index.view(f"m8[{unit}]")
-        result = cls._simple_new(td64values, dtype=td64values.dtype)
-        result._freq = freq
-        return result
+        return cls._simple_new(td64values, dtype=td64values.dtype)
 
     # ----------------------------------------------------------------
     # DatetimeLike Interface

pandas/core/groupby/grouper.py

@@ -681,7 +681,9 @@ def _codes_and_uniques(self) -> tuple[npt.NDArray[np.signedinteger], ArrayLike]:
         elif isinstance(self.grouping_vector, ops.BaseGrouper):
             # we have a list of groupers
             codes = self.grouping_vector.codes_info
-            uniques = self.grouping_vector.result_index._values
+            # Pass the full Index (not ._values) so DatetimeIndex/TimedeltaIndex
+            # freq survives the trip through _with_infer.
+            uniques = self.grouping_vector.result_index  # type: ignore[assignment]
         elif self._uniques is not None:
             # GH#50486 Code grouping_vector using _uniques; allows
             # including uniques that are not present in grouping_vector.

pandas/core/indexes/base.py

@@ -586,7 +586,14 @@ def __new__(
         klass = cls._dtype_to_subclass(arr.dtype)
 
         arr = klass._ensure_array(arr, arr.dtype, copy=False)
-        return klass._simple_new(arr, name, refs=refs)  # type: ignore[return-value]  # pyright: ignore[reportReturnType]
+        out = klass._simple_new(arr, name, refs=refs)
+        # Preserve freq when wrapping a DatetimeIndex/TimedeltaIndex input,
+        # since _simple_new doesn't copy Index-level attributes like _freq.
+        if isinstance(data, (ABCDatetimeIndex, ABCTimedeltaIndex)) and isinstance(
+            out, (ABCDatetimeIndex, ABCTimedeltaIndex)
+        ):
+            out._freq = data._freq
+        return out  # type: ignore[return-value]  # pyright: ignore[reportReturnType]
 
     @classmethod
     def _ensure_array(cls, data: ArrayLike, dtype: DtypeObj, copy: bool) -> ArrayLike: