Parse the whole class when generics are present

Previously when a generic signature was parsed, inner classes were
ignored. This resolves this by first building up a complete class name.
This also resolves the fact that inner classes in signatures are denoted
by . rather than $ and so replaces the . with $ to be consistent.

Author: thk123

src/java_bytecode/java_types.cpp

@@ -201,6 +201,97 @@ std::string gather_full_class_name(const std::string &src)
   std::replace(class_name.begin(), class_name.end(), '/', '.');
   return class_name;
 }
+
+reference_typet
+build_class_name(const std::string src, const std::string &class_name_prefix)
+{
+  PRECONDITION(src[0] == 'L');
+  // ends on ;
+  if(src[src.size() - 1] != ';')
+    throw "invalid string for reference type";
+
+  std::string container_class = gather_full_class_name(src);
+  std::string identifier = "java::" + container_class;
+  symbol_typet symbol_type(identifier);
+  symbol_type.set(ID_C_base_name, container_class);
+
+  // TODO(tkiley): The below code only parses the first generic argument list
+
+  std::size_t f_pos = src.find('<', 1);
+  // get generic type information
+  if(f_pos != std::string::npos)
+  {
+    std::size_t e_pos = find_closing_delimiter(src, f_pos, '<', '>');
+    if(e_pos == std::string::npos)
+      throw unsupported_java_class_signature_exceptiont("recursive generic");
+
+    // What needs to happen is the symbol_typet needs to use all parts
+    // of the name and all generic parts of the child names
+    // For now it might be sufficient to parse the rest of the name
+
+    java_generic_typet result(symbol_type);
+
+#ifdef DEBUG
+    std::cout << "INFO: found generic type "
+              << src.substr(f_pos + 1, e_pos - f_pos - 1) << " in " << src
+              << " with container " << generic_container_class << "\n";
+#endif
+
+    // parse contained types, can be either type variables, starting with T
+    // or instantiated types
+    size_t curr_start = f_pos + 1;
+    size_t curr_end;
+    do
+    {
+      // find next end of type name
+      curr_end = src.find(';', curr_start);
+      INVARIANT(
+        curr_end != std::string::npos, "Type not terminated with \';\'");
+      const size_t end = curr_end - curr_start + 1;
+      const typet &t =
+        java_type_from_string(src.substr(curr_start, end), class_name_prefix);
+#ifdef DEBUG
+      std::cout << "INFO: getting type " << src.substr(curr_start, end) << "\n"
+                << "INFO: type id " << id2string(t.id()) << "\n"
+                << "curr_start " << curr_start << " curr_end " << curr_end
+                << " e_pos " << e_pos << " src " << src << "\n";
+#endif
+      // is an uninstantiated (pure) generic type
+      if(is_java_generic_parameter(t))
+      {
+        const java_generic_parametert &gen_type = to_java_generic_parameter(t);
+#ifdef DEBUG
+        std::cout << " generic type var " << gen_type.id() << " bound "
+                  << to_symbol_type(gen_type.subtype()).get_identifier()
+                  << "\n";
+#endif
+        result.generic_type_variables().push_back(gen_type);
+      }
+
+      /// TODO(mgudemann): implement / test the case of iterated generic
+      /// types
+
+      // is a concrete type, i.e., instantiation of a generic type of the
+      // current type
+      else
+      {
+        java_generic_inst_parametert inst_type(to_symbol_type(t.subtype()));
+#ifdef DEBUG
+        std::cout << " instantiation of generic type var "
+                  << to_symbol_type(t.subtype()).get_identifier() << "\n";
+#endif
+        result.generic_type_variables().push_back(inst_type);
+      }
+
+      curr_start = curr_end + 1;
+    } while(curr_start < e_pos);
+
+    return result;
+  }
+
+  return java_reference_type(symbol_type);
+}
+
 /// Transforms a string representation of a Java type into an internal type
 /// representation thereof.
 ///
