Fix C++ demangler type substitution and prefix handling

- Refactor Meta struct to use DemAstNode for detected_types instead of Name
  - Change detected_types from Vec(Name) to Vec(DemAstNode) for consistency
  - Update meta_copy, meta_move, and meta_deinit functions accordingly
  - Change current_prefix from DemString to DemAstNode

- Fix bugs in meta.c:
  - Remove duplicate 'is_const' assignment in meta_copy_scalars
  - Fix logic error in append_type (was checking !dem_string_empty, should be dem_string_empty)
  - Fix append_type to properly append NULL and copy node data
  - Fix indentation in append_tparam function

- Update find_type_index and meta_substitute_type to work with DemAstNode

- Simplify rule_prefix_tail in v3.c:
  - Replace complex backtracking logic with cleaner while-loop approach
  - Build fully qualified prefix incrementally
  - Properly update substitution table and current_prefix in each iteration

- Fix minor issues:
  - Add missing semicolon in types.h function declaration
  - Fix const qualifier in cpdem_get_demangled return type (v2.c)
  - Fix formatting in v3.c (spacing around 'else')
  - Update trace_graph.c to use DemAstNode instead of Name

- Add test timeout configuration in meson.build for slow tests (cxx_base)
  to handle large number of test cases with ASAN

Author: b1llow

meson.build

@@ -136,6 +136,10 @@ if get_option('enable_tests') and not meson.is_subproject()
     if get_option('b_sanitize').contains('undefined')
         test_dependencies += cc.find_library('ubsan')
     endif
+    # Tests that need longer timeout due to large number of test cases
+    # (especially when running with sanitizers like ASAN)
+    slow_tests = ['cxx_base']
+
     foreach test : tests
         exe = executable(
             'test_@0@'.format(test),
@@ -147,7 +151,11 @@ if get_option('enable_tests') and not meson.is_subproject()
             install_rpath : '',
             implicit_include_directories : false,
         )
-        test(test, exe)
+        if test in slow_tests
+            test(test, exe, timeout : 120)
+        else
+            test(test, exe)
+        endif
     endforeach
 
     foreach test : unit_tests

src/cplusplus/meta.c

