Merge pull request #4165 from tautschnig/parametert-api

Use modern API to access parametert's identifier and base name

Author: tautschnig

src/cpp/cpp_typecheck_compound_type.cpp

@@ -639,7 +639,7 @@ void cpp_typecheckt::typecheck_compound_declarator(
           arg_symb.location=func_symb.location;
           arg_symb.type=arg.type();
 
-          arg.set(ID_C_identifier, arg_symb.name);
+          arg.set_identifier(arg_symb.name);
 
           // add the parameter to the symbol table
           const bool failed=!symbol_table.insert(std::move(arg_symb)).second;
@@ -648,7 +648,7 @@ void cpp_typecheckt::typecheck_compound_declarator(
 
         // do the body of the function
         typecast_exprt late_cast(
-          lookup(args[0].get(ID_C_identifier)).symbol_expr(),
+          lookup(args[0].get_identifier()).symbol_expr(),
           to_code_type(component.type()).parameters()[0].type());
 
         side_effect_expr_function_callt expr_call(
@@ -661,7 +661,7 @@ void cpp_typecheckt::typecheck_compound_declarator(
         for(const auto &arg : args)
         {
           expr_call.arguments().push_back(
-            lookup(arg.get(ID_C_identifier)).symbol_expr());
+            lookup(arg.get_identifier()).symbol_expr());
         }
 
         if(code_type.return_type().id()!=ID_empty &&

src/cpp/cpp_typecheck_conversions.cpp

@@ -576,13 +576,15 @@ bool cpp_typecheckt::standard_conversion_pointer_to_member(
       code_typet code1=to_code_type(expr.type().subtype());
       assert(!code1.parameters().empty());
       code_typet::parametert this1=code1.parameters()[0];
-      assert(this1.get(ID_C_base_name)==ID_this);
+      INVARIANT(
+        this1.get_base_name() == ID_this, "first parameter should be `this'");
       code1.parameters().erase(code1.parameters().begin());
 
       code_typet code2=to_code_type(type.subtype());
       assert(!code2.parameters().empty());
       code_typet::parametert this2=code2.parameters()[0];
-      assert(this2.get(ID_C_base_name)==ID_this);
+      INVARIANT(
+        this2.get_base_name() == ID_this, "first parameter should be `this'");
       code2.parameters().erase(code2.parameters().begin());
 
       if(this2.type().subtype().get_bool(ID_C_constant) &&

src/cpp/cpp_typecheck_expr.cpp

@@ -706,7 +706,7 @@ void cpp_typecheckt::typecheck_expr_address_of(exprt &expr)
     code_typet &code_type=to_code_type(op.type().subtype());
 
     code_typet::parameterst &args=code_type.parameters();
-    if(args.size() > 0 && args[0].get(ID_C_base_name)==ID_this)
+    if(!args.empty() && args[0].get_base_name() == ID_this)
     {
       // it's a pointer to member function
       const struct_tag_typet symbol(code_type.get(ID_C_member_name));
@@ -2192,21 +2192,23 @@ void cpp_typecheckt::typecheck_side_effect_function_call(
     // we are willing to add an "address_of"
     // for the sake of operator overloading
 
-    const irept::subt &arguments=
-      expr.function().type().find(ID_arguments).get_sub();
+    const code_typet::parameterst &parameters =
+      to_code_type(expr.function().type()).parameters();
 
-    if(arguments.size()>=1 &&
-       arguments.front().get(ID_C_base_name)==ID_this &&
-       expr.arguments().size()>=1)
+    if(
+      !parameters.empty() && parameters.front().get_base_name() == ID_this &&
+      !expr.arguments().empty())
     {
-      const exprt &argument=
-      static_cast<const exprt &>(arguments.front());
+      const code_typet::parametert &parameter = parameters.front();
 
-      exprt &operand=expr.op1();
-      assert(argument.type().id()==ID_pointer);
+      exprt &operand = expr.arguments().front();
+      INVARIANT(
+        parameter.type().id() == ID_pointer,
+        "`this' parameter should be a pointer");
 
-      if(operand.type().id()!=ID_pointer &&
-         operand.type()==argument.type().subtype())
+      if(
+        operand.type().id() != ID_pointer &&
+        operand.type() == parameter.type().subtype())
       {
         address_of_exprt tmp(operand, pointer_type(operand.type()));
         tmp.add_source_location()=operand.source_location();

src/cpp/cpp_typecheck_fargs.cpp

@@ -97,7 +97,7 @@ bool cpp_typecheck_fargst::match(
 
     // "this" is a special case -- we turn the pointer type
     // into a reference type to do the type matching
-    if(it==ops.begin() && parameter.get(ID_C_base_name)==ID_this)
+    if(it == ops.begin() && parameter.get_base_name() == ID_this)
     {
       type.set(ID_C_reference, true);
       type.set(ID_C_this, true);

src/cpp/cpp_typecheck_function.cpp

@@ -127,7 +127,7 @@ void cpp_typecheckt::convert_function(symbolt &symbol)
     code_typet::parametert &this_parameter_expr=parameters.front();
     function_scope.this_expr=exprt(ID_symbol, this_parameter_expr.type());
     function_scope.this_expr.set(
-      ID_identifier, this_parameter_expr.get(ID_C_identifier));
+      ID_identifier, this_parameter_expr.get_identifier());
   }
   else
     function_scope.this_expr.make_nil();

src/cpp/cpp_typecheck_initializer.cpp

@@ -89,18 +89,15 @@ void cpp_typecheckt::convert_initializer(symbolt &symbol)
 
       const code_typet &code_type=to_code_type(symbol.type.subtype());
 
-      for(code_typet::parameterst::const_iterator
-          ait=code_type.parameters().begin();
-          ait!=code_type.parameters().end();
-          ait++)
+      for(const auto &parameter : code_type.parameters())
       {
-        exprt new_object(ID_new_object, ait->type());
+        exprt new_object(ID_new_object, parameter.type());
         new_object.set(ID_C_lvalue, true);
 
-        if(ait->get(ID_C_base_name)==ID_this)
+        if(parameter.get_base_name() == ID_this)
         {
           fargs.has_object = true;
-          new_object.type() = ait->type().subtype();
+          new_object.type() = parameter.type().subtype();
         }
 
         fargs.operands.push_back(new_object);

src/cpp/cpp_typecheck_resolve.cpp

@@ -2073,8 +2073,9 @@ void cpp_typecheck_resolvet::apply_template_args(
     // check if it is a method
     const code_typet &code_type=to_code_type(new_symbol.type);
 
-    if(!code_type.parameters().empty() &&
-        code_type.parameters()[0].get(ID_C_base_name)==ID_this)
+    if(
+      !code_type.parameters().empty() &&
+      code_type.parameters()[0].get_base_name() == ID_this)
     {
       // do we have an object?
       if(fargs.has_object)
@@ -2128,7 +2129,9 @@ bool cpp_typecheck_resolvet::disambiguate_functions(
       const code_typet::parameterst &parameters=type.parameters();
       const code_typet::parametert &parameter=parameters.front();
 
-      assert(parameter.get(ID_C_base_name)==ID_this);
+      INVARIANT(
+        parameter.get_base_name() == ID_this,
+        "first parameter should be `this'");
 
       if(type.return_type().id() == ID_constructor)
       {

src/cpp/cpp_typecheck_type.cpp

@@ -103,15 +103,14 @@ void cpp_typecheckt::typecheck_type(typet &type)
       // there may be parameters if this is a pointer to member function
       if(type.subtype().id()==ID_code)
       {
-        irept::subt &parameters=type.subtype().add(ID_parameters).get_sub();
+        code_typet::parameterst &parameters =
+          to_code_type(type.subtype()).parameters();
 
-        if(parameters.empty() ||
-           parameters.front().get(ID_C_base_name)!=ID_this)
+        if(parameters.empty() || parameters.front().get_base_name() != ID_this)
         {
           // Add 'this' to the parameters
-          exprt a0(ID_parameter);
-          a0.set(ID_C_base_name, ID_this);
-          a0.type()=pointer_type(class_object);
+          code_typet::parametert a0(pointer_type(class_object));
+          a0.set_base_name(ID_this);
           parameters.insert(parameters.begin(), a0);
         }
       }