Merge pull request #7097 from diffblue/typet_subtype_const4

protect typet::subtype() const

Author: kroening

jbmc/unit/java-testing-utils/require_goto_statements.cpp

@@ -424,7 +424,7 @@ const irep_idt &require_goto_statements::require_struct_component_assignment(
     require_goto_statements::require_declaration_of_name(
       symbol_identifier, entry_point_instructions);
   const typet &component_type =
-    to_pointer_type(component_declaration.symbol().type()).subtype();
+    to_pointer_type(component_declaration.symbol().type()).base_type();
   REQUIRE(component_type.id() == ID_struct_tag);
   const auto &component_struct =
     ns.follow_tag(to_struct_tag_type(component_type));
@@ -480,7 +480,7 @@ require_goto_statements::require_struct_array_component_assignment(
   REQUIRE(component_assignment_rhs.type().id() == ID_pointer);
   REQUIRE(
     to_struct_tag_type(
-      to_pointer_type(component_assignment_rhs.type()).subtype())
+      to_pointer_type(component_assignment_rhs.type()).base_type())
       .get(ID_identifier) == array_type_name);
 
   // Get the tmp_object name and find assignments to it, there should be only
@@ -501,7 +501,8 @@ require_goto_statements::require_struct_array_component_assignment(
   PRECONDITION(
     array_component_reference_assignment_rhs.type().id() == ID_pointer);
   const typet &array =
-    to_pointer_type(array_component_reference_assignment_rhs.type()).subtype();
+    to_pointer_type(array_component_reference_assignment_rhs.type())
+      .base_type();
   PRECONDITION(is_java_array_tag(array.get(ID_identifier)));
   REQUIRE(array.get(ID_identifier) == array_type_name);
 

jbmc/unit/java-testing-utils/require_type.cpp

@@ -23,7 +23,7 @@ pointer_typet require_type::require_pointer(
   const pointer_typet &pointer = to_pointer_type(type);
 
   if(subtype)
-    REQUIRE(pointer.subtype() == subtype.value());
+    REQUIRE(pointer.base_type() == subtype.value());
 
   return pointer;
 }
@@ -155,8 +155,8 @@ bool require_java_generic_type_argument_expectation(
   {
     REQUIRE(!is_java_generic_parameter(type_argument));
     REQUIRE(
-      to_struct_tag_type(type_argument.subtype()).get_identifier() ==
-      expected.description);
+      to_struct_tag_type(to_pointer_type(type_argument).base_type())
+        .get_identifier() == expected.description);
     return true;
   }
   }
@@ -248,7 +248,7 @@ const typet &require_type::require_java_non_generic_type(
   REQUIRE(!is_java_generic_parameter(type));
   REQUIRE(!is_java_generic_type(type));
   if(expect_subtype)
-    REQUIRE(type.subtype() == expect_subtype.value());
+    REQUIRE(to_pointer_type(type).base_type() == expect_subtype.value());
   return type;
 }
 
@@ -474,7 +474,7 @@ pointer_typet
 require_type::require_pointer_to_tag(const typet &type, const irep_idt &tag)
 {
   const auto pointer_type = require_type::require_pointer(type, {});
-  require_type::require_struct_tag(pointer_type.subtype(), tag);
+  require_type::require_struct_tag(pointer_type.base_type(), tag);
   return pointer_type;
 }
 

src/cpp/cpp_typecheck_conversions.cpp

@@ -687,7 +687,8 @@ bool cpp_typecheckt::standard_conversion_sequence(
 
   // bit fields are converted like their underlying type
   if(type.id()==ID_c_bit_field)
-    return standard_conversion_sequence(expr, type.subtype(), new_expr, rank);
+    return standard_conversion_sequence(
+      expr, to_c_bit_field_type(type).underlying_type(), new_expr, rank);
 
   // we turn bit fields into their underlying type
   if(curr_expr.type().id()==ID_c_bit_field)
@@ -774,7 +775,9 @@ bool cpp_typecheckt::standard_conversion_sequence(
     }
     else if(type.id()==ID_pointer)
     {
-      if(expr.type().subtype().id()==ID_nullptr)
+      if(
+        expr.type().id() == ID_pointer &&
+        to_pointer_type(expr.type()).base_type().id() == ID_nullptr)
       {
         // std::nullptr_t to _any_ pointer type is ok
         new_expr = typecast_exprt::conditional_cast(new_expr, type);
@@ -1132,9 +1135,9 @@ bool cpp_typecheckt::reference_related(
     return subtype_typecast(to_struct_type(from),
                             to_struct_type(to));
 
-  if(from.id()==ID_struct &&
-     type.get_bool(ID_C_this) &&
-     type.subtype().id()==ID_empty)
+  if(
+    from.id() == ID_struct && type.get_bool(ID_C_this) &&
+    to_pointer_type(type).base_type().id() == ID_empty)
   {
     // virtual-call case
     return true;
@@ -1158,14 +1161,14 @@ bool cpp_typecheckt::reference_compatible(
   if(!reference_related(expr, type))
     return false;
 
-  if(expr.type()!=type.subtype())
+  if(expr.type() != to_reference_type(type).base_type())
     rank+=3;
 
   c_qualifierst qual_from;
     qual_from.read(expr.type());
 
   c_qualifierst qual_to;
-    qual_to.read(type.subtype());
+  qual_to.read(to_reference_type(type).base_type());
 
   if(qual_from!=qual_to)
     rank+=1;
@@ -1264,7 +1267,7 @@ bool cpp_typecheckt::reference_binding(
         new_expr.swap(tmp);
       }
 
-      if(expr.type()!=type.subtype())
+      if(expr.type() != to_reference_type(type).base_type())
       {
         c_qualifierst qual_from;
         qual_from.read(expr.type());
@@ -1341,7 +1344,7 @@ bool cpp_typecheckt::reference_binding(
 
           new_expr = to_multi_ary_expr(returned_value).op0();
 
-          if(returned_value.type() != type.subtype())
+          if(returned_value.type() != to_reference_type(type).base_type())
           {
             c_qualifierst qual_from;
             qual_from.read(returned_value.type());
@@ -1359,13 +1362,15 @@ bool cpp_typecheckt::reference_binding(
   if(type.get_bool(ID_C_this))
     return false;
 
-  if(!type.subtype().get_bool(ID_C_constant) ||
-     type.subtype().get_bool(ID_C_volatile))
+  if(
+    !to_reference_type(type).base_type().get_bool(ID_C_constant) ||
+    to_reference_type(type).base_type().get_bool(ID_C_volatile))
     return false;
 
   // TODO: handle the case for implicit parameters
-  if(!type.subtype().get_bool(ID_C_constant) &&
-     !expr.get_bool(ID_C_lvalue))
+  if(
+    !to_reference_type(type).base_type().get_bool(ID_C_constant) &&
+    !expr.get_bool(ID_C_lvalue))
     return false;
 
   exprt arg_expr=expr;
@@ -1376,7 +1381,8 @@ bool cpp_typecheckt::reference_binding(
     arg_expr.set(ID_C_lvalue, true);
   }
 
-  if(user_defined_conversion_sequence(arg_expr, type.subtype(), new_expr, rank))
+  if(user_defined_conversion_sequence(
+       arg_expr, to_reference_type(type).base_type(), new_expr, rank))
   {
     address_of_exprt tmp(new_expr, reference_type(new_expr.type()));
     tmp.add_source_location()=new_expr.source_location();
@@ -1385,12 +1391,15 @@ bool cpp_typecheckt::reference_binding(
   }
 
   rank=backup_rank;
-  if(standard_conversion_sequence(expr, type.subtype(), new_expr, rank))
+  if(standard_conversion_sequence(
+       expr, to_reference_type(type).base_type(), new_expr, rank))
   {
     {
       // create temporary object
       side_effect_exprt tmp(
-        ID_temporary_object, type.subtype(), expr.source_location());
+        ID_temporary_object,
+        to_reference_type(type).base_type(),
+        expr.source_location());
       tmp.set(ID_mode, ID_cpp);
       // tmp.set(ID_C_lvalue, true);
       tmp.add_to_operands(std::move(new_expr));

src/cpp/cpp_typecheck_expr.cpp

@@ -324,12 +324,13 @@ void cpp_typecheckt::typecheck_expr_sizeof(exprt &expr)
     {
       // sizeof(expr[index]) can be parsed as an array type!
 
-      if(type.subtype().id()==ID_cpp_name)
+      if(to_array_type(type).element_type().id() == ID_cpp_name)
       {
         cpp_typecheck_fargst fargs;
 
-        exprt symbol_expr=resolve(
-          to_cpp_name(static_cast<const irept &>(type.subtype())),
+        exprt symbol_expr = resolve(
+          to_cpp_name(
+            static_cast<const irept &>(to_array_type(type).element_type())),
           cpp_typecheck_resolvet::wantt::BOTH,
           fargs);
 
@@ -1652,7 +1653,7 @@ void cpp_typecheckt::typecheck_side_effect_function_call(
 
       // look for the right entry
       irep_idt vtentry_component_name =
-        vt_compo.type().subtype().get_string(ID_identifier) +
+        to_pointer_type(vt_compo.type()).base_type().get_string(ID_identifier) +
         "::" + expr.function().type().get_string(ID_C_virtual_name);
 
       exprt vtentry_member(ID_ptrmember);
@@ -1719,14 +1720,14 @@ void cpp_typecheckt::typecheck_side_effect_function_call(
 
     assert(parameters.size()>=1);
 
-    const typet &this_type=parameters[0].type();
+    const auto &this_type = to_pointer_type(parameters[0].type());
 
     // change type from 'constructor' to object type
-    expr.type()=this_type.subtype();
+    expr.type() = this_type.base_type();
 
     // create temporary object
     side_effect_exprt tmp_object_expr(
-      ID_temporary_object, this_type.subtype(), expr.source_location());
+      ID_temporary_object, this_type.base_type(), expr.source_location());
     tmp_object_expr.set(ID_C_lvalue, true);
     tmp_object_expr.set(ID_mode, ID_cpp);
 
@@ -1808,7 +1809,7 @@ void cpp_typecheckt::typecheck_side_effect_function_call(
 
       if(
         operand.type().id() != ID_pointer &&
-        operand.type() == parameter.type().subtype())
+        operand.type() == to_pointer_type(parameter.type()).base_type())
       {
         address_of_exprt tmp(operand, pointer_type(operand.type()));
         tmp.add_source_location()=operand.source_location();
@@ -1869,7 +1870,7 @@ void cpp_typecheckt::typecheck_function_call_arguments(
         exprt temporary;
         new_temporary(
           arg_it->source_location(),
-          parameter.type().subtype(),
+          to_reference_type(parameter.type()).base_type(),
           already_typechecked_exprt{*arg_it},
           temporary);
         arg_it->swap(temporary);

src/cpp/cpp_typecheck_resolve.cpp

@@ -269,10 +269,14 @@ exprt cpp_typecheck_resolvet::convert_identifier(
       {
         // use this->...
         assert(this_expr.type().id()==ID_pointer);
-        object=exprt(ID_dereference, this_expr.type().subtype());
+        object =
+          exprt(ID_dereference, to_pointer_type(this_expr.type()).base_type());
         object.copy_to_operands(this_expr);
-        object.type().set(ID_C_constant,
-                          this_expr.type().subtype().get_bool(ID_C_constant));
+        object.type().set(
+          ID_C_constant,
+          to_pointer_type(this_expr.type())
+            .base_type()
+            .get_bool(ID_C_constant));
         object.set(ID_C_lvalue, true);
         object.add_source_location()=source_location;
       }
@@ -1838,19 +1842,24 @@ void cpp_typecheck_resolvet::guess_template_args(
   else if(is_reference(template_type) ||
           is_rvalue_reference(template_type))
   {
-    guess_template_args(template_type.subtype(), desired_type);
+    guess_template_args(
+      to_reference_type(template_type).base_type(), desired_type);
   }
   else if(template_type.id()==ID_pointer)
   {
     if(desired_type.id() == ID_pointer)
-      guess_template_args(template_type.subtype(), desired_type.subtype());
+      guess_template_args(
+        to_pointer_type(template_type).base_type(),
+        to_pointer_type(desired_type).base_type());
   }
   else if(template_type.id()==ID_array)
   {
     if(desired_type.id() == ID_array)
     {
       // look at subtype first
-      guess_template_args(template_type.subtype(), desired_type.subtype());
+      guess_template_args(
+        to_array_type(template_type).element_type(),
+        to_array_type(desired_type).element_type());
 
       // size (e.g., buffer size guessing)
       guess_template_args(
@@ -2134,7 +2143,8 @@ bool cpp_typecheck_resolvet::disambiguate_functions(
       if(type.return_type().id() == ID_constructor)
       {
         // it's a constructor
-        const typet &object_type=parameter.type().subtype();
+        const typet &object_type =
+          to_pointer_type(parameter.type()).base_type();
         symbol_exprt object(irep_idt(), object_type);
         object.set(ID_C_lvalue, true);