Use node equality for MSVC name backrefs

Author: plafosse

demangler/gnu3/demangled_type_node.cpp

@@ -445,6 +445,63 @@ bool DemangledTypeNode::HasTemplateArguments() const
 }
 
 
+bool DemangledTypeNode::IsStructurallyEqual(const DemangledTypeNode& other) const
+{
+	if (m_typeClass != other.m_typeClass || m_ntrClass != other.m_ntrClass ||
+		m_pointerReference != other.m_pointerReference || m_nameType != other.m_nameType ||
+		m_callingConventionName != other.m_callingConventionName ||
+		m_pointerSuffixBits != other.m_pointerSuffixBits ||
+		m_returnTypeConfidence != other.m_returnTypeConfidence ||
+		m_const != other.m_const || m_volatile != other.m_volatile ||
+		m_signed != other.m_signed || m_hasVariableArgs != other.m_hasVariableArgs ||
+		m_hasTemplateArgs != other.m_hasTemplateArgs || m_width != other.m_width ||
+		m_widthKind != other.m_widthKind || m_altName != other.m_altName ||
+		m_spaceAfterTemplateComma != other.m_spaceAfterTemplateComma ||
+		m_memberPointerOwnerName != other.m_memberPointerOwnerName ||
+		m_isMemberPointer != other.m_isMemberPointer || m_elements != other.m_elements ||
+		m_nameSegments != other.m_nameSegments)
+		return false;
+
+	auto nodesEqual = [](const vector<DemangledTypeNode>& a, const vector<DemangledTypeNode>& b) {
+		if (a.size() != b.size())
+			return false;
+		for (size_t i = 0; i < a.size(); i++)
+		{
+			if (!a[i].IsStructurallyEqual(b[i]))
+				return false;
+		}
+		return true;
+	};
+
+	if (!nodesEqual(m_nameSegmentNodes, other.m_nameSegmentNodes) ||
+		!nodesEqual(m_memberPointerOwnerNameNodes, other.m_memberPointerOwnerNameNodes))
+		return false;
+
+	auto typePtrsEqual = [](const std::shared_ptr<DemangledTypeNode>& a, const std::shared_ptr<DemangledTypeNode>& b) {
+		if (!a || !b)
+			return a == b;
+		return a->IsStructurallyEqual(*b);
+	};
+
+	if (!typePtrsEqual(m_childType, other.m_childType) ||
+		!typePtrsEqual(m_implicitThisParameterType, other.m_implicitThisParameterType))
+		return false;
+
+	auto paramsEqual = [&typePtrsEqual](const vector<Param>& a, const vector<Param>& b) {
+		if (a.size() != b.size())
+			return false;
+		for (size_t i = 0; i < a.size(); i++)
+		{
+			if (a[i].name != b[i].name || !typePtrsEqual(a[i].type, b[i].type))
+				return false;
+		}
+		return true;
+	};
+
+	return paramsEqual(m_templateArgs, other.m_templateArgs) && paramsEqual(m_params, other.m_params);
+}
+
+
 void DemangledTypeNode::SetTemplateArguments(vector<Param> args, bool spaceAfterComma)
 {
 	m_templateArgs = std::move(args);

demangler/gnu3/demangled_type_node.h

@@ -126,6 +126,7 @@ class DemangledTypeNode
 	bool IsMemberPointer() const { return m_isMemberPointer; }
 	const StringList& GetMemberPointerOwnerName() const { return m_memberPointerOwnerName; }
 	StringList RenderTypeNameSegments() const;
+	bool IsStructurallyEqual(const DemangledTypeNode& other) const;
 
 	void SetTypeName(StringList name) { m_nameSegments = std::move(name); m_nameSegmentNodes.clear(); }
 	void SetTypeName(_STD_VECTOR<DemangledTypeNode> name) { m_nameSegmentNodes = std::move(name); m_nameSegments.clear(); }

demangler/msvc/demangle_msvc.cpp

@@ -93,10 +93,9 @@ void Demangle::BackrefList::PushNameBackref(const DemangledTypeNode& t)
 {
 	if (t.NameStringSize() > MAX_DEMANGLE_LENGTH)
 		throw DemangleException();
-	string rendered = t.GetString();
-	MSVC_TRACE("this: %p - Backref: %zu - %s\n", this, nameList.size(), rendered.c_str());
+	MSVC_TRACE("this: %p - Backref: %zu\n", this, nameList.size());
 	for (const auto& name : nameList)
-		if (name.GetString() == rendered)
+		if (name.IsStructurallyEqual(t))
 			return;
 	if (nameList.size() <= 9)
 		nameList.push_back(t);