CLN: Implement multiindex handling for get_op_result_name

pandas/core/indexes/base.py

@@ -2580,7 +2580,6 @@ def __nonzero__(self):
     # --------------------------------------------------------------------
     # Set Operation Methods
 
-    @final
     def _get_reconciled_name_object(self, other):
         """
         If the result of a set operation will be self,

pandas/core/indexes/multi.py

@@ -56,6 +56,7 @@
 from pandas.core.indexes.frozen import FrozenList
 from pandas.core.indexes.numeric import Int64Index
 import pandas.core.missing as missing
+from pandas.core.ops.common import maybe_match_names_multiindex
 from pandas.core.ops.invalid import make_invalid_op
 from pandas.core.sorting import (
     get_group_index,
@@ -3591,6 +3592,17 @@ def _union(self, other, sort):
     def _is_comparable_dtype(self, dtype: DtypeObj) -> bool:
         return is_object_dtype(dtype)
 
+    def _get_reconciled_name_object(self, other):
+        """
+        If the result of a set operation will be self,
+        return self, unless the names change, in which
+        case make a shallow copy of self.
+        """
+        names = maybe_match_names_multiindex(self, other)
+        if self.names != names:
+            return self.rename(names)
+        return self
+
     def intersection(self, other, sort=False):
         """
         Form the intersection of two MultiIndex objects.
@@ -3614,12 +3626,12 @@ def intersection(self, other, sort=False):
         """
         self._validate_sort_keyword(sort)
         self._assert_can_do_setop(other)
-        other, result_names = self._convert_can_do_setop(other)
+        other, _ = self._convert_can_do_setop(other)
 
         if self.equals(other):
             if self.has_duplicates:
-                return self.unique().rename(result_names)
-            return self.rename(result_names)
+                return self.unique()._get_reconciled_name_object(other)
+            return self._get_reconciled_name_object(other)
 
         return self._intersection(other, sort=sort)
 

pandas/core/ops/common.py

@@ -93,7 +93,7 @@ def _maybe_match_name(a, b):
     """
     Try to find a name to attach to the result of an operation between
     a and b.  If only one of these has a `name` attribute, return that
-    name.  Otherwise return a consensus name if they match of None if
+    name.  Otherwise return a consensus name if they match or None if
     they have different names.
 
     Parameters
@@ -122,3 +122,30 @@ def _maybe_match_name(a, b):
     elif b_has:
         return b.name
     return None
+
+
+def maybe_match_names_multiindex(a, b):
+    """
+    Try to find common names to attach to the result of an operation between
+    a and b.  Return a consensus list of names if they match at least partly
+    or None if they have completely different names.
+
+    Parameters
+    ----------
+    a : MultiIndex
+    b : MultiIndex
+
+    Returns
+    -------
+    name : list of optional str or None
+    """
+    if len(a.names) != len(b.names):
+        return None
+    names = []
+    for a_name, b_name in zip(a.names, b.names):
+        if a_name == b_name:
+            names.append(a_name)
+        else:
+            # TODO: what if they both have np.nan for their names?
+            names.append(None)
+    return names

pandas/tests/indexes/multi/test_setops.py

@@ -429,3 +429,11 @@ def test_intersection_equal_different_names():
     result = mi1.intersection(mi2)
     expected = MultiIndex.from_arrays([[1, 2], [3, 4]], names=[None, "b"])
     tm.assert_index_equal(result, expected)
+
+
+def test_intersection_different_names():
+    # GH#38323
+    mi = MultiIndex.from_arrays([[1], [3]], names=["c", "b"])
+    mi2 = MultiIndex.from_arrays([[1], [3]])
+    result = mi.intersection(mi2)
+    tm.assert_index_equal(result, mi2)

pandas/tests/test_common.py

@@ -109,6 +109,29 @@ def test_maybe_match_name(left, right, expected):
     assert ops.common._maybe_match_name(left, right) == expected
 
 
+@pytest.mark.parametrize(
+    "data, names, expected",
+    [
+        ((1,), None, None),
+        ((1,), ["a"], None),
+        ((1,), ["b"], None),
+        ((1, 2), ["c", "d"], [None, None]),
+        ((1, 2), ["b", "a"], [None, None]),
+        ((1, 2, 3), ["a", "b", "c"], None),
+        ((1, 2), ["a", "c"], ["a", None]),
+        ((1, 2), ["c", "b"], [None, "b"]),
+        ((1, 2), ["a", "b"], ["a", "b"]),
+        ((1, 2), [None, "b"], [None, "b"]),
+    ],
+)
+def test_maybe_match_names_multiindex(data, names, expected):
+    # GH#38323
+    mi = pd.MultiIndex.from_tuples([], names=["a", "b"])
+    mi2 = pd.MultiIndex.from_tuples([data], names=names)
+    result = ops.common.maybe_match_names_multiindex(mi, mi2)
+    assert result == expected
+
+
 def test_standardize_mapping():
     # No uninitialized defaultdicts
     msg = r"to_dict\(\) only accepts initialized defaultdicts"