Avoid repeated searches in map

Author: NathanJPhillips

jbmc/src/java_bytecode/generic_parameter_specialization_map_keys.cpp

@@ -49,7 +49,7 @@ void generic_parameter_specialization_map_keyst::insert_pairs(
   {
     // Only add the pair if the type is not the parameter itself, e.g.,
     // pair.first = pair.second = java::A::T. This can happen for example
-    // when initiating a pointer to an implicitly java generic class type
+    // when initializing a pointer to an implicitly generic Java class type
     // in gen_nondet_init and would result in a loop when the map is used
     // to look up the type of the parameter.
     if(
@@ -58,13 +58,13 @@ void generic_parameter_specialization_map_keyst::insert_pairs(
           pair.first.get_name()))
     {
       const irep_idt &key = pair.first.get_name();
-      if(generic_parameter_specialization_map.count(key) == 0)
-        generic_parameter_specialization_map.emplace(
-          key, std::vector<reference_typet>());
-      (*generic_parameter_specialization_map.find(key))
-        .second.push_back(pair.second);
+      const auto map_it = generic_parameter_specialization_map
+                            .emplace(key, std::vector<reference_typet>{})
+                            .first;
+      map_it->second.push_back(pair.second);
 
-      // We added something, so pop it when this is destroyed:
+      // We added something; pop it when this
+      // generic_parameter_specialization_map_keyst is destroyed
       erase_keys.push_back(key);
     }
   }

jbmc/src/java_bytecode/generic_parameter_specialization_map_keys.h

@@ -33,11 +33,12 @@ class generic_parameter_specialization_map_keyst
   {
     for(const auto key : erase_keys)
     {
-      PRECONDITION(generic_parameter_specialization_map.count(key) != 0);
-      auto &val = generic_parameter_specialization_map.find(key)->second;
+      const auto map_it = generic_parameter_specialization_map.find(key);
+      PRECONDITION(map_it != generic_parameter_specialization_map.end());
+      std::vector<reference_typet> &val = map_it->second;
       val.pop_back();
       if(val.empty())
-        generic_parameter_specialization_map.erase(key);
+        generic_parameter_specialization_map.erase(map_it);
     }
   }
 

jbmc/src/java_bytecode/select_pointer_type.cpp

@@ -58,16 +58,17 @@ pointer_typet select_pointer_typet::specialize_generics(
       return result.has_value() ? result.value() : pointer_type;
     }
 
-    if(generic_parameter_specialization_map.count(parameter_name) == 0)
+    const auto specialization =
+      generic_parameter_specialization_map.find(parameter_name);
+    if(specialization == generic_parameter_specialization_map.end())
     {
       // this means that the generic pointer_type has not been specialized
       // in the current context (e.g., the method under test is generic);
       // we return the pointer_type itself which is basically a pointer to
       // its upper bound
       return pointer_type;
     }
-    const pointer_typet &type =
-      generic_parameter_specialization_map.find(parameter_name)->second.back();
+    const pointer_typet &type = specialization->second.back();
 
     // generic parameters can be adopted from outer classes or superclasses so
     // we may need to search for the concrete type recursively