Merge pull request diffblue#497 from diffblue/jd/feature/autowire_detection

Make java-class-info generate additional information for DI generation

Author: JohnDumbell

env-model-generator/src/AnnotationConfig.ts

@@ -0,0 +1,19 @@
+export interface AnnotationConfig {
+    beans: Beans;
+}
+
+export interface Beans {
+    [name: string]: Bean;
+}
+
+export interface Bean {
+    fields: AnnotatedFields;
+}
+
+export interface AnnotatedFields {
+    [name: string]: AnnotatedField;
+}
+
+export interface AnnotatedField {
+    type: string;
+}

src/java-class-info/java_class_info.cpp

@@ -8,6 +8,8 @@
 #include <java_bytecode/java_bytecode_parser.h>
 
 #include <boost/filesystem.hpp>
+#include <java_bytecode/java_types.h>
+#include <utility>
 
 class cmdline_optionst final:
   public parse_options_baset
@@ -22,9 +24,12 @@ class cmdline_optionst final:
   ui_message_handlert ui_message_handler;
 };
 
-cmdline_optionst::cmdline_optionst(int argc, const char **argv):
-  parse_options_baset("(version)(in-json):(out-json):", argc, argv),
-  ui_message_handler(cmdline, "java-class-info " JAVA_CLASS_INFO_VERSION)
+cmdline_optionst::cmdline_optionst(int argc, const char **argv)
+  : parse_options_baset(
+      "(version)(in-json):(out-json):(out-di-json):",
+      argc,
+      argv),
+    ui_message_handler(cmdline, "java-class-info " JAVA_CLASS_INFO_VERSION)
 {}
 
 void cmdline_optionst::help()
@@ -48,6 +53,41 @@ void cmdline_optionst::help()
     "                             will be written.\n";
 }
 
+bool has_annotation_in_list(
+  const std::vector<java_bytecode_parse_treet::annotationt> &annotations,
+  const std::set<irep_idt> &names_to_match)
+{
+  if(annotations.empty())
+  {
+    return false;
+  }
+
+  std::vector<irep_idt> annotation_names;
+  std::transform(
+    annotations.begin(),
+    annotations.end(),
+    std::inserter(annotation_names, annotation_names.end()),
+    [](const java_bytecode_parse_treet::annotationt &annotation) {
+      INVARIANT(
+        annotation.type.id() == ID_pointer,
+        "Annotation type should be pointer.");
+      return annotation.type.subtype().get(ID_C_base_name);
+    });
+
+  // Set_intersection requires a sort to have been done.
+  std::sort(annotation_names.begin(), annotation_names.end());
+
+  std::set<irep_idt> matching_annotation_names;
+  std::set_intersection(
+    annotation_names.begin(),
+    annotation_names.end(),
+    names_to_match.begin(),
+    names_to_match.end(),
+    std::inserter(matching_annotation_names, matching_annotation_names.end()));
+
+  return !matching_annotation_names.empty();
+}
+
 int cmdline_optionst::doit()
 {
   messaget msg(ui_message_handler);
@@ -104,9 +144,32 @@ int cmdline_optionst::doit()
     return -6;
   }
 
+  struct annotated_fieldt
+  {
+    annotated_fieldt(irep_idt name, std::string type)
+      : name(name), type(std::move(type))
+    {
+    }
+
+    irep_idt name;
+    std::string type;
+  };
+
+  struct beant
+  {
+    explicit beant(irep_idt name) : name(name)
+    {
+    }
+
+    irep_idt name;
+    std::vector<annotated_fieldt> fields;
+  };
+
+  const std::string di_out_path = cmdline.get_value("out-di-json");
+  bool enable_di_scan = !di_out_path.empty();
   json_objectt results;
   json_arrayt errors;
-
+  std::vector<beant> beans;
   int ret_code=0;
   for(auto const &json_array_element : cfg.array)
   {
@@ -198,6 +261,35 @@ int cmdline_optionst::doit()
         }
         class_json=class_props;
       }
+
+      if(enable_di_scan)
+      {
+        static std::set<irep_idt> bean_annotations = {
+          "org.springframework.stereotype.Component"
+        };
+
+        static std::set<irep_idt> autowire_annotation = {
+          "org.springframework.beans.factory.annotation.Autowired"
+        };
+
+        const java_bytecode_parse_treet::classt &parsed_class =
+          parse_tree->parsed_class;
+        if(has_annotation_in_list(parsed_class.annotations, bean_annotations))
+        {
+          beant bean(parsed_class.name);
+          for(const java_bytecode_parse_treet::fieldt &field :
+              parsed_class.fields)
+          {
+            if(has_annotation_in_list(field.annotations, autowire_annotation))
+              bean.fields.emplace_back(
+                field.name,
+                field.signature.has_value() ? field.signature.value()
+                                            : field.descriptor);
+          }
+
+          beans.push_back(std::move(bean));
+        }
+      }
     }
     catch(...)
     {
@@ -238,6 +330,36 @@ int cmdline_optionst::doit()
   result["errors"]=errors;
   ofile << result;
 
+  if(enable_di_scan)
+  {
+    std::ofstream di_filename(di_out_path);
+    if(!di_filename)
+    {
+      msg.error()
+        << "ERROR: Cannot open the output JSON file '"
+        << di_out_path
+        << "' for writing."
+        << messaget::eom;
+      return -8;
+    }
+
+    json_objectt root;
+    json_objectt &json_beans = root["beans"].make_object();
+    for(const beant &bean : beans)
+    {
+      json_objectt &json_bean = json_beans[id2string(bean.name)].make_object();
+      json_objectt &json_fields = json_bean["fields"].make_object();
+      for(const annotated_fieldt &field : bean.fields)
+      {
+        json_objectt &json_field =
+          json_fields[id2string(field.name)].make_object();
+        json_field["type"] = json_stringt(field.type);
+      }
+    }
+
+    di_filename << root;
+  }
+
   return ret_code;
 }