Merge pull request #216 from robotpy/2024-beta

Various features required for beta

Author: virtuald

.github/workflows/dist.yml

@@ -71,6 +71,7 @@ jobs:
         - '3.9'
         - '3.10'
         - '3.11'
+        - '3.12'
         architecture: [x86, x64]
         exclude:
         - os: macos-latest

pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=45,<64", "wheel", "setuptools_scm>=6.2,<8"]
+requires = ["setuptools>=45", "wheel", "setuptools_scm>=6.2,<8"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools_scm]

robotpy_build/autowrap/cls_tmpl_impl.hpp.j2

@@ -3,6 +3,10 @@
 #}
 {% import "pybind11.cpp.j2" as pybind11 %}
 
+{% for inc in type_caster_includes %}
+#include <{{ inc }}>
+{% endfor %}
+
 namespace rpygen {
 
 {% if cls.namespace %}

robotpy_build/autowrap/cls_trampoline.hpp.j2

@@ -27,8 +27,10 @@
 
 {%- set trampoline = cls.trampoline -%}
 {%- if cls.template -%}
+    {%- set template_argument_list = cls.template.argument_list -%}
     {%- set template_parameter_list = cls.template.parameter_list -%}
 {%- else -%}
+    {%- set template_argument_list = "" %}
     {%- set template_parameter_list = "" %}
 {%- endif -%}
 
@@ -63,20 +65,14 @@ using {{ decl.format() }};
       and so if it's not defined in this config, then it falls back to the
       parent configuration)
 #}
+template <{{ postcomma(template_parameter_list) }}typename CfgBase = EmptyTrampolineCfg>
+struct PyTrampolineCfg_{{ cls.full_cpp_name_identifier }} :
 {% if cls.bases %}
-template <{{ postcomma(trampoline.tmpl_params) }}typename CfgBase>
-using PyTrampolineCfgBase_{{ cls.full_cpp_name_identifier }} =
 {% for base in cls.bases %}
     PyTrampolineCfg_{{ base.full_cpp_name_identifier }}<{{ postcomma(base.template_params) }}
 {% endfor %}
 CfgBase
-{% for base in cls.bases %}>{% endfor %};
-{% endif %}
-
-template <{{ postcomma(template_parameter_list) }}typename CfgBase = EmptyTrampolineCfg>
-struct PyTrampolineCfg_{{ cls.full_cpp_name_identifier }} :
-{% if cls.bases %}
-    PyTrampolineCfgBase_{{ cls.full_cpp_name_identifier }}<{{ postcomma(trampoline.tmpl_args) }} CfgBase>
+{% for base in cls.bases %}>{% endfor %}
 {% else %}
     CfgBase
 {% endif %}
@@ -97,7 +93,7 @@ struct PyTrampolineCfg_{{ cls.full_cpp_name_identifier }} :
 
     PyTrampolineBase is another trampoline or our base class
 #}
-template <typename PyTrampolineBase{{ precomma(trampoline.tmpl_params) }}, typename PyTrampolineCfg>
+template <typename PyTrampolineBase{{ precomma(template_parameter_list) }}, typename PyTrampolineCfg>
 using PyTrampolineBase_{{ cls.full_cpp_name_identifier }} =
 {% for base in cls.bases %}
     PyTrampoline_{{ base.full_cpp_name_identifier }}<
@@ -111,8 +107,8 @@ using PyTrampolineBase_{{ cls.full_cpp_name_identifier }} =
 ;
 
 template <typename PyTrampolineBase{{ precomma(template_parameter_list) }}, typename PyTrampolineCfg>
