feat: support template parameter packs and default values

Author: wu-vincent

src/dwarf2cpp/models.py

@@ -201,6 +201,7 @@ class TemplateParameter:
     kind: TemplateParameterKind
     type: str | None = None
     arg: str | None = field(default=None, compare=False)
+    pack: list["TemplateParameter"] | None = field(default_factory=list, compare=False)
     default: str | None = None
 
 

src/dwarf2cpp/templates/template.jinja

@@ -2,9 +2,9 @@
 template<
 {%- for parameter in obj.parameters -%}
   {%- if parameter.kind == "type" -%}
-    typename{{ " " ~ parameter.name if parameter.name }}{{ " = {}".format(parameter.default) if parameter.default }}
+    typename{{ " " ~ parameter.name if parameter.name }}{{ " = {}".format(parameter.default) if parameter.default is not none }}
   {%- elif parameter.kind == "constant" -%}
-    {{ parameter.type }}{{ " " ~ parameter.name if parameter.name }}
+    {{ parameter.type }}{{ " " ~ parameter.name if parameter.name }}{{ " = {}".format(parameter.default) if parameter.default is not none }}
   {%- elif parameter.kind == "pack" -%}
     typename...{{ " " ~ parameter.name if parameter.name }}
   {%- elif parameter.kind == "template" -%}

src/dwarf2cpp/visitor.py

@@ -107,11 +107,11 @@ def files(self) -> Generator[tuple[str, dict[int, list[Object]]]]:
             List of files
         """
         for i, cu in (
-                pbar := tqdm(
-                    enumerate(self.context.compile_units),
-                    total=self.context.num_compile_units,
-                    bar_format="[{n_fmt}/{total_fmt}] {desc}",
-                )
+            pbar := tqdm(
+                enumerate(self.context.compile_units),
+                total=self.context.num_compile_units,
+                bar_format="[{n_fmt}/{total_fmt}] {desc}",
+            )
         ):
             cu_die = cu.unit_die
             name = cu_die.short_name
@@ -632,11 +632,50 @@ def visit_template_type_parameter(self, die: DWARFDie) -> None:
         self._cache[die.offset] = param
 
     def visit_template_value_parameter(self, die: DWARFDie) -> None:
-        ty = get_qualified_type(die.find("DW_AT_type").as_referenced_die())
-        self._cache[die.offset] = TemplateParameter(die.short_name, TemplateParameterKind.CONSTANT, type=ty)
+        param = TemplateParameter(die.short_name, TemplateParameterKind.CONSTANT)
+        param.type = get_qualified_type(die.find("DW_AT_type").as_referenced_die())
+
+        if value := die.find("DW_AT_const_value"):
+            param.arg = value.as_constant()
+
+        for attribute in die.attributes:
+            if attribute.name in {"DW_AT_name", "DW_AT_type", "DW_AT_const_value", "DW_AT_location"}:
+                continue
+
+            match attribute.name:
+                case "DW_AT_default_value":
+                    param.default = param.arg
+                case _:
+                    raise ValueError(f"Unhandled attribute {attribute.name}")
+
+        for child in die.children:
+            raise ValueError(f"Unhandled child tag {child.tag}")
+
+        self._cache[die.offset] = param
 
     def visit_GNU_template_parameter_pack(self, die: DWARFDie) -> None:
-        self._cache[die.offset] = TemplateParameter(die.short_name, TemplateParameterKind.PACK)
+        param = TemplateParameter(die.short_name, TemplateParameterKind.PACK)
+
+        for attribute in die.attributes:
+            if attribute.name in {"DW_AT_name"}:
+                continue
+
+            match attribute.name:
+                case _:
+                    raise ValueError(f"Unhandled attribute {attribute.name}")
+
+        pack = []
+        for child in die.children:
+            if child.tag in {"DW_TAG_template_type_parameter", "DW_TAG_template_value_parameter"}:
+                self.visit(child)
+                pack.append(self._cache[child.offset])
+            else:
+                raise ValueError(f"Unhandled child tag {child.tag}")
+
+        if pack:
+            param.pack = pack
+
+        self._cache[die.offset] = param
 
     def visit_GNU_template_template_param(self, die: DWARFDie) -> None:
         self._cache[die.offset] = TemplateParameter(die.short_name, TemplateParameterKind.TEMPLATE)
@@ -661,9 +700,11 @@ def _register_template(self, key: str | int, lineno: int, template: Template) ->
         # make a copy for template declaration
         template = copy.copy(template)
         for parameter in template.parameters:
-            parameter.arg = None  # declaration must not have type replacement
+            # declaration must not have type replacement
+            parameter.arg = None
+            parameter.pack = None
 
-        # try to merge with existing templates
+            # try to merge with existing templates
         for t in templates:
             if t.merge(template):
                 return None