@@ -15,7 +15,6 @@ static inline void meta_copy_scalars(Meta *dst, Meta *src) {
 	dst->is_const = src->is_const;
 	dst->is_ctor = src->is_ctor;
 	dst->is_dtor = src->is_dtor;
-	dst->is_const = src->is_const;
 	dst->trace = src->trace;
 	dst->template_idx_start = src->template_idx_start;
 	dst->last_reset_idx = src->last_reset_idx;
@@ -32,34 +31,46 @@ void meta_deinit(Meta *m) {
 		return;
 	}
 
-	VecF(Name, deinit)(&m->detected_types);
+	VecF(DemAstNode, deinit)(&m->detected_types);
 	VecF(Name, deinit)(&m->template_params);
-	dem_string_deinit(&m->current_prefix);
+	DemAstNode_deinit(&m->current_prefix);
 	memset(m, 0, sizeof(Meta));
 }
 
 bool meta_copy(Meta *dst, Meta *src) {
 	if (!(src && dst && src != dst)) {
 		return false;
 	}
+
 	meta_copy_scalars(dst, src);
-	// Copy current_prefix (not included in scalars because it needs cloning)
-	dem_string_deinit(&dst->current_prefix);
-	if (src->current_prefix.buf && src->current_prefix.len > 0) {
-		dem_string_init_clone(&dst->current_prefix, &src->current_prefix);
+
+	/* Reset destination dynamic members before cloning */
+	VecF(DemAstNode, deinit)(&dst->detected_types);
+	VecF(Name, deinit)(&dst->template_params);
+	DemAstNode_deinit(&dst->current_prefix);
+
+	vec_init(&dst->detected_types);
+	vec_init(&dst->template_params);
+
+	if (!DemAstNode_is_empty(&src->current_prefix)) {
+		DemAstNode_init_clone(&dst->current_prefix, &src->current_prefix);
+	} else {
+		DemAstNode_init(&dst->current_prefix);
 	}
+
 	vec_foreach_ptr(&src->detected_types, n, {
-		Name new_name = { 0 };
-		dem_string_init_clone(&new_name.name, &n->name);
-		new_name.num_parts = n->num_parts;
-		VecF(Name, append)(&dst->detected_types, &new_name);
+		DemAstNode cloned = { 0 };
+		DemAstNode_init_clone(&cloned, n);
+		VecF(DemAstNode, append)(&dst->detected_types, &cloned);
 	});
+
 	vec_foreach_ptr(&src->template_params, n, {
 		Name new_name = { 0 };
 		dem_string_init_clone(&new_name.name, &n->name);
 		new_name.num_parts = n->num_parts;
 		VecF(Name, append)(&dst->template_params, &new_name);
 	});
+
 	return true;
 }
 
@@ -68,14 +79,16 @@ void meta_move(Meta *dst, Meta *src) {
 		return;
 	}
 	meta_copy_scalars(dst, src);
-	// Move current_prefix
-	dem_string_deinit(&dst->current_prefix);
+
+	DemAstNode_deinit(&dst->current_prefix);
 	dst->current_prefix = src->current_prefix;
-	src->current_prefix = (DemString){ 0 };
-	VecF(Name, deinit)(&dst->detected_types);
+	src->current_prefix = (DemAstNode){ 0 };
+
+	VecF(DemAstNode, deinit)(&dst->detected_types);
 	VecF(Name, deinit)(&dst->template_params);
-	VecF(Name, move)(&dst->detected_types, &src->detected_types);
+	VecF(DemAstNode, move)(&dst->detected_types, &src->detected_types);
 	VecF(Name, move)(&dst->template_params, &src->template_params);
+
 	memset(src, 0, sizeof(Meta));
 }
 
