Modernize varnames function

pluggy.py

@@ -627,50 +627,51 @@ def __repr__(self):
         return "<_MultiCall %s, kwargs=%r>" % (status, self.kwargs)
 
 
-def varnames(func, startindex=None):
-    """ return argument name tuple for a function, method, class or callable.
+def varnames(func):
+    """Return argument name tuple for a function, method, class or callable.
 
     In case of a class, its "__init__" method is considered.
     For methods the "self" parameter is not included unless you are passing
-    an unbound method with Python3 (which has no supports for unbound methods)
+    an unbound method with Python3 (which has no support for unbound methods)
     """
     cache = getattr(func, "__dict__", {})
     try:
         return cache["_varnames"]
     except KeyError:
         pass
+
     if inspect.isclass(func):
         try:
             func = func.__init__
         except AttributeError:
             return ()
-        startindex = 1
-    else:
-        if not inspect.isfunction(func) and not inspect.ismethod(func):
-            try:
-                func = getattr(func, '__call__', func)
-            except Exception:
-                return ()
-        if startindex is None:
-            startindex = int(inspect.ismethod(func))
+    elif not inspect.isroutine(func):  # callable object?
+        try:
+            func = getattr(func, '__call__', func)
+        except Exception:
+            return ()
 
-    try:
-        rawcode = func.__code__
-    except AttributeError:
+    try:  # func MUST be a function or method here or we won't parse any args
+        spec = inspect.getargspec(func)
+    except TypeError:
         return ()
+
+    args, defaults = spec.args, spec.defaults
+    args = args[:-len(defaults)] if defaults else args
+
+    # strip any implicit instance arg
+    if args:
+        if inspect.ismethod(func) or (
+            '.' in getattr(func, '__qualname__', ()) and args[0] == 'self'
+        ):
+            args = args[1:]
+
+    assert "self" not in args  # best naming practises check?
     try:
-        x = rawcode.co_varnames[startindex:rawcode.co_argcount]
-    except AttributeError:
-        x = ()
-    else:
-        defaults = func.__defaults__
-        if defaults:
-            x = x[:-len(defaults)]
-    try:
-        cache["_varnames"] = x
+        cache["_varnames"] = args
     except TypeError:
         pass
-    return x
+    return tuple(args)
 
 
 class _HookRelay:
@@ -700,8 +701,7 @@ def set_specification(self, specmodule_or_class, spec_opts):
         assert not self.has_spec()
         self._specmodule_or_class = specmodule_or_class
         specfunc = getattr(specmodule_or_class, self.name)
-        argnames = varnames(specfunc, startindex=inspect.isclass(specmodule_or_class))
-        assert "self" not in argnames  # sanity check
+        argnames = varnames(specfunc)
         self.argnames = ["__multicall__"] + list(argnames)
         self.spec_opts = spec_opts
         if spec_opts.get("historic"):

testing/test_pluggy.py

@@ -17,14 +17,23 @@ def pm():
     return PluginManager("example")
 
 
-@pytest.fixture
-def he_pm(pm):
+@pytest.fixture(
+    params=[
+        lambda spec: spec,
+        lambda spec: spec()
+    ],
+    ids=[
+        "don't instantiate",
+        "instatiate"
+    ],
+)
+def he_pm(request, pm):
     class Hooks:
         @hookspec
         def he_method1(self, arg):
             return arg + 1
 
-    pm.add_hookspecs(Hooks)
+    pm.add_hookspecs(request.param(Hooks))
     return pm
 
 
@@ -706,8 +715,17 @@ def __init__(self, x):
     class D:
         pass
 
+    class E(object):
+        def __init__(self, x):
+            pass
+
+    class F(object):
+        pass
+
     assert varnames(C) == ("x",)
     assert varnames(D) == ()
+    assert varnames(E) == ("x",)
+    assert varnames(F) == ()
 
 
 def test_formatdef():