Issue #22034: Improve handling of wrong argument types in posixpath.join().

diff --cc Lib/posixpath.py
index eb17dbab07198fa68623d843417a7e561340ea88,0aa53feac2e5885d2dfb1f90efa9bf2c4147ff7e..f08c9310d4e364e08ebcea0cb59a059eb5da00c7
--- 1/Lib/posixpath.py
--- 2/Lib/posixpath.py
+++ b/Lib/posixpath.py
@@@ -82,14 -82,12 +82,13 @@@ def join(a, *p)
                  path += b
              else:
                  path += sep + b
--    except TypeError:
-         valid_types = all(isinstance(s, (str, bytes, bytearray))
-                           for s in (a, ) + p)
-         if valid_types:
 -        if all(isinstance(s, (str, bytes)) for s in (a,) + p):
--            # Must have a mixture of text and binary data
--            raise TypeError("Can't mix strings and bytes in path "
-                             "components.") from None
 -                            "components") from None
--        raise
++    except (TypeError, AttributeError):
++        for s in (a,) + p:
++            if not isinstance(s, (str, bytes)):
++                raise TypeError('join() argument must be str or bytes, not %r' %
++                                s.__class__.__name__) from None
++        # Must have a mixture of text and binary data
++        raise TypeError("Can't mix strings and bytes in path components") from None
      return path
  
  

diff --cc Lib/test/test_posixpath.py
index 412849cff3a3a006a7700efbf22589af422f1fa9,ec2fbaee322dbe0e476f51817f1842384e324943..d5a12a31dd7cd59b684b57796ead6dbd6fb768fa
--- 1/Lib/test/test_posixpath.py
--- 2/Lib/test/test_posixpath.py
+++ b/Lib/test/test_posixpath.py
@@@ -57,21 -57,17 +57,21 @@@ class PosixPathTest(unittest.TestCase)
          self.assertEqual(posixpath.join(b"/foo/", b"bar/", b"baz/"),
                           b"/foo/bar/baz/")
  
-         def check_error_msg(list_of_args, msg):
-             """Check posixpath.join raises friendly TypeErrors."""
-             for args in (item for perm in list_of_args
-                               for item in itertools.permutations(perm)):
-                 with self.assertRaises(TypeError) as cm:
-                     posixpath.join(*args)
-                 self.assertEqual(msg, cm.exception.args[0])
- 
-         check_error_msg([[b'bytes', 'str'], [bytearray(b'bytes'), 'str']],
-                         "Can't mix strings and bytes in path components.")
+     def test_join_errors(self):
+         # Check posixpath.join raises friendly TypeErrors.
+         errmsg = "Can't mix strings and bytes in path components"
+         with self.assertRaisesRegex(TypeError, errmsg):
+             posixpath.join(b'bytes', 'str')
+         with self.assertRaisesRegex(TypeError, errmsg):
+             posixpath.join('str', b'bytes')
          # regression, see #15377
--        with self.assertRaises(TypeError) as cm:
++        errmsg = r'join\(\) argument must be str or bytes, not %r'
++        with self.assertRaisesRegex(TypeError, errmsg % 'NoneType'):
              posixpath.join(None, 'str')
-         self.assertNotEqual("Can't mix strings and bytes in path components.",
-                             cm.exception.args[0])
 -        self.assertNotEqual(cm.exception.args[0], errmsg)
++        with self.assertRaisesRegex(TypeError, errmsg % 'NoneType'):
++            posixpath.join('str', None)
++        with self.assertRaisesRegex(TypeError, errmsg % 'bytearray'):
++            posixpath.join(bytearray(b'foo'), bytearray(b'bar'))
  
      def test_split(self):
          self.assertEqual(posixpath.split("/foo/bar"), ("/foo", "bar"))