@@ -361,108 +452,7 @@ typet java_type_from_string(
   }
   case 'L':
     {
-      // ends on ;
-      if(src[src.size()-1]!=';')
-        return nil_typet();
-
-      std::size_t f_pos=src.find('<', 1);
-      // get generic type information
-      if(f_pos!=std::string::npos)
-      {
-        std::size_t e_pos=find_closing_delimiter(src, f_pos, '<', '>');
-        if(e_pos==std::string::npos)
-          throw unsupported_java_class_signature_exceptiont(
-            "recursive generic");
-
-        // construct container type
-        std::string generic_container_class=src.substr(1, f_pos-1);
-
-        for(unsigned i=0; i<generic_container_class.size(); i++)
-        {
-          if(generic_container_class[i]=='/')
-            generic_container_class[i]='.';
-        }
-
-        java_generic_typet result(
-          symbol_typet("java::"+generic_container_class));
-
-#ifdef DEBUG
-        std::cout << "INFO: found generic type "
-                  << src.substr(f_pos+1, e_pos-f_pos-1)
-                  << " in " << src
-                  << " with container " << generic_container_class << "\n";
-#endif
-
-        // parse contained types, can be either type variables, starting with T
-        // or instantiated types
-        size_t curr_start=f_pos+1;
-        size_t curr_end;
-        do
-        {
-          // find next end of type name
-          curr_end=src.find(';', curr_start);
-          INVARIANT(
-            curr_end!=std::string::npos,
-            "Type not terminated with \';\'");
-          const size_t end=curr_end-curr_start+1;
-          const typet &t=
-            java_type_from_string(src.substr(curr_start, end),
-                                  class_name_prefix);
-#ifdef DEBUG
-          std::cout << "INFO: getting type "
-                    << src.substr(curr_start, end) << "\n"
-                    << "INFO: type id " << id2string(t.id()) << "\n"
-                    << "curr_start " << curr_start
-                    << " curr_end " << curr_end
-                    << " e_pos " << e_pos
-                    << " src " << src << "\n";
-#endif
-          // is an uninstantiated (pure) generic type
-          if(is_java_generic_parameter(t))
-          {
-            const java_generic_parametert &gen_type=
-              to_java_generic_parameter(t);
-#ifdef DEBUG
-            std::cout << " generic type var " << gen_type.id() << " bound "
-                      << to_symbol_type(gen_type.subtype()).get_identifier()
-                      << "\n";
-#endif
-            result.generic_type_variables().push_back(gen_type);
-          }
-
-          /// TODO(mgudemann): implement / test the case of iterated generic
-          /// types
-
-          // is a concrete type, i.e., instantiation of a generic type of the
-          // current type
-          else
-          {
-            java_generic_inst_parametert inst_type(
-              to_symbol_type(t.subtype()));
-#ifdef DEBUG
-            std::cout << " instantiation of generic type var "
-                      << to_symbol_type(t.subtype()).get_identifier() << "\n";
-#endif
-            result.generic_type_variables().push_back(inst_type);
-          }
-
-          curr_start=curr_end+1;
-        }
-        while(curr_start<e_pos);
-
-
-        return result;
-      }
-      std::string class_name=src.substr(1, src.size()-2);
-      for(auto &letter : class_name)
-        if(letter=='/')
-          letter='.';
-
-      std::string identifier="java::"+class_name;
-      symbol_typet symbol_type(identifier);
-      symbol_type.set(ID_C_base_name, class_name);
-
-      return java_reference_type(symbol_type);
+      return build_class_name(src, class_name_prefix);
     }
   case '*':
   case '+':

unit/java_bytecode/java_bytecode_parse_generics/GenericClass.class

@@ -4,20 +4,30 @@ class InnerClass
   {
   }
 
-  // class GenericInnerClass<V>
-  // {
-  //   V field;
-  // }
+  class GenericInnerClass<V>
+  {
+    V field;
+
+    class DoublyNestedInnerClass
+    {
 
-  // class SameGenericParamInnerClass<T>
-  // {
-  //   T field;
-  // }
+    }
+
+    class DoublyNestedInnerGemericClass<U>
+    {
+      T field;
+    }
+  }
+
+  class SameGenericParamInnerClass<T>
+  {
+    T field;
+  }
 
   InnerClass field;
-  // GenericInnerClass<Foo> field2;
-  // SameGenericParamInnerClass<Foo> field3;
+  GenericInnerClass<Foo> field2;
+  SameGenericParamInnerClass<Foo> field3;
 
-  // GenericInnerClass<T> field4;
-  // SameGenericParamInnerClass<T> field5;
+  GenericInnerClass<T> field4;
+  SameGenericParamInnerClass<T> field5;
 }

unit/java_bytecode/java_bytecode_parse_generics/GenericClass.java

@@ -29,7 +29,7 @@ SCENARIO(
     "GenericClass", "./java_bytecode/java_bytecode_parse_generics");
 
   std::string class_prefix = "java::GenericClass";
-  THEN("There should be a symbol for GenericClass")
+  THEN("There should be a symbol for GenericClass with correct components")
   {
     REQUIRE(new_symbol_table.has_symbol(class_prefix));
     const symbolt &class_symbol = new_symbol_table.lookup_ref(class_prefix);
@@ -44,6 +44,59 @@ SCENARIO(
 
       require_type::require_pointer(
         field_component.type(), symbol_typet("java::GenericClass$InnerClass"));
+
+      // TODO: then the generic type should be correctly stored
+    }
+
+    THEN("The field component should be a pointer to GenericClass$InnerClass")
+    {
+      const struct_typet::componentt &field_component =
+        require_type::require_component(class_type, "field2");
+
+      require_type::require_pointer(
+        field_component.type(),
+        symbol_typet("java::GenericClass$GenericInnerClass"));
+
+      // TODO: then the generic type should be correctly stored
     }
+
+    THEN("The field component should be a pointer to GenericClass$InnerClass")
+    {
+      const struct_typet::componentt &field_component =
+        require_type::require_component(class_type, "field3");
+
+      require_type::require_pointer(
+        field_component.type(),
+        symbol_typet("java::GenericClass$SameGenericParamInnerClass"));
+
+      // TODO: then the generic type should be correctly stored
+    }
+
+    THEN("The field component should be a pointer to GenericClass$InnerClass")
+    {
+      const struct_typet::componentt &field_component =
+        require_type::require_component(class_type, "field4");
+
+      require_type::require_pointer(
+        field_component.type(),
+        symbol_typet("java::GenericClass$GenericInnerClass"));
+
+      // TODO: then the generic type should be correctly stored
+    }
+    THEN("The field component should be a pointer to GenericClass$InnerClass")
+    {
+      const struct_typet::componentt &field_component =
+        require_type::require_component(class_type, "field5");
+
+      require_type::require_pointer(
+        field_component.type(),
+        symbol_typet("java::GenericClass$SameGenericParamInnerClass"));
+
+      // TODO: then the generic type should be correctly stored
+    }
+  }
+
+  THEN("There should be a symbol for the generic inner class")
+  {
   }
 }