Rename things to better reflect true meaning

Author: NathanJPhillips

src/java_bytecode/ci_lazy_methods.cpp

@@ -61,13 +61,13 @@ ci_lazy_methodst::ci_lazy_methodst(
 /// from the main entry point (usually provided with the --function command-
 /// line option
 /// \param symbol_table: global symbol table
-/// \param [out] lazy_methods: map from method names to relevant symbol and
+/// \param [out] method_bytecode: map from method names to relevant symbol and
 ///   parsed-method objects.
 /// \param method_converter: Function for converting methods on demand.
 /// \return Returns false on success
 bool ci_lazy_methodst::operator()(
   symbol_tablet &symbol_table,
-  lazy_methodst &lazy_methods,
+  method_bytecodet &method_bytecode,
   method_convertert method_converter)
 {
   std::vector<irep_idt> method_worklist1;
@@ -141,8 +141,8 @@ bool ci_lazy_methodst::operator()(
       {
         if(!methods_already_populated.insert(mname).second)
           continue;
-        auto findit=lazy_methods.find(mname);
-        if(findit==lazy_methods.end())
+        auto findit = method_bytecode.find(mname);
+        if(findit == method_bytecode.end())
         {
           debug() << "Skip " << mname << eom;
           continue;
@@ -191,8 +191,9 @@ bool ci_lazy_methodst::operator()(
   {
     if(sym.second.is_static_lifetime)
       continue;
-    if(lazy_methods.count(sym.first) &&
-       !methods_already_populated.count(sym.first))
+    if(
+      method_bytecode.count(sym.first) &&
+      !methods_already_populated.count(sym.first))
     {
       continue;
     }
@@ -263,13 +264,13 @@ void ci_lazy_methodst::resolve_method_names(
 /// \param entry_points: list of fully-qualified function names that
 ///   we should assume are reachable
 /// \param ns: global namespace
-/// \param [out] lazy_methods: Populated with all Java reference types whose
-///   references may be passed, directly or indirectly, to any of the functions
-///   in `entry_points`.
+/// \param [out] needed_lazy_methods: Populated with all Java reference types
+///   whose references may be passed, directly or indirectly, to any of the
+///   functions in `entry_points`.
 void ci_lazy_methodst::initialize_needed_classes(
   const std::vector<irep_idt> &entry_points,
   const namespacet &ns,
-  ci_lazy_methods_neededt &lazy_methods)
+  ci_lazy_methods_neededt &needed_lazy_methods)
 {
   for(const auto &mname : entry_points)
   {
@@ -281,67 +282,66 @@ void ci_lazy_methodst::initialize_needed_classes(
       {
         const pointer_typet &original_pointer=to_pointer_type(param.type());
         initialize_all_needed_classes_from_pointer(
-          original_pointer, ns, lazy_methods);
+          original_pointer, ns, needed_lazy_methods);
       }
     }
   }
 
   // Also add classes whose instances are magically
   // created by the JVM and so won't be spotted by
   // looking for constructors and calls as usual:
-  lazy_methods.add_needed_class("java::java.lang.String");
-  lazy_methods.add_needed_class("java::java.lang.Class");
-  lazy_methods.add_needed_class("java::java.lang.Object");
+  needed_lazy_methods.add_needed_class("java::java.lang.String");
+  needed_lazy_methods.add_needed_class("java::java.lang.Class");
+  needed_lazy_methods.add_needed_class("java::java.lang.Object");
 
   // As in class_loader, ensure these classes stay available
   for(const auto &id : extra_needed_classes)
-    lazy_methods.add_needed_class("java::" + id2string(id));
+    needed_lazy_methods.add_needed_class("java::" + id2string(id));
 }
 
 /// Build up list of methods for types for a pointer and any types it
 /// might be subsituted for. See
 /// `initialize_needed_classes` for more details.
 /// \param pointer_type: The type to gather methods for.
 /// \param ns: global namespace
-/// \param [out] lazy_methods: Populated with all Java reference types whose
-///   references may be passed, directly or indirectly, to any of the functions
-///   in `entry_points
+/// \param [out] needed_lazy_methods: Populated with all Java reference types
+///   whose references may be passed, directly or indirectly, to any of the
+///   functions in `entry_points`
 void ci_lazy_methodst::initialize_all_needed_classes_from_pointer(
   const pointer_typet &pointer_type,
   const namespacet &ns,
-  ci_lazy_methods_neededt &lazy_methods)
+  ci_lazy_methods_neededt &needed_lazy_methods)
 {
-  initialize_needed_classes_from_pointer(
-    pointer_type, ns, lazy_methods);
+  initialize_needed_classes_from_pointer(pointer_type, ns, needed_lazy_methods);
 
   const pointer_typet &subbed_pointer_type=
     pointer_type_selector.convert_pointer_type(pointer_type, ns);
 
   if(subbed_pointer_type!=pointer_type)
   {
     initialize_needed_classes_from_pointer(
-      subbed_pointer_type, ns, lazy_methods);
+      subbed_pointer_type, ns, needed_lazy_methods);
   }
 }
 
 /// Build up list of methods for types for a specific pointer type. See
 /// `initialize_needed_classes` for more details.
 /// \param pointer_type: The type to gather methods for.
 /// \param ns: global namespace
-/// \param [out] lazy_methods: Populated with all Java reference types whose
-///   references may be passed, directly or indirectly, to any of the functions
-///   in `entry_points
+/// \param [out] needed_lazy_methods: Populated with all Java reference types
+///   whose references may be passed, directly or indirectly, to any of the
+///   functions in `entry_points`
 void ci_lazy_methodst::initialize_needed_classes_from_pointer(
   const pointer_typet &pointer_type,
   const namespacet &ns,
-  ci_lazy_methods_neededt &lazy_methods)
+  ci_lazy_methods_neededt &needed_lazy_methods)
 {
   const symbol_typet &class_type=to_symbol_type(pointer_type.subtype());
   const auto &param_classid=class_type.get_identifier();
 
-  if(lazy_methods.add_needed_class(param_classid))
+  if(needed_lazy_methods.add_needed_class(param_classid))
   {
-    gather_field_types(pointer_type.subtype(), ns, lazy_methods);
+    gather_field_types(pointer_type.subtype(), ns, needed_lazy_methods);
   }
 }
 
@@ -462,30 +462,30 @@ void ci_lazy_methodst::gather_needed_globals(
       gather_needed_globals(*opit, symbol_table, needed);
 }
 
-/// See param lazy_methods
+/// See param needed_lazy_methods
 /// \param class_type: root of class tree to search
 /// \param ns: global namespace
-/// \param [out] lazy_methods: Popualted with all Java reference types reachable
-///   starting at `class_type`. For example if `class_type` is
+/// \param [out] needed_lazy_methods: Popualted with all Java reference types
+///   reachable starting at `class_type`. For example if `class_type` is
 ///   `symbol_typet("java::A")` and A has a B field, then `B` (but not `A`) will
 ///   noted as a needed class.
 void ci_lazy_methodst::gather_field_types(
   const typet &class_type,
   const namespacet &ns,
-  ci_lazy_methods_neededt &lazy_methods)
+  ci_lazy_methods_neededt &needed_lazy_methods)
 {
   const auto &underlying_type=to_struct_type(ns.follow(class_type));
   for(const auto &field : underlying_type.components())
   {
     if(field.type().id()==ID_struct || field.type().id()==ID_symbol)
-      gather_field_types(field.type(), ns, lazy_methods);
+      gather_field_types(field.type(), ns, needed_lazy_methods);
     else if(field.type().id()==ID_pointer)
     {
       // Skip array primitive pointers, for example:
       if(field.type().subtype().id()!=ID_symbol)
         continue;
       initialize_all_needed_classes_from_pointer(
-        to_pointer_type(field.type()), ns, lazy_methods);
+        to_pointer_type(field.type()), ns, needed_lazy_methods);
     }
   }
 }

src/java_bytecode/ci_lazy_methods.h

@@ -26,13 +26,11 @@
 
 class java_string_library_preprocesst;
 
-typedef std::pair<
-          const symbolt *,
-          const java_bytecode_parse_treet::methodt *>
-  lazy_method_valuet;
-
-typedef std::map<irep_idt, lazy_method_valuet>
-  lazy_methodst;
+// Pair of class id and methodt
+typedef std::pair<const symbolt *, const java_bytecode_parse_treet::methodt *>
+  class_and_bytecodet;
+// Map from method id to class_and_bytecodet
+typedef std::map<irep_idt, class_and_bytecodet> method_bytecodet;
 
 typedef std::function<void(
   const symbolt &,
@@ -55,7 +53,7 @@ class ci_lazy_methodst:public messaget
   // not const since messaget
   bool operator()(
     symbol_tablet &symbol_table,
-    lazy_methodst &lazy_methods,
+    method_bytecodet &method_bytecode,
     method_convertert method_converter);
 
 private:
@@ -66,17 +64,17 @@ class ci_lazy_methodst:public messaget
   void initialize_needed_classes(
     const std::vector<irep_idt> &entry_points,
     const namespacet &ns,
-    ci_lazy_methods_neededt &lazy_methods);
+    ci_lazy_methods_neededt &needed_lazy_methods);
 
   void initialize_all_needed_classes_from_pointer(
     const pointer_typet &pointer_type,
     const namespacet &ns,
-    ci_lazy_methods_neededt &lazy_methods);
+    ci_lazy_methods_neededt &needed_lazy_methods);
 
   void initialize_needed_classes_from_pointer(
     const pointer_typet &pointer_type,
     const namespacet &ns,
-    ci_lazy_methods_neededt &lazy_methods);
+    ci_lazy_methods_neededt &needed_lazy_methods);
 
   void gather_virtual_callsites(
     const exprt &e,
@@ -93,9 +91,10 @@ class ci_lazy_methodst:public messaget
     const symbol_tablet &symbol_table,
     symbol_tablet &needed);
 
