Fix class name in alias constructors

For classes with an alias, the type shows up in the constructor as
"handle" rather than the actual type, because py::init<> uses a
`handle` first argument in such a case because it needs to make a
run-time decision as to whether to construct a Base or Alias type.

This fixes the signature by replacing the first argument type the scope
(i.e. module) name when the first argument of an instance method is set
to `handle`.  This also ends up fixing the `self` argument of
non-constructor methods taking `self` as a handle, which seems less
important, but still desirable.

Author: jagerman

include/pybind11/pybind11.h

@@ -230,7 +230,16 @@ class cpp_function : public function {
                 const std::type_info *t = types[type_index++];
                 if (!t)
                     pybind11_fail("Internal error while parsing type signature (1)");
-                if (auto tinfo = detail::get_type_info(*t)) {
+
+                detail::type_info *tinfo = nullptr;
+                // If this is the first arg of a constructor (i.e. self) and is `handle`,
+                // replace it with the class (handle is used internally when dealing with
+                // aliases and factory initializers).
+                if (arg_index == 0 && rec->is_method && t == &typeid(handle) && PyType_Check(rec->scope.ptr()))
+                    tinfo = detail::get_type_info((PyTypeObject *) rec->scope.ptr());
+                if (!tinfo)
+                    tinfo = detail::get_type_info(*t);
+                if (tinfo) {
 #if defined(PYPY_VERSION)
                     signature += handle((PyObject *) tinfo->type)
                                      .attr("__module__")

tests/test_alias_initialization.cpp

@@ -32,7 +32,8 @@ test_initializer alias_initialization([](py::module &m) {
 
     py::class_<A, PyA>(m, "A")
         .def(py::init<>())
-        .def("f", &A::f);
+        .def("f", &A::f)
+        .def("self_as_handle", [](py::handle) {});
 
     m.def("call_f", call_f);
 

tests/test_alias_initialization.py

@@ -1,7 +1,7 @@
 import pytest
 
 
-def test_alias_delay_initialization1(capture):
+def test_alias_delay_initialization1(capture, msg):
     """
     A only initializes its trampoline class when we inherit from it; if we just
     create and use an A instance directly, the trampoline initialization is
@@ -37,6 +37,19 @@ def f(self):
         PyA.~PyA()
     """
 
+    # Check doc string and failure for the proper type (not just "handle") in the output
+    assert A.__init__.__doc__ == "__init__(self: pybind11_tests.A) -> None\n"
+    with pytest.raises(TypeError) as excinfo:
+        A(1, 2)
+    assert msg(excinfo.value) == """
+        __init__(): incompatible constructor arguments. The following argument types are supported:
+            1. m.A()
+
+        Invoked with: 1, 2
+    """
+
+    assert A.self_as_handle.__doc__ == "self_as_handle(self: pybind11_tests.A) -> None\n"
+
 
 def test_alias_delay_initialization2(capture):
     """A2, unlike the above, is configured to always initialize the alias; while