Change variables named code_type to method_type

This is for variables that have been changed to java_method_typet from code_typet

Author: jeannielynnmoulton

jbmc/src/java_bytecode/expr2java.cpp

@@ -56,10 +56,11 @@ std::string expr2javat::convert_code_function_call(
     dest+='=';
   }
 
-  const java_method_typet &code_type =
+  const java_method_typet &method_type=
     to_java_method_type(src.function().type());
 
-  bool has_this = code_type.has_this() && !src.arguments().empty();
+  bool has_this=method_type.has_this() &&
+                !src.arguments().empty();
 
   if(has_this)
   {
@@ -283,7 +284,7 @@ std::string expr2javat::convert_rec(
     return q+"byte"+d;
   else if(src.id()==ID_code)
   {
-    const java_method_typet &code_type = to_java_method_type(src);
+    const java_method_typet &method_type=to_java_method_type(src);
 
     // Java doesn't really have syntax for function types,
     // so we make one up, loosely inspired by the syntax
@@ -292,7 +293,7 @@ std::string expr2javat::convert_rec(
     std::string dest="";
 
     dest+='(';
-    const java_method_typet::parameterst &parameters = code_type.parameters();
+    const java_method_typet::parameterst &parameters=method_type.parameters();
 
     for(java_method_typet::parameterst::const_iterator
         it=parameters.begin();
@@ -305,7 +306,7 @@ std::string expr2javat::convert_rec(
       dest+=convert(it->type());
     }
 
-    if(code_type.has_ellipsis())
+    if(method_type.has_ellipsis())
     {
       if(!parameters.empty())
         dest+=", ";
@@ -314,7 +315,7 @@ std::string expr2javat::convert_rec(
 
     dest+=')';
 
-    const typet &return_type = code_type.return_type();
+    const typet &return_type=method_type.return_type();
     dest+=" -> "+convert(return_type);
 
     return q + dest;

jbmc/src/java_bytecode/java_bytecode_convert_method.cpp

@@ -1254,10 +1254,9 @@ codet java_bytecode_convert_methodt::convert_instructions(
             id2string(arg0.get(ID_identifier))==
             "java::org.cprover.CProver.assume:(Z)V")
     {
-      const java_method_typet &code_type = to_java_method_type(arg0.type());
-      INVARIANT(
-        code_type.parameters().size() == 1,
-        "function expected to have exactly one parameter");
+      const java_method_typet &method_type=to_java_method_type(arg0.type());
+      INVARIANT(method_type.parameters().size()==1,
+                "function expected to have exactly one parameter");
       c = replace_call_to_cprover_assume(i_it->source_location, c);
     }
     // replace calls to CProver.atomicBegin
@@ -2107,8 +2106,8 @@ void java_bytecode_convert_methodt::convert_invoke(
   const bool is_virtual(
     statement == "invokevirtual" || statement == "invokeinterface");
 
-  java_method_typet &code_type = to_java_method_type(arg0.type());
-  java_method_typet::parameterst &parameters(code_type.parameters());
+  java_method_typet &method_type = to_java_method_type(arg0.type());
+  java_method_typet::parameterst &parameters(method_type.parameters());
 
   if(use_this)
   {
@@ -2124,10 +2123,10 @@ void java_bytecode_convert_methodt::convert_invoke(
         {
           if(needed_lazy_methods)
             needed_lazy_methods->add_needed_class(classname);
-          code_type.set_is_constructor();
+          method_type.set_is_constructor();
         }
         else
-          code_type.set(ID_java_super_method_call, true);
+          method_type.set(ID_java_super_method_call, true);
       }
       reference_typet object_ref_type = java_reference_type(thistype);
       java_method_typet::parametert this_p(object_ref_type);
@@ -2172,7 +2171,7 @@ void java_bytecode_convert_methodt::convert_invoke(
 
   // do some type adjustment for return values
 
-  const typet &return_type = code_type.return_type();
+  const typet &return_type = method_type.return_type();
 
   if(return_type.id() != ID_empty)
   {
@@ -2954,11 +2953,11 @@ optionalt<exprt> java_bytecode_convert_methodt::convert_invoke_dynamic(
   const source_locationt &location,
   const exprt &arg0)
 {
-  const java_method_typet &code_type = to_java_method_type(arg0.type());
+  const java_method_typet &method_type = to_java_method_type(arg0.type());
 
   const optionalt<symbolt> &lambda_method_symbol = get_lambda_method_symbol(
     lambda_method_handles,
-    code_type.get_int(ID_java_lambda_method_handle_index));
+    method_type.get_int(ID_java_lambda_method_handle_index));
   if(lambda_method_symbol.has_value())
     debug() << "Converting invokedynamic for lambda: "
             << lambda_method_symbol.value().name << eom;
@@ -2967,11 +2966,11 @@ optionalt<exprt> java_bytecode_convert_methodt::convert_invoke_dynamic(
                "type"
             << eom;
 
-  const java_method_typet::parameterst &parameters(code_type.parameters());
+  const java_method_typet::parameterst &parameters(method_type.parameters());
 
   pop(parameters.size());
 
-  const typet &return_type = code_type.return_type();
+  const typet &return_type = method_type.return_type();
 
   if(return_type.id() == ID_empty)
     return {};
@@ -3030,11 +3029,11 @@ void java_bytecode_initialize_parameter_names(
 {
   // Obtain a std::vector of java_method_typet::parametert objects from the
   // (function) type of the symbol
-  java_method_typet &code_type = to_java_method_type(method_symbol.type);
-  java_method_typet::parameterst &parameters = code_type.parameters();
+  java_method_typet &method_type = to_java_method_type(method_symbol.type);
+  java_method_typet::parameterst &parameters = method_type.parameters();
 
   // Find number of parameters
-  unsigned slots_for_parameters = java_method_parameter_slots(code_type);
+  unsigned slots_for_parameters = java_method_parameter_slots(method_type);
 
   // Find parameter names in the local variable table:
   typedef std::pair<irep_idt, irep_idt> base_name_and_identifiert;

jbmc/src/java_bytecode/java_bytecode_typecheck_type.cpp

@@ -38,10 +38,10 @@ void java_bytecode_typecheckt::typecheck_type(typet &type)
   }
   else if(type.id()==ID_code)
   {
-    java_method_typet &code_type = to_java_method_type(type);
-    typecheck_type(code_type.return_type());
+    java_method_typet &method_type=to_java_method_type(type);
+    typecheck_type(method_type.return_type());
 
-    java_method_typet::parameterst &parameters = code_type.parameters();
+    java_method_typet::parameterst &parameters=method_type.parameters();
 
     for(java_method_typet::parameterst::iterator
         it=parameters.begin(); it!=parameters.end(); it++)

jbmc/src/java_bytecode/java_types.cpp

@@ -974,13 +974,13 @@ std::string pretty_java_type(const typet &type)
     return "?";
 }
 
-std::string pretty_signature(const java_method_typet &code_type)
+std::string pretty_signature(const java_method_typet &method_type)
 {
   std::ostringstream result;
   result << '(';
 
   bool first = true;
-  for(const auto p : code_type.parameters())
+  for(const auto p : method_type.parameters())
   {
     if(p.get_this())
       continue;

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

@@ -54,7 +54,7 @@ struct_union_typet::componentt require_type::require_component(
 
 /// Checks a type is a code_type (i.e. a function)
 /// \param type: The type to check
-/// \return The cast version of the type code_type
+/// \return The cast version of the type method_type
 java_method_typet require_type::require_code(const typet &type)
 {
   REQUIRE(type.id() == ID_code);
@@ -70,9 +70,9 @@ java_method_typet require_type::require_code(const typet &type)
 java_method_typet
 require_type::require_code(const typet &type, const size_t num_params)
 {
-  java_method_typet code_type = require_code(type);
-  REQUIRE(code_type.parameters().size() == num_params);
-  return code_type;
+  java_method_typet method_type = require_code(type);
+  REQUIRE(method_type.parameters().size() == num_params);
+  return method_type;
 }
 
 /// Verify that a function has a parameter of a specific name.

jbmc/unit/util/parameter_indices.cpp

@@ -12,9 +12,9 @@
 
 void check_consistency(const symbolt &symbol)
 {
-  const auto &code_type = to_java_method_type(symbol.type);
-  auto parameter_ids = code_type.parameter_identifiers();
-  auto parameter_indices = code_type.parameter_indices();
+  const auto &method_type = to_java_method_type(symbol.type);
+  auto parameter_ids = method_type.parameter_identifiers();
+  auto parameter_indices = method_type.parameter_indices();
 
   REQUIRE(parameter_ids.size() == parameter_indices.size());
   for(std::size_t i = 0; i < parameter_ids.size(); ++i)