feat: improve template parameter parsing logics

Author: wu-vincent

src/dwarf2cpp/models.py

@@ -197,12 +197,41 @@ class TemplateParameterKind(enum.StrEnum):
 
 @dataclass
 class TemplateParameter:
-    name: str
     kind: TemplateParameterKind
-    type: str | None = None
-    arg: str | None = field(default=None, compare=False)
-    pack: list["TemplateParameter"] | None = field(default_factory=list, compare=False)
+    name: str | None = None
     default: str | None = None
+    type: str | None = None
+    value: str | None = None
+    parameters: list["TemplateParameter"] = field(default_factory=list)
+
+    def to_declaration(self) -> "TemplateParameter":
+        match self.kind:
+            case TemplateParameterKind.TYPE:
+                return TemplateParameter(
+                    TemplateParameterKind.TYPE,
+                    name=self.name,
+                    default=self.default,
+                )
+            case TemplateParameterKind.CONSTANT:
+                return TemplateParameter(
+                    TemplateParameterKind.CONSTANT,
+                    type=self.type,
+                    name=self.name,
+                    default=self.default,
+                )
+            case TemplateParameterKind.TEMPLATE:
+                return TemplateParameter(
+                    TemplateParameterKind.TEMPLATE,
+                    parameters=[p.to_declaration() for p in self.parameters],
+                    name=self.name,
+                    default=self.default,
+                )
+            case TemplateParameterKind.PACK:
+                return TemplateParameter(
+                    TemplateParameterKind.PACK,
+                    parameters=[p.to_declaration() for p in self.parameters],
+                    name=self.name,
+                )
 
 
 @dataclass
@@ -223,16 +252,10 @@ def merge(self, other: "Template") -> bool:
             return False
 
         for p1, p2 in zip(self.parameters, other.parameters):
-            if (
-                p1.name != p2.name
-                or p1.kind != p2.kind
-                or p1.type != p2.type
-                or p1.arg is not None
-                or p2.arg is not None
-            ):
+            if p1.name != p2.name or p1.kind != p2.kind:
                 return False
 
         for p1, p2 in zip(self.parameters, other.parameters):
-            p1.default = p1.default or p2.default
+            raise NotImplementedError
 
         return True

src/dwarf2cpp/visitor.py

@@ -607,22 +607,22 @@ def visit_imported_declaration(self, die: DWARFDie) -> None:
         self._cache[die.offset] = imported_decl
 
     def visit_template_type_parameter(self, die: DWARFDie) -> None:
-        param = TemplateParameter(die.short_name, TemplateParameterKind.TYPE)
+        param = TemplateParameter(TemplateParameterKind.TYPE, name=die.short_name)
 
         # A template type parameter entry has a DW_AT_type attribute
         # describing the actual type by which the formal is replaced.
         if ty := die.find("DW_AT_type"):
-            param.arg = get_qualified_type(ty.as_referenced_die())
+            param.type = get_qualified_type(ty.as_referenced_die())
         else:
-            param.arg = "void"
+            param.type = "void"
 
         for attribute in die.attributes:
             if attribute.name in {"DW_AT_name", "DW_AT_type"}:
                 continue
 
             match attribute.name:
                 case "DW_AT_default_value":
-                    param.default = param.arg
+                    param.default = param.type
                 case _:
                     raise ValueError(f"Unhandled attribute {attribute.name}")
 
@@ -632,19 +632,19 @@ def visit_template_type_parameter(self, die: DWARFDie) -> None:
         self._cache[die.offset] = param
 
     def visit_template_value_parameter(self, die: DWARFDie) -> None:
-        param = TemplateParameter(die.short_name, TemplateParameterKind.CONSTANT)
+        param = TemplateParameter(TemplateParameterKind.CONSTANT, name=die.short_name)
         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()
+            param.value = 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
+                    param.default = param.value
                 case _:
                     raise ValueError(f"Unhandled attribute {attribute.name}")
 
@@ -654,7 +654,7 @@ def visit_template_value_parameter(self, die: DWARFDie) -> None:
         self._cache[die.offset] = param
 
     def visit_GNU_template_parameter_pack(self, die: DWARFDie) -> None:
-        param = TemplateParameter(die.short_name, TemplateParameterKind.PACK)
+        param = TemplateParameter(TemplateParameterKind.PACK, name=die.short_name)
 
         for attribute in die.attributes:
             if attribute.name in {"DW_AT_name"}:
@@ -664,21 +664,49 @@ def visit_GNU_template_parameter_pack(self, die: DWARFDie) -> None:
                 case _:
                     raise ValueError(f"Unhandled attribute {attribute.name}")
 
-        pack = []
+        pack_type = None
+        parameters = []
         for child in die.children:
-            if child.tag in {"DW_TAG_template_type_parameter", "DW_TAG_template_value_parameter"}:
+            if child.tag == "DW_TAG_template_type_parameter":
+                assert pack_type is None, "Expected pack type to be None"
                 self.visit(child)
-                pack.append(self._cache[child.offset])
+                p = self._cache[child.offset]
+                parameters.append(p)
+            elif child.tag == "DW_TAG_template_value_parameter":
+                self.visit(child)
+                p = self._cache[child.offset]
+                if pack_type is None:
+                    assert len(parameters) == 0, "Expected no parameters"
+                    pack_type = p.type
+                else:
+                    assert p.type == pack_type, "Expected same type"
+                parameters.append(p)
             else:
                 raise ValueError(f"Unhandled child tag {child.tag}")
 
-        if pack:
-            param.pack = pack
+        if parameters:
+            param.parameters = parameters
 
         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)
+        param = TemplateParameter(TemplateParameterKind.TEMPLATE, name=die.short_name)
+
+        for attribute in die.attributes:
+            if attribute.name in {"DW_AT_name"}:
+                continue
+
+            match attribute.name:
+                case "DW_AT_GNU_template_name":
+                    param.type = attribute.value.as_string()
+                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
+        print(param)
 
     def generic_visit(self, die: DWARFDie) -> None:
         for child in die.children:
@@ -699,12 +727,9 @@ 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:
-            # declaration must not have type replacement
-            parameter.arg = None
-            parameter.pack = None
+        template.parameters = [p.to_declaration() for p in template.parameters]
 
-            # try to merge with existing templates
+        # try to merge with existing templates
         for t in templates:
             if t.merge(template):
                 return None