[PATCH 1/5] XML writer: use consistent type pointers for type ids and emission tracking

[Matthias Maennich <maennich@google.com>]

Insertion resolves the canonical type, if available, but look-up did
not. Given that type id insertion and look-up also resolve canonical
types, it makes sense to adjust the remaining code accordingly.

Neither decl_only_type_is_emitted nor record_decl_only_type_as_emitted
do the check, but very few types end up being recorded this way.

The functions write_class_decl and write_union_decl (but not
write_class_decl_opening_tag and write_union_decl_opening_tag which
can be called in other contexts) resolve declaration-only types to a
definition where possible.

To ensure type ids consistently refer to the same resolved type we
should resolve canonical types and definitions-of-declarations more
consistently.

This change introduces get_preferred_type to return the exemplar type
that should be used for type id and emitted checks.

However, it does not also change all the write functions to write out
the exemplar types.

	* src/abg-writer.cc (get_preferred_type): new function.
	(type_has_existing_id): use get_preferred_type for resolution.
	(get_id_for_type): Likewise.
	(record_type_as_emitted): Likewise.
	(type_is_emitted): Likewise.

Reviewed-by: Giuliano Procida <gprocida@google.com>
Signed-off-by: Matthias Maennich <maennich@google.com>
---
 src/abg-writer.cc | 36 ++++++++++++++++++++++--------------
 1 file changed, 22 insertions(+), 14 deletions(-)

diff --git a/src/abg-writer.cc b/src/abg-writer.cc
index 21b79e888f31..9c3ae6f8d5b4 100644
--- a/src/abg-writer.cc
+++ b/src/abg-writer.cc
@@ -390,14 +390,25 @@ public:
   type_has_existing_id(type_base_sptr type) const
   {return type_has_existing_id(type.get());}
 
+  type_base*
+  get_preferred_type(const type_base* type) const
+  {
+    // declaration -> definition -> canonical is possible
+    if (decl_base* decl = look_through_decl_only(is_decl(type)))
+      {
+	type = is_type(decl);
+	ABG_ASSERT(type);
+      }
+    type_base* canonical = type->get_naked_canonical_type();
+    return canonical ? canonical : const_cast<type_base*>(type);
+  }
+
   /// @return true iff type has already been assigned an ID.
   bool
   type_has_existing_id(type_base* type) const
   {
-    type_base *c = type->get_naked_canonical_type();
-    if (c == 0)
-      c = const_cast<type_base*>(type);
-    return (m_type_id_map.find(c) != m_type_id_map.end());
+    type = get_preferred_type(type);
+    return m_type_id_map.find(type) != m_type_id_map.end();
   }
 
   /// Associate a unique id to a given type.  For that, put the type
@@ -413,11 +424,9 @@ public:
   /// associated to it, create a new one and return it.  Otherwise,
   /// return the existing id for that type.
   interned_string
-  get_id_for_type(const type_base* t) const
+  get_id_for_type(type_base* type) const
   {
-    type_base *c = t->get_naked_canonical_type();
-    if (c == 0)
-      c = const_cast<type_base*>(t);
+    type_base* c = get_preferred_type(type);
 
     type_ptr_map::const_iterator it = m_type_id_map.find(c);
     if (it != m_type_id_map.end())
@@ -715,11 +724,9 @@ public:
   ///
   /// @param t the type to flag.
   void
-  record_type_as_emitted(const type_base *t)
+  record_type_as_emitted(const type_base* t)
   {
-    type_base *c = t->get_naked_canonical_type();
-    if (c == 0)
-      c = const_cast<type_base*>(t);
+    type_base* c = get_preferred_type(t);
     m_emitted_type_set.insert(c);
   }
 
@@ -730,9 +737,10 @@ public:
   /// @return true if the type has already been emitted, false
   /// otherwise.
   bool
-  type_is_emitted(const type_base *t) const
+  type_is_emitted(const type_base* t) const
   {
-    return m_emitted_type_set.find(t) != m_emitted_type_set.end();
+    type_base* c = get_preferred_type(t);
+    return m_emitted_type_set.find(c) != m_emitted_type_set.end();
   }
 
   /// Test if a given type has been written out to the XML output.
-- 
2.34.1.400.ga245620fadb-goog