-  void gather_field_types(const typet &class_type,
+  void gather_field_types(
+    const typet &class_type,
     const namespacet &ns,
-    ci_lazy_methods_neededt &lazy_methods);
+    ci_lazy_methods_neededt &needed_lazy_methods);
 
   irep_idt get_virtual_method_target(
     const std::set<irep_idt> &needed_classes,

src/java_bytecode/java_bytecode_convert_class.cpp

@@ -35,15 +35,15 @@ class java_bytecode_convert_classt:public messaget
     symbol_tablet &_symbol_table,
     message_handlert &_message_handler,
     size_t _max_array_length,
-    lazy_methodst& _lazy_methods,
+    method_bytecodet &method_bytecode,
     lazy_methods_modet _lazy_methods_mode,
-    java_string_library_preprocesst &_string_preprocess):
-    messaget(_message_handler),
-    symbol_table(_symbol_table),
-    max_array_length(_max_array_length),
-    lazy_methods(_lazy_methods),
-    lazy_methods_mode(_lazy_methods_mode),
-    string_preprocess(_string_preprocess)
+    java_string_library_preprocesst &_string_preprocess)
+    : messaget(_message_handler),
+      symbol_table(_symbol_table),
+      max_array_length(_max_array_length),
+      method_bytecode(method_bytecode),
+      lazy_methods_mode(_lazy_methods_mode),
+      string_preprocess(_string_preprocess)
   {
   }
 
