From 3d201a18187a74579e6b68f05d13496d696a4704 Mon Sep 17 00:00:00 2001
From: Gianluca Ficarelli <gianluca.ficarelli@epfl.ch>
Date: Fri, 26 May 2023 10:29:16 +0200
Subject: [PATCH 1/8] PERF: Do not init cache in RangeIndex.take

Improve performance when passing an array to RangeIndex.take, DataFrame.loc, or DataFrame.iloc and the DataFrame is using a RangeIndex
---
 doc/source/whatsnew/v2.0.2.rst               |  1 +
 pandas/core/indexes/base.py                  |  5 ++-
 pandas/core/indexes/range.py                 | 41 ++++++++++++++++++++
 pandas/tests/indexes/ranges/test_indexing.py | 36 +++++++++++++++++
 pandas/tests/indexes/ranges/test_range.py    | 18 +++++++++
 5 files changed, 100 insertions(+), 1 deletion(-)

diff --git a/doc/source/whatsnew/v2.0.2.rst b/doc/source/whatsnew/v2.0.2.rst
index 559078d501a00..a10d63ae93353 100644
--- a/doc/source/whatsnew/v2.0.2.rst
+++ b/doc/source/whatsnew/v2.0.2.rst
@@ -46,6 +46,7 @@ Bug fixes
 
 Other
 ~~~~~
