gh-154690: Narrow ensure_distinct_paths() resolve() exception handling

Only catch AttributeError (no resolve) and OSError (realpath failed),
and test the lexical fallback for both cases.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: dura0ok

Lib/pathlib/_os.py

@@ -265,19 +265,14 @@ def ensure_distinct_paths(source, target):
     """
     Raise OSError(EINVAL) if the other path is within this path.
     """
-    # Note: there is no straightforward, foolproof algorithm to determine
-    # if one directory is within another (a particularly perverse example
-    # would be a single network share mounted in one location via NFS, and
-    # in another location via CIFS). Resolve when possible so relative vs
-    # absolute paths and symlink aliases are compared like shutil._destinsrc
-    # (realpath); otherwise fall back to a lexical check.
+    # Prefer resolve() (like shutil._destinsrc); else compare lexically.
+    # Cross-mount aliases (e.g. NFS vs CIFS) still cannot be detected reliably.
     source_orig, target_orig = source, target
     try:
         source = source.resolve(strict=False)
         target = target.resolve(strict=False)
-    except (AttributeError, TypeError):
-        pass
-    except (OSError, ValueError, RuntimeError, NotImplementedError):
+    except (AttributeError, OSError):
+        # No resolve(), or realpath failed.
         pass
     if source == target:
         err = OSError(EINVAL, "Source and target are the same path")

Lib/test/test_pathlib/test_pathlib.py

@@ -1454,7 +1454,6 @@ def test_copy_directory_symlink_into_itself(self):
         self.assertFalse(target.exists())
 
     def test_copy_dir_into_itself_relative_source_absolute_target(self):
-        # ensure_distinct_paths() must not be fooled by relative vs absolute.
         with os_helper.change_cwd(self.base):
             source = self.cls('dirC')
             target = source.resolve() / 'copyC'
@@ -1481,6 +1480,22 @@ def test_copy_dir_into_itself_via_symlink(self):
         self.assertRaises(OSError, source.copy, target, follow_symlinks=False)
         self.assertFalse((source / 'copyC').exists())
 
+    def test_copy_dir_into_itself_when_no_resolve(self):
+        base = self.cls(self.base)
+        source = base / 'dirC'
+        target = source / 'copyC'
+        with mock.patch.object(self.cls, 'resolve', side_effect=AttributeError):
+            self.assertRaises(OSError, source.copy, target)
+            self.assertFalse(target.exists())
+
+    def test_copy_dir_into_itself_when_resolve_raises_oserror(self):
+        base = self.cls(self.base)
+        source = base / 'dirC'
+        target = source / 'copyC'
+        with mock.patch.object(self.cls, 'resolve', side_effect=OSError):
+            self.assertRaises(OSError, source.copy, target)
+            self.assertFalse(target.exists())
+
     @needs_symlinks
     def test_copy_directory_symlink_to_existing_symlink(self):
         base = self.cls(self.base)