inspect.getcallargs doesn't properly interpret set comprehension code objects.

Lib/test/test_inspect.py

 import builtins
 import collections
 import datetime
 import functools
 import importlib
 import inspect
 import io
 import linecache
 import os
 from os.path import normcase
@@ skipping 2884 matching lines @@
 
         with self.assertRaisesRegex(ValueError, 'not a valid parameter name'):
             inspect.Parameter('1', kind=inspect.Parameter.VAR_KEYWORD)
 
         with self.assertRaisesRegex(TypeError, 'name must be a str'):
             inspect.Parameter(None, kind=inspect.Parameter.VAR_KEYWORD)
 
         with self.assertRaisesRegex(ValueError,
                                     'is not a valid parameter name'):
             inspect.Parameter('$', kind=inspect.Parameter.VAR_KEYWORD)
+
+        with self.assertRaisesRegex(ValueError,
+                                    'is not a valid parameter name'):
+            inspect.Parameter('.a', kind=inspect.Parameter.VAR_KEYWORD)
 
         with self.assertRaisesRegex(ValueError, 'cannot have default values'):
             inspect.Parameter('a', default=42,
                               kind=inspect.Parameter.VAR_KEYWORD)
 
         with self.assertRaisesRegex(ValueError, 'cannot have default values'):
             inspect.Parameter('a', default=42,
                               kind=inspect.Parameter.VAR_POSITIONAL)
 
         p = inspect.Parameter('a', default=42,
                               kind=inspect.Parameter.POSITIONAL_OR_KEYWORD)
         with self.assertRaisesRegex(ValueError, 'cannot have default values'):
             p.replace(kind=inspect.Parameter.VAR_POSITIONAL)
 
         self.assertTrue(repr(p).startswith('<Parameter'))
         self.assertTrue('"a=42"' in repr(p))
+
+        implicit_param = inspect.Parameter('.0', kind=inspect.Parameter.POSITIONAL_ONLY)
+        self.assertEqual(implicit_param.name, '.0')
 
     def test_signature_parameter_hashable(self):
         P = inspect.Parameter
         foo = P('foo', kind=P.POSITIONAL_ONLY)
         self.assertEqual(hash(foo), hash(P('foo', kind=P.POSITIONAL_ONLY)))
         self.assertNotEqual(hash(foo), hash(P('foo', kind=P.POSITIONAL_ONLY,
                                               default=42)))
         self.assertNotEqual(hash(foo),
                             hash(foo.replace(kind=P.VAR_POSITIONAL)))
 
@@ skipping 295 matching lines @@
 
             sig.bind(a=0, args=1)
 
         def test(*args, **kwargs):
             return args, kwargs
         self.assertEqual(self.call(test, args=1), ((), {'args': 1}))
 
         sig = inspect.signature(test)
         ba = sig.bind(args=1)
         self.assertEqual(ba.arguments, {'kwargs': {'args': 1}})
+
+    def test_signature_bind_implicit_arg(self):
+        # Issue #19611: getcallargs should work with set comprehensions
+        def make_set():
+            return {z * z for z in range(5)}
+        setcomp_code = make_set.__code__.co_consts[1]
+        setcomp_func = types.FunctionType(setcomp_code, {})
+
+        iterator = iter(range(5))
+        self.assertEqual(self.call(setcomp_func, iterator), ((iterator,), {}))
 
 
 class TestBoundArguments(unittest.TestCase):
     def test_signature_bound_arguments_unhashable(self):
         def foo(a): pass
         ba = inspect.signature(foo).bind(1)
 
         with self.assertRaisesRegex(TypeError, 'unhashable type'):
             hash(ba)
 
@@ skipping 347 matching lines @@
         TestGetcallargsUnboundMethods, TestGetattrStatic, TestGetGeneratorState,
         TestNoEOL, TestSignatureObject, TestSignatureBind, TestParameterObject,
         TestBoundArguments, TestSignaturePrivateHelpers,
         TestSignatureDefinitions,
         TestGetClosureVars, TestUnwrap, TestMain, TestReload,
         TestGetCoroutineState
     )
 
 if __name__ == "__main__":
     test_main()