+- Improved performance when passing an array to :meth:`RangeIndex.take`, :meth:`DataFrame.loc`, or :meth:`DataFrame.iloc` and the DataFrame is using a RangeIndex (:issue:`53387`)
 - Raised a better error message when calling :func:`Series.dt.to_pydatetime` with :class:`ArrowDtype` with ``pyarrow.date32`` or ``pyarrow.date64`` type (:issue:`52812`)
 
 .. ---------------------------------------------------------------------------
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 4b6b59898c199..e273d8c798e03 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -1162,7 +1162,6 @@ def take(
             taken = values.take(
                 indices, allow_fill=allow_fill, fill_value=self._na_value
             )
-        # _constructor so RangeIndex-> Index with an int64 dtype
         return self._constructor._simple_new(taken, name=self.name)
 
     @final
@@ -5560,6 +5559,10 @@ def equals(self, other: Any) -> bool:
         if not isinstance(other, Index):
             return False
 
+        if len(self) != len(other):
+            # quickly return if the lengths are different
+            return False
+
         if is_object_dtype(self.dtype) and not is_object_dtype(other.dtype):
             # if other is not object, use other's logic for coercion
             return other.equals(self)
diff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py
index ca415d2089ecf..8700d1f21d33e 100644
--- a/pandas/core/indexes/range.py
+++ b/pandas/core/indexes/range.py
@@ -50,6 +50,7 @@
 
 if TYPE_CHECKING:
     from pandas._typing import (
+        Axis,
         Dtype,
         NaPosition,
         Self,
@@ -1105,3 +1106,43 @@ def _arith_method(self, other, op):
         except (ValueError, TypeError, ZeroDivisionError):
             # test_arithmetic_explicit_conversions
             return super()._arith_method(other, op)
+
+    def take(
+        self,
+        indices,
+        axis: Axis = 0,
+        allow_fill: bool = True,
+        fill_value=None,
+        **kwargs,
+    ):
+        if kwargs:
+            nv.validate_take((), kwargs)
+        if is_scalar(indices):
+            raise TypeError("Expected indices to be array-like")
+        indices = ensure_platform_int(indices)
+        allow_fill = self._maybe_disallow_fill(allow_fill, fill_value, indices)
+        assert allow_fill is False, "allow_fill isn't supported by RangeIndex"
+
+        if len(indices) == 0:
+            taken = np.array([], dtype=self.dtype)
+        else:
+            ind_max = indices.max()
+            if ind_max >= len(self):
+                raise IndexError(
+                    f"index {ind_max} is out of bounds for axis 0 with size {len(self)}"
+                )
+            ind_min = indices.min()
+            if ind_min < -len(self):
+                raise IndexError(
+                    f"index {ind_min} is out of bounds for axis 0 with size {len(self)}"
+                )
+            taken = indices.astype(self.dtype, casting="safe")
+            if ind_min < 0:
+                taken %= len(self)
+            if self.step != 1:
+                taken *= self.step
+            if self.start != 0:
+                taken += self.start
+
+        # _constructor so RangeIndex-> Index with an int64 dtype
+        return self._constructor._simple_new(taken, name=self.name)
diff --git a/pandas/tests/indexes/ranges/test_indexing.py b/pandas/tests/indexes/ranges/test_indexing.py
index 84a78ad86c3d3..9596c664a96cf 100644
--- a/pandas/tests/indexes/ranges/test_indexing.py
+++ b/pandas/tests/indexes/ranges/test_indexing.py
@@ -76,10 +76,46 @@ def test_take_fill_value(self):
         with pytest.raises(ValueError, match=msg):
             idx.take(np.array([1, 0, -5]), fill_value=True)
 
+    def test_take_raises_index_error(self):
+        idx = RangeIndex(1, 4, name="xxx")
+
         msg = "index -5 is out of bounds for (axis 0 with )?size 3"
         with pytest.raises(IndexError, match=msg):
             idx.take(np.array([1, -5]))
 
+        msg = "index -4 is out of bounds for (axis 0 with )?size 3"
+        with pytest.raises(IndexError, match=msg):
+            idx.take(np.array([1, -4]))
+
+        # no errors
+        result = idx.take(np.array([1, -3]))
+        expected = Index([2, 1], dtype=np.int64, name="xxx")
+        tm.assert_index_equal(result, expected)
+
+    def test_take_accepts_empty_array(self):
+        idx = RangeIndex(1, 4, name="foo")
+        result = idx.take(np.array([]))
+        expected = Index([], dtype=np.int64, name="foo")
+        tm.assert_index_equal(result, expected)
+
+        # empty index
+        idx = RangeIndex(0, name="foo")
+        result = idx.take(np.array([]))
+        expected = Index([], dtype=np.int64, name="foo")
+        tm.assert_index_equal(result, expected)
+
+    def test_take_accepts_non_int64_array(self):
+        idx = RangeIndex(1, 4, name="foo")
+        result = idx.take(np.array([2, 1], dtype=np.uint32))
+        expected = Index([3, 2], dtype=np.int64, name="foo")
+        tm.assert_index_equal(result, expected)
+
+    def test_take_when_index_has_step(self):
+        idx = RangeIndex(1, 11, 3, name="foo")  # [1, 4, 7, 10]
+        result = idx.take(np.array([1, 0, -1, -4]))
+        expected = Index([4, 1, 10, 1], dtype=np.int64, name="foo")
+        tm.assert_index_equal(result, expected)
+
 
 class TestWhere:
     def test_where_putmask_range_cast(self):
diff --git a/pandas/tests/indexes/ranges/test_range.py b/pandas/tests/indexes/ranges/test_range.py
index 06ad1f3c865c8..5d2069252f832 100644
--- a/pandas/tests/indexes/ranges/test_range.py
+++ b/pandas/tests/indexes/ranges/test_range.py
@@ -272,6 +272,24 @@ def test_cache(self):
         expected = np.arange(0, 100, 10, dtype="int64")
         tm.assert_numpy_array_equal(idx._cache["_data"], expected)
 
+    def test_cache_after_calling_loc_with_array(self):
+        # GH 53387
+        # the cache will contain a _constructor key, so it should be tested separately
+        idx = RangeIndex(0, 100, 10)
+        df = pd.DataFrame({"a": range(10)}, index=idx)
+
+        assert "_data" not in idx._cache
+
+        # take is internally called by loc, but it's also tested explicitly
+        idx.take([3, 0, 1])
+        assert "_data" not in idx._cache
+
+        df.loc[[50]]
+        assert "_data" not in idx._cache
+
+        df.iloc[[5, 6, 7, 8, 9]]
+        assert "_data" not in idx._cache
+
     def test_is_monotonic(self):
         index = RangeIndex(0, 20, 2)
         assert index.is_monotonic_increasing is True

From f8d95ff2c55b1b68578024153f24e3bbb2e5a84c Mon Sep 17 00:00:00 2001
From: Gianluca Ficarelli <gianluca.ficarelli@epfl.ch>
Date: Tue, 30 May 2023 15:00:34 +0200
Subject: [PATCH 2/8] Explicitly raise ValueError in RangeIndex.take when
 allow_fill is True and fill_value is not None

---
 pandas/core/indexes/range.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py
index 8700d1f21d33e..8e8a57cd227d1 100644
--- a/pandas/core/indexes/range.py
+++ b/pandas/core/indexes/range.py
@@ -1120,8 +1120,14 @@ def take(
         if is_scalar(indices):
             raise TypeError("Expected indices to be array-like")
         indices = ensure_platform_int(indices)
-        allow_fill = self._maybe_disallow_fill(allow_fill, fill_value, indices)
-        assert allow_fill is False, "allow_fill isn't supported by RangeIndex"
+
+        # If allow_fill=True and fill_value=None, just ignore allow_fill,
+        # without raising an exception, as it's done in the base class.
+        if allow_fill and fill_value is not None:
+            cls_name = type(self).__name__
+            raise ValueError(
+                f"Unable to fill values because {cls_name} cannot contain NA"
+            )
 
         if len(indices) == 0:
             taken = np.array([], dtype=self.dtype)

From cf37945596ca7c6bbf6eeb65a158e2ebe7f732b2 Mon Sep 17 00:00:00 2001
From: Gianluca Ficarelli <gianluca.ficarelli@epfl.ch>
Date: Tue, 30 May 2023 15:00:48 +0200
Subject: [PATCH 3/8] Add test_take_when_index_has_negative_step

---
 pandas/tests/indexes/ranges/test_indexing.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/pandas/tests/indexes/ranges/test_indexing.py b/pandas/tests/indexes/ranges/test_indexing.py
index 9596c664a96cf..6202074a11d78 100644
--- a/pandas/tests/indexes/ranges/test_indexing.py
+++ b/pandas/tests/indexes/ranges/test_indexing.py
@@ -116,6 +116,12 @@ def test_take_when_index_has_step(self):
         expected = Index([4, 1, 10, 1], dtype=np.int64, name="foo")
         tm.assert_index_equal(result, expected)
 
+    def test_take_when_index_has_negative_step(self):
+        idx = RangeIndex(11, -4, -2, name="foo")  # [11, 9, 7, 5, 3, 1, -1, -3]
+        result = idx.take(np.array([1, 0, -1, -8]))
+        expected = Index([9, 11, -3, 11], dtype=np.int64, name="foo")
+        tm.assert_index_equal(result, expected)
+
 
 class TestWhere:
     def test_where_putmask_range_cast(self):

From 1c44210783db8fcdf6eed5ca957f5e9ddedcb38d Mon Sep 17 00:00:00 2001
From: Gianluca Ficarelli <gianluca.ficarelli@epfl.ch>
Date: Tue, 30 May 2023 16:30:41 +0200
Subject: [PATCH 4/8] Override RangeIndex._find_common_type_compat

---
 pandas/core/indexes/base.py  |  1 -
 pandas/core/indexes/range.py | 24 ++++++++++++++++++++++++
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index e273d8c798e03..5d885dc075e34 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -6273,7 +6273,6 @@ def _maybe_promote(self, other: Index) -> tuple[Index, Index]:
 
         return self, other
 
-    @final
     def _find_common_type_compat(self, target) -> DtypeObj:
         """
         Implementation of find_common_type that adjusts for Index-specific
diff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py
index 8e8a57cd227d1..6f6b6f8af1aa6 100644
--- a/pandas/core/indexes/range.py
+++ b/pandas/core/indexes/range.py
@@ -28,6 +28,10 @@
     doc,
 )
 
+from pandas.core.dtypes.cast import (
+    find_common_type,
+    infer_dtype_from,
+)
 from pandas.core.dtypes.common import (
     ensure_platform_int,
     ensure_python_int,
@@ -52,12 +56,14 @@
     from pandas._typing import (
         Axis,
         Dtype,
+        DtypeObj,
         NaPosition,
         Self,
         npt,
     )
 _empty_range = range(0)
 _dtype_int64 = np.dtype(np.int64)
+_dtype_obj = np.dtype("object")
 
 
 class RangeIndex(Index):
@@ -1152,3 +1158,21 @@ def take(
 
         # _constructor so RangeIndex-> Index with an int64 dtype
         return self._constructor._simple_new(taken, name=self.name)
+
+    def _find_common_type_compat(self, target) -> DtypeObj:
+        target_dtype, _ = infer_dtype_from(target)
+
+        # special case: if one dtype is uint64 and the other a signed int, return object
+        # See https://github.com/pandas-dev/pandas/issues/26778 for discussion
+        # Now it's:
+        # * float | [u]int -> float
+        # * uint64 | signed int  -> object
+        # We may change union(float | [u]int) to go to object.
+        if self.dtype == "uint64" or target_dtype == "uint64":
+            if is_signed_integer_dtype(self.dtype) or is_signed_integer_dtype(
+                target_dtype
+            ):
+                return _dtype_obj
+
+        dtype = find_common_type([self.dtype, target_dtype])
+        return dtype

From 4cc6809490960154694dc8e300c72d476ba21e33 Mon Sep 17 00:00:00 2001
From: Gianluca Ficarelli <gianluca.ficarelli@epfl.ch>
Date: Mon, 3 Jul 2023 11:18:54 +0200
Subject: [PATCH 5/8] Revert "Override RangeIndex._find_common_type_compat"

This reverts commit 102644c04cc7f7a8efb57955414331663078cd52.
---
 pandas/core/indexes/base.py  |  1 +
 pandas/core/indexes/range.py | 24 ------------------------
 2 files changed, 1 insertion(+), 24 deletions(-)

diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 5d885dc075e34..e273d8c798e03 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -6273,6 +6273,7 @@ def _maybe_promote(self, other: Index) -> tuple[Index, Index]:
 
         return self, other
 
+    @final
     def _find_common_type_compat(self, target) -> DtypeObj:
         """
         Implementation of find_common_type that adjusts for Index-specific
diff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py
index 6f6b6f8af1aa6..8e8a57cd227d1 100644
--- a/pandas/core/indexes/range.py
+++ b/pandas/core/indexes/range.py
@@ -28,10 +28,6 @@
     doc,
 )
 
-from pandas.core.dtypes.cast import (
-    find_common_type,
-    infer_dtype_from,
-)
 from pandas.core.dtypes.common import (
     ensure_platform_int,
     ensure_python_int,
@@ -56,14 +52,12 @@
     from pandas._typing import (
         Axis,
         Dtype,
-        DtypeObj,
         NaPosition,
         Self,
         npt,
     )
 _empty_range = range(0)
 _dtype_int64 = np.dtype(np.int64)
-_dtype_obj = np.dtype("object")
 
 
 class RangeIndex(Index):
@@ -1158,21 +1152,3 @@ def take(
 
         # _constructor so RangeIndex-> Index with an int64 dtype
         return self._constructor._simple_new(taken, name=self.name)
-
-    def _find_common_type_compat(self, target) -> DtypeObj:
-        target_dtype, _ = infer_dtype_from(target)
-
-        # special case: if one dtype is uint64 and the other a signed int, return object
-        # See https://github.com/pandas-dev/pandas/issues/26778 for discussion
-        # Now it's:
-        # * float | [u]int -> float
-        # * uint64 | signed int  -> object
-        # We may change union(float | [u]int) to go to object.
-        if self.dtype == "uint64" or target_dtype == "uint64":
-            if is_signed_integer_dtype(self.dtype) or is_signed_integer_dtype(
-                target_dtype
-            ):
-                return _dtype_obj
-
-        dtype = find_common_type([self.dtype, target_dtype])
-        return dtype

From 483333d07b82a096e71b7a0748945cc42699a861 Mon Sep 17 00:00:00 2001
From: Gianluca Ficarelli <gianluca.ficarelli@epfl.ch>
Date: Mon, 3 Jul 2023 13:35:13 +0200
Subject: [PATCH 6/8] Change find_result_type to take a dtype instead of values

---
 doc/source/whatsnew/v2.0.2.rst              |  1 -
 doc/source/whatsnew/v2.1.0.rst              |  1 +
 pandas/core/dtypes/cast.py                  | 28 ++++++++++-----------
 pandas/core/indexes/base.py                 |  2 +-
 pandas/core/internals/blocks.py             |  2 +-
 pandas/tests/indexes/numeric/test_setops.py | 11 ++++++++
 6 files changed, 27 insertions(+), 18 deletions(-)

diff --git a/doc/source/whatsnew/v2.0.2.rst b/doc/source/whatsnew/v2.0.2.rst
index a10d63ae93353..559078d501a00 100644
--- a/doc/source/whatsnew/v2.0.2.rst
+++ b/doc/source/whatsnew/v2.0.2.rst
@@ -46,7 +46,6 @@ Bug fixes
 
 Other
 ~~~~~
-- Improved performance when passing an array to :meth:`RangeIndex.take`, :meth:`DataFrame.loc`, or :meth:`DataFrame.iloc` and the DataFrame is using a RangeIndex (:issue:`53387`)
 - Raised a better error message when calling :func:`Series.dt.to_pydatetime` with :class:`ArrowDtype` with ``pyarrow.date32`` or ``pyarrow.date64`` type (:issue:`52812`)
 
 .. ---------------------------------------------------------------------------
diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index 44e091e12bfa6..57cbccaf0c35f 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -408,6 +408,7 @@ Performance improvements
 - Performance improvement in various :class:`MultiIndex` set and indexing operations (:issue:`53955`)
 - Performance improvement when doing various reshaping operations on :class:`arrays.IntegerArrays` & :class:`arrays.FloatingArray` by avoiding doing unnecessary validation (:issue:`53013`)
 - Performance improvement when indexing with pyarrow timestamp and duration dtypes (:issue:`53368`)
+- Performance improvement when passing an array to :meth:`RangeIndex.take`, :meth:`DataFrame.loc`, or :meth:`DataFrame.iloc` and the DataFrame is using a RangeIndex (:issue:`53387`)
 -
 
 .. ---------------------------------------------------------------------------
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index 344a6c2be7a2a..09105bf49c050 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -1266,17 +1266,17 @@ def _ensure_nanosecond_dtype(dtype: DtypeObj) -> None:
 
 # TODO: other value-dependent functions to standardize here include
 #  Index._find_common_type_compat
-def find_result_type(left: ArrayLike, right: Any) -> DtypeObj:
+def find_result_type(left_dtype: DtypeObj, right: Any) -> DtypeObj:
     """
-    Find the type/dtype for a the result of an operation between these objects.
+    Find the type/dtype for the result of an operation between objects.
 
-    This is similar to find_common_type, but looks at the objects instead
-    of just their dtypes. This can be useful in particular when one of the
-    objects does not have a `dtype`.
+    This is similar to find_common_type, but looks at the right object instead
+    of just its dtype. This can be useful in particular when the right
+    object does not have a `dtype`.
 
     Parameters
     ----------
-    left : np.ndarray or ExtensionArray
+    left_dtype : np.dtype or ExtensionDtype
     right : Any
 
     Returns
@@ -1291,26 +1291,24 @@ def find_result_type(left: ArrayLike, right: Any) -> DtypeObj:
     new_dtype: DtypeObj
 
     if (
-        isinstance(left, np.ndarray)
-        and left.dtype.kind in "iuc"
+        isinstance(left_dtype, np.dtype)
+        and left_dtype.kind in "iuc"
         and (lib.is_integer(right) or lib.is_float(right))
     ):
         # e.g. with int8 dtype and right=512, we want to end up with
         # np.int16, whereas infer_dtype_from(512) gives np.int64,
         #  which will make us upcast too far.
-        if lib.is_float(right) and right.is_integer() and left.dtype.kind != "f":
+        if lib.is_float(right) and right.is_integer() and left_dtype.kind != "f":
             right = int(right)
+        new_dtype = np.result_type(left_dtype, right)
 
-        new_dtype = np.result_type(left, right)
-
-    elif is_valid_na_for_dtype(right, left.dtype):
+    elif is_valid_na_for_dtype(right, left_dtype):
         # e.g. IntervalDtype[int] and None/np.nan
-        new_dtype = ensure_dtype_can_hold_na(left.dtype)
+        new_dtype = ensure_dtype_can_hold_na(left_dtype)
 
     else:
         dtype, _ = infer_dtype_from(right)
-
-        new_dtype = find_common_type([left.dtype, dtype])
+        new_dtype = find_common_type([left_dtype, dtype])
 
     return new_dtype
 
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index e273d8c798e03..bee0eb842c38f 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -6293,7 +6293,7 @@ def _find_common_type_compat(self, target) -> DtypeObj:
             ):
                 return _dtype_obj
 
-        dtype = find_result_type(self._values, target)
+        dtype = find_result_type(self.dtype, target)
         dtype = common_dtype_categorical_compat([self, target], dtype)
         return dtype
 
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index f649319a9e955..347b7417543ae 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -449,7 +449,7 @@ def coerce_to_target_dtype(self, other) -> Block:
         we can also safely try to coerce to the same dtype
         and will receive the same block
         """
-        new_dtype = find_result_type(self.values, other)
+        new_dtype = find_result_type(self.values.dtype, other)
 
         return self.astype(new_dtype, copy=False)
 
diff --git a/pandas/tests/indexes/numeric/test_setops.py b/pandas/tests/indexes/numeric/test_setops.py
index 2276b10db1fe3..d3789f2477896 100644
--- a/pandas/tests/indexes/numeric/test_setops.py
+++ b/pandas/tests/indexes/numeric/test_setops.py
@@ -74,6 +74,17 @@ def test_range_float_union_dtype(self):
         result = other.union(index)
         tm.assert_index_equal(result, expected)
 
+    def test_range_uint64_union_dtype(self):
+        # https://github.com/pandas-dev/pandas/issues/26778
+        index = RangeIndex(start=0, stop=3)
+        other = Index([0, 10], dtype=np.uint64)
+        result = index.union(other)
+        expected = Index([0, 1, 2, 10], dtype=object)
+        tm.assert_index_equal(result, expected)
+
+        result = other.union(index)
+        tm.assert_index_equal(result, expected)
+
     def test_float64_index_difference(self):
         # https://github.com/pandas-dev/pandas/issues/35217
         float_index = Index([1.0, 2, 3])

From b677053a6886e7b2ce90ecaac94ebae0c9b4ce4e Mon Sep 17 00:00:00 2001
From: Gianluca Ficarelli <gianluca.ficarelli@epfl.ch>
Date: Wed, 12 Jul 2023 17:01:12 +0200
Subject: [PATCH 7/8] Call _maybe_disallow_fill

---
 pandas/core/indexes/range.py | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py
index 8e8a57cd227d1..1e8a3851b406e 100644
--- a/pandas/core/indexes/range.py
+++ b/pandas/core/indexes/range.py
@@ -1121,13 +1121,8 @@ def take(
             raise TypeError("Expected indices to be array-like")
         indices = ensure_platform_int(indices)
 
-        # If allow_fill=True and fill_value=None, just ignore allow_fill,
-        # without raising an exception, as it's done in the base class.
-        if allow_fill and fill_value is not None:
-            cls_name = type(self).__name__
-            raise ValueError(
-                f"Unable to fill values because {cls_name} cannot contain NA"
-            )
+        # raise an exception if allow_fill is True and fill_value is not None
+        self._maybe_disallow_fill(allow_fill, fill_value, indices)
 
         if len(indices) == 0:
             taken = np.array([], dtype=self.dtype)

From 637d1684fe289f133ff7d38fa0ceb7f7a76e7acb Mon Sep 17 00:00:00 2001
From: Gianluca Ficarelli <gianluca.ficarelli@epfl.ch>
Date: Thu, 13 Jul 2023 16:16:46 +0200
Subject: [PATCH 8/8] Move checks from test_cache_after_calling_loc_with_array
 to test_cache

---
 pandas/tests/indexes/ranges/test_range.py | 28 ++++++++---------------
 1 file changed, 10 insertions(+), 18 deletions(-)

diff --git a/pandas/tests/indexes/ranges/test_range.py b/pandas/tests/indexes/ranges/test_range.py
index 5d2069252f832..1ec78cf494a0c 100644
--- a/pandas/tests/indexes/ranges/test_range.py
+++ b/pandas/tests/indexes/ranges/test_range.py
@@ -210,7 +210,7 @@ def test_dtype(self, simple_index):
         assert index.dtype == np.int64
 
     def test_cache(self):
-        # GH 26565, GH26617, GH35432
+        # GH 26565, GH26617, GH35432, GH53387
         # This test checks whether _cache has been set.
         # Calling RangeIndex._cache["_data"] creates an int64 array of the same length
         # as the RangeIndex and stores it in _cache.
@@ -264,23 +264,7 @@ def test_cache(self):
         df.iloc[5:10]
         assert idx._cache == {}
 
-        # idx._cache should contain a _data entry after call to idx._data
-        idx._data
-        assert isinstance(idx._data, np.ndarray)
-        assert idx._data is idx._data  # check cached value is reused
-        assert len(idx._cache) == 1
-        expected = np.arange(0, 100, 10, dtype="int64")
-        tm.assert_numpy_array_equal(idx._cache["_data"], expected)
-
-    def test_cache_after_calling_loc_with_array(self):
-        # GH 53387
-        # the cache will contain a _constructor key, so it should be tested separately
-        idx = RangeIndex(0, 100, 10)
-        df = pd.DataFrame({"a": range(10)}, index=idx)
-
-        assert "_data" not in idx._cache
-
-        # take is internally called by loc, but it's also tested explicitly
+        # after calling take, _cache may contain other keys, but not "_data"
         idx.take([3, 0, 1])
         assert "_data" not in idx._cache
 
@@ -290,6 +274,14 @@ def test_cache_after_calling_loc_with_array(self):
         df.iloc[[5, 6, 7, 8, 9]]
         assert "_data" not in idx._cache
 
+        # idx._cache should contain a _data entry after call to idx._data
+        idx._data
+        assert isinstance(idx._data, np.ndarray)
+        assert idx._data is idx._data  # check cached value is reused
+        assert "_data" in idx._cache
+        expected = np.arange(0, 100, 10, dtype="int64")
+        tm.assert_numpy_array_equal(idx._cache["_data"], expected)
+
     def test_is_monotonic(self):
         index = RangeIndex(0, 20, 2)
         assert index.is_monotonic_increasing is True