Inline two functions that are only called once

Now that init_external_value_set() has been split into two, each version
is only called once, so it makes more sense to just inline the code.

Author: Owen Jones

src/pointer-analysis/local_value_set.cpp

@@ -40,46 +40,6 @@ void local_value_sett::make_union_adjusting_evs_types(
   }
 }
 
-std::pair<value_sett::valuest::iterator, bool>
-local_value_sett::init_per_field_external_value_set(
-  const external_value_set_exprt &evse)
-{
-  PRECONDITION(!evse.access_path_entries().empty());
-  const typet &declared_on_type =
-    evse.access_path_entries().back().declared_on_type();
-  std::string basename = evse.get_access_path_basename(declared_on_type);
-  std::string access_path_suffix=evse.get_access_path_suffix();
-  std::string entryname=basename+access_path_suffix;
-
-  entryt entry(basename, access_path_suffix, declared_on_type, evse);
-
-  auto insert_result=values.insert(std::make_pair(irep_idt(entryname), entry));
-
-  if(insert_result.second)
-    insert(insert_result.first->second.object_map, evse.as_initializer());
-
-  return insert_result;
-}
-
-void local_value_sett::init_precise_external_value_set(
-  const external_value_set_exprt &evse,
-  object_mapt &dest)
-{
-  PRECONDITION(!evse.access_path_entries().empty());
-  const typet &declared_on_type =
-    external_value_set_exprt::get_precise_evs_irep_id();
-  std::string basename = evse.get_access_path_basename(declared_on_type);
-  std::string access_path_suffix = evse.get_access_path_suffix();
-  std::string entryname = basename + access_path_suffix;
-
-  const irep_idt key(entryname);
-
-  if(values.count(key))
-    make_union(dest, values.at(key).object_map);
-  else
-    insert(dest, evse);
-}
-
 /// Builds a version of expr suitable for alias-comparison
 /// \param expr: The expression to be converted to the alias-uniform structure
 /// \return expr without information which is irrelevant to alias-comparison
@@ -303,10 +263,27 @@ void local_value_sett::get_value_set_rec(
           new_entry, external_value_set_typet::PER_FIELD);
         new_ext_set.type()=field_type.subtype();
 
-        // TODO: figure out how to do this sort of on-demand-insert
-        // without such ugly const hacking:
-        auto insert_result = (const_cast<local_value_sett *>(this))
-                               ->init_per_field_external_value_set(new_ext_set);
+        std::string basename =
+          new_ext_set.get_access_path_basename(declared_on_type);
+        std::string entryname = basename + access_path_suffix;
+
+        entryt entry(
+          basename, access_path_suffix, declared_on_type, new_ext_set);
+
+        /// If there is already an entry for this EVS then find it, otherwise
+        /// create a new entry for it
+        /// TODO: figure out how to do this sort of on-demand-insert
+        /// without such ugly const hacking:
+        auto insert_result =
+          (const_cast<local_value_sett *>(this))
+            ->values.insert(std::make_pair(irep_idt(entryname), entry));
+
+        /// If we've just created a new entry then populate the object map
+        /// with an initializer EVS
+        if(insert_result.second)
+          insert(
+            insert_result.first->second.object_map,
+            new_ext_set.as_initializer());
 
         make_union(dest, insert_result.first->second.object_map);
       }
@@ -329,10 +306,21 @@ void local_value_sett::get_value_set_rec(
         {
           new_ext_set.type()=field_type.subtype();
 
-          // TODO: figure out how to do this sort of on-demand-insert
-          // without such ugly const hacking:
-          (const_cast<local_value_sett *>(this))
-            ->init_precise_external_value_set(new_ext_set, dest);
+          declared_on_type =
+            external_value_set_exprt::get_precise_evs_irep_id();
+          std::string basename =
+            new_ext_set.get_access_path_basename(declared_on_type);
+          access_path_suffix = new_ext_set.get_access_path_suffix();
+          std::string entryname = basename + access_path_suffix;
+
+          const auto it = values.find(entryname);
+
+          /// If an entry already exists then use the values in the object
+          /// map, otherwise do not create an entry and use the EVS
+          if(it != values.end())
+            make_union(dest, it->second.object_map);
+          else
+            insert(dest, new_ext_set);
         }
       }
     }

src/pointer-analysis/local_value_set.h

@@ -50,22 +50,6 @@ class local_value_sett:public value_sett
     const object_mapt &src,
     const typet&) const;
 
-  /// Gets or creates a value-set entry corresponding to an external value set
-  /// expression, which initially contains the EVS itself. For example, given
-  /// EVS(A.x), representing all `x` fields of objects of type `A`, this would
-  /// create an entry `external_objects.A.x <- EVS(A.x)` if it didn't already
-  /// exist and return an iterator pointing to it.
-  /// \param evse: external value set whose entry to create
-  /// \return a la `std::map::insert`, a pair of an iterator pointing to the
-  ///   relevant entry and a boolean indicating if it is new.
-  std::pair<valuest::iterator, bool>
-  init_per_field_external_value_set(const external_value_set_exprt &evse);
-
-  /// TODO
-  void init_precise_external_value_set(
-    const external_value_set_exprt &evse,
-    object_mapt &dest);
-
   // For all the overrides below, see the base type for parameter-level docs
   // as their meanings are unchanged.