the namespacet::follow_tag(...) methods now return the corresponding compound type

A struct_tag, union_tag, c_enum_tag always points to a struct, union, c_enum
type, respectively.  This is now reflected in the return type of the method,
which implies that a number of explicit casts and checks can be removed.

Author: Daniel Kroening

src/ansi-c/c_typecheck_expr.cpp

@@ -1888,8 +1888,7 @@ void c_typecheck_baset::typecheck_expr_side_effect(side_effect_exprt &expr)
 
     if(final_type0.id()==ID_c_enum_tag)
     {
-      if(to_c_enum_type(follow_tag(to_c_enum_tag_type(final_type0)))
-           .is_incomplete())
+      if(follow_tag(to_c_enum_tag_type(final_type0)).is_incomplete())
       {
         error().source_location = expr.source_location();
         error() << "operator `" << statement
@@ -3159,15 +3158,15 @@ void c_typecheck_baset::typecheck_arithmetic_pointer(const exprt &expr)
 
   if(
     subtype.id() == ID_struct_tag &&
-    to_struct_type(follow_tag(to_struct_tag_type(subtype))).is_incomplete())
+    follow_tag(to_struct_tag_type(subtype)).is_incomplete())
   {
     error().source_location = expr.source_location();
     error() << "pointer arithmetic with unknown object size" << eom;
     throw 0;
   }
   else if(
     subtype.id() == ID_union_tag &&
-    to_union_type(follow_tag(to_union_tag_type(subtype))).is_incomplete())
+    follow_tag(to_union_tag_type(subtype)).is_incomplete())
   {
     error().source_location = expr.source_location();
     error() << "pointer arithmetic with unknown object size" << eom;
@@ -3371,8 +3370,7 @@ void c_typecheck_baset::typecheck_side_effect_assignment(
 
         if(underlying_type.id()==ID_c_enum_tag)
         {
-          const typet &c_enum_type=
-            follow_tag(to_c_enum_tag_type(underlying_type));
+          const auto &c_enum_type = to_c_enum_tag_type(underlying_type);
           underlying_type=c_enum_type.subtype();
         }
 

src/ansi-c/padding.cpp

@@ -120,9 +120,9 @@ underlying_width(const c_bit_field_typet &type, const namespacet &ns)
     // These point to an enum, which has a sub-subtype,
     // which may be smaller or larger than int, and we thus have
     // to check.
-    const typet &c_enum_type = ns.follow_tag(to_c_enum_tag_type(subtype));
+    const auto &c_enum_type = ns.follow_tag(to_c_enum_tag_type(subtype));
 
-    if(c_enum_type.id() == ID_c_enum)
+    if(!c_enum_type.is_incomplete())
       return to_bitvector_type(c_enum_type.subtype()).get_width();
     else
       return {};

src/goto-programs/goto_convert_side_effect.cpp

@@ -110,7 +110,7 @@ void goto_convertt::remove_assignment(
       // We convert c_enums to their underlying type, do the
       // operation, and then convert back
       const auto &enum_type = ns.follow_tag(to_c_enum_tag_type(op0_type));
-      auto underlying_type = to_c_enum_type(enum_type).subtype();
+      auto underlying_type = enum_type.subtype();
       auto op0 = typecast_exprt(expr.op0(), underlying_type);
       auto op1 = typecast_exprt(expr.op1(), underlying_type);
       binary_exprt tmp(op0, new_id, op1, underlying_type);

src/util/json_expr.cpp

@@ -158,10 +158,7 @@ json_objectt json(
   else if(type.id()==ID_c_enum_tag)
   {
     // we return the base type
-    return json(
-      to_c_enum_type(ns.follow_tag(to_c_enum_tag_type(type))).subtype(),
-      ns,
-      mode);
+    return json(ns.follow_tag(to_c_enum_tag_type(type)).subtype(), ns, mode);
   }
   else if(type.id()==ID_fixedbv)
   {

src/util/namespace.cpp

@@ -87,34 +87,36 @@ const typet &namespace_baset::follow(const typet &src) const
 /// Follow type tag of union type.
 /// \param src: The union tag type to dispatch on.
 /// \return The type of the union tag in the symbol table.
-const typet &namespace_baset::follow_tag(const union_tag_typet &src) const
+const union_typet &namespace_baset::follow_tag(const union_tag_typet &src) const
 {
   const symbolt &symbol=lookup(src.get_identifier());
   CHECK_RETURN(symbol.is_type);
   CHECK_RETURN(symbol.type.id() == ID_union);
-  return symbol.type;
+  return to_union_type(symbol.type);
 }
 
 /// Follow type tag of struct type.
 /// \param src: The struct tag type to dispatch on.
 /// \return The type of the struct tag in the symbol table.
-const typet &namespace_baset::follow_tag(const struct_tag_typet &src) const
+const struct_typet &
+namespace_baset::follow_tag(const struct_tag_typet &src) const
 {
   const symbolt &symbol=lookup(src.get_identifier());
   CHECK_RETURN(symbol.is_type);
   CHECK_RETURN(symbol.type.id() == ID_struct);
-  return symbol.type;
+  return to_struct_type(symbol.type);
 }
 
 /// Follow type tag of enum type.
 /// \param src: The enum tag type to dispatch on.
 /// \return The type of the enum tag in the symbol table.
-const typet &namespace_baset::follow_tag(const c_enum_tag_typet &src) const
+const c_enum_typet &
+namespace_baset::follow_tag(const c_enum_tag_typet &src) const
 {
   const symbolt &symbol=lookup(src.get_identifier());
   CHECK_RETURN(symbol.is_type);
   CHECK_RETURN(symbol.type.id() == ID_c_enum);
-  return symbol.type;
+  return to_c_enum_type(symbol.type);
 }
 
 /// Follow macros to their values in a given expression.

src/util/namespace.h

@@ -65,9 +65,9 @@ class namespace_baset
 
   // These produce union_typet, struct_typet, c_enum_typet or
   // the incomplete version.
-  const typet &follow_tag(const union_tag_typet &) const;
-  const typet &follow_tag(const struct_tag_typet &) const;
-  const typet &follow_tag(const c_enum_tag_typet &) const;
+  const union_typet &follow_tag(const union_tag_typet &) const;
+  const struct_typet &follow_tag(const struct_tag_typet &) const;
+  const c_enum_typet &follow_tag(const c_enum_tag_typet &) const;
 
   /// Returns the minimal integer n such that there is no symbol (in any of the
   /// symbol tables) whose name is of the form "An" where A is \p prefix.

src/util/simplify_expr.cpp

@@ -494,8 +494,8 @@ bool simplify_exprt::simplify_typecast(exprt &expr)
       }
       else if(expr_type_id==ID_c_enum_tag)
       {
-        const typet &c_enum_type=ns.follow_tag(to_c_enum_tag_type(expr_type));
-        if(c_enum_type.id()==ID_c_enum) // possibly incomplete
+        const auto &c_enum_type = ns.follow_tag(to_c_enum_tag_type(expr_type));
+        if(!c_enum_type.is_incomplete()) // possibly incomplete
         {
           unsigned int_value = operand.is_true() ? 1u : 0u;
           exprt tmp=from_integer(int_value, c_enum_type);
@@ -564,8 +564,8 @@ bool simplify_exprt::simplify_typecast(exprt &expr)
 
       if(expr_type_id==ID_c_enum_tag)
       {
-        const typet &c_enum_type=ns.follow_tag(to_c_enum_tag_type(expr_type));
-        if(c_enum_type.id()==ID_c_enum) // possibly incomplete
+        const auto &c_enum_type = ns.follow_tag(to_c_enum_tag_type(expr_type));
+        if(!c_enum_type.is_incomplete()) // possibly incomplete
         {
           exprt tmp=from_integer(int_value, c_enum_type);
           tmp.type()=expr_type; // we maintain the tag type
@@ -678,7 +678,7 @@ bool simplify_exprt::simplify_typecast(exprt &expr)
     else if(op_type_id==ID_c_enum_tag) // enum to int
     {
       const typet &base_type =
-        to_c_enum_type(ns.follow_tag(to_c_enum_tag_type(op_type))).subtype();
+        ns.follow_tag(to_c_enum_tag_type(op_type)).subtype();
       if(base_type.id()==ID_signedbv || base_type.id()==ID_unsignedbv)
       {
         // enum constants use the representation of their base type
@@ -1574,7 +1574,7 @@ optionalt<std::string> simplify_exprt::expr2bits(
     }
     else if(type.id() == ID_c_enum_tag)
     {
-      const typet &c_enum_type = ns.follow_tag(to_c_enum_tag_type(type));
+      const auto &c_enum_type = ns.follow_tag(to_c_enum_tag_type(type));
       return expr2bits(constant_exprt(value, c_enum_type), little_endian);
     }
     else if(type.id() == ID_c_enum)

src/util/simplify_expr_floatbv.cpp

@@ -243,8 +243,8 @@ bool simplify_exprt::simplify_floatbv_typecast(exprt &expr)
       {
         // go through underlying type
         const auto &enum_type = ns.follow_tag(to_c_enum_tag_type(src_type));
-        exprt simplified_typecast = simplify_expr(
-          typecast_exprt(casted_expr, to_c_enum_type(enum_type).subtype()), ns);
+        exprt simplified_typecast =
+          simplify_expr(typecast_exprt(casted_expr, enum_type.subtype()), ns);
         if(simplified_typecast.is_constant())
         {
           floatbv_typecast_exprt new_floatbv_typecast_expr =

src/util/xml_expr.cpp

@@ -85,8 +85,7 @@ xmlt xml(
   else if(type.id()==ID_c_enum_tag)
   {
     // we return the base type
-    return xml(
-      to_c_enum_type(ns.follow_tag(to_c_enum_tag_type(type))).subtype(), ns);
+    return xml(ns.follow_tag(to_c_enum_tag_type(type)).subtype(), ns);
   }
   else if(type.id()==ID_fixedbv)
   {