@@ -73,7 +73,7 @@ class java_bytecode_convert_classt:public messaget
 protected:
   symbol_tablet &symbol_table;
   const size_t max_array_length;
-  lazy_methodst &lazy_methods;
+  method_bytecodet &method_bytecode;
   lazy_methods_modet lazy_methods_mode;
   java_string_library_preprocesst &string_preprocess;
 
@@ -205,7 +205,7 @@ void java_bytecode_convert_classt::convert(const classt &c)
       method,
       symbol_table,
       get_message_handler());
-    lazy_methods[method_identifier]=std::make_pair(class_symbol, &method);
+    method_bytecode[method_identifier] = std::make_pair(class_symbol, &method);
   }
 
   // is this a root class?
@@ -483,15 +483,15 @@ bool java_bytecode_convert_class(
   symbol_tablet &symbol_table,
   message_handlert &message_handler,
   size_t max_array_length,
-  lazy_methodst &lazy_methods,
+  method_bytecodet &method_bytecode,
   lazy_methods_modet lazy_methods_mode,
   java_string_library_preprocesst &string_preprocess)
 {
   java_bytecode_convert_classt java_bytecode_convert_class(
     symbol_table,
     message_handler,
     max_array_length,
-    lazy_methods,
+    method_bytecode,
     lazy_methods_mode,
     string_preprocess);
 

src/java_bytecode/java_bytecode_convert_class.h

@@ -24,7 +24,7 @@ bool java_bytecode_convert_class(
   symbol_tablet &symbol_table,
   message_handlert &message_handler,
   size_t max_array_length,
-  lazy_methodst &,
+  method_bytecodet &,
   lazy_methods_modet,
   java_string_library_preprocesst &string_preprocess);
 

src/java_bytecode/java_bytecode_convert_method.cpp

@@ -1429,8 +1429,8 @@ codet java_bytecode_convert_methodt::convert_instructions(
             if(as_string(arg0.get(ID_identifier))
                .find("<init>")!=std::string::npos)
             {
-              if(lazy_methods)
-                lazy_methods->add_needed_class(classname);
+              if(needed_lazy_methods)
+                needed_lazy_methods->add_needed_class(classname);
               code_type.set(ID_constructor, true);
             }
             else
@@ -1548,11 +1548,11 @@ codet java_bytecode_convert_methodt::convert_instructions(
       {
         // static binding
         call.function()=symbol_exprt(arg0.get(ID_identifier), arg0.type());
-        if(lazy_methods)
+        if(needed_lazy_methods)
         {
-          lazy_methods->add_needed_method(arg0.get(ID_identifier));
+          needed_lazy_methods->add_needed_method(arg0.get(ID_identifier));
           // Calling a static method causes static initialization:
-          lazy_methods->add_needed_class(arg0.get(ID_C_class));
+          needed_lazy_methods->add_needed_class(arg0.get(ID_C_class));
         }
       }
 
@@ -2180,25 +2180,25 @@ codet java_bytecode_convert_methodt::convert_instructions(
       // If external, create a symbol table entry for this static field:
       check_static_field_stub(symbol_expr, field_name);
 
-      if(lazy_methods)
+      if(needed_lazy_methods)
       {
         if(arg0.type().id()==ID_symbol)
         {
-          lazy_methods->add_needed_class(
+          needed_lazy_methods->add_needed_class(
             to_symbol_type(arg0.type()).get_identifier());
         }
         else if(arg0.type().id()==ID_pointer)
         {
           const auto &pointer_type=to_pointer_type(arg0.type());
           if(pointer_type.subtype().id()==ID_symbol)
           {
-            lazy_methods->add_needed_class(
+            needed_lazy_methods->add_needed_class(
               to_symbol_type(pointer_type.subtype()).get_identifier());
           }
         }
         else if(is_assertions_disabled_field)
         {
-          lazy_methods->add_needed_class(arg0.get_string(ID_class));
+          needed_lazy_methods->add_needed_class(arg0.get_string(ID_class));
         }
       }
       results[0]=java_bytecode_promotion(symbol_expr);
@@ -2235,9 +2235,9 @@ codet java_bytecode_convert_methodt::convert_instructions(
       // If external, create a symbol table entry for this static field:
       check_static_field_stub(symbol_expr, field_name);
 
-      if(lazy_methods && arg0.type().id()==ID_symbol)
+      if(needed_lazy_methods && arg0.type().id() == ID_symbol)
       {
-        lazy_methods->add_needed_class(
+        needed_lazy_methods->add_needed_class(
           to_symbol_type(arg0.type()).get_identifier());
       }
 
@@ -2850,7 +2850,7 @@ void java_bytecode_convert_method(
   symbol_tablet &symbol_table,
   message_handlert &message_handler,
   size_t max_array_length,
-  safe_pointer<ci_lazy_methods_neededt> lazy_methods,
+  safe_pointer<ci_lazy_methods_neededt> needed_lazy_methods,
   java_string_library_preprocesst &string_preprocess)
 {
   static const std::unordered_set<std::string> methods_to_ignore
@@ -2881,7 +2881,7 @@ void java_bytecode_convert_method(
     symbol_table,
     message_handler,
     max_array_length,
-    lazy_methods,
+    needed_lazy_methods,
     string_preprocess);
 
   java_bytecode_convert_method(class_symbol, method);