Merge pull request #2 from kunaltyagi/gen_func

Author: kunaltyagi

bindings/python/scripts/generate.py

@@ -1,5 +1,6 @@
 from context import scripts
 import scripts.utils as utils
+from typing import Any, List, Dict
 
 
 class bind:
@@ -44,7 +45,7 @@ def __init__(self, root: dict, module_name: str) -> None:
             "ANONYMOUS_UNION_DECL": handled_elsewhere,  # in (handle_struct_decl) via get_fields_from_anonymous
             "ANONYMOUS_STRUCT_DECL": handled_elsewhere,  # in (handle_struct_decl) via get_fields_from_anonymous
             "FRIEND_DECL": unsure,
-            "FUNCTION_DECL": unsure,
+            "FUNCTION_DECL": self.handle_function,
             # EXPRs: An expression that refers to a member of a struct, union, class, Objective-C class, etc.
             "CALL_EXPR": handled_by_pybind,
             "UNEXPOSED_EXPR": unsure,
@@ -281,6 +282,26 @@ def handle_struct_decl(self) -> None:
                         f'.def("{sub_item["name"]}", py::overload_cast<>(&{self.name}::{sub_item["name"]}))'
                     )
 
+    def handle_function(self) -> None:
+        """
+        Handles `CursorKind.FUNCTION_DECL`
+
+        - Bind the function and its parameter list
+        """
+        parameter_type_list = []
+        details = self._state_stack[-1]
+        for sub_item in self.members:
+            if sub_item["kind"] == "PARM_DECL":
+                parameter_type_list.append(f'"{sub_item["name"]}"_a')
+
+        parameter_type_list = ",".join(parameter_type_list)
+        if parameter_type_list:
+            parameter_type_list = "," + parameter_type_list
+
+        self._linelist.append(
+            f'm.def("{self.name}", &{self.name} {parameter_type_list});'
+        )
+
     def handle_constructor(self) -> None:
         """
         Handles `CursorKind.CONSTRUCTOR`
@@ -295,35 +316,35 @@ def handle_constructor(self) -> None:
         # generate parameter type list
         for sub_item in self.members:
             if sub_item["kind"] == "PARM_DECL":
-                if sub_item["element_type"] == "LValueReference":
-                    for sub_sub_item in sub_item["members"]:
-                        if sub_sub_item["kind"] == "TYPE_REF":
-                            # @TODO: Make more robust
-                            type_ref = (
-                                sub_sub_item["name"]
-                                .replace("struct ", "")
-                                .replace("pcl::", "")
-                            )
-                            parameter_type_list.append(f"{type_ref} &")
-                elif sub_item["element_type"] == "Elaborated":
-                    namespace_ref = ""
-                    for sub_sub_item in sub_item["members"]:
-                        if sub_sub_item["kind"] == "NAMESPACE_REF":
-                            namespace_ref += f'{sub_sub_item["name"]}::'
-                        if sub_sub_item["kind"] == "TYPE_REF":
-                            parameter_type_list.append(
-                                f'{namespace_ref}{sub_sub_item["name"]}'
-                            )
-                elif sub_item["element_type"] in ("Float", "Int"):
-                    parameter_type_list.append(f'{sub_item["element_type"].lower()}')
-                else:
-                    parameter_type_list.append(f'{sub_item["element_type"]}')
+                parameter_type_list.append(self.get_parm_types(sub_item))
         parameter_type_list = ",".join(parameter_type_list)
 
         # default ctor `.def(py::init<>())` already inserted while handling struct/class decl
         if parameter_type_list:
             self._linelist.append(f".def(py::init<{parameter_type_list}>())")
 
+    def get_parm_types(self, item: Dict[str, Any]) -> List[str]:
+        if item["element_type"] == "LValueReference":
+            for sub_item in item["members"]:
+                if sub_item["kind"] == "TYPE_REF":
+                    # @TODO: Make more robust
+                    type_ref = (
+                        sub_item["name"].replace("struct ", "").replace("pcl::", "")
+                    )
+                    parameter_type_list = f"{type_ref} &"
+        elif item["element_type"] == "Elaborated":
+            namespace_ref = ""
+            for sub_item in item["members"]:
+                if sub_item["kind"] == "NAMESPACE_REF":
+                    namespace_ref += f'{sub_item["name"]}::'
+                if sub_item["kind"] == "TYPE_REF":
+                    parameter_type_list = f'{namespace_ref}{sub_item["name"]}'
+        elif item["element_type"] in ("Float", "Double", "Int"):
+            parameter_type_list = f'{item["element_type"].lower()}'
+        else:
+            parameter_type_list = f'{item["element_type"]}'
+        return parameter_type_list
+
     def handle_inclusion_directive(self) -> None:
         """
         Handle `CursorKind.INCLUSION_DIRECTIVE`

