replace uses of typet::subtype() nonconst

This commit replaces uses of the nonconst typet::subtype() by casting the
type to the applicable subtype, and then using the appropriate accessor
method.

Author: kroening

jbmc/src/java_bytecode/remove_java_new.cpp

@@ -280,7 +280,7 @@ goto_programt::targett remove_java_newt::lower_java_new_array(
   if(!rhs.get_bool(ID_skip_initialize))
   {
     const auto zero_element =
-      zero_initializer(data.type().subtype(), location, ns);
+      zero_initializer(to_pointer_type(data.type()).base_type(), location, ns);
     CHECK_RETURN(zero_element.has_value());
     codet array_set{ID_array_set, {new_array_data_symbol, *zero_element}};
     dest.insert_before(next, goto_programt::make_other(array_set, location));
@@ -316,7 +316,7 @@ goto_programt::targett remove_java_newt::lower_java_new_array(
 
     plus_exprt(tmp_i, from_integer(1, tmp_i.type()));
     dereference_exprt deref_expr(
-      plus_exprt(data, tmp_i), data.type().subtype());
+      plus_exprt(data, tmp_i), to_pointer_type(data.type()).base_type());
 
     code_blockt for_body;
     symbol_exprt init_sym =

src/cpp/cpp_convert_type.cpp

@@ -85,7 +85,8 @@ void cpp_convert_typet::read_rec(const typet &type)
   else if(type.id()==ID_array)
   {
     other.push_back(type);
-    cpp_convert_plain_type(other.back().subtype(), get_message_handler());
+    cpp_convert_plain_type(
+      to_array_type(other.back()).element_type(), get_message_handler());
   }
   else if(type.id()==ID_template)
   {
@@ -124,7 +125,8 @@ void cpp_convert_typet::read_template(const typet &type)
   other.push_back(type);
   typet &t=other.back();
 
-  cpp_convert_plain_type(t.subtype(), get_message_handler());
+  cpp_convert_plain_type(
+    to_type_with_subtype(t).subtype(), get_message_handler());
 
   irept &arguments=t.add(ID_arguments);
 
@@ -157,7 +159,7 @@ void cpp_convert_typet::read_function_type(const typet &type)
   // change subtype to return_type
   typet &return_type = t.return_type();
 
-  return_type.swap(t.subtype());
+  return_type.swap(to_type_with_subtype(t).subtype());
   t.remove_subtype();
 
   if(return_type.is_not_nil())
@@ -203,7 +205,7 @@ void cpp_convert_typet::read_function_type(const typet &type)
         if(final_type.id()==ID_array)
         {
           // turn into pointer type
-          final_type=pointer_type(final_type.subtype());
+          final_type = pointer_type(to_array_type(final_type).element_type());
         }
 
         code_typet::parametert new_parameter(final_type);
@@ -352,7 +354,8 @@ void cpp_convert_auto(
 {
   if(dest.id() != ID_merged_type && dest.has_subtype())
   {
-    cpp_convert_auto(dest.subtype(), src, message_handler);
+    cpp_convert_auto(
+      to_type_with_subtype(dest).subtype(), src, message_handler);
     return;
   }
 

src/cpp/cpp_typecheck_code.cpp

@@ -128,7 +128,8 @@ void cpp_typecheckt::typecheck_try_catch(codet &code)
           cpp_declaratort &declarator=cpp_declaration.declarators().front();
 
           if(is_reference(declarator.type()))
-            declarator.type()=declarator.type().subtype();
+            declarator.type() =
+              to_reference_type(declarator.type()).base_type();
         }
 
         // typecheck the body
@@ -309,7 +310,9 @@ void cpp_typecheckt::typecheck_member_initializer(codet &code)
       // maybe the name of the member collides with a parameter of the
       // constructor
       exprt dereference(
-        ID_dereference, cpp_scopes.current_scope().this_expr.type().subtype());
+        ID_dereference,
+        to_pointer_type(cpp_scopes.current_scope().this_expr.type())
+          .base_type());
       dereference.copy_to_operands(cpp_scopes.current_scope().this_expr);
       cpp_typecheck_fargst deref_fargs;
       deref_fargs.add_object(dereference);

src/cpp/cpp_typecheck_expr.cpp

@@ -250,9 +250,11 @@ void cpp_typecheckt::typecheck_expr_trinary(if_exprt &expr)
       expr.type()=e2.type();
       expr.op2().swap(e2);
     }
-    else if(expr.op1().type().id()==ID_array &&
-            expr.op2().type().id()==ID_array &&
-            expr.op1().type().subtype() == expr.op2().type().subtype())
+    else if(
+      expr.op1().type().id() == ID_array &&
+      expr.op2().type().id() == ID_array &&
+      to_array_type(expr.op1().type()).element_type() ==
+        to_array_type(expr.op2().type()).element_type())
     {
       // array-to-pointer conversion
 
@@ -409,7 +411,7 @@ bool cpp_typecheckt::overloadable(const exprt &expr)
     typet t = it->type();
 
     if(is_reference(t))
-      t=t.subtype();
+      t = to_reference_type(t).base_type();
 
     if(
       t.id() == ID_struct || t.id() == ID_union || t.id() == ID_c_enum ||
@@ -693,7 +695,8 @@ void cpp_typecheckt::typecheck_expr_address_of(exprt &expr)
   if(op.id() == ID_address_of && op.get_bool(ID_C_implicit))
   {
     // must be the address of a function
-    code_typet &code_type=to_code_type(op.type().subtype());
+    code_typet &code_type =
+      to_code_type(to_pointer_type(op.type()).base_type());
 
     code_typet::parameterst &args=code_type.parameters();
     if(!args.empty() && args.front().get_this())
@@ -714,15 +717,16 @@ void cpp_typecheckt::typecheck_expr_address_of(exprt &expr)
   else if(op.id() == ID_ptrmember && to_unary_expr(op).op().id() == "cpp-this")
   {
     expr.type() = pointer_type(op.type());
-    expr.type().add(ID_to_member) = to_unary_expr(op).op().type().subtype();
+    expr.type().add(ID_to_member) =
+      to_pointer_type(to_unary_expr(op).op().type()).base_type();
     return;
   }
 
   // the C front end does not know about references
   const bool is_ref=is_reference(expr.type());
   c_typecheck_baset::typecheck_expr_address_of(expr);
   if(is_ref)
-    expr.type()=reference_type(expr.type().subtype());
+    expr.type() = reference_type(to_pointer_type(expr.type()).base_type());
 }
 
 void cpp_typecheckt::typecheck_expr_throw(exprt &expr)
@@ -756,8 +760,8 @@ void cpp_typecheckt::typecheck_expr_new(exprt &expr)
 
   if(expr.type().id()==ID_array)
   {
-    // first typecheck subtype
-    typecheck_type(expr.type().subtype());
+    // first typecheck the element type
+    typecheck_type(to_array_type(expr.type()).element_type());
 
     // typecheck the size
     exprt &size=to_array_type(expr.type()).size();
@@ -774,8 +778,8 @@ void cpp_typecheckt::typecheck_expr_new(exprt &expr)
     expr.set(ID_size, to_array_type(expr.type()).size());
 
     // new actually returns a pointer, not an array
-    pointer_typet ptr_type=
-      pointer_type(expr.type().subtype());
+    pointer_typet ptr_type =
+      pointer_type(to_array_type(expr.type()).element_type());
     expr.type().swap(ptr_type);
   }
   else
@@ -789,7 +793,7 @@ void cpp_typecheckt::typecheck_expr_new(exprt &expr)
     expr.type().swap(ptr_type);
   }
 
-  exprt object_expr(ID_new_object, expr.type().subtype());
+  exprt object_expr(ID_new_object, to_pointer_type(expr.type()).base_type());
   object_expr.set(ID_C_lvalue, true);
 
   already_typechecked_exprt::make_already_typechecked(object_expr);
@@ -817,13 +821,15 @@ void cpp_typecheckt::typecheck_expr_new(exprt &expr)
 
   // we add the size of the object for convenience of the
   // runtime library
-  auto size_of_opt = size_of_expr(expr.type().subtype(), *this);
+  auto size_of_opt =
+    size_of_expr(to_pointer_type(expr.type()).base_type(), *this);
 
   if(size_of_opt.has_value())
   {
     auto &sizeof_expr = static_cast<exprt &>(expr.add(ID_sizeof));
     sizeof_expr = size_of_opt.value();
-    sizeof_expr.add(ID_C_c_sizeof_type) = expr.type().subtype();
+    sizeof_expr.add(ID_C_c_sizeof_type) =
+      to_pointer_type(expr.type()).base_type();
   }
 }
 
@@ -1024,14 +1030,14 @@ void cpp_typecheckt::typecheck_expr_delete(exprt &expr)
 
   // remove any const-ness of the argument
   // (which would impair the call to the destructor)
-  pointer_type.subtype().remove(ID_C_constant);
+  to_pointer_type(pointer_type).base_type().remove(ID_C_constant);
 
   // delete expressions are always void
   expr.type()=typet(ID_empty);
 
   // we provide the right destructor, for the convenience
   // of later stages
-  exprt new_object(ID_new_object, pointer_type.subtype());
+  exprt new_object(ID_new_object, to_pointer_type(pointer_type).base_type());
   new_object.add_source_location()=expr.source_location();
   new_object.set(ID_C_lvalue, true);
 
@@ -1636,13 +1642,13 @@ void cpp_typecheckt::typecheck_side_effect_function_call(
       }
 
       // get the virtual table
-      typet this_type=
-        to_code_type(expr.function().type()).parameters().front().type();
-      irep_idt vtable_name=
-        this_type.subtype().get_string(ID_identifier) +"::@vtable_pointer";
+      auto this_type = to_pointer_type(
+        to_code_type(expr.function().type()).parameters().front().type());
+      irep_idt vtable_name =
+        this_type.base_type().get_string(ID_identifier) + "::@vtable_pointer";
 
-      const struct_typet &vt_struct=
-        to_struct_type(follow(this_type.subtype()));
+      const struct_typet &vt_struct =
+        to_struct_type(follow(this_type.base_type()));
 
       const struct_typet::componentt &vt_compo=
         vt_struct.get_component(vtable_name);
@@ -2011,7 +2017,7 @@ void cpp_typecheckt::typecheck_side_effect_assignment(side_effect_exprt &expr)
   typet type0 = to_binary_expr(expr).op0().type();
 
   if(is_reference(type0))
-    type0=type0.subtype();
+    type0 = to_reference_type(type0).base_type();
 
   if(cpp_is_pod(type0))
   {
@@ -2188,7 +2194,9 @@ void cpp_typecheckt::convert_pmop(exprt &expr)
     throw 0;
   }
 
-  typet t0 = op0.type().id() == ID_pointer ? op0.type().subtype() : op0.type();
+  typet t0 = op0.type().id() == ID_pointer
+               ? to_pointer_type(op0.type()).base_type()
+               : op0.type();
 
   typet t1((const typet &)op1.type().find(ID_to_member));
 

src/cpp/cpp_typecheck_initializer.cpp

@@ -79,7 +79,8 @@ void cpp_typecheckt::convert_initializer(symbolt &symbol)
   else if(cpp_is_pod(symbol.type))
   {
     if(
-      symbol.type.id() == ID_pointer && symbol.type.subtype().id() == ID_code &&
+      symbol.type.id() == ID_pointer &&
+      to_pointer_type(symbol.type).base_type().id() == ID_code &&
       symbol.value.id() == ID_address_of &&
       to_address_of_expr(symbol.value).object().id() == ID_cpp_name)
     {
@@ -90,7 +91,8 @@ void cpp_typecheckt::convert_initializer(symbolt &symbol)
       cpp_typecheck_fargst fargs;
       fargs.in_use = true;
 
-      const code_typet &code_type=to_code_type(symbol.type.subtype());
+      const code_typet &code_type =
+        to_code_type(to_pointer_type(symbol.type).base_type());
 
       for(const auto &parameter : code_type.parameters())
       {

src/cpp/cpp_typecheck_resolve.cpp

@@ -526,13 +526,13 @@ void cpp_typecheck_resolvet::disambiguate_functions(
 
           if(type1.id()==ID_pointer)
           {
-            typet tmp=type1.subtype();
+            typet tmp = to_pointer_type(type1).base_type();
             type1=tmp;
           }
 
           if(type2.id()==ID_pointer)
           {
-            typet tmp=type2.subtype();
+            typet tmp = to_pointer_type(type2).base_type();
             type2=tmp;
           }
 

src/cpp/cpp_typecheck_type.cpp

@@ -82,7 +82,7 @@ void cpp_typecheckt::typecheck_type(typet &type)
 
     // the pointer/reference might have a qualifier,
     // but do subtype first
-    typecheck_type(type.subtype());
+    typecheck_type(to_pointer_type(type).base_type());
 
     // Check if it is a pointer-to-member
     if(type.find(ID_to_member).is_not_nil())
@@ -101,10 +101,10 @@ void cpp_typecheckt::typecheck_type(typet &type)
       typecheck_type(class_object);
 
       // there may be parameters if this is a pointer to member function
-      if(type.subtype().id()==ID_code)
+      if(to_pointer_type(type).base_type().id() == ID_code)
       {
         code_typet::parameterst &parameters =
-          to_code_type(type.subtype()).parameters();
+          to_code_type(to_pointer_type(type).base_type()).parameters();
 
         if(parameters.empty() || !parameters.front().get_this())
         {
@@ -132,12 +132,12 @@ void cpp_typecheckt::typecheck_type(typet &type)
       simplify(size_expr, *this);
     }
 
-    typecheck_type(type.subtype());
+    typecheck_type(to_array_type(type).element_type());
 
-    if(type.subtype().get_bool(ID_C_constant))
+    if(to_array_type(type).element_type().get_bool(ID_C_constant))
       type.set(ID_C_constant, true);
 
-    if(type.subtype().get_bool(ID_C_volatile))
+    if(to_array_type(type).element_type().get_bool(ID_C_volatile))
       type.set(ID_C_volatile, true);
   }
   else if(type.id()==ID_vector)
@@ -169,7 +169,7 @@ void cpp_typecheckt::typecheck_type(typet &type)
   }
   else if(type.id()==ID_template)
   {
-    typecheck_type(type.subtype());
+    typecheck_type(to_template_type(type).subtype());
   }
   else if(type.id()==ID_c_enum)
   {
@@ -245,7 +245,7 @@ void cpp_typecheckt::typecheck_type(typet &type)
     typecheck_expr(e);
 
     if(e.type().id() == ID_c_bit_field)
-      type = e.type().subtype();
+      type = to_c_bit_field_type(e.type()).underlying_type();
     else
       type = e.type();
   }
@@ -276,7 +276,7 @@ void cpp_typecheckt::typecheck_type(typet &type)
   {
     PRECONDITION(type.has_subtype());
     merged_typet as_parsed;
-    as_parsed.move_to_subtypes(type.subtype());
+    as_parsed.move_to_subtypes(to_type_with_subtype(type).subtype());
     type.get_sub().clear();
     as_parsed.move_to_subtypes(type);
     type.swap(as_parsed);

src/cpp/template_map.cpp

@@ -11,14 +11,15 @@ Author: Daniel Kroening, kroening@cs.cmu.edu
 
 #include "template_map.h"
 
-#include <ostream>
-
+#include <util/c_types.h>
 #include <util/invariant.h>
 #include <util/std_expr.h>
 
 #include "cpp_template_parameter.h"
 #include "cpp_template_type.h"
 
+#include <ostream>
+
 void template_mapt::apply(typet &type) const
 {
   if(type.id()==ID_array)
@@ -28,7 +29,7 @@ void template_mapt::apply(typet &type) const
   }
   else if(type.id()==ID_pointer)
   {
-    apply(type.subtype());
+    apply(to_pointer_type(type).base_type());
   }
   else if(type.id()==ID_struct ||
           type.id()==ID_union)

src/goto-symex/symex_dereference.cpp

@@ -63,7 +63,7 @@ exprt goto_symext::address_arithmetic(
       address_of_exprt &a=to_address_of_expr(result);
 
       // turn &a of type T[i][j] into &(a[0][0])
-      for(const typet *t = &(a.type().subtype());
+      for(const typet *t = &(to_type_with_subtype(a.type()).subtype());
           t->id() == ID_array && expr.type() != *t;
           t = &(to_array_type(*t).element_type()))
         a.object() = index_exprt(a.object(), from_integer(0, c_index_type()));