Improve handling of unsuported properties&methods in bindings, enable support for virtual methods in bindings

Author: touilleMan

generation/bindings_templates/class.tmpl.pyx

@@ -250,12 +250,20 @@ TODO: see PinJoint.params/bias for a good example
 
     @property
     def {{ prop.name }}(self):
+{% if prop.is_supported %}
         return self.{{ prop.getter }}({% if prop.index is not none %}{{ prop.index }}{% endif %})
+{% else %}
+        raise NotImplementedError("{{prop.unsupported_reason}}")
+{% endif %}
 
 {% if prop.setter %}
     @{{ prop.name }}.setter
     def {{ prop.name }}(self, val):
+{% if prop.is_supported %}
         self.{{ prop.setter }}({% if prop.index is not none %}{{ prop.index }},{% endif %}val)
+{% else %}
+        raise NotImplementedError("{{prop.unsupported_reason}}")
+{% endif %}
 {% endif %}
 
 {% endfor %}

generation/bindings_templates/method.tmpl.pyx

@@ -147,8 +147,12 @@ with nogil:
 {% macro render_method(cls, method) %}
 # {{ render_method_c_signature(method) }}
 def {{ render_method_signature(method) }}:
+{% if method.is_supported %}
     {{ _render_method_cook_args(method) | indent }}
     {{ _render_method_call(cls, method) | indent }}
     {{ _render_method_destroy_args(method) | indent }}
     {{ _render_method_return(method) | indent }}
+{% else %}
+    raise NotImplementedError("{{method.unsupported_reason}}")
+{% endif %}
 {% endmacro %}

generation/generate_bindings.py

@@ -26,6 +26,13 @@ class PropertyInfo:
     setter: str
     index: Optional[int]
 
+    # If using feature we don't support yet
+    unsupported_reason: Optional[str] = None
+
+    @property
+    def is_supported(self) -> bool:
+        return self.unsupported_reason is None
+
 
 @dataclass
 class ArgumentInfo:
@@ -43,6 +50,13 @@ class SignalInfo:
     name: str
     arguments: List[ArgumentInfo]
 
+    # If using feature we don't support yet
+    unsupported_reason: Optional[str] = None
+
+    @property
+    def is_supported(self) -> bool:
+        return self.unsupported_reason is None
+
 
 @dataclass
 class MethodInfo:
@@ -57,6 +71,13 @@ class MethodInfo:
     is_from_script: bool
     arguments: List[ArgumentInfo]
 
+    # If using feature we don't support yet
+    unsupported_reason: Optional[str] = None
+
+    @property
+    def is_supported(self) -> bool:
+        return self.unsupported_reason is None
+
 
 @dataclass
 class EnumInfo:
@@ -240,66 +261,43 @@ def _is_supported_type(specs):
         else:
             return True
 
-    kept_classes = []
     for klass in classes:
-        methods = []
         for meth in klass.methods:
+            unsupported_reason = None
             # TODO: handle default param values
             # TODO: handle those flags
             if meth.is_editor:
-                # warn(f"Ignoring `{klass.name}.{meth.name}` (attribute `is_editor=True` not supported)")
-                continue
+                unsupported_reason = "attribute `is_editor=True` not supported"
             if meth.is_reverse:
-                warn(
-                    f"Ignoring `{klass.name}.{meth.name}` (attribute `is_reverse=True` not supported)"
-                )
-                continue
-            if meth.is_virtual:
-                # warn(f"Ignoring `{klass.name}.{meth.name}` (attribute `is_virtual=True` not supported)")
-                continue
+                unsupported_reason = "attribute `is_reverse=True` not supported"
             if meth.has_varargs:
-                # warn(f"Ignoring `{klass.name}.{meth.name}` (attribute `has_varargs=True` not supported)")
-                continue
+                unsupported_reason = "attribute `has_varargs=True` not supported"
             if not _is_supported_type(meth.return_type):
-                warn(
-                    f"Ignoring `{klass.name}.{meth.name}` (return type {meth.return_type} not supported)"
-                )
-                continue
+                unsupported_reason = f"return type {meth.return_type} not supported"
             bad_arg = next(
                 (arg for arg in meth.arguments if not _is_supported_type(arg.type)), None
             )
             if bad_arg:
-                warn(f"Ignoring `{klass.name}.{meth.name}` (argument type {bad_arg} not supported)")
-                continue
-            methods.append(meth)
-        klass.methods = methods
+                unsupported_reason = f"argument type {bad_arg} not supported"
+
+            if unsupported_reason:
+                warn(f"Ignoring `{klass.name}.{meth.name}` ({unsupported_reason})")
+                meth.unsupported_reason = unsupported_reason
 
-        properties = []
         for prop in klass.properties:
             if not _is_supported_type(prop.type):
-                warn(
-                    f"Ignoring property `{klass.name}.{prop.name}` (property type {prop.type} not supported)"
-                )
-                continue
-            properties.append(prop)
-        klass.properties = properties
+                unsupported_reason = f"property type {prop.type} not supported"
+                warn(f"Ignoring property `{klass.name}.{prop.name}` ({unsupported_reason})")
+                prop.unsupported_reason = unsupported_reason
 
-        signals = []
         for signal in klass.signals:
             bad_arg = next(
                 (arg for arg in signal.arguments if not _is_supported_type(arg.type)), None
             )
             if bad_arg:
-                warn(
-                    f"Ignoring signal `{klass.name}.{signal.name}` (argument type {bad_arg} not supported)"
-                )
-                continue
-            signals.append(signal)
-        klass.signals = signals
-
-        kept_classes.append(klass)
-
-    return kept_classes
+                unsupported_reason = f"argument type {bad_arg} not supported"
+                warn(f"Ignoring signal `{klass.name}.{signal.name}` ({unsupported_reason})")
+                signal.unsupported_reason = unsupported_reason
 
 
 def strip_sample_stuff(classes):

tests/bindings/test_bindings.py

@@ -5,6 +5,8 @@
 import godot
 from godot import (
     Vector3,
+    GDString,
+    NodePath,
     Object,
     Node,
     CanvasItem,
@@ -156,6 +158,19 @@ def test_call_with_refcounted_param_value(generate_obj):
     node.set_script(script)
 
 
+def test_access_property(generate_obj):
+    node = generate_obj(Node)
+    path = NodePath("/foo/bar")
+    node._import_path = path
+    assert node._import_path == path
+
+
+def test_call_virtual(generate_obj):
+    node = generate_obj(Node)
+    ret = node._to_string()
+    assert isinstance(ret, GDString)
+
+
 def test_create_refcounted_value(current_node):
     script1_ref1 = PluginScript()
     script2_ref1 = PluginScript()