Merge pull request #3026 from tautschnig/no-id_type

Use type() instead of find(ID_type) or get(ID_type)

Author: tautschnig

src/cpp/cpp_template_parameter.h

@@ -43,17 +43,6 @@ struct template_parametert:public exprt
   {
     return set(ID_identifier, identifier);
   }
-
-  // the type of expression parameters
-  typet &type()
-  {
-    return static_cast<typet &>(add(ID_type));
-  }
-
-  const typet &type() const
-  {
-    return static_cast<const typet &>(find(ID_type));
-  }
   #endif
 
   exprt &default_argument()

src/cpp/cpp_typecheck_compound_type.cpp

@@ -476,11 +476,8 @@ void cpp_typecheckt::typecheck_compound_declarator(
     component.set(ID_is_inline, declaration.member_spec().is_inline());
 
     // the 'virtual' name of the function
-    std::string virtual_name =
-      id2string(component.get_base_name()) +
-      id2string(
-        function_identifier(
-          static_cast<const typet &>(component.find(ID_type))));
+    std::string virtual_name = id2string(component.get_base_name()) +
+                               id2string(function_identifier(component.type()));
 
     if(has_const(method_qualifier))
       virtual_name+="$const";

src/cpp/cpp_typecheck_constructor.cpp

@@ -462,16 +462,16 @@ void cpp_typecheckt::default_assignop_value(
     if(
       c.get_bool(ID_from_base) || c.get_bool(ID_is_type) ||
       c.get_bool(ID_is_static) || c.get_bool(ID_is_vtptr) ||
-      c.get(ID_type) == ID_code)
+      c.type().id() == ID_code)
     {
       continue;
     }
 
     const irep_idt &mem_name = c.get_base_name();
 
-    if(c.get(ID_type) == ID_array)
+    if(c.type().id() == ID_array)
     {
-      const exprt &size_expr = to_array_type((typet &)c.find(ID_type)).size();
+      const exprt &size_expr = to_array_type(c.type()).size();
 
       if(size_expr.id()==ID_infinity)
       {
@@ -570,7 +570,7 @@ void cpp_typecheckt::check_member_initializers(
       // Data member
       if(
         !c.get_bool(ID_from_base) && !c.get_bool(ID_is_static) &&
-        c.get(ID_type) != ID_code)
+        c.type().id() != ID_code)
       {
         ok=true;
         break;
@@ -579,11 +579,10 @@ void cpp_typecheckt::check_member_initializers(
       // Maybe it is a parent constructor?
       if(c.get_bool(ID_is_type))
       {
-        typet type = static_cast<const typet &>(c.find(ID_type));
-        if(type.id() != ID_symbol_type)
+        if(c.type().id() != ID_symbol_type)
           continue;
 
-        const symbolt &symb=lookup(type.get(ID_identifier));
+        const symbolt &symb = lookup(to_symbol_type(c.type()).get_identifier());
         if(symb.type.id()!=ID_struct)
           break;
 
@@ -741,7 +740,7 @@ void cpp_typecheckt::full_member_initialization(
           for(const auto &c : components)
           {
             if(
-              c.get_base_name() == base_name && c.get(ID_type) != ID_code &&
+              c.get_base_name() == base_name && c.type().id() != ID_code &&
               !c.get_bool(ID_is_type))
             {
               is_data=true;
@@ -881,8 +880,8 @@ void cpp_typecheckt::full_member_initialization(
     // If the data member is a reference, it must be explicitly
     // initialized
     if(
-      !found && c.find(ID_type).id() == ID_pointer &&
-      c.find(ID_type).get_bool(ID_C_reference))
+      !found && c.type().id() == ID_pointer &&
+      c.type().get_bool(ID_C_reference))
     {
       error().source_location = c.source_location();
       error() << "reference must be explicitly initialized" << eom;
@@ -891,7 +890,7 @@ void cpp_typecheckt::full_member_initialization(
 
     // If the data member is not POD and is not explicitly initialized,
     // then its default constructor is called.
-    if(!found && !cpp_is_pod((const typet &)(c.find(ID_type))))
+    if(!found && !cpp_is_pod(c.type()))
     {
       irept name(ID_name);
       name.set(ID_identifier, mem_name);

src/cpp/cpp_typecheck_conversions.cpp

@@ -921,8 +921,7 @@ bool cpp_typecheckt::user_defined_conversion_sequence(
         if(component.get_bool(ID_is_explicit))
           continue;
 
-        const typet &comp_type =
-          static_cast<const typet&>(component.find(ID_type));
+        const typet &comp_type = component.type();
 
         if(comp_type.id() !=ID_code)
           continue;
@@ -1058,22 +1057,17 @@ bool cpp_typecheckt::user_defined_conversion_sequence(
     bool found=false;
     for(const auto &component : to_struct_type(from).components())
     {
-      const typet comp_type=static_cast<const typet&>(component.find(ID_type));
-
       if(component.get_bool(ID_from_base))
         continue;
 
       if(!component.get_bool(ID_is_cast_operator))
         continue;
 
-      assert(component.get(ID_type)==ID_code &&
-             component.find(ID_type).find(ID_parameters).get_sub().size()==1);
+      const code_typet &comp_type = to_code_type(component.type());
+      DATA_INVARIANT(
+        comp_type.parameters().size() == 1, "expected exactly one parameter");
 
-      typet this_type =
-        static_cast<const typet&>(comp_type.find(ID_parameters)
-                                           .get_sub()
-                                           .front()
-                                           .find(ID_type));
+      typet this_type = comp_type.parameters().front().type();
       this_type.set(ID_C_reference, true);
 
       exprt this_expr(expr);

src/cpp/cpp_typecheck_resolve.cpp

@@ -2314,7 +2314,7 @@ void cpp_typecheck_resolvet::filter_for_named_scopes(
         cpp_typecheck.lookup(id.identifier);
 
       // Template struct? Really needs arguments to be a scope!
-      if(symbol.type.get(ID_type)==ID_struct)
+      if(symbol.type.id() == ID_struct)
       {
         id.print(std::cout);
         assert(id.is_scope);

src/cpp/template_map.cpp

@@ -33,7 +33,7 @@ void template_mapt::apply(typet &type) const
   {
     for(auto &c : to_struct_union_type(type).components())
     {
-      typet &subtype = static_cast<typet &>(c.add(ID_type));
+      typet &subtype = c.type();
       apply(subtype);
     }
   }