@@ -159,7 +172,7 @@ bool is_builtin_type(const char *t) {
  * rules.
  */
 bool append_type(Meta *m, const DemAstNode *x, bool force_append) {
-	if (!m || !x || !dem_string_empty(&x->dem)) {
+	if (!m || !x || dem_string_empty(&x->dem)) {
 		return false;
 	}
 
@@ -205,7 +218,7 @@ bool append_type(Meta *m, const DemAstNode *x, bool force_append) {
 		});
 	}
 
-	DemAstNode *new_node = VecF(DemAstNode, append)(&m->detected_types, x);
+	DemAstNode *new_node = VecF(DemAstNode, append)(&m->detected_types, NULL);
 	DemAstNode_copy(new_node, x);
 	if (!count_name_parts(&new_node->dem)) {
 		m->detected_types.length--;
@@ -231,12 +244,12 @@ bool append_tparam(Meta *m, DemString *t) {
 	UNUSED(vec_reserve(&m->template_params, m->template_params.length + 1));
 	m->template_params.length += 1;
 
-	Name *new_name = vec_end(&m->template_params);
-	dem_string_init_clone(&new_name->name, t);
-	if (!count_name_parts(new_name)) {
-		m->template_params.length--;
-		return false;
-	}
+    Name *new_name = vec_end(&m->template_params);
+    dem_string_init_clone(&new_name->name, t);
+    if (!count_name_parts(&new_name->name)) {
+        m->template_params.length--;
+        return false;
+    }
 
 	return true;
 }
@@ -250,8 +263,8 @@ st64 find_type_index(Meta *m, const char *type_str) {
 		return -1;
 	}
 	for (ut64 i = 0; i < m->detected_types.length; i++) {
-		Name *dt = vec_ptr_at(&m->detected_types, i);
-		if (dt && dt->name.buf && !strcmp(dt->name.buf, type_str)) {
+		DemAstNode *dt = vec_ptr_at(&m->detected_types, i);
+		if (dt && dt->dem.buf && !strcmp(dt->dem.buf, type_str)) {
 			return (st64)i;
 		}
 	}
@@ -264,9 +277,9 @@ st64 find_type_index(Meta *m, const char *type_str) {
  */
 bool meta_substitute_type(Meta *m, ut64 id, DemString *dem) {
 	if (m->detected_types.length > id) {
-		Name *type_name = vec_ptr_at(&m->detected_types, id);
-		if (type_name && type_name->name.buf) {
-			dem_string_append(dem, type_name->name.buf);
+		DemAstNode *type_node = vec_ptr_at(&m->detected_types, id);
+		if (type_node && type_node->dem.buf) {
+			dem_string_append(dem, type_node->dem.buf);
 			return true;
 		}
 	}

src/cplusplus/trace_graph.c

@@ -318,7 +318,7 @@ void trace_graph_output_dot(TraceGraph *graph, const char *filename, Meta *meta)
 
 		// Add each detected type
 		for (size_t i = 0; i < meta->detected_types.length; i++) {
-			Name *type = vec_ptr_at(&meta->detected_types, i);
+			DemAstNode *type_node = vec_ptr_at(&meta->detected_types, i);
 			const char *sub_notation;
 
 			if (i == 0) {
@@ -333,13 +333,13 @@ void trace_graph_output_dot(TraceGraph *graph, const char *filename, Meta *meta)
 
 			// Escape HTML characters in the type name
 			char *escaped_name = NULL;
-			if (type->name.buf && type->name.len > 0) {
-				size_t escaped_len = type->name.len * 6 + 1; // worst case: all chars become &xxxx;
+			if (type_node && type_node->dem.buf && type_node->dem.len > 0) {
+				size_t escaped_len = type_node->dem.len * 6 + 1; // worst case: all chars become &xxxx;
 				escaped_name = calloc(escaped_len, sizeof(char));
 				if (escaped_name) {
-					const char *src = type->name.buf;
+					const char *src = type_node->dem.buf;
 					char *dst = escaped_name;
-					for (size_t j = 0; j < type->name.len && src[j]; j++) {
+					for (size_t j = 0; j < type_node->dem.len && src[j]; j++) {
 						switch (src[j]) {
 						case '<':
 							strcpy(dst, "&lt;");
@@ -374,7 +374,7 @@ void trace_graph_output_dot(TraceGraph *graph, const char *filename, Meta *meta)
 				f,
 				"          <TD><FONT FACE=\"Courier\">%s</FONT></TD>\n",
 				escaped_name ? escaped_name : "(empty)");
-			fprintf(f, "          <TD>%u</TD>\n", type->num_parts);
+			fprintf(f, "          <TD>%u</TD>\n", count_name_parts(&type_node->dem));
 			fprintf(f, "        </TR>\n");
 
 			if (escaped_name) {

src/cplusplus/types.h

@@ -225,7 +225,7 @@ bool meta_substitute_type(Meta *m, ut64 id, DemString *dem);
 bool meta_substitute_tparam(Meta *m, ut64 id, DemString *dem);
 st64 find_type_index(Meta *m, const char *type_str);
 
-ut32 count_name_parts(const DemString *x)
+ut32 count_name_parts(const DemString *x);
 bool is_builtin_type(const char *t);
 
 #endif // V3_IMPL_TYPES_H

src/cplusplus/v2.c

@@ -18,7 +18,7 @@
 // For name mangling scheme for GNU v3 ABI, see
 //   https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling-structure
 
-static const char *cpdem_get_demangled(CpDem *dem);
+static char *cpdem_get_demangled(CpDem *dem);
 static CpDem *cpdem_public_name(CpDem *dem);
 
 /* if base name comes with qualifiers then it's a class */
@@ -219,7 +219,7 @@ char *cpdem_get_demangled(CpDem *dem) {
 		dem_string_concat(&demangled, &dem->suffix);
 	}
 
-	const char *res = dem_str_ndup(demangled.buf, demangled.len);
+	char *res = dem_str_ndup(demangled.buf, demangled.len);
 	dem_string_deinit(&demangled);
 
 	return res;