bindings/python/scripts/parse.py

@@ -97,6 +97,8 @@ def generate_parsed_info(node):
     parsed_info["line"] = cursor.location.line
     parsed_info["column"] = cursor.location.column
     parsed_info["kind"] = cursor.kind.name
+    parsed_info["tokens"] = [x.spelling for x in cursor.get_tokens()]
+
     if cursor.is_anonymous():
         parsed_info["kind"] = "ANONYMOUS_" + parsed_info["kind"]
     parsed_info["name"] = cursor.spelling

bindings/python/tests/test_generate.py

@@ -82,6 +82,40 @@ def get_expected_string(file_include, expected_module_code):
     return expected_output
 
 
+def test_function_without_parameters(tmp_path):
+    cpp_code_block = "void AFunction();"
+    file_include, output = generate_bindings(
+        tmp_path=tmp_path, cpp_code_block=cpp_code_block, module_name="pcl"
+    )
+
+    expected_module_code = """
+    PYBIND11_MODULE(pcl, m){
+        m.def("AFunction", &AFunction);
+    }
+    """
+
+    assert output == get_expected_string(
+        file_include=file_include, expected_module_code=expected_module_code
+    )
+
+
+def test_function_with_parameters(tmp_path):
+    cpp_code_block = "void AFunction(int firstParam, double secondParam);"
+    file_include, output = generate_bindings(
+        tmp_path=tmp_path, cpp_code_block=cpp_code_block, module_name="pcl"
+    )
+
+    expected_module_code = """
+    PYBIND11_MODULE(pcl, m){
+        m.def("AFunction", &AFunction, "firstParam"_a, "secondParam"_a);
+    }
+    """
+
+    assert output == get_expected_string(
+        file_include=file_include, expected_module_code=expected_module_code
+    )
+
+
 def test_struct_without_members(tmp_path):
     cpp_code_block = "struct AStruct {};"
     file_include, output = generate_bindings(

bindings/python/tests/test_parse.py

@@ -134,7 +134,42 @@ def test_parsed_info_structure(tmp_path):
     assert len(parsed_info["members"]) == 0
 
 
-def test_call_expr(tmp_path):
+def test_function_decl_without_parameters(tmp_path):
+    file_contents = """
+    int aFunction();
+    """
+    parsed_info = get_parsed_info(tmp_path=tmp_path, file_contents=file_contents)
+
+    func_decl = parsed_info["members"][0]
+
+    assert func_decl["kind"] == "FUNCTION_DECL"
+    assert func_decl["name"] == "aFunction"
+    assert func_decl["result_type"] == "int"
+
+
+def test_function_decl_with_parameters(tmp_path):
+    file_contents = """
+    int aFunction(int firstParam, double secondParam);
+    """
+    parsed_info = get_parsed_info(tmp_path=tmp_path, file_contents=file_contents)
+
+    func_decl = parsed_info["members"][0]
+
+    assert func_decl["kind"] == "FUNCTION_DECL"
+    assert func_decl["name"] == "aFunction"
+    assert func_decl["result_type"] == "int"
+
+    first_param = func_decl["members"][0]
+    second_param = func_decl["members"][1]
+
+    assert first_param["name"] == "firstParam"
+    assert first_param["element_type"] == "Int"
+
+    assert second_param["name"] == "secondParam"
+    assert second_param["element_type"] == "Double"
+
+
+def test_simple_call_expr(tmp_path):
     file_contents = """
     int aFunction() {
         return 1;