fix: update visibility detection

Author: edimetia3d

README.md

@@ -16,13 +16,15 @@ This tool takes a [sample.h](https://github.com/edimetia3d/pybind11_weaver/blob/
 - [x] Namespace hierarchy to Python submodules
 - [x] Enum
 - [x] Function, function overload
+- [ ] Operation overloading
 - [x] Class method, method overloading, static method, static method overloading, constructor, constructor overloading
 - [x] Class field
 - [x] Class access control
 - [x] Generate docstring from c++ comment, for enum, enum item, function, class, class method, class field
 - [ ] Trampoline class for virtual function
 - [x] Support working with hand-written code
 - [ ] Auto snake case
+- [ ] Binding for Template specialization
 
 ## Background & Recommendations
 

pybind11_weaver/entity/__init__.py

@@ -1,3 +1,5 @@
+import logging
+
 from . import entity_base
 from . import enum
 from . import klass
@@ -6,9 +8,17 @@
 
 from clang import cindex
 
+from pybind11_weaver import gen_unit
+
+_logger = logging.getLogger(__name__)
 _KIND = cindex.CursorKind
 
-from pybind11_weaver import gen_unit
+
+def _is_specialization(cursor: cindex.Cursor):
+    if "<" in cursor.displayname and ">" in cursor.displayname:
+        _logger.warning(f"Specialized template not supported `{cursor.canonical.displayname}` ")
+        return True
+    return False
 
 
 def create_entity(gu: gen_unit.GenUnit, cursor: cindex.Cursor):
@@ -26,9 +36,9 @@ def create_entity(gu: gen_unit.GenUnit, cursor: cindex.Cursor):
         return enum.EnumEntity(gu, cursor)
     if kind == _KIND.NAMESPACE:
         return namespace.NamespaceEntity(gu, cursor)
-    if kind in [_KIND.CLASS_DECL, _KIND.STRUCT_DECL] and cursor.is_definition():
+    if kind in [_KIND.CLASS_DECL, _KIND.STRUCT_DECL] and cursor.is_definition() and not _is_specialization(cursor):
         return klass.ClassEntity(gu, cursor)
-    if kind == _KIND.FUNCTION_DECL:
+    if kind == _KIND.FUNCTION_DECL and not _is_specialization(cursor):
         return funktion.FunctionEntity(gu, cursor)
 
     return None

pybind11_weaver/entity/klass.py

@@ -1,12 +1,11 @@
 from typing import List, Dict
+import logging
 
 from clang import cindex
 
 from . import entity_base
 from pybind11_weaver.utils import fn
 
-import logging
-
 from pybind11_weaver import gen_unit
 
 _logger = logging.getLogger(__name__)
@@ -74,16 +73,23 @@ def update_stmts(self, pybind11_obj_sym: str) -> List[str]:
         codes = []
 
         def is_pubic(cursor):
-            return cursor.access_specifier == cindex.AccessSpecifier.PUBLIC and self.gu.is_visible(cursor)
+            return cursor.access_specifier == cindex.AccessSpecifier.PUBLIC and not cursor.is_deleted_method()
+
+        def not_operator(cursor):
+            is_operator = "operator" in cursor.spelling
+            if is_operator:
+                _logger.warning(f"Operator overloading not supported `{cursor.spelling}`")
+            return not is_operator
 
         # generate constructor binding
         ctor_found = False
         for cursor in self.cursor.get_children():
-            if cursor.kind == cindex.CursorKind.CONSTRUCTOR and is_pubic(cursor):
+            if cursor.kind == cindex.CursorKind.CONSTRUCTOR:
                 ctor_found = True
-                param_types = fn.fn_arg_type(cursor)
-                codes.append(
-                    f"{pybind11_obj_sym}.def(pybind11::init<{','.join(param_types)}>());")
+                if is_pubic(cursor) and not (cursor.is_move_constructor() or cursor.is_copy_constructor()):
+                    param_types = fn.fn_arg_type(cursor)
+                    codes.append(
+                        f"{pybind11_obj_sym}.def(pybind11::init<{','.join(param_types)}>());")
         if not ctor_found:
             codes.append(f"{pybind11_obj_sym}.def(pybind11::init<>());")
         if self.gu.io_config.gen_docstring:
@@ -93,7 +99,7 @@ def is_pubic(cursor):
         # generate method binding
         methods: Dict[str, MethodCoder] = dict()
         for cursor in self.cursor.get_children():
-            if cursor.kind == cindex.CursorKind.CXX_METHOD and is_pubic(cursor):
+            if cursor.kind == cindex.CursorKind.CXX_METHOD and is_pubic(cursor) and not_operator(cursor):
                 if not cursor.spelling in methods:
                     methods[cursor.spelling] = MethodCoder(cursor, self.qualified_name(),
                                                            self.gu.io_config.gen_docstring)
@@ -118,9 +124,14 @@ def is_pubic(cursor):
 
         # generate field binding
         for cursor in self.cursor.get_children():
-            if cursor.kind == cindex.CursorKind.FIELD_DECL and is_pubic(cursor):
+            if cursor.kind == cindex.CursorKind.FIELD_DECL and \
+                    is_pubic(cursor) and \
+                    cursor.type.kind != cindex.TypeKind.CONSTANTARRAY:
+                filed_binder = "def_readwrite"
+                if cursor.type.is_const_qualified():
+                    filed_binder = "def_readonly"
                 codes.append(
-                    f"{pybind11_obj_sym}.def_readwrite(\"{cursor.spelling}\",&{self.qualified_name()}::{cursor.spelling});")
+                    f"{pybind11_obj_sym}.{filed_binder}(\"{cursor.spelling}\",&{self.qualified_name()}::{cursor.spelling});")
                 if self.gu.io_config.gen_docstring:
                     codes[-1] = entity_base._inject_docstring(codes[-1], cursor, "last_arg")
 

