Fixed the failing ANSI-C test caused by typedef types not being equal

Previously, basic types were being compared by directly calling
operator== on the two types. However, we now add a flag to all types
defined with a typedef saying what the typedef'd name was. This was
causing the two types to not be equal.

Now, instead of directly comparing them, we remove the ID_C_typedef flag
from them if present and then compare the resulting types.

Also added a few more checks to the test to cover some other typedef
cases.

Author: thk123

regression/ansi-c/gcc_types_compatible_p1/main.c

@@ -7,6 +7,14 @@ double d;
 typedef enum T1 { hot, dog, poo, bear } dingos;
 typedef enum T2 { janette, laura, amanda } cranberry;
 
+typedef enum AnonEnum { jim, bob, fred } names;
+
+typedef dingos altdingos;
+typedef dingos diffdingos;
+
+typedef names altnames;
+typedef names diffnames;
+
 typedef float same1;
 typedef float same2;
 
@@ -52,6 +60,9 @@ STATIC_ASSERT(__builtin_types_compatible_p(typeof (dingos), unsigned)); // ha!
 STATIC_ASSERT(__builtin_types_compatible_p(typeof (hot), typeof (laura)));
 STATIC_ASSERT(__builtin_types_compatible_p(int[5], int[]));
 STATIC_ASSERT(__builtin_types_compatible_p(same1, same2));
+STATIC_ASSERT(__builtin_types_compatible_p(dingos, altdingos));
+STATIC_ASSERT(__builtin_types_compatible_p(diffdingos, altdingos));
+STATIC_ASSERT(__builtin_types_compatible_p(diffnames, altnames));
 STATIC_ASSERT(__builtin_types_compatible_p(typeof (hot) *, int *));
 STATIC_ASSERT(__builtin_types_compatible_p(typeof (hot), typeof (janette)));
 STATIC_ASSERT(__builtin_types_compatible_p(__int128, signed __int128));
@@ -84,7 +95,6 @@ STATIC_ASSERT(!__builtin_types_compatible_p(__float128, long double));
 STATIC_ASSERT(!__builtin_types_compatible_p(__float128, double));
 STATIC_ASSERT(!__builtin_types_compatible_p(__int128, unsigned __int128));
 #endif
-
 #endif
 
 int main(void)

regression/ansi-c/gcc_types_compatible_p4/main.c

@@ -0,0 +1,27 @@
+#define STATIC_ASSERT(condition) \
+  int some_array[(condition) ? 1 : -1];
+
+typedef struct struct_tag
+{
+  int x;
+  float y;
+} struct_typedef;
+
+typedef struct struct_tag alt_typedef;
+typedef struct_typedef another_typedef;
+
+#ifdef __GNUC__
+
+
+STATIC_ASSERT(__builtin_types_compatible_p(struct struct_tag, struct_typedef));
+STATIC_ASSERT(__builtin_types_compatible_p(struct struct_tag, alt_typedef));
+STATIC_ASSERT(__builtin_types_compatible_p(struct struct_tag, another_typedef));
+STATIC_ASSERT(__builtin_types_compatible_p(struct_typedef, alt_typedef));
+STATIC_ASSERT(__builtin_types_compatible_p(struct_typedef, another_typedef));
+STATIC_ASSERT(__builtin_types_compatible_p(alt_typedef, another_typedef));
+
+#endif
+
+int main(void)
+{
+}

regression/ansi-c/gcc_types_compatible_p4/test.desc

@@ -0,0 +1,8 @@
+CORE
+main.c
+
+^EXIT=0$
+^SIGNAL=0$
+--
+^warning: ignoring
+^CONVERSION ERROR$

src/ansi-c/c_typecheck_base.h

@@ -262,6 +262,10 @@ class c_typecheck_baset:
   asm_label_mapt asm_label_map;
 
   void apply_asm_label(const irep_idt &asm_label, symbolt &symbol);
+
+private:
+  static bool are_types_equal_ignoring_typedef(
+    const typet type1, const typet &type2);
 };
 
 #endif // CPROVER_ANSI_C_C_TYPECHECK_BASE_H

src/ansi-c/c_typecheck_expr.cpp

@@ -140,6 +140,8 @@ bool c_typecheck_baset::gcc_types_compatible_p(
   if(type1.id()==ID_c_enum)
   {
     if(type2.id()==ID_c_enum) // both are enums
+      // We don't need to remove the typedef flag here since as it is an enum
+      // we have already followed the enum tag to get to the underlying enum
       return type1==type2; // compares the tag
     else if(type2==type1.subtype())
       return true;
@@ -184,12 +186,13 @@ bool c_typecheck_baset::gcc_types_compatible_p(
   }
   else
   {
-    if(type1==type2)
+    if(are_types_equal_ignoring_typedef(type1, type2))
     {
       // Need to distinguish e.g. long int from int or
       // long long int from long int.
       // The rules appear to match those of C++.
-
+      // Isn't this explictly handled by checking type1==type2 (since
+      // operator== recursively checks all sub types).
       if(type1.get(ID_C_c_type)==type2.get(ID_C_c_type))
         return true;
     }
@@ -200,6 +203,38 @@ bool c_typecheck_baset::gcc_types_compatible_p(
 
 /*******************************************************************\
 
+Function: c_typecheck_baset::are_types_equal_ignoring_typedef
+
+  Inputs:
+   type1 - the first type to compare
+   type2 - the second type to compare
+
+ Outputs: True if the types are equal
+
+ Purpose: To check whether two types are equal, ignoring if they have a
+          different typedef tag. We do this by explictly removing the
+          ID_C_typedef from the type before comparing. Then we just use
+          operator== to compare the resultant types.
+
+\*******************************************************************/
+bool c_typecheck_baset::are_types_equal_ignoring_typedef(
+  const typet type1, const typet &type2)
+{
+  typet non_typedefd_type1=type1;
+  typet non_typedefd_type2=type2;
+  if(type1.get(ID_C_typedef)!=ID_nil)
+  {
+    non_typedefd_type1.remove(ID_C_typedef);
+  }
+  if(type2.get(ID_C_typedef)!=ID_nil)
+  {
+    non_typedefd_type2.remove(ID_C_typedef);
+  }
+  return non_typedefd_type1==non_typedefd_type2;
+}
+
+/*******************************************************************\
+
 Function: c_typecheck_baset::typecheck_expr_main
 
   Inputs: