Chang the structure to use a lambda rather than a class

This reduces overall boilerplate.

Author: thk123

jbmc/src/java_bytecode/ci_lazy_methods.cpp

@@ -34,8 +34,7 @@ ci_lazy_methodst::ci_lazy_methodst(
   const symbol_tablet &symbol_table,
   const irep_idt &main_class,
   const std::vector<irep_idt> &main_jar_classes,
-  const std::vector<std::unique_ptr<load_extra_methodst>>
-    &lazy_methods_extra_entry_points,
+  const std::vector<load_extra_methodst> &lazy_methods_extra_entry_points,
   java_class_loadert &java_class_loader,
   const std::vector<irep_idt> &extra_instantiated_classes,
   const select_pointer_typet &pointer_type_selector,
@@ -107,8 +106,7 @@ bool ci_lazy_methodst::operator()(
   std::vector<irep_idt> extra_entry_points;
   for(const auto &extra_function_generator : lazy_methods_extra_entry_points)
   {
-    const auto &extra_methods =
-      extra_function_generator->extra_methods(symbol_table);
+    const auto &extra_methods = extra_function_generator(symbol_table);
     extra_entry_points.insert(
       extra_entry_points.end(), extra_methods.begin(), extra_methods.end());
   }

jbmc/src/java_bytecode/ci_lazy_methods.h

@@ -91,12 +91,8 @@ typedef std::function<
   bool(const irep_idt &function_id, ci_lazy_methods_neededt)>
   method_convertert;
 
-class load_extra_methodst
-{
-public:
-  virtual std::vector<irep_idt>
-  extra_methods(const symbol_tablet &symbol_table) const = 0;
-};
+typedef std::function<std::vector<irep_idt>(const symbol_tablet &)>
+  load_extra_methodst;
 
 class ci_lazy_methodst:public messaget
 {
@@ -105,8 +101,7 @@ class ci_lazy_methodst:public messaget
     const symbol_tablet &symbol_table,
     const irep_idt &main_class,
     const std::vector<irep_idt> &main_jar_classes,
-    const std::vector<std::unique_ptr<load_extra_methodst>>
-      &lazy_methods_extra_entry_points,
+    const std::vector<load_extra_methodst> &lazy_methods_extra_entry_points,
     java_class_loadert &java_class_loader,
     const std::vector<irep_idt> &extra_instantiated_classes,
     const select_pointer_typet &pointer_type_selector,
@@ -153,8 +148,7 @@ class ci_lazy_methodst:public messaget
   class_hierarchyt class_hierarchy;
   irep_idt main_class;
   std::vector<irep_idt> main_jar_classes;
-  const std::vector<std::unique_ptr<load_extra_methodst>>
-    &lazy_methods_extra_entry_points;
+  const std::vector<load_extra_methodst> &lazy_methods_extra_entry_points;
   java_class_loadert &java_class_loader;
   const std::vector<irep_idt> &extra_instantiated_classes;
   const select_pointer_typet &pointer_type_selector;

jbmc/src/java_bytecode/java_bytecode_language.cpp

@@ -102,7 +102,7 @@ void java_bytecode_languaget::get_language_options(const cmdlinet &cmd)
     extra_entry_points.end(),
     std::back_inserter(extra_methods),
     [](const std::string &pattern) {
-      return util_make_unique<load_method_by_regext>(pattern);
+      return build_load_method_by_regex(pattern);
     });
 
   if(cmd.isset("java-cp-include-files"))

jbmc/src/java_bytecode/java_bytecode_language.h

@@ -184,7 +184,7 @@ class java_bytecode_languaget:public languaget
   // List of classes to never load
   std::unordered_set<std::string> no_load_classes;
 
-  std::vector<std::unique_ptr<load_extra_methodst>> extra_methods;
+  std::vector<load_extra_methodst> extra_methods;
 };
 
 std::unique_ptr<languaget> new_java_bytecode_language();

jbmc/src/java_bytecode/load_method_by_regex.cpp

@@ -13,13 +13,12 @@ Author: Diffblue Ltd.
 
 #include <util/symbol_table.h>
 
-/// Create a load_method_by_regext matching the pattern. If the pattern doesn't
-/// include a colon for matching the descriptor, append a `:\(.*\).*` to the
-/// regex. Note this will mean all overloaded methods will be marked as extra
-/// entry points for CI lazy loading.
-/// If the pattern doesn't include the java:: prefix, prefix that
+/// For a given user provided pattern, return a regex, having dealt with the
+/// cases where the user has not prefixed with java:: or suffixed with the
+/// descriptor
 /// \param pattern: The user provided pattern
-load_method_by_regext::load_method_by_regext(const std::string &pattern)
+/// \return The regex to match with
+static std::regex build_regex_from_pattern(const std::string &pattern)
 {
   std::string modified_pattern = pattern;
   if(does_pattern_miss_descriptor(pattern))
@@ -28,43 +27,51 @@ load_method_by_regext::load_method_by_regext(const std::string &pattern)
   if(!has_prefix(pattern, "java::"))
     modified_pattern = "java::" + modified_pattern;
 
-  regex = std::regex{modified_pattern};
+  return std::regex{modified_pattern};
 }
 
-/// Get the methods that match the regex
-/// \param symbol_table: The symbol table to look through
-/// \return: The method identifiers that should be loaded
-std::vector<irep_idt>
-load_method_by_regext::extra_methods(const symbol_tablet &symbol_table) const
-{
-  std::vector<irep_idt> matched_methods;
-  for(const auto &symbol : symbol_table.symbols)
-  {
-    if(symbol.second.is_function())
-    {
-      const std::string symbol_name = id2string(symbol.first);
-      if(std::regex_match(symbol_name, regex))
-      {
-        matched_methods.push_back(symbol_name);
-      }
-    }
-  }
-  return matched_methods;
-}
 
 /// Identify if a parameter includes a part that will match a descriptor. That
 /// is, does it have a colon separtor.
 /// \param pattern: The user provided pattern
 /// \return True if no descriptor is found (that is, the only : relates to the
 /// java:: prefix.
-bool load_method_by_regext::does_pattern_miss_descriptor(
-  const std::string &pattern)
+bool does_pattern_miss_descriptor(const std::string &pattern)
 {
   const size_t descriptor_index = pattern.rfind(':');
   if(descriptor_index == std::string::npos)
     return true;
 
   static const std::string java_prefix = "java::";
   return descriptor_index == java_prefix.length() - 1 &&
-         has_prefix(pattern, "java::");
+         has_prefix(pattern, java_prefix);
+}
+
+/// Create a lambda that returns the symbols that the given pattern should be
+/// loaded.If the pattern doesn't include a colon for matching the descriptor,
+/// append a `:\(.*\).*` to the regex. Note this will mean all overloaded
+/// methods will be marked as extra entry points for CI lazy loading.
+/// If the pattern doesn't include the java:: prefix, prefix that
+/// \param pattern: The user provided pattern
+/// \return The lambda to execute.
+std::function<std::vector<irep_idt>(const symbol_tablet &symbol_table)>
+build_load_method_by_regex(const std::string &pattern)
+{
+  std::regex regex = build_regex_from_pattern(pattern);
+
+  return [=](const symbol_tablet &symbol_table) {
+    std::vector<irep_idt> matched_methods;
+    for(const auto &symbol : symbol_table.symbols)
+    {
+      if(symbol.second.is_function())
+      {
+        const std::string symbol_name = id2string(symbol.first);
+        if(std::regex_match(symbol_name, regex))
+        {
+          matched_methods.push_back(symbol_name);
+        }
+      }
+    }
+    return matched_methods;
+  };
 }

jbmc/src/java_bytecode/load_method_by_regex.h

@@ -17,20 +17,9 @@ Author: Diffblue Ltd.
 
 class symbol_tablet;
 
-class load_method_by_regext : public load_extra_methodst
-{
-public:
-  explicit load_method_by_regext(const std::string &pattern);
+std::function<std::vector<irep_idt>(const symbol_tablet &symbol_table)>
+build_load_method_by_regex(const std::string &pattern);
 
-  std::vector<irep_idt>
-  extra_methods(const symbol_tablet &symbol_table) const override;
-private:
-
-  std::regex regex;
-
-  static bool does_pattern_miss_descriptor(const std::string &pattern);
-
-  friend class load_method_by_regex_testt;
-};
+bool does_pattern_miss_descriptor(const std::string &pattern);
 
 #endif // CPROVER_JAVA_BYTECODE_LOAD_METHOD_BY_REGEX_H

jbmc/unit/java_bytecode/load_method_by_regex.cpp

@@ -10,15 +10,6 @@
 #include <testing-utils/catch.hpp>
 #include <testing-utils/require_vectors_equal_unordered.h>
 
-class load_method_by_regex_testt
-{
-public:
-  static bool does_pattern_miss_descriptor(const std::string &pattern)
-  {
-    return load_method_by_regext::does_pattern_miss_descriptor(pattern);
-  }
-};
-
 SCENARIO(
   "load_method_by_regex::does_pattern_miss_descriptor",
   "[core][java_bytecode][load_method_by_regex]")
@@ -28,8 +19,7 @@ SCENARIO(
     const std::string pattern = "java::com.diffblue.ClassName.methodName";
     WHEN("When calling does_pattern_miss_descriptor")
     {
-      bool result =
-        load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);
+      bool result = does_pattern_miss_descriptor(pattern);
       THEN("It should miss discriptor")
       {
         REQUIRE(result);
@@ -41,8 +31,7 @@ SCENARIO(
     const std::string pattern = "java::com.diffblue.ClassName.methodName:()V";
     WHEN("When calling does_pattern_miss_descriptor")
     {
-      bool result =
-        load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);
+      bool result = does_pattern_miss_descriptor(pattern);
       THEN("It should have the discriptor")
       {
         REQUIRE_FALSE(result);
@@ -54,8 +43,7 @@ SCENARIO(
     const std::string pattern = "com.diffblue.ClassName.methodName";
     WHEN("When calling does_pattern_miss_descriptor")
     {
-      bool result =
-        load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);
+      bool result = does_pattern_miss_descriptor(pattern);
       THEN("It should miss discriptor")
       {
         REQUIRE(result);
@@ -67,8 +55,7 @@ SCENARIO(
     const std::string pattern = "com.diffblue.ClassName.methodName:()V";
     WHEN("When calling does_pattern_miss_descriptor")
     {
-      bool result =
-        load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);
+      bool result = does_pattern_miss_descriptor(pattern);
       THEN("It should have the discriptor")
       {
         REQUIRE_FALSE(result);
@@ -80,8 +67,7 @@ SCENARIO(
     const std::string pattern = "java:com.diffblue.ClassName.methodName";
     WHEN("When calling does_pattern_miss_descriptor")
     {
-      bool result =
-        load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);
+      bool result = does_pattern_miss_descriptor(pattern);
       THEN("It should classify the last : as a descriptor")
       {
         REQUIRE_FALSE(result);
@@ -93,8 +79,7 @@ SCENARIO(
     const std::string pattern = "java:com.diffblue.ClassName.methodName:()V";
     WHEN("When calling does_pattern_miss_descriptor")
     {
-      bool result =
-        load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);
+      bool result = does_pattern_miss_descriptor(pattern);
       THEN("It should have the discriptor")
       {
         REQUIRE_FALSE(result);
@@ -118,8 +103,8 @@ static void require_result_for_pattern(
 {
   WHEN("Constructing a load_method_by_regex")
   {
-    load_method_by_regext matcher{pattern};
-    const auto &results = matcher.extra_methods(symbol_table);
+    const auto matcher = build_load_method_by_regex(pattern);
+    const auto &results = matcher(symbol_table);
     if(expected.size() == 1)
     {
       THEN("Expect " + id2string(expected[0]))