Use optionalt for signature

Author: Matthias Güdemann

src/java_bytecode/java_bytecode_convert_class.cpp

@@ -102,16 +102,18 @@ void java_bytecode_convert_classt::convert(const classt &c)
   }
 
   java_class_typet class_type;
-  if(c.has_signature)
+  if(c.signature.has_value())
   {
     java_generics_class_typet generic_class_type;
 #ifdef DEBUG
     std::cout << "INFO: found generic class signature "
-              << c.signature
+              << c.signature.value()
               << " in parsed class "
               << c.name << "\n";
 #endif
-    for(auto t : java_generic_type_from_string(id2string(c.name), c.signature))
+    for(auto t : java_generic_type_from_string(
+          id2string(c.name),
+          c.signature.value()))
     {
       generic_class_type.generic_types()
         .push_back(to_java_generic_parameter(t));
@@ -214,9 +216,11 @@ void java_bytecode_convert_classt::convert(
   const fieldt &f)
 {
   typet field_type;
-  if(f.has_signature)
+  if(f.signature.has_value())
   {
-    field_type=java_type_from_string(f.signature, id2string(class_symbol.name));
+    field_type=java_type_from_string(
+      f.signature.value(),
+      id2string(class_symbol.name));
 
     /// this is for a free type variable, e.g., a field of the form `T f;`
     if(is_java_generic_parameter(field_type))

src/java_bytecode/java_bytecode_convert_method.cpp

@@ -264,14 +264,15 @@ void java_bytecode_convert_method_lazy(
 {
   symbolt method_symbol;
   typet member_type;
-  if(m.has_signature)
+  if(m.signature.has_value())
   {
 #ifdef DEBUG
     std::cout << "method " << m.name
-              << " has signature " << m.signature << "\n";
+              << " has signature " << m.signature.value() << "\n";
 #endif
-    member_type=
-      java_type_from_string(m.signature, id2string(class_symbol.name));
+    member_type=java_type_from_string(
+      m.signature.value(),
+      id2string(class_symbol.name));
   }
   else
     member_type=java_type_from_string(m.descriptor);
@@ -362,8 +363,12 @@ void java_bytecode_convert_methodt::convert(
     // e.g. my.package.ClassName.myMethodName:(II)I::anIntParam, and then a
     // symbol_exprt with the parameter and its type
     typet t;
-    if(v.has_signature)
-      t=java_type_from_string(v.signature, id2string(class_symbol.name));
+    if(v.signature.has_value())
+    {
+      t=java_type_from_string(
+        v.signature.value(),
+        id2string(class_symbol.name));
+    }
     else
       t=java_type_from_string(v.descriptor);
 

src/java_bytecode/java_bytecode_parse_tree.cpp

@@ -28,7 +28,6 @@ void java_bytecode_parse_treet::classt::swap(
   std::swap(other.is_public, is_public);
   std::swap(other.is_protected, is_protected);
   std::swap(other.is_private, is_private);
-  std::swap(other.has_signature, has_signature);
   std::swap(other.signature, signature);
   other.implements.swap(implements);
   other.fields.swap(fields);

src/java_bytecode/java_bytecode_parse_tree.h

@@ -12,6 +12,7 @@ Author: Daniel Kroening, [email protected]
 
 #include <set>
 
+#include <util/optional.h>
 #include <util/std_code.h>
 #include <util/std_types.h>
 
@@ -55,16 +56,15 @@ class java_bytecode_parse_treet
   {
   public:
     std::string descriptor;
-    bool has_signature;
-    std::string signature;
+    optionalt<std::string> signature;
     irep_idt name;
     bool is_public, is_protected, is_private, is_static, is_final;
     annotationst annotations;
 
     virtual void output(std::ostream &out) const = 0;
 
     membert():
-      has_signature(false), is_public(false), is_protected(false),
+      is_public(false), is_protected(false),
       is_private(false), is_static(false), is_final(false)
     {
     }
@@ -103,8 +103,7 @@ class java_bytecode_parse_treet
     public:
       irep_idt name;
       std::string descriptor;
-      bool has_signature=false;
-      std::string signature;
+      optionalt<std::string> signature;
       std::size_t index;
       std::size_t start_pc;
       std::size_t length;
@@ -178,8 +177,7 @@ class java_bytecode_parse_treet
 
     typedef std::list<irep_idt> implementst;
     implementst implements;
-    bool has_signature=false;
-    std::string signature;
+    optionalt<std::string> signature;
     typedef std::list<fieldt> fieldst;
     typedef std::list<methodt> methodst;
     fieldst fields;

src/java_bytecode/java_bytecode_parser.cpp

@@ -337,36 +337,38 @@ void java_bytecode_parsert::get_class_refs()
   for(const auto &field : parse_tree.parsed_class.fields)
   {
     typet field_type;
-    if(field.has_signature)
+    if(field.signature.has_value())
     {
       field_type=java_type_from_string(
-        field.signature,
+        field.signature.value(),
         "java::"+id2string(parse_tree.parsed_class.name));
     }
     else
       field_type=java_type_from_string(field.descriptor);
+
     get_class_refs_rec(field_type);
   }
 
   for(const auto &method : parse_tree.parsed_class.methods)
   {
     typet method_type;
-    if(method.has_signature)
+    if(method.signature.has_value())
     {
       method_type=java_type_from_string(
-        method.signature,
+        method.signature.value(),
         "java::"+id2string(parse_tree.parsed_class.name));
     }
     else
       method_type=java_type_from_string(method.descriptor);
+
     get_class_refs_rec(method_type);
     for(const auto &var : method.local_variable_table)
     {
       typet var_type;
-      if(var.has_signature)
+      if(var.signature.has_value())
       {
         var_type=java_type_from_string(
-          var.signature,
+          var.signature.value(),
           "java::"+id2string(parse_tree.parsed_class.name));
       }
       else
@@ -973,7 +975,6 @@ void java_bytecode_parsert::rmethod_attribute(methodt &method)
   else if(attribute_name=="Signature")
   {
     u2 signature_index=read_u2();
-    method.has_signature=true;
     method.signature=id2string(pool_entry(signature_index).s);
   }
   else if(attribute_name=="RuntimeInvisibleAnnotations" ||
@@ -995,7 +996,6 @@ void java_bytecode_parsert::rfield_attribute(fieldt &field)
   if(attribute_name=="Signature")
   {
     u2 signature_index=read_u2();
-    field.has_signature=true;
     field.signature=id2string(pool_entry(signature_index).s);
   }
   else if(attribute_name=="RuntimeInvisibleAnnotations" ||
@@ -1352,7 +1352,6 @@ void java_bytecode_parsert::rclass_attribute(classt &parsed_class)
   else if(attribute_name=="Signature")
   {
     u2 signature_index=read_u2();
-    parsed_class.has_signature=true;
     parsed_class.signature=id2string(pool_entry(signature_index).s);
   }
   else if(attribute_name=="RuntimeInvisibleAnnotations" ||
@@ -1480,7 +1479,6 @@ void java_bytecode_parsert::parse_local_variable_type_table(methodt &method)
       {
         found=true;
         lvar.signature=id2string(pool_entry(signature_index).s);
-        lvar.has_signature=true;
         break;
       }
     }

src/java_bytecode/java_local_variable_table.cpp

@@ -769,8 +769,8 @@ void java_bytecode_convert_methodt::setup_local_variables(
             << v.var.descriptor << "' holes " << v.holes.size() << eom;
 #endif
     typet t;
-    if(v.var.has_signature)
-      t=java_type_from_string(v.var.signature);
+    if(v.var.signature.has_value())
+      t=java_type_from_string(v.var.signature.value());
     else
       t=java_type_from_string(v.var.descriptor);