-struct PyTrampoline_{{ cls.full_cpp_name_identifier }} : PyTrampolineBase_{{ cls.full_cpp_name_identifier }}<PyTrampolineBase{{ precomma(trampoline.tmpl_args) }}, PyTrampolineCfg> {
-    using PyTrampolineBase_{{ cls.full_cpp_name_identifier }}<PyTrampolineBase{{ precomma(trampoline.tmpl_args) }}, PyTrampolineCfg>::PyTrampolineBase_{{ cls.full_cpp_name_identifier }};
+struct PyTrampoline_{{ cls.full_cpp_name_identifier }} : PyTrampolineBase_{{ cls.full_cpp_name_identifier }}<PyTrampolineBase{{ precomma(template_argument_list) }}, PyTrampolineCfg> {
+    using PyTrampolineBase_{{ cls.full_cpp_name_identifier }}<PyTrampolineBase{{ precomma(template_argument_list) }}, PyTrampolineCfg>::PyTrampolineBase_{{ cls.full_cpp_name_identifier }};
 {% else %}
 template <typename PyTrampolineBase{{ precomma(template_parameter_list) }}, typename PyTrampolineCfg>
 struct PyTrampoline_{{ cls.full_cpp_name_identifier }} : PyTrampolineBase, virtual py::trampoline_self_life_support {

robotpy_build/autowrap/cxxparser.py

@@ -29,6 +29,7 @@
     AnonymousName,
     Array,
     ClassDecl,
+    Concept,
     DecoratedType,
     EnumDecl,
     Field,
@@ -381,6 +382,9 @@ def on_namespace_alias(
         # TODO: add to some sort of resolver?
         pass
 
+    def on_concept(self, state: AWNonClassBlockState, concept: Concept) -> None:
+        pass
+
     def on_forward_decl(self, state: AWState, fdecl: ForwardDecl) -> None:
         # TODO: add to some sort of resolver?
         pass
@@ -447,6 +451,16 @@ def on_using_declaration(self, state: AWState, using: UsingDecl) -> None:
 
         if using.access is None:
             self.hctx.using_declarations.append(using.typename)
+        elif isinstance(state, ClassBlockState):
+            # A using declaration might bring in a colliding name for a function,
+            # so mark it as overloaded
+            lseg = using.typename.segments[-1]
+            if isinstance(lseg, NameSpecifier):
+                cdata = state.user_data
+                name = lseg.name
+                self.gendata.add_using_decl(
+                    name, cdata.cls_key, cdata.data, state.access == "private"
+                )
 
     #
     # Enums
@@ -566,7 +580,11 @@ def on_class_start(self, state: AWClassBlockState) -> typing.Optional[bool]:
         ):
             return False
 
-        cls_key, cls_name, cls_namespace, parent_ctx = self._process_class_name(state)
+        cls_name_result = self._process_class_name(state)
+        if cls_name_result is None:
+            return False
+
+        cls_key, cls_name, cls_namespace, parent_ctx = cls_name_result
         class_data = self.gendata.get_class_data(cls_key)
 
         # Ignore explicitly ignored classes
@@ -647,6 +665,7 @@ def on_class_start(self, state: AWClassBlockState) -> typing.Optional[bool]:
             template_parameter_list = ", ".join(template_params)
 
             template_data = ClassTemplateData(
+                argument_list=template_argument_list,
                 parameter_list=template_parameter_list,
                 inline_code=class_data.template_inline_code,
             )
@@ -746,23 +765,24 @@ def on_class_start(self, state: AWClassBlockState) -> typing.Optional[bool]:
 
     def _process_class_name(
         self, state: AWClassBlockState
-    ) -> typing.Tuple[str, str, str, typing.Optional[ClassContext]]:
+    ) -> typing.Optional[typing.Tuple[str, str, str, typing.Optional[ClassContext]]]:
         class_decl = state.class_decl
         segments = class_decl.typename.segments
         assert len(segments) > 0
 
-        name_segment = segments[-1]
-        if not isinstance(name_segment, NameSpecifier):
-            raise ValueError(f"not sure how to handle '{class_decl.typename}'")
-
-        cls_name = name_segment.name
+        segment_names: typing.List[str] = []
+        for segment in segments:
+            if not isinstance(segment, NameSpecifier):
+                raise ValueError(
+                    f"not sure how to handle '{class_decl.typename.format()}'"
+                )
+            # ignore specializations for now
+            if segment.specialization is not None:
+                return None
+            segment_names.append(segment.name)
 
-        # for now, don't support these?
-        other_segments = segments[:-1]
-        if other_segments:
-            raise ValueError(
-                f"not sure what to do with compound name '{class_decl.typename}'"
-            )
+        cls_name = segment_names[-1]
+        extra_segments = "::".join(segment_names[:-1])
 
         parent_ctx: typing.Optional[ClassContext] = None
 
@@ -772,13 +792,18 @@ def _process_class_name(
             # easy case -- namespace is the next user_data up
             cls_key = cls_name
             cls_namespace = typing.cast(str, parent.user_data)
+            if extra_segments:
+                cls_namespace = f"{cls_namespace}::{extra_segments}"
         else:
             # Use things the parent already computed
             cdata = typing.cast(ClassStateData, parent.user_data)
             # parent: AWClassBlockState = state.parent
             parent_ctx = cdata.ctx
             # the parent context already computed namespace, so use that
-            cls_key = f"{cdata.cls_key}::{cls_name}"
+            if extra_segments:
+                cls_key = f"{cdata.cls_key}::{extra_segments}::{cls_name}"
+            else:
+                cls_key = f"{cdata.cls_key}::{cls_name}"
             cls_namespace = parent_ctx.namespace
 
         return cls_key, cls_name, cls_namespace, parent_ctx
@@ -1028,6 +1053,23 @@ def _on_class_method(
             self.hctx.need_operators_h = True
             if method_data.no_release_gil is None:
                 fctx.release_gil = False
+
+            # Use cpp_code to setup the operator
+            if fctx.cpp_code is None:
+                if len(method.parameters) == 0:
+                    fctx.cpp_code = f"{operator} py::self"
+                else:
+                    ptype, _, _, _ = _count_and_unwrap(method.parameters[0].type)
+                    if (
+                        isinstance(ptype, Type)
+                        and isinstance(ptype.typename.segments[-1], NameSpecifier)
+                        and ptype.typename.segments[-1].name == cdata.ctx.cpp_name
+                    ):
+                        # don't try to predict the type, use py::self instead
+                        fctx.cpp_code = f"py::self {operator} py::self"
+                    else:
+                        fctx.cpp_code = f"py::self {operator} {fctx.all_params[0].cpp_type_no_const}()"
+
         if method.const:
             fctx.const = True
         if method.static:

robotpy_build/autowrap/generator_data.py

@@ -40,10 +40,6 @@ class ClsReportData:
     functions: FnMissingData = dataclasses.field(default_factory=dict)
 
 
-_default_enum_data = EnumData()
-_default_fn_data = FunctionData()
-
-
 class GeneratorData:
     """
     Used by the hooks to retrieve user-specified generation data, and
@@ -55,6 +51,13 @@ class GeneratorData:
     def __init__(self, data: AutowrapConfigYaml):
         self.data = data
 
+        default_ignore = self.data.defaults.ignore
+        self._default_enum_data = EnumData(ignore=default_ignore)
+        self._default_fn_data = FunctionData(ignore=default_ignore)
+        self._default_method_data = FunctionData()
+        self._default_class_data = ClassData(ignore=default_ignore)
+        self._default_class_enum_data = EnumData()
+
         # report data
         self.functions: FnMissingData = {}
         self.classes: Dict[str, ClsReportData] = {}
@@ -68,7 +71,7 @@ def get_class_data(self, name: str) -> ClassData:
         data = self.data.classes.get(name)
         missing = data is None
         if missing:
-            data = ClassData()
+            data = self._default_class_data
 
         self.classes[name] = ClsReportData(missing=missing)
         return data
@@ -78,19 +81,19 @@ def get_cls_enum_data(
     ) -> EnumData:
         if name is None:
             # TODO
-            return _default_enum_data
+            return self._default_class_enum_data
         data = cls_data.enums.get(name)
         if data is None:
             self.classes[cls_key].enums[name] = False
-            data = _default_enum_data
+            data = self._default_class_enum_data
 
         return data
 
     def get_enum_data(self, name: str) -> EnumData:
         data = self.data.enums.get(name)
         if data is None:
             self.enums[name] = False
-            data = _default_enum_data
+            data = self._default_enum_data
         return data
 
     def get_function_data(
@@ -124,7 +127,10 @@ def get_function_data(
         # signature each time we defer it until we actually need to use it
 
         if missing:
-            data = _default_fn_data
+            if cls_key:
+                data = self._default_method_data
+            else:
+                data = self._default_fn_data
             report_data.deferred_signatures.append((fn, is_private))
         elif not data.overloads:
             report_data.deferred_signatures.append((fn, True))
@@ -145,6 +151,24 @@ def get_function_data(
         report_data.tracker.add_overload()
         return data, report_data.tracker
 
+    def add_using_decl(
+        self, name: str, cls_key: str, cls_data: ClassData, is_private: bool
+    ):
+        # copied from get_function_data
+        data = cls_data.methods.get(name)
+        report_base = self.classes[cls_key].functions
+
+        report_data = report_base.get(name)
+        if not report_data:
+            report_data = FnReportData()
+            report_base[name] = report_data
+
+        missing = data is None
+        report_data.missing = missing and not is_private
+
+        # We count this as an overload because it might be
+        report_data.tracker.add_overload()
+
     def get_cls_prop_data(
         self, name: str, cls_key: str, cls_data: ClassData
     ) -> PropData:
@@ -169,22 +193,39 @@ def report_missing(self, name: str, reporter: "MissingReporter"):
         data yaml and print it out if there's missing data
         """
 
+        ignore_default = self.data.defaults.ignore
+        report_missing = True
+        if ignore_default and not self.data.defaults.report_ignored_missing:
+            report_missing = False
+
         # note: sometimes we have strings from CppHeaderParser that aren't
         # strings, so we need to cast them to str so yaml doesn't complain
 
         data = self._process_missing(
-            self.attributes, self.functions, self.enums, "functions"
+            self.attributes,
+            self.functions,
+            self.enums,
+            "functions",
+            ignore_default,
+            report_missing,
         )
 
         all_cls_data = {}
         for cls_key, cls_data in self.classes.items():
+            if cls_data.missing and not report_missing:
+                continue
+
             result = self._process_missing(
                 cls_data.attributes,
                 cls_data.functions,
                 cls_data.enums,
                 "methods",
+                False,
+                True,
             )
             if result or cls_data.missing:
+                if ignore_default and cls_data.missing:
+                    result["ignore"] = True
                 all_cls_data[str(cls_key)] = result
         if all_cls_data:
             data["classes"] = all_cls_data
@@ -200,6 +241,8 @@ def _process_missing(
         fns: FnMissingData,
         enums: EnumMissingData,
         fn_key: str,
+        ignore_default: bool,
+        report_missing: bool,
     ):
         data: Dict[str, Dict[str, Dict]] = {}
 
@@ -212,11 +255,22 @@ def _process_missing(
 
         # enums
         if enums:
-            data["enums"] = {str(n): {} for n in enums.keys()}
+            enums_report = {}
+            for en, enum_present in enums.items():
+                if not enum_present and not report_missing:
+                    continue
+                enums_report[en] = {}
+                if ignore_default:
+                    enums_report[en]["ignore"] = True
+            if enums_report:
+                data["enums"] = enums_report
 
         # functions
         fn_report = {}
         for fn, fndata in fns.items():
+            if fndata.missing and not report_missing:
+                continue
+
             fn = str(fn)
             overloads = fndata.overloads
             deferred_signatures = fndata.deferred_signatures
@@ -246,8 +300,12 @@ def _process_missing(
                     for k, v in fn_report[fn]["overloads"].items():
                         if "initializer_list" in k:
                             v["ignore"] = True
+                        if ignore_default:
+                            v["ignore"] = True
                 else:
                     fn_report[fn] = d
+                    if ignore_default:
+                        d["ignore"] = True
         if fn_report:
             data[fn_key] = fn_report