Add the generic type arguments to the specalised type

This is useful information when trying to output this type without
muddying the waters by labeling it as a generic type (which it isn't)

Author: thk123

src/java_bytecode/generate_java_generic_type.cpp

@@ -73,8 +73,12 @@ symbolt generate_java_generic_typet::operator()(
     pre_modification_size==after_modification_size,
     "All components in the original class should be in the new class");
 
-  const java_specialized_generic_class_typet new_java_class =
-    construct_specialised_generic_type(new_tag, replacement_components);
+  const java_specialized_generic_class_typet new_java_class{
+    new_tag,
+    generic_class_definition.get_tag(),
+    replacement_components,
+    existing_generic_type.generic_type_arguments()};
+
   const type_symbolt &class_symbol =
     build_symbol_from_specialised_class(new_java_class);
 
@@ -227,19 +231,6 @@ irep_idt generate_java_generic_typet::build_generic_tag(
   return new_tag_buffer.str();
 }
 
-/// Build the specialised version of the specific class, with the specified
-/// parameters and name.
-/// \param new_tag: The new name for the class (like Generic<java::Float>)
-/// \param new_components: The specialised components
-/// \return The newly constructed class.
-java_specialized_generic_class_typet
-generate_java_generic_typet::construct_specialised_generic_type(
-  const irep_idt &new_tag,
-  const struct_typet::componentst &new_components) const
-{
-  return java_specialized_generic_class_typet{new_tag, new_components};
-}
-
 /// Construct the symbol to be moved into the symbol table
 /// \param specialised_class: The newly constructed specialised class
 /// \return The symbol to add to the symbol table

src/java_bytecode/generate_java_generic_type.h

@@ -32,10 +32,6 @@ class generate_java_generic_typet
     const java_generic_class_typet &replacement_type,
     const java_generic_typet &generic_reference) const;
 
-  java_specialized_generic_class_typet construct_specialised_generic_type(
-    const irep_idt &new_tag,
-    const struct_typet::componentst &new_components) const;
-
   type_symbolt build_symbol_from_specialised_class(
     const java_class_typet &specialised_class) const;
 

src/java_bytecode/java_types.h

@@ -442,22 +442,41 @@ void get_dependencies_from_generic_parameters(
 class java_specialized_generic_class_typet : public java_class_typet
 {
 public:
+  typedef std::vector<reference_typet> generic_type_argumentst;
+
   /// Build the specialised version of the specific class, with the specified
   /// parameters and name.
   /// \param generic_name: The new name for the class
   ///   (like Generic<java::Float>)
+  /// \param tag: The name for the original class (like java::Generic)
   /// \param new_components: The specialised components
   /// \return The newly constructed class.
   java_specialized_generic_class_typet(
     const irep_idt &generic_name,
-    const struct_typet::componentst &new_components)
+    const irep_idt &tag,
+    const struct_typet::componentst &new_components,
+    const generic_type_argumentst &specialised_parameters)
   {
     set(ID_C_specialized_generic_java_class, true);
     set(ID_name, "java::" + id2string(generic_name));
     set(ID_base_name, id2string(generic_name));
     components() = new_components;
-    const std::string &class_tag = id2string(new_tag);
-    set_tag(class_tag.substr(0, class_tag.find('<')));
+    set_tag(tag);
+
+    generic_type_arguments() = specialised_parameters;
+  }
+
+  /// \return vector of type variables
+  const generic_type_argumentst &generic_type_arguments() const
+  {
+    return (const generic_type_argumentst &)(find(ID_type_variables).get_sub());
+  }
+
+private:
+  /// \return vector of type variables
+  generic_type_argumentst &generic_type_arguments()
+  {
+    return (generic_type_argumentst &)(add(ID_type_variables).get_sub());
   }
 };