Merge pull request #3758 from tautschnig/no-follow-ansi-c

Remove unnecessary use of ns.follow in ansi-c/

Author: Daniel Kroening

src/ansi-c/anonymous_member.cpp

@@ -51,14 +51,15 @@ exprt get_component_rec(
 
   for(const auto &comp : components)
   {
-    const typet &type=ns.follow(comp.type());
+    const typet &type = comp.type();
 
     if(comp.get_name()==component_name)
     {
       return std::move(make_member_expr(struct_union, comp, ns));
     }
-    else if(comp.get_anonymous() &&
-            (type.id()==ID_struct || type.id()==ID_union))
+    else if(
+      comp.get_anonymous() &&
+      (type.id() == ID_struct_tag || type.id() == ID_union_tag))
     {
       const member_exprt tmp = make_member_expr(struct_union, comp, ns);
       exprt result=get_component_rec(tmp, component_name, ns);

src/ansi-c/c_typecast.cpp

@@ -388,14 +388,12 @@ void c_typecastt::implicit_typecast_arithmetic(
 {
   typet new_type;
 
-  const typet &expr_type=ns.follow(expr.type());
-
   switch(c_type)
   {
   case PTR:
-    if(expr_type.id()==ID_array)
+    if(expr.type().id() == ID_array)
     {
-      new_type=pointer_type(expr_type.subtype());
+      new_type = pointer_type(expr.type().subtype());
       break;
     }
     return;
@@ -423,7 +421,7 @@ void c_typecastt::implicit_typecast_arithmetic(
   default: return;
   }
 
-  if(new_type!=expr_type)
+  if(new_type != expr.type())
     do_typecast(expr, new_type);
 }
 
@@ -538,8 +536,8 @@ void c_typecastt::implicit_typecast_followed(
     {
       // we are quite generous about pointers
 
-      const typet &src_sub=ns.follow(src_type.subtype());
-      const typet &dest_sub=ns.follow(dest_type.subtype());
+      const typet &src_sub = src_type.subtype();
+      const typet &dest_sub = dest_type.subtype();
 
       if(is_void_pointer(src_type) ||
          is_void_pointer(dest_type))
@@ -603,8 +601,8 @@ void c_typecastt::implicit_typecast_arithmetic(
   exprt &expr1,
   exprt &expr2)
 {
-  const typet &type1=ns.follow(expr1.type());
-  const typet &type2=ns.follow(expr2.type());
+  const typet &type1 = expr1.type();
+  const typet &type2 = expr2.type();
 
   c_typet c_type1=minimum_promotion(type1),
           c_type2=minimum_promotion(type2);
@@ -718,17 +716,15 @@ void c_typecastt::do_typecast(exprt &expr, const typet &dest_type)
   // special case: array -> pointer is actually
   // something like address_of
 
-  const typet &src_type=ns.follow(expr.type());
+  const typet &src_type = expr.type();
 
   if(src_type.id()==ID_array)
   {
     index_exprt index;
     index.array()=expr;
     index.index()=from_integer(0, index_type());
     index.type()=src_type.subtype();
-    expr=address_of_exprt(index);
-    if(ns.follow(expr.type())!=ns.follow(dest_type))
-      expr.make_typecast(dest_type);
+    expr = typecast_exprt::conditional_cast(address_of_exprt(index), dest_type);
     return;
   }
 

src/ansi-c/c_typecheck_base.cpp

@@ -284,8 +284,7 @@ void c_typecheck_baset::typecheck_redefinition_non_type(
   }
 
   // do initializer, this may change the type
-  if(follow(new_symbol.type).id()!=ID_code &&
-     !new_symbol.is_macro)
+  if(new_symbol.type.id() != ID_code && !new_symbol.is_macro)
     do_initializer(new_symbol);
 
   const typet &final_new=follow(new_symbol.type);
@@ -419,22 +418,20 @@ void c_typecheck_baset::typecheck_redefinition_non_type(
       PRECONDITION(old_symbol.type.id() != ID_symbol_type);
       old_symbol.type=new_symbol.type;
     }
-    else if(final_old.id()==ID_pointer &&
-            follow(final_old).subtype().id()==ID_code &&
-            to_code_type(follow(final_old).subtype()).has_ellipsis() &&
-            final_new.id()==ID_pointer &&
-            follow(final_new).subtype().id()==ID_code)
+    else if(
+      final_old.id() == ID_pointer && final_old.subtype().id() == ID_code &&
+      to_code_type(final_old.subtype()).has_ellipsis() &&
+      final_new.id() == ID_pointer && final_new.subtype().id() == ID_code)
     {
       // to allow
       // int (*f) ();
       // int (*f) (int)=0;
       old_symbol.type=new_symbol.type;
     }
-    else if(final_old.id()==ID_pointer &&
-            follow(final_old).subtype().id()==ID_code &&
-            final_new.id()==ID_pointer &&
-            follow(final_new).subtype().id()==ID_code &&
-            to_code_type(follow(final_new).subtype()).has_ellipsis())
+    else if(
+      final_old.id() == ID_pointer && final_old.subtype().id() == ID_code &&
+      final_new.id() == ID_pointer && final_new.subtype().id() == ID_code &&
+      to_code_type(final_new.subtype()).has_ellipsis())
     {
       // to allow
       // int (*f) (int)=0;

src/ansi-c/c_typecheck_expr.cpp

@@ -334,8 +334,7 @@ void c_typecheck_baset::typecheck_expr_main(exprt &expr)
       expr.operands().size() == 1,
       "real part retrieval operation should have one operand");
 
-    exprt op = expr.op0();
-    op.type() = follow(op.type());
+    const exprt &op = expr.op0();
 
     if(op.type().id() != ID_complex)
     {
@@ -372,8 +371,7 @@ void c_typecheck_baset::typecheck_expr_main(exprt &expr)
       expr.operands().size() == 1,
       "imaginary part retrieval operation should have one operand");
 
-    exprt op = expr.op0();
-    op.type() = follow(op.type());
+    const exprt &op = expr.op0();
 
     if(op.type().id() != ID_complex)
     {
@@ -636,8 +634,8 @@ void c_typecheck_baset::typecheck_expr_builtin_offsetof(exprt &expr)
           for(const auto &c : struct_union_type.components())
           {
             if(
-              c.get_anonymous() && (follow(c.type()).id() == ID_struct ||
-                                    follow(c.type()).id() == ID_union))
+              c.get_anonymous() &&
+              (c.type().id() == ID_struct_tag || c.type().id() == ID_union_tag))
             {
               if(has_component_rec(c.type(), component_name, *this))
               {
@@ -1160,7 +1158,7 @@ void c_typecheck_baset::typecheck_expr_typecast(exprt &expr)
   if(expr_type.id()==ID_empty)
     return;
 
-  const typet op_type=follow(op.type());
+  const typet op_type = op.type();
 
   // cast to same type?
   if(base_type_eq(expr_type, op_type, *this))
@@ -2009,7 +2007,7 @@ void c_typecheck_baset::typecheck_side_effect_function_call(
   // typecheck it now
   typecheck_expr(f_op);
 
-  const typet f_op_type=follow(f_op.type());
+  const typet f_op_type = f_op.type();
 
   if(f_op_type.id()!=ID_pointer)
   {
@@ -2853,8 +2851,7 @@ void c_typecheck_baset::typecheck_function_call_arguments(
     {
       // don't know type, just do standard conversion
 
-      const typet &type=follow(op.type());
-      if(type.id()==ID_array)
+      if(op.type().id() == ID_array)
       {
         typet dest_type=pointer_type(void_type());
         dest_type.subtype().set(ID_C_constant, true);
@@ -2881,7 +2878,7 @@ void c_typecheck_baset::typecheck_expr_unary_arithmetic(exprt &expr)
 
   exprt &operand=expr.op0();
 
-  const typet &o_type=follow(operand.type());
+  const typet &o_type = operand.type();
 
   if(o_type.id()==ID_vector)
   {
@@ -2970,15 +2967,16 @@ void c_typecheck_baset::typecheck_expr_binary_arithmetic(exprt &expr)
   exprt &op0=expr.op0();
   exprt &op1=expr.op1();
 
-  const typet o_type0=follow(op0.type());
-  const typet o_type1=follow(op1.type());
+  const typet o_type0 = op0.type();
+  const typet o_type1 = op1.type();
 
   if(o_type0.id()==ID_vector &&
      o_type1.id()==ID_vector)
   {
-    if(gcc_vector_types_compatible(
+    if(
+      gcc_vector_types_compatible(
         to_vector_type(o_type0), to_vector_type(o_type1)) &&
-       is_number(follow(o_type0.subtype())))
+      is_number(o_type0.subtype()))
     {
       // Vector arithmetic has fairly strict typing rules, no promotion
       if(o_type0!=o_type1)
@@ -3010,8 +3008,8 @@ void c_typecheck_baset::typecheck_expr_binary_arithmetic(exprt &expr)
 
   implicit_typecast_arithmetic(op0, op1);
 
-  const typet &type0=follow(op0.type());
-  const typet &type1=follow(op1.type());
+  const typet &type0 = op0.type();
+  const typet &type1 = op1.type();
 
   if(expr.id()==ID_plus || expr.id()==ID_minus ||
      expr.id()==ID_mult || expr.id()==ID_div)
@@ -3083,14 +3081,13 @@ void c_typecheck_baset::typecheck_expr_shifts(shift_exprt &expr)
   exprt &op0=expr.op0();
   exprt &op1=expr.op1();
 
-  const typet o_type0=follow(op0.type());
-  const typet o_type1=follow(op1.type());
+  const typet o_type0 = op0.type();
+  const typet o_type1 = op1.type();
 
   if(o_type0.id()==ID_vector &&
      o_type1.id()==ID_vector)
   {
-    if(follow(o_type0.subtype())==follow(o_type1.subtype()) &&
-       is_number(follow(o_type0.subtype())))
+    if(o_type0.subtype() == o_type1.subtype() && is_number(o_type0.subtype()))
     {
       // {a0, a1, ..., an} >> {b0, b1, ..., bn} ==
       // {a0 >> b0, a1 >> b1, ..., an >> bn}
@@ -3100,9 +3097,9 @@ void c_typecheck_baset::typecheck_expr_shifts(shift_exprt &expr)
     }
   }
 
-  if(o_type0.id()==ID_vector &&
-     is_number(follow(o_type0.subtype())) &&
-     is_number(o_type1))
+  if(
+    o_type0.id() == ID_vector && is_number(o_type0.subtype()) &&
+    is_number(o_type1))
   {
     // {a0, a1, ..., an} >> b == {a0 >> b, a1 >> b, ..., an >> b}
     expr.type()=op0.type();
@@ -3120,7 +3117,7 @@ void c_typecheck_baset::typecheck_expr_shifts(shift_exprt &expr)
 
     if(expr.id()==ID_shr) // shifting operation depends on types
     {
-      const typet &op0_type=follow(op0.type());
+      const typet &op0_type = op0.type();
 
       if(op0_type.id()==ID_unsignedbv)
       {
@@ -3177,8 +3174,8 @@ void c_typecheck_baset::typecheck_expr_pointer_arithmetic(exprt &expr)
   exprt &op0=expr.op0();
   exprt &op1=expr.op1();
 
-  const typet &type0=follow(op0.type());
-  const typet &type1=follow(op1.type());
+  const typet &type0 = op0.type();
+  const typet &type1 = op1.type();
 
   if(expr.id()==ID_minus ||
      (expr.id()==ID_side_effect && expr.get(ID_statement)==ID_assign_minus))
@@ -3229,7 +3226,7 @@ void c_typecheck_baset::typecheck_expr_pointer_arithmetic(exprt &expr)
       UNREACHABLE;
     }
 
-    const typet &int_op_type=follow(int_op->type());
+    const typet &int_op_type = int_op->type();
 
     if(int_op_type.id()==ID_bool ||
        int_op_type.id()==ID_c_bool ||

src/ansi-c/c_typecheck_initializer.cpp

@@ -794,8 +794,9 @@ designatort c_typecheck_baset::make_designator(
               entry.type=tmp_type;
             }
             else if(
-              c.get_anonymous() && (follow(c.type()).id() == ID_struct ||
-                                    follow(c.type()).id() == ID_union) &&
+              c.get_anonymous() &&
+              (c.type().id() == ID_struct_tag ||
+               c.type().id() == ID_union_tag) &&
               has_component_rec(c.type(), component_name, *this))
             {
               entry.index=number;

src/ansi-c/expr2c.cpp

@@ -1287,7 +1287,7 @@ std::string expr2ct::convert_complex(
   // float complex CMPLXF(float x, float y);
   // long double complex CMPLXL(long double x, long double y);
 
-  const typet &subtype = ns.follow(src.type()).subtype();
+  const typet &subtype = src.type().subtype();
 
   std::string name;
 
@@ -1749,7 +1749,7 @@ std::string expr2ct::convert_constant(
   unsigned &precedence)
 {
   const irep_idt &base=src.get(ID_C_base);
-  const typet &type=ns.follow(src.type());
+  const typet &type = src.type();
   const irep_idt value=src.get_value();
   std::string dest;