pybind11_weaver/entity_tree.py

@@ -8,11 +8,13 @@
 from pybind11_weaver.entity import entity_base
 from pybind11_weaver.entity import funktion, klass
 
+from pybind11_weaver.utils import common
+
 
 class _DummyNode(entity_base.Entity):
 
-    def __init__(self, cursor: cindex.Cursor):
-        entity_base.Entity.__init__(self, cursor)
+    def __init__(self, gu: gen_unit.GenUnit, cursor: cindex.Cursor):
+        entity_base.Entity.__init__(self, gu, cursor)
 
     def transfer(self, new_entity: "Entity"):
         # update parent
@@ -51,7 +53,7 @@ def nest_update_parent(self, entity: entity_base.Entity) -> None:
         outer = self.entities
         for name in scopes:
             if name not in outer:
-                outer[name] = _DummyNode(None)
+                outer[name] = _DummyNode(entity.gu, None)
                 if not outer is self.entities:
                     outer[name].update_parent(outer)
             outer = outer[name]
@@ -62,9 +64,9 @@ def nest_update_parent(self, entity: entity_base.Entity) -> None:
             if isinstance(outer[entity_name], _DummyNode):
                 outer[entity_name].transfer(entity)
             else:
-                assert isinstance(entity, funktion.FunctionEntity)
-                assert isinstance(outer[entity_name], funktion.FunctionEntity)
-                outer[entity_name].overloads.append(entity.cursor)
+                if isinstance(entity, funktion.FunctionEntity):
+                    assert isinstance(outer[entity_name], funktion.FunctionEntity)
+                    outer[entity_name].overloads.append(entity.cursor)
         else:
             outer[entity_name] = entity
         if not outer is self.entities:
@@ -76,8 +78,6 @@ def load_from_gu(self, gu: gen_unit.GenUnit) -> None:
         for cursor in root_cursor.walk_preorder():
             if not self.check_valid_cursor(cursor, valid_file_tail_names):
                 continue
-            if not gu.is_visible(cursor):
-                continue
             new_entity = create_entity(gu, cursor)
             if new_entity is not None:
                 self.nest_update_parent(new_entity)

pybind11_weaver/gen_unit.py

@@ -116,20 +116,6 @@ def __init__(self, tu, io_config: Dict[str, Any], cxx_flags: List[str]):
         self.src_files: List[str] = io_config["inputs"]
         self.io_config = GenUnit.IOConifg(io_config)
         self.cxx_flags = cxx_flags
-        self.fvisibility_hidden = ("-fvisibility=hidden" in " ".join(cxx_flags))
-
-    def is_visible(self, cursor: cindex.Cursor):
-        """Utility method to check if a cursor is visible in the current translation unit."""
-        if cursor.kind in [cindex.CursorKind.ENUM_DECL, cindex.CursorKind.NAMESPACE]:
-            return True
-        visible = not self.fvisibility_hidden
-        for c in cursor.get_children():
-            if c.kind == cindex.CursorKind.VISIBILITY_ATTR:
-                if c.spelling == "default":
-                    visible = True
-                elif c.spelling == "hidden":
-                    visible = False
-        return visible
 
     def src_file_tail_names(self):
         files = []

pybind11_weaver/main.py

@@ -18,6 +18,9 @@ def parse_args():
     if hasattr(args, "get_include") and args.get_include:
         print(pybind11_weaver.get_include())
         exit(0)
+    if args.config is None:
+        parser.print_help()
+        exit(0)
     return args
 
 

pybind11_weaver/utils/common.py

@@ -0,0 +1,7 @@
+from clang import cindex
+
+
+def is_visible(cursor: cindex.Cursor):
+    if cursor.kind not in [cindex.CursorKind.FUNCTION_DECL, cindex.CursorKind.CXX_METHOD]:
+        return True  # only control visibility of function and method
+    return cursor.linkage == cindex.LinkageKind.EXTERNAL

pybind11_weaver/utils/fn.py

@@ -4,15 +4,16 @@
 
 
 def fn_arg_type(cursor: cindex.Cursor):
-    return [param.type.spelling for param in cursor.get_arguments()]
+    return [param.type.get_canonical().spelling for param in cursor.get_arguments()]
 
 
 def fn_ret_type(cursor: cindex.Cursor):
-    return cursor.result_type.spelling
+    return cursor.result_type.get_canonical().spelling
 
 
 def get_fn_pointer_type(cursor: cindex.Cursor):
     if cursor.kind == cindex.CursorKind.CXX_METHOD and not cursor.is_static_method():
-        return f"{fn_ret_type(cursor)} ({scope_list.get_full_qualified_name(cursor.semantic_parent)}::*)({','.join(fn_arg_type(cursor))})"
+        const_mark = "const" if cursor.is_const_method() else ""
+        return f"{fn_ret_type(cursor)} ({scope_list.get_full_qualified_name(cursor.semantic_parent)}::*)({','.join(fn_arg_type(cursor))}) {const_mark}"
     else:
         return f"{fn_ret_type(cursor)} (*)({','.join(fn_arg_type(cursor))})"