Add equality operators to symbolt and symbol_tablet

This adds equality member operators to symbolt and symbol_tablet. They will be
useful in unit tests to check that when outputting a symbol table in JSON and
reading it back in again the same symbol table is obtained.

Author: danpoe

src/util/symbol.cpp

@@ -144,3 +144,34 @@ bool symbolt::is_well_formed() const
 
   return true;
 }
+
+bool symbolt::operator==(const symbolt &other) const
+{
+  // clang-format off
+  return
+    type == other.type &&
+    value == other.value &&
+    location == other.location &&
+    name == other.name &&
+    module == other.module &&
+    base_name == other.base_name &&
+    mode == other.mode &&
+    pretty_name == other.pretty_name &&
+    is_type == other.is_type &&
+    is_macro == other.is_macro &&
+    is_exported == other.is_exported &&
+    is_input == other.is_input &&
+    is_output == other.is_output &&
+    is_state_var == other.is_state_var &&
+    is_property == other.is_property &&
+    is_parameter == other.is_parameter &&
+    is_auxiliary == other.is_auxiliary &&
+    is_weak == other.is_weak &&
+    is_lvalue == other.is_lvalue &&
+    is_static_lifetime == other.is_static_lifetime &&
+    is_thread_local == other.is_thread_local &&
+    is_file_local == other.is_file_local &&
+    is_extern == other.is_extern &&
+    is_volatile == other.is_volatile;
+  // clang-format on
+}

src/util/symbol.h

@@ -124,6 +124,8 @@ class symbolt
 
   /// Check that a symbol is well formed.
   bool is_well_formed() const;
+
+  bool operator==(const symbolt &other) const;
 };
 
 std::ostream &operator<<(std::ostream &out, const symbolt &symbol);

src/util/symbol_table.cpp

@@ -6,6 +6,8 @@
 #include <util/invariant.h>
 #include <util/validate.h>
 
+#include <set>
+
 /// Move or copy a new symbol to the symbol table.
 /// \remarks This is a nicer interface than move and achieves the same
 ///   result as both move and add.
@@ -219,3 +221,42 @@ void symbol_tablet::validate(const validation_modet vm) const
       "'");
   }
 }
+
+bool symbol_tablet::operator==(const symbol_tablet &other) const
+{
+  // we cannot use == for comparing the multimaps as it compares the items
+  // sequentially, but the order of items with equal keys depends on the
+  // insertion order
+
+  {
+    std::vector<std::pair<irep_idt, irep_idt>> v1(
+      internal_symbol_base_map.begin(), internal_symbol_base_map.end());
+
+    std::vector<std::pair<irep_idt, irep_idt>> v2(
+      other.internal_symbol_base_map.begin(),
+      other.internal_symbol_base_map.end());
+
+    std::sort(v1.begin(), v1.end());
+    std::sort(v2.begin(), v2.end());
+
+    if(v1 != v2)
+      return false;
+  }
+
+  {
+    std::vector<std::pair<irep_idt, irep_idt>> v1(
+      internal_symbol_module_map.begin(), internal_symbol_module_map.end());
+
+    std::vector<std::pair<irep_idt, irep_idt>> v2(
+      other.internal_symbol_module_map.begin(),
+      other.internal_symbol_module_map.end());
+
+    std::sort(v1.begin(), v1.end());
+    std::sort(v2.begin(), v2.end());
+
+    if(v1 != v2)
+      return false;
+  }
+
+  return internal_symbols == other.internal_symbols;
+}

src/util/symbol_table.h

@@ -119,6 +119,8 @@ class symbol_tablet : public symbol_table_baset
 
   /// Check that the symbol table is well-formed
   void validate(const validation_modet vm = validation_modet::INVARIANT) const;
+
+  bool operator==(const symbol_tablet &other) const;
 };
 
 #endif // CPROVER_UTIL_SYMBOL_TABLE_H