Remove demangled type value nodes

plafosse · plafosse · commit 1cd85f572886 · 2026-05-16T14:59:04.000+02:00
diff --git a/demangler/gnu3/demangled_type_node.cpp b/demangler/gnu3/demangled_type_node.cpp
@@ -618,18 +618,9 @@ DemangledTypeNode DemangledTypeNode::WideCharType(size_t width, const string& al
 }
 
 
-DemangledTypeNode DemangledTypeNode::ValueType(const string& value)
-{
-	DemangledTypeNode n;
-	n.m_typeClass = ValueTypeClass;
-	n.m_altName = value;
-	return n;
-}
-
-
 DemangledTypeNode DemangledTypeNode::NameSegment(const string& name)
 {
-	return ValueType(name);
+	return NamedType(UnknownNamedTypeClass, StringList{name});
 }
 
 
@@ -1037,8 +1028,6 @@ void DemangledTypeNode::SetTemplateArguments(vector<Param> args, bool spaceAfter
 
 string DemangledTypeNode::GetNameSegmentBase() const
 {
-	if (m_typeClass == ValueTypeClass)
-		return m_altName;
 	if (!m_nameSegments.empty())
 		return m_nameSegments.back();
 	if (!m_nameSegmentNodes.empty())
@@ -1049,11 +1038,6 @@ string DemangledTypeNode::GetNameSegmentBase() const
 
 void DemangledTypeNode::SetNameSegmentBase(const string& name)
 {
-	if (m_typeClass == ValueTypeClass)
-	{
-		m_altName = name;
-		return;
-	}
 	if (!m_nameSegments.empty())
 	{
 		m_nameSegments.back() = name;
@@ -1064,8 +1048,9 @@ void DemangledTypeNode::SetNameSegmentBase(const string& name)
 		m_nameSegmentNodes.back().SetNameSegmentBase(name);
 		return;
 	}
-	m_typeClass = ValueTypeClass;
-	m_altName = name;
+	m_typeClass = NamedTypeReferenceClass;
+	m_ntrClass = UnknownNamedTypeClass;
+	m_nameSegments = StringList{name};
 }
 
 
@@ -1166,7 +1151,7 @@ void DemangledTypeNode::AppendPointerSuffix(string& out) const
 
 void DemangledTypeNode::AppendTemplateArguments(string& out) const
 {
-	if (m_templateArgs.empty() && m_hasTemplateArgs && m_typeClass == ValueTypeClass)
+	if (m_templateArgs.empty() && m_hasTemplateArgs)
 	{
 		out += "<>";
 		return;
@@ -1177,12 +1162,6 @@ void DemangledTypeNode::AppendTemplateArguments(string& out) const
 
 void DemangledTypeNode::AppendNameSegment(string& out) const
 {
-	if (m_typeClass == ValueTypeClass)
-	{
-		out += m_altName;
-		AppendTemplateArguments(out);
-		return;
-	}
 	if (m_typeClass == NamedTypeReferenceClass)
 	{
 		AppendTypeName(out);
@@ -1391,11 +1370,6 @@ void DemangledTypeNode::AppendBeforeName(string& out, const DemangledTypeNode* p
 		AppendModifiers(out);
 		break;
 
-	case ValueTypeClass:
-		out += m_altName;
-		AppendTemplateArguments(out);
-		break;
-
 	default:
 		break;
 	}
@@ -1585,9 +1559,6 @@ Ref<Type> DemangledTypeNode::Finalize(Architecture* arch, Platform* platform) co
 		return tb.Finalize();
 	}
 
-	case ValueTypeClass:
-		return Type::ValueType(m_altName);
-
 	case PointerTypeClass:
 	{
 		Ref<Type> child = m_childType ? m_childType->Finalize(arch, platform) : Ref<Type>(Type::VoidType());
diff --git a/demangler/gnu3/demangled_type_node.h b/demangler/gnu3/demangled_type_node.h
@@ -173,7 +173,6 @@ class DemangledTypeNode
 	static DemangledTypeNode AddressSizedIntegerType(bool isSigned, const _STD_STRING& altName = "");
 	static DemangledTypeNode FloatType(size_t width, const _STD_STRING& altName = "");
 	static DemangledTypeNode WideCharType(size_t width, const _STD_STRING& altName = "");
-	static DemangledTypeNode ValueType(const _STD_STRING& value);
 	static DemangledTypeNode NameSegment(const _STD_STRING& name);
 	static DemangledTypeNode VarArgsType();
 	static DemangledTypeNode PointerType(DemangledTypeNode child, bool cnst, bool vltl, BNReferenceType refType);
@@ -215,7 +214,7 @@ class DemangledTypeNode
 	bool HasVariableArguments() const { return m_hasVariableArgs; }
 	BNNameType GetNameType() const { return m_nameType; }
 	bool HasTemplateArguments() const;
-	bool HasOwnTemplateArguments() const { return !m_templateArgs.empty() || (m_hasTemplateArgs && m_typeClass == ValueTypeClass); }
+	bool HasOwnTemplateArguments() const { return m_hasTemplateArgs || !m_templateArgs.empty(); }
 	const _STD_VECTOR<Param>& GetTemplateArguments() const { return m_templateArgs; }
 	uint8_t GetPointerSuffixBits() const { return m_pointerSuffixBits; }
 	bool HasPointerSuffix(BNPointerSuffix ps) const { return (m_pointerSuffixBits & PointerSuffixBit(ps)) != 0; }
diff --git a/demangler/msvc/demangle_msvc.cpp b/demangler/msvc/demangle_msvc.cpp
@@ -313,7 +313,7 @@ DemangledTypeNode Demangle::DemangleReferencedSymbolValue(BackrefList& varList)
 		string value = "&" + context.type.GetTypeAndName(FinalizeNameList(m_varName));
 		m_varName = std::move(savedVarName);
 
-		return DemangledTypeNode::ValueType(value);
+		return DemangledTypeNode::NameSegment(value);
 	}
 	catch (const DemangleException&)
 	{
@@ -330,7 +330,7 @@ DemangledTypeNode Demangle::DemangleAutoNonTypeTemplateParam(BackrefList& varLis
 		reader.Consume();
 		int64_t value;
 		DemangleNumber(value);
-		return DemangledTypeNode::ValueType(to_string(value));
+		return DemangledTypeNode::NameSegment(to_string(value));
 	}
 	if (reader.Peek() == '1')
 	{
@@ -601,7 +601,7 @@ DemangledTypeNode Demangle::DemangleVarType(BackrefList& varList, bool isReturn,
 			reader.Consume();
 			int64_t value;
 			DemangleNumber(value);
-			return DemangledTypeNode::ValueType(to_string(value));
+			return DemangledTypeNode::NameSegment(to_string(value));
 		}
 		else if (reader.Peek() == 'D')
 		{
@@ -639,7 +639,7 @@ DemangledTypeNode Demangle::DemangleVarType(BackrefList& varList, bool isReturn,
 				value += "," + to_string(adj);
 			}
 			value += "}";
-			return DemangledTypeNode::ValueType(value);
+			return DemangledTypeNode::NameSegment(value);
 		}
 		else if (reader.Peek() == '1')
 		{

Original file line number	Diff line number	Diff line change
`@@ -618,18 +618,9 @@ DemangledTypeNode DemangledTypeNode::WideCharType(size_t width, const string& al`
`618`	`618`	`}`
`619`	`619`
`620`	`620`
`621`		`-DemangledTypeNode DemangledTypeNode::ValueType(const string& value)`
`622`		`-{`
`623`		`- DemangledTypeNode n;`
`624`		`- n.m_typeClass = ValueTypeClass;`
`625`		`- n.m_altName = value;`
`626`		`- return n;`
`627`		`-}`
`628`		`-`
`629`		`-`
`630`	`621`	`DemangledTypeNode DemangledTypeNode::NameSegment(const string& name)`
`631`	`622`	`{`
`632`		`- return ValueType(name);`
	`623`	`+ return NamedType(UnknownNamedTypeClass, StringList{name});`
`633`	`624`	`}`
`634`	`625`
`635`	`626`
`@@ -1037,8 +1028,6 @@ void DemangledTypeNode::SetTemplateArguments(vector<Param> args, bool spaceAfter`
`1037`	`1028`
`1038`	`1029`	`string DemangledTypeNode::GetNameSegmentBase() const`
`1039`	`1030`	`{`
`1040`		`- if (m_typeClass == ValueTypeClass)`
`1041`		`- return m_altName;`
`1042`	`1031`	`if (!m_nameSegments.empty())`
`1043`	`1032`	`return m_nameSegments.back();`
`1044`	`1033`	`if (!m_nameSegmentNodes.empty())`
`@@ -1049,11 +1038,6 @@ string DemangledTypeNode::GetNameSegmentBase() const`
`1049`	`1038`
`1050`	`1039`	`void DemangledTypeNode::SetNameSegmentBase(const string& name)`
`1051`	`1040`	`{`
`1052`		`- if (m_typeClass == ValueTypeClass)`
`1053`		`- {`
`1054`		`- m_altName = name;`
`1055`		`- return;`
`1056`		`- }`
`1057`	`1041`	`if (!m_nameSegments.empty())`
`1058`	`1042`	`{`
`1059`	`1043`	`m_nameSegments.back() = name;`
`@@ -1064,8 +1048,9 @@ void DemangledTypeNode::SetNameSegmentBase(const string& name)`
`1064`	`1048`	`m_nameSegmentNodes.back().SetNameSegmentBase(name);`
`1065`	`1049`	`return;`
`1066`	`1050`	`}`
`1067`		`- m_typeClass = ValueTypeClass;`
`1068`		`- m_altName = name;`
	`1051`	`+ m_typeClass = NamedTypeReferenceClass;`
	`1052`	`+ m_ntrClass = UnknownNamedTypeClass;`
	`1053`	`+ m_nameSegments = StringList{name};`
`1069`	`1054`	`}`
`1070`	`1055`
`1071`	`1056`
`@@ -1166,7 +1151,7 @@ void DemangledTypeNode::AppendPointerSuffix(string& out) const`
`1166`	`1151`
`1167`	`1152`	`void DemangledTypeNode::AppendTemplateArguments(string& out) const`
`1168`	`1153`	`{`
`1169`		`- if (m_templateArgs.empty() && m_hasTemplateArgs && m_typeClass == ValueTypeClass)`
	`1154`	`+ if (m_templateArgs.empty() && m_hasTemplateArgs)`
`1170`	`1155`	`{`
`1171`	`1156`	`out += "<>";`
`1172`	`1157`	`return;`
`@@ -1177,12 +1162,6 @@ void DemangledTypeNode::AppendTemplateArguments(string& out) const`
`1177`	`1162`
`1178`	`1163`	`void DemangledTypeNode::AppendNameSegment(string& out) const`
`1179`	`1164`	`{`
`1180`		`- if (m_typeClass == ValueTypeClass)`
`1181`		`- {`
`1182`		`- out += m_altName;`
`1183`		`- AppendTemplateArguments(out);`
`1184`		`- return;`
`1185`		`- }`
`1186`	`1165`	`if (m_typeClass == NamedTypeReferenceClass)`
`1187`	`1166`	`{`
`1188`	`1167`	`AppendTypeName(out);`
`@@ -1391,11 +1370,6 @@ void DemangledTypeNode::AppendBeforeName(string& out, const DemangledTypeNode* p`
`1391`	`1370`	`AppendModifiers(out);`
`1392`	`1371`	`break;`
`1393`	`1372`
`1394`		`- case ValueTypeClass:`
`1395`		`- out += m_altName;`
`1396`		`- AppendTemplateArguments(out);`
`1397`		`- break;`
`1398`		`-`
`1399`	`1373`	`default:`
`1400`	`1374`	`break;`
`1401`	`1375`	`}`
`@@ -1585,9 +1559,6 @@ Ref<Type> DemangledTypeNode::Finalize(Architecture* arch, Platform* platform) co`
`1585`	`1559`	`return tb.Finalize();`
`1586`	`1560`	`}`
`1587`	`1561`
`1588`		`- case ValueTypeClass:`
`1589`		`- return Type::ValueType(m_altName);`
`1590`		`-`
`1591`	`1562`	`case PointerTypeClass:`
`1592`	`1563`	`{`
`1593`	`1564`	`Ref<Type> child = m_childType ? m_childType->Finalize(arch, platform) : Ref<Type>(Type::VoidType());`
Original file line number	Diff line number	Diff line change
`@@ -313,7 +313,7 @@ DemangledTypeNode Demangle::DemangleReferencedSymbolValue(BackrefList& varList)`
`313`	`313`	`string value = "&" + context.type.GetTypeAndName(FinalizeNameList(m_varName));`
`314`	`314`	`m_varName = std::move(savedVarName);`
`315`	`315`
`316`		`- return DemangledTypeNode::ValueType(value);`
	`316`	`+ return DemangledTypeNode::NameSegment(value);`
`317`	`317`	`}`
`318`	`318`	`catch (const DemangleException&)`
`319`	`319`	`{`
`@@ -330,7 +330,7 @@ DemangledTypeNode Demangle::DemangleAutoNonTypeTemplateParam(BackrefList& varLis`
`330`	`330`	`reader.Consume();`
`331`	`331`	`int64_t value;`
`332`	`332`	`DemangleNumber(value);`
`333`		`- return DemangledTypeNode::ValueType(to_string(value));`
	`333`	`+ return DemangledTypeNode::NameSegment(to_string(value));`
`334`	`334`	`}`
`335`	`335`	`if (reader.Peek() == '1')`
`336`	`336`	`{`
`@@ -601,7 +601,7 @@ DemangledTypeNode Demangle::DemangleVarType(BackrefList& varList, bool isReturn,`
`601`	`601`	`reader.Consume();`
`602`	`602`	`int64_t value;`
`603`	`603`	`DemangleNumber(value);`
`604`		`- return DemangledTypeNode::ValueType(to_string(value));`
	`604`	`+ return DemangledTypeNode::NameSegment(to_string(value));`
`605`	`605`	`}`
`606`	`606`	`else if (reader.Peek() == 'D')`
`607`	`607`	`{`
`@@ -639,7 +639,7 @@ DemangledTypeNode Demangle::DemangleVarType(BackrefList& varList, bool isReturn,`
`639`	`639`	`value += "," + to_string(adj);`
`640`	`640`	`}`
`641`	`641`	`value += "}";`
`642`		`- return DemangledTypeNode::ValueType(value);`
	`642`	`+ return DemangledTypeNode::NameSegment(value);`
`643`	`643`	`}`
`644`	`644`	`else if (reader.Peek() == '1')`
`645`	`645`	`{`