diff --git a/src/java_bytecode/generate_java_generic_type.cpp b/src/java_bytecode/generate_java_generic_type.cpp
index 7edcdf08bd1..00f45eb8ec9 100644
--- a/src/java_bytecode/generate_java_generic_type.cpp
+++ b/src/java_bytecode/generate_java_generic_type.cpp
@@ -116,7 +116,7 @@ typet generate_java_generic_typet::substitute_type(
       java_generics_get_index_for_subtype(generic_class, component_identifier);
 
     INVARIANT(results.has_value(), "generic component type not found");
-    return generic_reference.generic_type_variables()[*results];
+    return generic_reference.generic_type_arguments()[*results];
   }
   else if(parameter_type.id() == ID_pointer)
   {
@@ -125,36 +125,35 @@ typet generate_java_generic_typet::substitute_type(
       const java_generic_typet &generic_type =
         to_java_generic_type(parameter_type);
 
-      java_generic_typet::generic_type_variablest replaced_type_variables;
+      java_generic_typet::generic_type_argumentst replaced_type_variables;
 
       // Swap each parameter
       std::transform(
-        generic_type.generic_type_variables().begin(),
-        generic_type.generic_type_variables().end(),
+        generic_type.generic_type_arguments().begin(),
+        generic_type.generic_type_arguments().end(),
         std::back_inserter(replaced_type_variables),
-        [&](const java_generic_parametert &generic_param)
-          -> java_generic_parametert {
-            const typet &replacement_type =
-              substitute_type(generic_param, generic_class, generic_reference);
-
-            // This code will be simplified when references aren't considered to
-            // be generic parameters
-            if(is_java_generic_parameter(replacement_type))
-            {
-              return to_java_generic_parameter(replacement_type);
-            }
-            else
-            {
-              INVARIANT(
-                is_reference(replacement_type),
-                "All generic parameters should be references");
-              return java_generic_inst_parametert(
-                to_symbol_type(replacement_type.subtype()));
-            }
-          });
+        [&](const reference_typet &generic_param) -> reference_typet
+        {
+          const typet &replacement_type =
+            substitute_type(generic_param, generic_class, generic_reference);
+
+          // This code will be simplified when references aren't considered to
+          // be generic parameters
+          if(is_java_generic_parameter(replacement_type))
+          {
+            return to_java_generic_parameter(replacement_type);
+          }
+          else
+          {
+            INVARIANT(
+              is_reference(replacement_type),
+              "All generic parameters should be references");
+            return to_reference_type(replacement_type);
+          }
+        });
 
       java_generic_typet new_type = generic_type;
-      new_type.generic_type_variables() = replaced_type_variables;
+      new_type.generic_type_arguments() = replaced_type_variables;
       return new_type;
     }
     else if(parameter_type.subtype().id() == ID_symbol)
@@ -190,21 +189,22 @@ irep_idt generate_java_generic_typet::build_generic_tag(
   new_tag_buffer << original_class.get_tag();
   new_tag_buffer << "<";
   bool first=true;
-  for(const typet &param : existing_generic_type.generic_type_variables())
+  for(const typet &type_argument : existing_generic_type
+    .generic_type_arguments())
   {
     if(!first)
       new_tag_buffer << ",";
     first=false;
 
     INVARIANT(
-      is_java_generic_inst_parameter(param),
+      !is_java_generic_parameter(type_argument),
       "Only create full concretized generic types");
-    const irep_idt &id(id2string(param.subtype().get(ID_identifier)));
+    const irep_idt &id(id2string(type_argument.subtype().get(ID_identifier)));
     new_tag_buffer << id2string(id);
     if(is_java_array_tag(id))
     {
       const typet &element_type =
-        java_array_element_type(to_symbol_type(param.subtype()));
+        java_array_element_type(to_symbol_type(type_argument.subtype()));
 
       // If this is an array of references then we will specialize its
       // identifier using the type of the objects in the array. Else, there can
diff --git a/src/java_bytecode/java_bytecode_convert_class.cpp b/src/java_bytecode/java_bytecode_convert_class.cpp
index b84978b2020..42d3992081d 100644
--- a/src/java_bytecode/java_bytecode_convert_class.cpp
+++ b/src/java_bytecode/java_bytecode_convert_class.cpp
@@ -236,7 +236,7 @@ void java_bytecode_convert_classt::convert(
 #endif
     }
 
-    /// this is for a field that holds a generic type, wither with instantiated
+    /// this is for a field that holds a generic type, either with instantiated
     /// or with free type variables, e.g., `List<T> l;` or `List<Integer> l;`
     else if(is_java_generic_type(field_type))
     {
@@ -244,19 +244,13 @@ void java_bytecode_convert_classt::convert(
         to_java_generic_type(field_type);
 #ifdef DEBUG
       std::cout << "fieldtype: generic container type "
-                << std::to_string(with_gen_type.generic_type_variables().size())
+                << std::to_string(with_gen_type.generic_type_arguments().size())
                 << " type " << with_gen_type.id()
                 << " name " << f.name
                 << " subtype id " << with_gen_type.subtype().id() << "\n";
 #endif
       field_type=with_gen_type;
     }
-
-    /// This case is not possible, a field is either a non-instantiated type
-    /// variable or a generics container type.
-    INVARIANT(
-      !is_java_generic_inst_parameter(field_type),
-      "Cannot be an instantiated type variable here.");
   }
   else
     field_type=java_type_from_string(f.descriptor);
diff --git a/src/java_bytecode/java_types.cpp b/src/java_bytecode/java_types.cpp
index ad928710f5b..bbb24205439 100644
--- a/src/java_bytecode/java_types.cpp
+++ b/src/java_bytecode/java_types.cpp
@@ -188,49 +188,42 @@ exprt java_bytecode_promotion(const exprt &expr)
     return typecast_exprt(expr, new_type);
 }
 
-/// Take a list of generic arguments and parse them into the generic type.
+/// Take a list of generic type arguments and parse them into the generic type.
 /// \param generic_type [out]: The existing generic type to add the information
 ///   to
-/// \param parameters: The string representing the generic arguments for a
-///   signature. For example <TT;Ljava/lang/Foo;> (including wrapping angle
-///   brackets).
+/// \param type_arguments: The string representing the generic type arguments
+///   for a signature. For example `<TT;Ljava/lang/Foo;LList<LInteger;>;>`
+///   (including the wrapping angle brackets).
 /// \param class_name_prefix: The name of the class to use to prefix any found
 ///   generic types
 void add_generic_type_information(
   java_generic_typet &generic_type,
-  const std::string &parameters,
+  const std::string &type_arguments,
   const std::string &class_name_prefix)
 {
-  PRECONDITION(parameters.size() >= 2);
-  PRECONDITION(parameters[0] == '<');
-  PRECONDITION(parameters[parameters.size() - 1] == '>');
+  PRECONDITION(type_arguments.size() >= 2);
+  PRECONDITION(type_arguments[0] == '<');
+  PRECONDITION(type_arguments[type_arguments.size() - 1] == '>');
 
-  // parse contained types, can be either type variables, starting with T
-  // or instantiated types
-  std::vector<typet> params =
-    parse_list_types(parameters, class_name_prefix, '<', '>');
+  // Parse contained arguments, can be either type parameters (`TT;`)
+  // or instantiated types - either generic types (`LList<LInteger;>;`) or
+  // just references (`Ljava/lang/Foo;`)
+  std::vector<typet> type_arguments_types =
+    parse_list_types(type_arguments, class_name_prefix, '<', '>');
 
-  CHECK_RETURN(!params.empty()); // We should have at least one generic param
-
-  // take these types - they should either be java_generic_parameters, in which
-  // case they can be directly added to the generic_type
-  // otherwise they should be wrapped in a java_generic_inst_parametert
+  // We should have at least one generic type argument
+  CHECK_RETURN(!type_arguments_types.empty());
 
+  // Add the type arguments to the generic type
   std::transform(
-    params.begin(),
-    params.end(),
-    std::back_inserter(generic_type.generic_type_variables()),
-    [](const typet &type) -> java_generic_parametert {
-      if(is_java_generic_parameter(type))
-      {
-        return to_java_generic_parameter(type);
-      }
-      else
-      {
-        INVARIANT(
-          is_reference(type), "All generic parameters should be references");
-        return java_generic_inst_parametert(to_symbol_type(type.subtype()));
-      }
+    type_arguments_types.begin(),
+    type_arguments_types.end(),
+    std::back_inserter(generic_type.generic_type_arguments()),
+    [](const typet &type) -> reference_typet
+    {
+      INVARIANT(
+        is_reference(type), "All generic type arguments should be references");
+      return to_reference_type(type);
     });
 }
 
@@ -286,8 +279,8 @@ std::string gather_full_class_name(const std::string &src)
 
 /// Given a substring of a descriptor or signature that contains one or more
 /// types parse out the individual types. This is used for parsing the
-/// parameters of a function or the generic arguments contained within angle
-/// brackets.
+/// parameters of a function or the generic type variables/parameters or
+/// arguments contained within angle brackets.
 /// \param src: The input string that is wrapped in either ( ) or < >
 /// \param class_name_prefix: The name of the class to use to prefix any found
 ///   generic types
@@ -314,18 +307,18 @@ std::vector<typet> parse_list_types(
     size_t start = i;
     while(i < src.size())
     {
-      // parameter is an object type or instantiated generic type
+      // type is an object type or instantiated generic type
       if(src[i] == 'L')
       {
         i = find_closing_semi_colon_for_reference_type(src, i);
         break;
       }
 
-      // parameter is an array
+      // type is an array
       else if(src[i] == '[')
         i++;
 
-      // parameter is a type variable
+      // type is a type variable/parameter
       else if(src[i] == 'T')
         i = src.find(';', i); // ends on ;
 
@@ -425,12 +418,13 @@ size_t find_closing_semi_colon_for_reference_type(
 /// Transforms a string representation of a Java type into an internal type
 /// representation thereof.
 ///
-/// Example use are object types like "Ljava/lang/Integer;", type variables like
-/// "TE;" which require a non-empty \p class_name or generic types like
-/// "Ljava/util/List<T>;" or "Ljava/util/List<Integer>;"
+/// Example use are object types like "Ljava/lang/Integer;", type
+/// variables/parameters like "TE;" which require a non-empty \p class_name
+/// or generic types like "Ljava/util/List<T>;" or "Ljava/util/List<Integer>;"
 ///
 /// \param src: the string representation as used in the class file
-/// \param class_name_prefix: name of class to append to generic type variables
+/// \param class_name_prefix: name of class to append to generic type
+///   variables/parameters
 /// \returns internal type representation for GOTO programs
 typet java_type_from_string(
   const std::string &src,
diff --git a/src/java_bytecode/java_types.h b/src/java_bytecode/java_types.h
index cd4aa45813d..4925f03a4f8 100644
--- a/src/java_bytecode/java_types.h
+++ b/src/java_bytecode/java_types.h
@@ -85,8 +85,9 @@ exprt java_bytecode_promotion(const exprt &);
 bool is_java_array_tag(const irep_idt &tag);
 bool is_valid_java_array(const struct_typet &);
 
-/// class to hold a Java generic type
-/// upper bound can specify type requirements
+/// Class to hold a Java generic type parameter (also called type variable),
+/// e.g., `T` in `List<T>`.
+/// The bound can specify type requirements.
 class java_generic_parametert:public reference_typet
 {
 public:
@@ -121,8 +122,10 @@ class java_generic_parametert:public reference_typet
   }
 };
 
-/// \param type: type the type to check
-/// \return true if type is a generic Java parameter type, e.g., T in List<T>
+/// Checks whether the type is a java generic parameter/variable, e.g., `T` in
+/// `List<T>`.
+/// \param type: the type to check
+/// \return true if type is a generic Java parameter type
 inline bool is_java_generic_parameter(const typet &type)
 {
   return type.get_bool(ID_C_java_generic_parameter);
@@ -145,61 +148,25 @@ inline java_generic_parametert &to_java_generic_parameter(typet &type)
   return static_cast<java_generic_parametert &>(type);
 }
 
-/// class to hold an instantiated type variable bound is exact, for example the
-/// `java.lang.Integer` type in a `List<Integer>`
-class java_generic_inst_parametert:public java_generic_parametert
-{
-public:
-  // uses empty name for base type variable java_generic_parametert as real name
-  // is not known here
-  explicit java_generic_inst_parametert(const symbol_typet &type):
-    java_generic_parametert(irep_idt(), type)
-  {
-    set(ID_C_java_generic_inst_parameter, true);
-  }
-};
-
-/// \param type: the type to check
-/// \return true if type is an instantiated generic Java type, e.g., the Integer
-/// in List<Integer>
-inline bool is_java_generic_inst_parameter(const typet &type)
-{
-  return type.get_bool(ID_C_java_generic_inst_parameter);
-}
-
-/// \param type: source type
-/// \return cast of type into an instantiated java_generic_parameter
-inline const java_generic_inst_parametert &to_java_generic_inst_parameter(
-  const typet &type)
-{
-  PRECONDITION(
-    type.id()==ID_pointer &&
-    is_java_generic_inst_parameter(type));
-  return static_cast<const java_generic_inst_parametert &>(type);
-}
-
-/// \param type: source type
-/// \return cast of type into an instantiated java_generic_inst_parametert
-inline java_generic_inst_parametert &to_java_generic_inst_parameter(typet &type)
-{
-  PRECONDITION(
-    type.id()==ID_pointer &&
-    is_java_generic_inst_parameter(type));
-  return static_cast<java_generic_inst_parametert &>(type);
-}
-
-/// class to hold type with generic type variable, for example `java.util.List`
-/// in either a reference of type List<Integer> or List<T>. The vector holds
-/// the types of the type Variables, that is the vector has the length of the
-/// number of type variables of the generic class. For example in `HashMap<K,
-/// V>` it would contain two elements, each of type `java_generic_parametert`,
-/// in `HashMap<Integer, V>` it would contains two elements, the first of type
-/// `java_generic_inst_parametert` and the second of type
-/// `java_generic_parametert`.
+/// Class to hold type with generic type arguments, for example `java.util.List`
+/// in either a reference of type List<Integer> or List<T> (here T must have
+/// been concretized already to create this object so technically it is an
+/// argument rather than parameter/variable, but in the symbol table this still
+/// shows as the parameter T). The vector holds the types of the type arguments
+/// (all of type or subtype of reference_typet), that is the vector has
+/// the length of the number of type parameters of the generic class.
+/// For example:
+/// - in `HashMap<K, V>` it would contain two elements, each of type
+///   `java_generic_parametert`,
+/// - in `HashMap<Integer, V>` it would contain two elements, the first of type
+///   `reference_typet` and the second of type `java_generic_parametert`,
+/// - in `HashMap<List<T>, V>` it would contain two elements, the first of
+///   type `java_generic_typet` and the second of type
+///   `java_generic_parametert`.
 class java_generic_typet:public reference_typet
 {
 public:
-  typedef std::vector<java_generic_parametert> generic_type_variablest;
+  typedef std::vector<reference_typet> generic_type_argumentst;
 
   explicit java_generic_typet(const typet &_type):
     reference_typet(java_reference_type(_type))
@@ -208,16 +175,16 @@ class java_generic_typet:public reference_typet
   }
 
   /// \return vector of type variables
-  const generic_type_variablest &generic_type_variables() const
+  const generic_type_argumentst &generic_type_arguments() const
   {
-    return (const generic_type_variablest &)(
+    return (const generic_type_argumentst &)(
       find(ID_type_variables).get_sub());
   }
 
   /// \return vector of type variables
-  generic_type_variablest &generic_type_variables()
+  generic_type_argumentst &generic_type_arguments()
   {
-    return (generic_type_variablest &)(
+    return (generic_type_argumentst &)(
       add(ID_type_variables).get_sub());
   }
 };
@@ -251,10 +218,9 @@ inline java_generic_typet &to_java_generic_type(typet &type)
 }
 
 /// Class to hold a class with generics, extends the java class type with a
-/// vector of java_generic_type variables.
-///
-/// For example, a class definition `class MyGenericClass<T>`
-class java_generic_class_typet : public java_class_typet
+/// vector of java generic type parameters (also called type variables). For
+/// example, a class definition `class MyGenericClass<T>`.
+class java_generic_class_typet:public java_class_typet
 {
  public:
   typedef std::vector<java_generic_parametert> generic_typest;
@@ -300,18 +266,18 @@ to_java_generic_class_type(java_class_typet &type)
   return static_cast<java_generic_class_typet &>(type);
 }
 
-/// Access information of instantiated type params of java instantiated type.
-/// \param index: the index of the type variable
-/// \param type: the type from which to extract the type variable
+/// Access information of type arguments of java instantiated type.
+/// \param index: the index of the type argument
+/// \param type: the type from which to extract the type argument
 /// \return the type variable of t at the given index
 inline const typet &java_generic_get_inst_type(
   size_t index,
   const java_generic_typet &type)
 {
-  const std::vector<java_generic_parametert> &gen_types=
-    type.generic_type_variables();
-  PRECONDITION(index<gen_types.size());
-  return gen_types[index];
+  const std::vector<reference_typet> &type_arguments =
+    type.generic_type_arguments();
+  PRECONDITION(index<type_arguments.size());
+  return type_arguments[index];
 }
 
 /// Access information of type variables of a generic java class type.
diff --git a/src/util/irep_ids.def b/src/util/irep_ids.def
index 005124d0ea7..810e2f4b260 100644
--- a/src/util/irep_ids.def
+++ b/src/util/irep_ids.def
@@ -828,7 +828,6 @@ IREP_ID_ONE(java_array_access)
 IREP_ID_ONE(java_member_access)
 IREP_ID_ONE(integer_dereference)
 IREP_ID_TWO(C_java_generic_parameter, #java_generic_parameter)
-IREP_ID_TWO(C_java_generic_inst_parameter, #java_generic_inst_parameter)
 IREP_ID_TWO(C_java_generic_type, #java_generic_type)
 IREP_ID_TWO(C_java_generics_class_type, #java_generics_class_type)
 IREP_ID_TWO(generic_types, #generic_types)
diff --git a/unit/java_bytecode/generate_concrete_generic_type/generate_java_generic_type.cpp b/unit/java_bytecode/generate_concrete_generic_type/generate_java_generic_type.cpp
index 81be01d6c2b..7fb1a1a2519 100644
--- a/unit/java_bytecode/generate_concrete_generic_type/generate_java_generic_type.cpp
+++ b/unit/java_bytecode/generate_concrete_generic_type/generate_java_generic_type.cpp
@@ -66,7 +66,7 @@ SCENARIO(
 
       REQUIRE(class_type.has_component("first"));
       const auto &first_component=class_type.get_component("first");
-      REQUIRE(is_java_generic_inst_parameter(first_component.type()));
+      REQUIRE(!is_java_generic_parameter(first_component.type()));
       REQUIRE(first_component.type().id()==ID_pointer);
       REQUIRE(first_component.type().subtype().id()==ID_symbol);
       REQUIRE(to_symbol_type(
@@ -74,7 +74,7 @@ SCENARIO(
           "java::java.lang.Integer");
       REQUIRE(class_type.has_component("second"));
       const auto &second_component=class_type.get_component("second");
-      REQUIRE(is_java_generic_inst_parameter(second_component.type()));
+      REQUIRE(!is_java_generic_parameter(second_component.type()));
       REQUIRE(second_component.type().id()==ID_pointer);
       REQUIRE(second_component.type().subtype().id()==ID_symbol);
       REQUIRE(to_symbol_type(
@@ -118,10 +118,10 @@ SCENARIO(
 
       REQUIRE(class_type.has_component("key"));
       const auto &first_component=class_type.get_component("key");
-      REQUIRE(is_java_generic_inst_parameter(first_component.type()));
+      REQUIRE(!is_java_generic_parameter(first_component.type()));
       REQUIRE(class_type.has_component("value"));
       const auto &second_component=class_type.get_component("value");
-      REQUIRE(is_java_generic_inst_parameter(second_component.type()));
+      REQUIRE(!is_java_generic_parameter(second_component.type()));
     }
   }
 }
@@ -321,7 +321,7 @@ SCENARIO(
 
           require_type::require_java_generic_type(
             field_component.type(),
-            {{require_type::type_parameter_kindt::Inst,
+            {{require_type::type_argument_kindt::Inst,
               "java::java.lang.Float"}});
         }
       }
@@ -383,11 +383,11 @@ SCENARIO(
           const java_generic_typet &param_type =
             require_type::require_java_generic_type(
               field_component.type(),
-              {{require_type::type_parameter_kindt::Inst,
+              {{require_type::type_argument_kindt::Inst,
                 "java::array[reference]"}});
 
           const typet &array_type = java_array_element_type(
-            to_symbol_type(param_type.generic_type_variables()[0].subtype()));
+            to_symbol_type(param_type.generic_type_arguments()[0].subtype()));
           require_type::require_pointer(
             array_type, symbol_typet("java::java.lang.Float"));
         }
diff --git a/unit/java_bytecode/java_bytecode_parse_generics/parse_bounded_generic_inner_classes.cpp b/unit/java_bytecode/java_bytecode_parse_generics/parse_bounded_generic_inner_classes.cpp
index c79b6f4f87b..40891998771 100644
--- a/unit/java_bytecode/java_bytecode_parse_generics/parse_bounded_generic_inner_classes.cpp
+++ b/unit/java_bytecode/java_bytecode_parse_generics/parse_bounded_generic_inner_classes.cpp
@@ -42,8 +42,7 @@ SCENARIO(
           require_type::require_component(
             to_struct_type(class_symbol.type), "elem");
         require_type::require_java_generic_parameter(
-          elem.type(),
-          {require_type::type_parameter_kindt::Var, inner_name + "::E"});
+          elem.type(), inner_name + "::E");
       }
     }
   }
@@ -68,9 +67,7 @@ SCENARIO(
           require_type::require_component(
             to_struct_type(class_symbol.type), "elem");
         require_type::require_java_generic_parameter(
-          elem.type(),
-          {require_type::type_parameter_kindt::Var,
-           boundedinner_name + "::NUM"});
+          elem.type(), boundedinner_name + "::NUM");
       }
     }
   }
@@ -84,7 +81,7 @@ SCENARIO(
       belem_type.type(), symbol_typet(class_prefix + "$BoundedInner"));
     require_type::require_java_generic_type(
       belem_type.type(),
-      {{require_type::type_parameter_kindt::Inst, "java::java.lang.Integer"}});
+      {{require_type::type_argument_kindt::Inst, "java::java.lang.Integer"}});
   }
 
   WHEN("Parsing an inner class with double bounded type variable")
@@ -108,9 +105,7 @@ SCENARIO(
           require_type::require_component(
             to_struct_type(class_symbol.type), "elem");
         require_type::require_java_generic_parameter(
-          elem.type(),
-          {require_type::type_parameter_kindt::Var,
-           doubleboundedinner_name + "::T"});
+          elem.type(), doubleboundedinner_name + "::T");
 
         // TODO extend when bounds are parsed correctly - TG-1286
       }
@@ -138,17 +133,13 @@ SCENARIO(
           require_type::require_component(
             to_struct_type(class_symbol.type), "k");
         require_type::require_java_generic_parameter(
-          elemk.type(),
-          {require_type::type_parameter_kindt::Var,
-           twoelementinner_name + "::K"});
+          elemk.type(), twoelementinner_name + "::K");
 
         const struct_union_typet::componentt &elemv =
           require_type::require_component(
             to_struct_type(class_symbol.type), "v");
         require_type::require_java_generic_parameter(
-          elemv.type(),
-          {require_type::type_parameter_kindt::Var,
-           twoelementinner_name + "::V"});
+          elemv.type(), twoelementinner_name + "::V");
       }
     }
   }
diff --git a/unit/java_bytecode/java_bytecode_parse_generics/parse_functions_with_generics.cpp b/unit/java_bytecode/java_bytecode_parse_generics/parse_functions_with_generics.cpp
index f1aef3ff5d8..aeaf670150e 100644
--- a/unit/java_bytecode/java_bytecode_parse_generics/parse_functions_with_generics.cpp
+++ b/unit/java_bytecode/java_bytecode_parse_generics/parse_functions_with_generics.cpp
@@ -46,7 +46,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_x.type(),
-            {{require_type::type_parameter_kindt::Inst,
+            {{require_type::type_argument_kindt::Inst,
               "java::java.lang.Integer"}});
         }
       }
@@ -61,7 +61,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             return_type,
-            {{require_type::type_parameter_kindt::Inst,
+            {{require_type::type_argument_kindt::Inst,
               "java::java.lang.Integer"}});
         }
       }
@@ -94,7 +94,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_s.type(),
-            {{require_type::type_parameter_kindt::Inst,
+            {{require_type::type_argument_kindt::Inst,
               "java::java.lang.String"}});
         }
       }
@@ -109,7 +109,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             return_type,
-            {{require_type::type_parameter_kindt::Inst,
+            {{require_type::type_argument_kindt::Inst,
               "java::java.lang.Integer"}});
         }
       }
@@ -142,7 +142,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_x.type(),
-            {{require_type::type_parameter_kindt::Inst,
+            {{require_type::type_argument_kindt::Inst,
               "java::java.lang.Integer"}});
         }
       }
@@ -158,7 +158,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_y.type(),
-            {{require_type::type_parameter_kindt::Inst,
+            {{require_type::type_argument_kindt::Inst,
               "java::java.lang.Integer"}});
         }
       }
@@ -173,7 +173,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             return_type,
-            {{require_type::type_parameter_kindt::Inst,
+            {{require_type::type_argument_kindt::Inst,
               "java::java.lang.Integer"}});
         }
       }
@@ -206,7 +206,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_s.type(),
-            {{require_type::type_parameter_kindt::Inst,
+            {{require_type::type_argument_kindt::Inst,
               "java::java.lang.String"}});
         }
       }
@@ -222,7 +222,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_b.type(),
-            {{require_type::type_parameter_kindt::Inst,
+            {{require_type::type_argument_kindt::Inst,
               "java::java.lang.Boolean"}});
         }
       }
@@ -237,7 +237,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             return_type,
-            {{require_type::type_parameter_kindt::Inst,
+            {{require_type::type_argument_kindt::Inst,
               "java::java.lang.Integer"}});
         }
       }
@@ -278,7 +278,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             return_type,
-            {{require_type::type_parameter_kindt::Inst,
+            {{require_type::type_argument_kindt::Inst,
               "java::java.lang.Integer"}});
         }
       }
diff --git a/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_array_class.cpp b/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_array_class.cpp
index 5d35cd08131..7b375625c07 100644
--- a/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_array_class.cpp
+++ b/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_array_class.cpp
@@ -45,8 +45,7 @@ SCENARIO(
       {
         const typet &element = java_array_element_type(field_t_subtype);
         require_type::require_java_generic_parameter(
-          element,
-          {require_type::type_parameter_kindt::Var, class_prefix + "::T"});
+          element, class_prefix + "::T");
       }
     }
   }
@@ -73,7 +72,7 @@ SCENARIO(
         require_type::require_pointer(element, symbol_typet("java::Generic"));
         require_type::require_java_generic_type(
           element,
-          {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+          {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
       }
     }
   }
@@ -100,7 +99,7 @@ SCENARIO(
         require_type::require_pointer(element, symbol_typet("java::Generic"));
         require_type::require_java_generic_type(
           element,
-          {{require_type::type_parameter_kindt::Inst,
+          {{require_type::type_argument_kindt::Inst,
             "java::java.lang.Integer"}});
       }
     }
diff --git a/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_class.cpp b/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_class.cpp
index 46103893048..6738d87ccfa 100644
--- a/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_class.cpp
+++ b/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_class.cpp
@@ -39,8 +39,7 @@ SCENARIO(
         THEN("It is the generic parameter T")
         {
           require_type::require_java_generic_parameter(
-            field_t.type(),
-            {require_type::type_parameter_kindt::Var, class_prefix + "::T"});
+            field_t.type(), class_prefix + "::T");
         }
       }
 
@@ -55,7 +54,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             field_g.type(),
-            {{require_type::type_parameter_kindt::Inst,
+            {{require_type::type_argument_kindt::Inst,
               "java::java.lang.Integer"}});
         }
       }
@@ -92,8 +91,7 @@ SCENARIO(
         THEN("It is the generic parameter T")
         {
           require_type::require_java_generic_parameter(
-            field_t.type(),
-            {require_type::type_parameter_kindt::Var, class_prefix + "::T"});
+            field_t.type(), class_prefix + "::T");
         }
       }
       THEN("It has field u")
@@ -104,8 +102,7 @@ SCENARIO(
         THEN("It is the generic parameter U")
         {
           require_type::require_java_generic_parameter(
-            field_u.type(),
-            {require_type::type_parameter_kindt::Var, class_prefix + "::U"});
+            field_u.type(), class_prefix + "::U");
         }
       }
     }
diff --git a/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_class_with_generic_inner_classes.cpp b/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_class_with_generic_inner_classes.cpp
index b04b5dfbd83..3d0b45dba8e 100644
--- a/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_class_with_generic_inner_classes.cpp
+++ b/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_class_with_generic_inner_classes.cpp
@@ -43,7 +43,7 @@ SCENARIO(
       {
         require_type::require_java_generic_type(
           field_component.type(),
-          {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+          {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
       }
     }
 
@@ -62,9 +62,9 @@ SCENARIO(
       {
         require_type::require_java_generic_type(
           field_component.type(),
-          {{require_type::type_parameter_kindt::Var,
+          {{require_type::type_argument_kindt::Var,
              class_prefix + "::T"},
-           {require_type::type_parameter_kindt::Inst,
+           {require_type::type_argument_kindt::Inst,
              "java::Interface_Implementation"}});
       }
     }
@@ -84,8 +84,8 @@ SCENARIO(
       {
         require_type::require_java_generic_type(
           field_component.type(),
-          {{require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-           {require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+          {{require_type::type_argument_kindt::Var, class_prefix + "::T"},
+           {require_type::type_argument_kindt::Var, class_prefix + "::T"}});
       }
     }
 
@@ -105,9 +105,9 @@ SCENARIO(
       {
         require_type::require_java_generic_type(
           field_component.type(),
-          {{require_type::type_parameter_kindt::Var,
+          {{require_type::type_argument_kindt::Var,
              class_prefix + "::T"},
-           {require_type::type_parameter_kindt::Inst,
+           {require_type::type_argument_kindt::Inst,
              "java::Interface_Implementation"}});
       }
     }
@@ -128,8 +128,8 @@ SCENARIO(
       {
         require_type::require_java_generic_type(
           field_component.type(),
-          {{require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-           {require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+          {{require_type::type_argument_kindt::Var, class_prefix + "::T"},
+           {require_type::type_argument_kindt::Var, class_prefix + "::T"}});
       }
     }
 
@@ -149,11 +149,11 @@ SCENARIO(
       {
         require_type::require_java_generic_type(
           field_component.type(),
-          {{require_type::type_parameter_kindt::Var,
+          {{require_type::type_argument_kindt::Var,
              class_prefix + "::T"},
-           {require_type::type_parameter_kindt::Inst,
+           {require_type::type_argument_kindt::Inst,
              "java::Interface_Implementation"},
-           {require_type::type_parameter_kindt::Inst,
+           {require_type::type_argument_kindt::Inst,
              "java::Interface_Implementation"}});
       }
     }
@@ -174,9 +174,9 @@ SCENARIO(
       {
         require_type::require_java_generic_type(
           field_component.type(),
-          {{require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-           {require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-           {require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+          {{require_type::type_argument_kindt::Var, class_prefix + "::T"},
+           {require_type::type_argument_kindt::Var, class_prefix + "::T"},
+           {require_type::type_argument_kindt::Var, class_prefix + "::T"}});
       }
     }
 
@@ -195,11 +195,11 @@ SCENARIO(
       {
         require_type::require_java_generic_type(
           field_component.type(),
-          {{require_type::type_parameter_kindt::Var,
+          {{require_type::type_argument_kindt::Var,
              class_prefix + "::T"},
-           {require_type::type_parameter_kindt::Inst,
+           {require_type::type_argument_kindt::Inst,
              "java::Interface_Implementation"},
-           {require_type::type_parameter_kindt::Inst,
+           {require_type::type_argument_kindt::Inst,
              "java::Interface_Implementation"}});
       }
     }
@@ -219,11 +219,11 @@ SCENARIO(
       {
         require_type::require_java_generic_type(
           field_component.type(),
-          {{require_type::type_parameter_kindt::Var,
+          {{require_type::type_argument_kindt::Var,
              class_prefix + "::T"},
-           {require_type::type_parameter_kindt::Inst,
+           {require_type::type_argument_kindt::Inst,
              "java::Interface_Implementation"},
-           {require_type::type_parameter_kindt::Var,
+           {require_type::type_argument_kindt::Var,
              class_prefix + "::T"}});
       }
     }
@@ -243,9 +243,9 @@ SCENARIO(
       {
         require_type::require_java_generic_type(
           field_component.type(),
-          {{require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-           {require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-           {require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+          {{require_type::type_argument_kindt::Var, class_prefix + "::T"},
+           {require_type::type_argument_kindt::Var, class_prefix + "::T"},
+           {require_type::type_argument_kindt::Var, class_prefix + "::T"}});
       }
     }
   }
@@ -286,7 +286,7 @@ SCENARIO(
         param_type.type(), symbol_typet(class_prefix + "$InnerClass"));
       require_type::require_java_generic_type(
         param_type.type(),
-        {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+        {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
     }
   }
   THEN(
@@ -315,7 +315,7 @@ SCENARIO(
         param_type.type(), symbol_typet(class_prefix + "$InnerClass"));
       require_type::require_java_generic_type(
         param_type.type(),
-        {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+        {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
       const auto &param_type2 =
         require_type::require_parameter(function_call, "input2");
@@ -323,7 +323,7 @@ SCENARIO(
         param_type2.type(), symbol_typet(class_prefix + "$InnerClass"));
       require_type::require_java_generic_type(
         param_type2.type(),
-        {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+        {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
     }
   }
   THEN(
@@ -351,9 +351,9 @@ SCENARIO(
         param_type.type(), symbol_typet(class_prefix + "$GenericInnerClass"));
       require_type::require_java_generic_type(
         param_type.type(),
-        {{require_type::type_parameter_kindt::Var,
+        {{require_type::type_argument_kindt::Var,
            class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Inst,
+         {require_type::type_argument_kindt::Inst,
            "java::Interface_Implementation"}});
     }
   }
@@ -382,8 +382,8 @@ SCENARIO(
         param_type.type(), symbol_typet(class_prefix + "$GenericInnerClass"));
       require_type::require_java_generic_type(
         param_type.type(),
-        {{require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+        {{require_type::type_argument_kindt::Var, class_prefix + "::T"},
+         {require_type::type_argument_kindt::Var, class_prefix + "::T"}});
     }
   }
   THEN(
@@ -414,9 +414,9 @@ SCENARIO(
           class_prefix + "$GenericInnerClass$DoublyNestedInnerClass"));
       require_type::require_java_generic_type(
         param_type.type(),
-        {{require_type::type_parameter_kindt::Var,
+        {{require_type::type_argument_kindt::Var,
            class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Inst,
+         {require_type::type_argument_kindt::Inst,
            "java::Interface_Implementation"}});
     }
   }
@@ -448,8 +448,8 @@ SCENARIO(
           class_prefix + "$GenericInnerClass$DoublyNestedInnerClass"));
       require_type::require_java_generic_type(
         param_type.type(),
-        {{require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+        {{require_type::type_argument_kindt::Var, class_prefix + "::T"},
+         {require_type::type_argument_kindt::Var, class_prefix + "::T"}});
     }
   }
   THEN(
@@ -480,11 +480,11 @@ SCENARIO(
           class_prefix + "$GenericInnerClass$DoublyNestedInnerGenericClass"));
       require_type::require_java_generic_type(
         param_type.type(),
-        {{require_type::type_parameter_kindt::Var,
+        {{require_type::type_argument_kindt::Var,
            class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Inst,
+         {require_type::type_argument_kindt::Inst,
            "java::Interface_Implementation"},
-         {require_type::type_parameter_kindt::Inst,
+         {require_type::type_argument_kindt::Inst,
            "java::Interface_Implementation"}});
     }
   }
@@ -516,9 +516,9 @@ SCENARIO(
           class_prefix + "$GenericInnerClass$DoublyNestedInnerGenericClass"));
       require_type::require_java_generic_type(
         param_type.type(),
-        {{require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+        {{require_type::type_argument_kindt::Var, class_prefix + "::T"},
+         {require_type::type_argument_kindt::Var, class_prefix + "::T"},
+         {require_type::type_argument_kindt::Var, class_prefix + "::T"}});
     }
   }
   THEN(
@@ -546,11 +546,11 @@ SCENARIO(
         param_type.type(), symbol_typet(class_prefix + "$TwoParamInnerClass"));
       require_type::require_java_generic_type(
         param_type.type(),
-        {{require_type::type_parameter_kindt::Var,
+        {{require_type::type_argument_kindt::Var,
            class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Inst,
+         {require_type::type_argument_kindt::Inst,
            "java::Interface_Implementation"},
-         {require_type::type_parameter_kindt::Inst,
+         {require_type::type_argument_kindt::Inst,
            "java::Interface_Implementation"}});
     }
   }
@@ -579,11 +579,11 @@ SCENARIO(
         param_type.type(), symbol_typet(class_prefix + "$TwoParamInnerClass"));
       require_type::require_java_generic_type(
         param_type.type(),
-        {{require_type::type_parameter_kindt::Var,
+        {{require_type::type_argument_kindt::Var,
            class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Inst,
+         {require_type::type_argument_kindt::Inst,
            "java::Interface_Implementation"},
-         {require_type::type_parameter_kindt::Var,
+         {require_type::type_argument_kindt::Var,
            class_prefix + "::T"}});
     }
   }
@@ -612,9 +612,9 @@ SCENARIO(
         param_type.type(), symbol_typet(class_prefix + "$TwoParamInnerClass"));
       require_type::require_java_generic_type(
         param_type.type(),
-        {{require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+        {{require_type::type_argument_kindt::Var, class_prefix + "::T"},
+         {require_type::type_argument_kindt::Var, class_prefix + "::T"},
+         {require_type::type_argument_kindt::Var, class_prefix + "::T"}});
     }
   }
   THEN(
@@ -641,7 +641,7 @@ SCENARIO(
         symbol_typet(class_prefix + "$InnerClass"));
       require_type::require_java_generic_type(
         function_call.return_type(),
-        {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+        {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
     }
   }
   THEN(
@@ -668,9 +668,9 @@ SCENARIO(
         symbol_typet(class_prefix + "$GenericInnerClass"));
       require_type::require_java_generic_type(
         function_call.return_type(),
-        {{require_type::type_parameter_kindt::Var,
+        {{require_type::type_argument_kindt::Var,
            class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Inst,
+         {require_type::type_argument_kindt::Inst,
            "java::Interface_Implementation"}});
     }
   }
@@ -698,8 +698,8 @@ SCENARIO(
         symbol_typet(class_prefix + "$GenericInnerClass"));
       require_type::require_java_generic_type(
         function_call.return_type(),
-        {{require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+        {{require_type::type_argument_kindt::Var, class_prefix + "::T"},
+         {require_type::type_argument_kindt::Var, class_prefix + "::T"}});
     }
   }
   THEN(
@@ -728,9 +728,9 @@ SCENARIO(
           class_prefix + "$GenericInnerClass$DoublyNestedInnerClass"));
       require_type::require_java_generic_type(
         function_call.return_type(),
-        {{require_type::type_parameter_kindt::Var,
+        {{require_type::type_argument_kindt::Var,
            class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Inst,
+         {require_type::type_argument_kindt::Inst,
            "java::Interface_Implementation"}});
     }
   }
@@ -760,8 +760,8 @@ SCENARIO(
           class_prefix + "$GenericInnerClass$DoublyNestedInnerClass"));
       require_type::require_java_generic_type(
         function_call.return_type(),
-        {{require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+        {{require_type::type_argument_kindt::Var, class_prefix + "::T"},
+         {require_type::type_argument_kindt::Var, class_prefix + "::T"}});
     }
   }
   THEN(
@@ -790,11 +790,11 @@ SCENARIO(
           class_prefix + "$GenericInnerClass$DoublyNestedInnerGenericClass"));
       require_type::require_java_generic_type(
         function_call.return_type(),
-        {{require_type::type_parameter_kindt::Var,
+        {{require_type::type_argument_kindt::Var,
            class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Inst,
+         {require_type::type_argument_kindt::Inst,
            "java::Interface_Implementation"},
-         {require_type::type_parameter_kindt::Inst,
+         {require_type::type_argument_kindt::Inst,
            "java::Interface_Implementation"}});
     }
   }
@@ -824,9 +824,9 @@ SCENARIO(
           class_prefix + "$GenericInnerClass$DoublyNestedInnerGenericClass"));
       require_type::require_java_generic_type(
         function_call.return_type(),
-        {{require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+        {{require_type::type_argument_kindt::Var, class_prefix + "::T"},
+         {require_type::type_argument_kindt::Var, class_prefix + "::T"},
+         {require_type::type_argument_kindt::Var, class_prefix + "::T"}});
     }
   }
   THEN(
@@ -854,11 +854,11 @@ SCENARIO(
         symbol_typet(class_prefix + "$TwoParamInnerClass"));
       require_type::require_java_generic_type(
         function_call.return_type(),
-        {{require_type::type_parameter_kindt::Var,
+        {{require_type::type_argument_kindt::Var,
            class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Inst,
+         {require_type::type_argument_kindt::Inst,
            "java::Interface_Implementation"},
-         {require_type::type_parameter_kindt::Inst,
+         {require_type::type_argument_kindt::Inst,
            "java::Interface_Implementation"}});
     }
   }
@@ -886,11 +886,11 @@ SCENARIO(
         symbol_typet(class_prefix + "$TwoParamInnerClass"));
       require_type::require_java_generic_type(
         function_call.return_type(),
-        {{require_type::type_parameter_kindt::Var,
+        {{require_type::type_argument_kindt::Var,
            class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Inst,
+         {require_type::type_argument_kindt::Inst,
            "java::Interface_Implementation"},
-         {require_type::type_parameter_kindt::Var,
+         {require_type::type_argument_kindt::Var,
            class_prefix + "::T"}});
     }
   }
@@ -918,9 +918,9 @@ SCENARIO(
         symbol_typet(class_prefix + "$TwoParamInnerClass"));
       require_type::require_java_generic_type(
         function_call.return_type(),
-        {{require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-         {require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+        {{require_type::type_argument_kindt::Var, class_prefix + "::T"},
+         {require_type::type_argument_kindt::Var, class_prefix + "::T"},
+         {require_type::type_argument_kindt::Var, class_prefix + "::T"}});
     }
   }
 }
diff --git a/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_fields.cpp b/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_fields.cpp
index 21b2be51eee..c0df0bfab17 100644
--- a/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_fields.cpp
+++ b/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_fields.cpp
@@ -37,8 +37,7 @@ SCENARIO(
         const struct_union_typet::componentt &field =
           require_type::require_component(class_struct, "f");
         require_type::require_java_generic_parameter(
-          field.type(),
-          {require_type::type_parameter_kindt::Var, class_prefix + "::T"});
+          field.type(), class_prefix + "::T");
       }
 
       THEN("It has field f2 pointing to Generic")
@@ -51,7 +50,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             field.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
         }
       }
 
@@ -65,22 +64,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             field.type(),
-            {{require_type::type_parameter_kindt::Inst,
-              "java::java.lang.Integer"}});
-        }
-      }
-
-      THEN("It has field f3 pointing to Generic")
-      {
-        const struct_typet::componentt &field =
-          require_type::require_component(class_struct, "f3");
-        require_type::require_pointer(
-          field.type(), symbol_typet("java::Generic"));
-        THEN("The pointer should be generic")
-        {
-          require_type::require_java_generic_type(
-            field.type(),
-            {{require_type::type_parameter_kindt::Inst,
+            {{require_type::type_argument_kindt::Inst,
               "java::java.lang.Integer"}});
         }
       }
@@ -93,10 +77,16 @@ SCENARIO(
           field.type(), symbol_typet("java::Generic"));
         THEN("The pointer should be generic")
         {
+          const java_generic_typet &generic_field =
+            require_type::require_java_generic_type(
+              field.type(),
+              {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+          const typet &type_argument_1 =
+            generic_field.generic_type_arguments().at(0);
           require_type::require_java_generic_type(
-            field.type(),
-            {{require_type::type_parameter_kindt::Inst, "java::Generic"}});
-          // TODO extend when nested generics are parsed correctly - TG-1301
+            type_argument_1,
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
         }
       }
 
@@ -108,10 +98,24 @@ SCENARIO(
           field.type(), symbol_typet("java::Generic"));
         THEN("The pointer should be generic")
         {
+          const java_generic_typet &generic_field =
+            require_type::require_java_generic_type(
+              field.type(),
+              {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+          const typet &type_argument_1 =
+            generic_field.generic_type_arguments().at(0);
+          const java_generic_typet &generic_type_argument_1 =
+            require_type::require_java_generic_type(
+              type_argument_1,
+              {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+          const typet &type_argument_1_1 =
+            generic_type_argument_1.generic_type_arguments().at(0);
           require_type::require_java_generic_type(
-            field.type(),
-            {{require_type::type_parameter_kindt::Inst, "java::Generic"}});
-          // TODO extend when nested generics are parsed correctly - TG-1301
+            type_argument_1_1,
+            {{require_type::type_argument_kindt::Inst,
+               "java::java.lang.Integer"}});
         }
       }
 
@@ -125,8 +129,8 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             field.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-             {require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"},
+             {require_type::type_argument_kindt::Var, class_prefix + "::T"}});
         }
       }
 
@@ -140,8 +144,8 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             field.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"},
-             {require_type::type_parameter_kindt::Var, class_prefix + "::S"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"},
+             {require_type::type_argument_kindt::Var, class_prefix + "::S"}});
         }
       }
 
@@ -155,9 +159,9 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             field.type(),
-            {{require_type::type_parameter_kindt::Inst,
+            {{require_type::type_argument_kindt::Inst,
                "java::java.lang.Integer"},
-             {require_type::type_parameter_kindt::Var,
+             {require_type::type_argument_kindt::Var,
                class_prefix + "::T"}});
         }
       }
@@ -172,9 +176,9 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             field.type(),
-            {{require_type::type_parameter_kindt::Var,
+            {{require_type::type_argument_kindt::Var,
                class_prefix + "::T"},
-             {require_type::type_parameter_kindt::Inst,
+             {require_type::type_argument_kindt::Inst,
               "java::java.lang.Integer"}});
         }
       }
@@ -189,9 +193,9 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             field.type(),
-            {{require_type::type_parameter_kindt::Inst,
+            {{require_type::type_argument_kindt::Inst,
               "java::java.lang.Integer"},
-             {require_type::type_parameter_kindt::Inst,
+             {require_type::type_argument_kindt::Inst,
               "java::java.lang.String"}});
         }
       }
@@ -204,13 +208,29 @@ SCENARIO(
           field.type(), symbol_typet("java::GenericTwoParam"));
         THEN("The pointer should be generic")
         {
+          const java_generic_typet &generic_field =
+            require_type::require_java_generic_type(
+              field.type(),
+              {{require_type::type_argument_kindt::Inst,
+                 "java::Generic"},
+               {require_type::type_argument_kindt::Inst,
+                 "java::GenericTwoParam"}});
+
+          const typet &type_argument_1 =
+            generic_field.generic_type_arguments().at(0);
           require_type::require_java_generic_type(
-            field.type(),
-            {{require_type::type_parameter_kindt::Inst,
-               "java::Generic"},
-             {require_type::type_parameter_kindt::Inst,
-               "java::GenericTwoParam"}});
-          // TODO extend when nested generics are parsed correctly - TG-1301
+            type_argument_1,
+            {{require_type::type_argument_kindt::Var,
+               class_prefix + "::T"}});
+
+          const typet &type_argument_2 =
+            generic_field.generic_type_arguments().at(1);
+          require_type::require_java_generic_type(
+            type_argument_2,
+            {{require_type::type_argument_kindt::Var,
+               class_prefix + "::S"},
+             {require_type::type_argument_kindt::Inst,
+               "java::java.lang.Integer"}});
         }
       }
     }
diff --git a/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_functions.cpp b/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_functions.cpp
index e4818e7639a..456f839d869 100644
--- a/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_functions.cpp
+++ b/unit/java_bytecode/java_bytecode_parse_generics/parse_generic_functions.cpp
@@ -45,7 +45,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_x.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
         }
       }
     }
@@ -76,7 +76,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_x.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -113,7 +113,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_x.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -150,7 +150,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_x.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -187,7 +187,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_x.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -225,7 +225,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_t.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
         }
       }
       THEN("It contains parameter u pointing to Generic")
@@ -239,7 +239,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_u.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::U"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::U"}});
         }
       }
     }
@@ -271,7 +271,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_t.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -291,7 +291,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_u.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::U"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::U"}});
 
           THEN("The bounds are set correctly")
           {
@@ -327,7 +327,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             func_code.return_type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
         }
       }
     }
@@ -356,8 +356,7 @@ SCENARIO(
         THEN("It is the generic parameter T")
         {
           require_type::require_java_generic_parameter(
-            func_code.return_type(),
-            {require_type::type_parameter_kindt::Var, class_prefix + "::T"});
+            func_code.return_type(), class_prefix + "::T");
         }
       }
     }
@@ -385,7 +384,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             func_code.return_type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -420,7 +419,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             func_code.return_type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -455,7 +454,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             func_code.return_type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -490,7 +489,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             func_code.return_type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -529,7 +528,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_x.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
         }
       }
 
@@ -542,7 +541,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             func_code.return_type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
         }
       }
     }
@@ -574,7 +573,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_x.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -593,7 +592,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             func_code.return_type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -631,7 +630,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_x.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -650,7 +649,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             func_code.return_type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -688,7 +687,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_x.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -707,7 +706,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             func_code.return_type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -746,7 +745,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_x.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -765,7 +764,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             func_code.return_type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -803,7 +802,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_u.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::U"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::U"}});
         }
       }
 
@@ -816,7 +815,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             func_code.return_type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
         }
       }
     }
@@ -848,7 +847,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_u.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::U"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::U"}});
 
           THEN("The bounds are set correctly")
           {
@@ -867,7 +866,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             func_code.return_type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
@@ -905,7 +904,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_u.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::U"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::U"}});
         }
       }
 
@@ -920,7 +919,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_v.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::V"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::V"}});
         }
       }
 
@@ -933,7 +932,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             func_code.return_type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
         }
       }
     }
@@ -965,7 +964,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_u.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::U"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::U"}});
 
           THEN("The bounds are set correctly")
           {
@@ -986,7 +985,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             param_v.type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::V"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::V"}});
 
           THEN("The bounds are set correctly")
           {
@@ -1005,7 +1004,7 @@ SCENARIO(
         {
           require_type::require_java_generic_type(
             func_code.return_type(),
-            {{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
+            {{require_type::type_argument_kindt::Var, class_prefix + "::T"}});
 
           THEN("The bounds are set correctly")
           {
diff --git a/unit/java_bytecode/java_bytecode_parse_generics/parse_nested_generics.cpp b/unit/java_bytecode/java_bytecode_parse_generics/parse_nested_generics.cpp
index 17441a81dd9..779569c0928 100644
--- a/unit/java_bytecode/java_bytecode_parse_generics/parse_nested_generics.cpp
+++ b/unit/java_bytecode/java_bytecode_parse_generics/parse_nested_generics.cpp
@@ -35,12 +35,17 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
-        require_type::require_java_generic_type(
-          field_component.type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"}});
+        const java_generic_typet &generic_field =
+          require_type::require_java_generic_type(
+            field_component.type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
 
-        // TODO: extend tests when nested generics are parsed correctly -
-        // issue TG-1301
+        const typet &type_argument_1 =
+          generic_field.generic_type_arguments().at(0);
+        require_type::require_java_generic_type(
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
       }
     }
 
@@ -53,12 +58,17 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
-        require_type::require_java_generic_type(
-          field_component.type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"}});
+        const java_generic_typet &generic_field =
+          require_type::require_java_generic_type(
+            field_component.type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
 
-        // TODO: extend tests when nested generics are parsed correctly -
-        // issue TG-1301
+        const typet &type_argument_1 =
+          generic_field.generic_type_arguments().at(0);
+        require_type::require_java_generic_type(
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
 
@@ -71,12 +81,24 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_field =
+          require_type::require_java_generic_type(
+            field_component.type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_field.generic_type_arguments().at(0);
+        const java_generic_typet generic_type_argument_1 =
+          require_type::require_java_generic_type(
+            type_argument_1,
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1_1 =
+          generic_type_argument_1.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          field_component.type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"}});
-
-        // TODO: extend tests when nested generics are parsed correctly -
-        // issue TG-1301
+          type_argument_1_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
       }
     }
 
@@ -89,12 +111,24 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_field =
+          require_type::require_java_generic_type(
+            field_component.type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_field.generic_type_arguments().at(0);
+        const java_generic_typet generic_type_argument_1 =
+          require_type::require_java_generic_type(
+            type_argument_1,
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1_1 =
+          generic_type_argument_1.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          field_component.type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"}});
-
-        // TODO: extend tests when nested generics are parsed correctly -
-        // issue TG-1301
+          type_argument_1_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
 
@@ -107,13 +141,20 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_field =
+          require_type::require_java_generic_type(
+            field_component.type(),
+            {{require_type::type_argument_kindt::Inst,
+               "java::GenericTwoParam"}});
+
+        const typet &type_argument_1 =
+          generic_field.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          field_component.type(),
-          {{require_type::type_parameter_kindt::Inst,
-            "java::GenericTwoParam"}});
-
-        // TODO: extend tests when nested generics are parsed correctly -
-        // issue TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"},
+           {require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
       }
     }
 
@@ -126,13 +167,20 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_field =
+          require_type::require_java_generic_type(
+            field_component.type(),
+            {{require_type::type_argument_kindt::Inst,
+               "java::GenericTwoParam"}});
+
+        const typet &type_argument_1 =
+          generic_field.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          field_component.type(),
-          {{require_type::type_parameter_kindt::Inst,
-            "java::GenericTwoParam"}});
-
-        // TODO: extend tests when nested generics are parsed correctly -
-        // issue TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"},
+           {require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
 
@@ -145,12 +193,20 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_field =
+          require_type::require_java_generic_type(
+            field_component.type(),
+            {{require_type::type_argument_kindt::Inst,
+               "java::GenericTwoParam"}});
+
+        const typet &type_argument_1 =
+          generic_field.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          field_component.type(),
-          {{require_type::type_parameter_kindt::Inst,
-            "java::GenericTwoParam"}});
-        // TODO: extend tests when nested generics are parsed correctly -
-        // issue TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"},
+           {require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
 
@@ -163,12 +219,25 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_field =
+          require_type::require_java_generic_type(
+            field_component.type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"},
+             {require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_field.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          field_component.type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"},
-           {require_type::type_parameter_kindt::Inst, "java::Generic"}});
-        // TODO: extend tests when nested generics are parsed correctly -
-        // issue TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
+
+        const typet &type_argument_2 =
+          generic_field.generic_type_arguments().at(1);
+        require_type::require_java_generic_type(
+          type_argument_2,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
       }
     }
 
@@ -181,12 +250,25 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_field =
+          require_type::require_java_generic_type(
+            field_component.type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"},
+             {require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_field.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          field_component.type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"},
-           {require_type::type_parameter_kindt::Inst, "java::Generic"}});
-        // TODO: extend tests when nested generics are parsed correctly -
-        // issue TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
+
+        const typet &type_argument_2 =
+          generic_field.generic_type_arguments().at(1);
+        require_type::require_java_generic_type(
+          type_argument_2,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
 
@@ -199,13 +281,25 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_field =
+          require_type::require_java_generic_type(
+            field_component.type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"},
+             {require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_field.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          field_component.type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"},
-           {require_type::type_parameter_kindt::Inst, "java::Generic"}});
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
 
-        // TODO: extend tests when nested generics are parsed correctly -
-        // issue TG-1301
+        const typet &type_argument_2 =
+          generic_field.generic_type_arguments().at(1);
+        require_type::require_java_generic_type(
+          type_argument_2,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
 
@@ -218,15 +312,20 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_field =
+          require_type::require_java_generic_type(
+            field_component.type(),
+            {{require_type::type_argument_kindt::Inst,
+               "java::Generic"},
+             {require_type::type_argument_kindt::Inst,
+               "java::Interface_Implementation"}});
+
+        const typet &type_argument_1 =
+          generic_field.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          field_component.type(),
-          {{require_type::type_parameter_kindt::Inst,
-             "java::Generic"},
-           {require_type::type_parameter_kindt::Inst,
-             "java::Interface_Implementation"}});
-
-        // TODO: extend tests when nested generics are parsed correctly -
-        // issue TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
 
@@ -239,15 +338,27 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_field =
+          require_type::require_java_generic_type(
+            field_component.type(),
+            {{require_type::type_argument_kindt::Inst,
+               "java::Generic"},
+             {require_type::type_argument_kindt::Inst,
+               "java::Interface_Implementation"}});
+
+        const typet &type_argument_1 =
+          generic_field.generic_type_arguments().at(0);
+        const java_generic_typet generic_type_argument_1 =
+          require_type::require_java_generic_type(
+            type_argument_1,
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1_1 =
+          generic_type_argument_1.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          field_component.type(),
-          {{require_type::type_parameter_kindt::Inst,
-             "java::Generic"},
-           {require_type::type_parameter_kindt::Inst,
-             "java::Interface_Implementation"}});
-
-        // TODO: extend tests when nested generics are parsed correctly -
-        // issue TG-1301
+          type_argument_1_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
 
@@ -260,13 +371,27 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_field =
+          require_type::require_java_generic_type(
+            field_component.type(),
+            {{require_type::type_argument_kindt::Inst, "java::GenericTwoParam"},
+             {require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_field.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          field_component.type(),
-          {{require_type::type_parameter_kindt::Inst, "java::GenericTwoParam"},
-           {require_type::type_parameter_kindt::Inst, "java::Generic"}});
-
-        // TODO: extend tests when nested generics are parsed correctly -
-        // issue TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"},
+           {require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
+
+        const typet &type_argument_2 =
+          generic_field.generic_type_arguments().at(1);
+        require_type::require_java_generic_type(
+          type_argument_2,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -304,11 +429,17 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_param =
+          require_type::require_java_generic_type(
+            param_type.type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_param.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          param_type.type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"}});
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
       }
     }
   }
@@ -336,11 +467,17 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_param =
+          require_type::require_java_generic_type(
+            param_type.type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_param.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          param_type.type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"}});
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -368,12 +505,24 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_param =
+          require_type::require_java_generic_type(
+            param_type.type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_param.generic_type_arguments().at(0);
+        const java_generic_typet &generic_type_argument_1 =
+          require_type::require_java_generic_type(
+            type_argument_1,
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1_1 =
+          generic_type_argument_1.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          param_type.type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
       }
     }
   }
@@ -401,12 +550,24 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_param =
+          require_type::require_java_generic_type(
+            param_type.type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_param.generic_type_arguments().at(0);
+        const java_generic_typet &generic_type_argument_1 =
+          require_type::require_java_generic_type(
+            type_argument_1,
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1_1 =
+          generic_type_argument_1.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          param_type.type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -434,13 +595,20 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_param =
+          require_type::require_java_generic_type(
+            param_type.type(),
+            {{require_type::type_argument_kindt::Inst,
+               "java::GenericTwoParam"}});
+
+        const typet &type_argument_1 =
+          generic_param.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          param_type.type(),
-          {{require_type::type_parameter_kindt::Inst,
-            "java::GenericTwoParam"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"},
+           {require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
       }
     }
   }
@@ -468,13 +636,20 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_param =
+          require_type::require_java_generic_type(
+            param_type.type(),
+            {{require_type::type_argument_kindt::Inst,
+               "java::GenericTwoParam"}});
+
+        const typet &type_argument_1 =
+          generic_param.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          param_type.type(),
-          {{require_type::type_parameter_kindt::Inst,
-            "java::GenericTwoParam"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"},
+           {require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -502,13 +677,20 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_param =
+          require_type::require_java_generic_type(
+            param_type.type(),
+            {{require_type::type_argument_kindt::Inst,
+               "java::GenericTwoParam"}});
+
+        const typet &type_argument_1 =
+          generic_param.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          param_type.type(),
-          {{require_type::type_parameter_kindt::Inst,
-            "java::GenericTwoParam"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"},
+           {require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -536,13 +718,24 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_param =
+          require_type::require_java_generic_type(
+            param_type.type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"},
+             {require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_param.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          param_type.type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"},
-           {require_type::type_parameter_kindt::Inst, "java::Generic"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
+        const typet &type_argument_2 =
+          generic_param.generic_type_arguments().at(1);
+        require_type::require_java_generic_type(
+          type_argument_2,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
       }
     }
   }
@@ -570,12 +763,24 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_param =
+          require_type::require_java_generic_type(
+            param_type.type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"},
+             {require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_param.generic_type_arguments().at(0);
+        require_type::require_java_generic_type(
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
+        const typet &type_argument_2 =
+          generic_param.generic_type_arguments().at(1);
         require_type::require_java_generic_type(
-          param_type.type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"},
-           {require_type::type_parameter_kindt::Inst, "java::Generic"}});
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_2,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -603,13 +808,24 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_param =
+          require_type::require_java_generic_type(
+            param_type.type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"},
+             {require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_param.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          param_type.type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"},
-           {require_type::type_parameter_kindt::Inst, "java::Generic"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
+        const typet &type_argument_2 =
+          generic_param.generic_type_arguments().at(1);
+        require_type::require_java_generic_type(
+          type_argument_2,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -637,15 +853,20 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_param =
+          require_type::require_java_generic_type(
+            param_type.type(),
+            {{require_type::type_argument_kindt::Inst,
+               "java::Generic"},
+             {require_type::type_argument_kindt::Inst,
+               "java::Interface_Implementation"}});
+
+        const typet &type_argument_1 =
+          generic_param.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          param_type.type(),
-          {{require_type::type_parameter_kindt::Inst,
-             "java::Generic"},
-           {require_type::type_parameter_kindt::Inst,
-             "java::Interface_Implementation"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -673,15 +894,26 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_param =
+          require_type::require_java_generic_type(
+            param_type.type(),
+            {{require_type::type_argument_kindt::Inst,
+               "java::Generic"},
+             {require_type::type_argument_kindt::Inst,
+               "java::Interface_Implementation"}});
+
+        const typet &type_argument_1 =
+          generic_param.generic_type_arguments().at(0);
+        const java_generic_typet &generic_type_argument_1 =
+          require_type::require_java_generic_type(
+            type_argument_1,
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+        const typet &type_argument_1_1 =
+          generic_type_argument_1.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          param_type.type(),
-          {{require_type::type_parameter_kindt::Inst,
-             "java::Generic"},
-           {require_type::type_parameter_kindt::Inst,
-             "java::Interface_Implementation"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -709,13 +941,26 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_param =
+          require_type::require_java_generic_type(
+            param_type.type(),
+            {{require_type::type_argument_kindt::Inst, "java::GenericTwoParam"},
+             {require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_param.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          param_type.type(),
-          {{require_type::type_parameter_kindt::Inst, "java::GenericTwoParam"},
-           {require_type::type_parameter_kindt::Inst, "java::Generic"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"},
+           {require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
+        const typet &type_argument_2 =
+          generic_param.generic_type_arguments().at(1);
+        require_type::require_java_generic_type(
+          type_argument_2,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -741,12 +986,17 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
-        require_type::require_java_generic_type(
-          function_call.return_type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"}});
+        const java_generic_typet &generic_return =
+          require_type::require_java_generic_type(
+            function_call.return_type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
 
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+        const typet &type_argument_1 =
+          generic_return.generic_type_arguments().at(0);
+        require_type::require_java_generic_type(
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
       }
     }
   }
@@ -772,12 +1022,17 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
-        require_type::require_java_generic_type(
-          function_call.return_type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"}});
+        const java_generic_typet &generic_return =
+          require_type::require_java_generic_type(
+            function_call.return_type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
 
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+        const typet &type_argument_1 =
+          generic_return.generic_type_arguments().at(0);
+        require_type::require_java_generic_type(
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -803,12 +1058,23 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_return =
+          require_type::require_java_generic_type(
+            function_call.return_type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_return.generic_type_arguments().at(0);
+        const java_generic_typet &generic_type_argument_1 =
+          require_type::require_java_generic_type(
+            type_argument_1,
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+        const typet &type_argument_1_1 =
+          generic_type_argument_1.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          function_call.return_type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
       }
     }
   }
@@ -834,12 +1100,23 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_return =
+          require_type::require_java_generic_type(
+            function_call.return_type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_return.generic_type_arguments().at(0);
+        const java_generic_typet &generic_type_argument_1 =
+          require_type::require_java_generic_type(
+            type_argument_1,
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+        const typet &type_argument_1_1 =
+          generic_type_argument_1.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          function_call.return_type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -865,13 +1142,20 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_return =
+          require_type::require_java_generic_type(
+            function_call.return_type(),
+            {{require_type::type_argument_kindt::Inst,
+               "java::GenericTwoParam"}});
+
+        const typet &type_argument_1 =
+          generic_return.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          function_call.return_type(),
-          {{require_type::type_parameter_kindt::Inst,
-            "java::GenericTwoParam"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"},
+           {require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
       }
     }
   }
@@ -897,13 +1181,20 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_return =
+          require_type::require_java_generic_type(
+            function_call.return_type(),
+            {{require_type::type_argument_kindt::Inst,
+               "java::GenericTwoParam"}});
+
+        const typet &type_argument_1 =
+          generic_return.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          function_call.return_type(),
-          {{require_type::type_parameter_kindt::Inst,
-            "java::GenericTwoParam"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"},
+           {require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -929,13 +1220,20 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_return =
+          require_type::require_java_generic_type(
+            function_call.return_type(),
+            {{require_type::type_argument_kindt::Inst,
+               "java::GenericTwoParam"}});
+
+        const typet &type_argument_1 =
+          generic_return.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          function_call.return_type(),
-          {{require_type::type_parameter_kindt::Inst,
-            "java::GenericTwoParam"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"},
+           {require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -961,13 +1259,24 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_return =
+          require_type::require_java_generic_type(
+            function_call.return_type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"},
+             {require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_return.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          function_call.return_type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"},
-           {require_type::type_parameter_kindt::Inst, "java::Generic"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
+        const typet &type_argument_2 =
+          generic_return.generic_type_arguments().at(1);
+        require_type::require_java_generic_type(
+          type_argument_2,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
       }
     }
   }
@@ -993,13 +1302,24 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_return =
+          require_type::require_java_generic_type(
+            function_call.return_type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"},
+             {require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_return.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          function_call.return_type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"},
-           {require_type::type_parameter_kindt::Inst, "java::Generic"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"}});
+        const typet &type_argument_2 =
+          generic_return.generic_type_arguments().at(1);
+        require_type::require_java_generic_type(
+          type_argument_2,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -1025,13 +1345,24 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_return =
+          require_type::require_java_generic_type(
+            function_call.return_type(),
+            {{require_type::type_argument_kindt::Inst, "java::Generic"},
+             {require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_return.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          function_call.return_type(),
-          {{require_type::type_parameter_kindt::Inst, "java::Generic"},
-           {require_type::type_parameter_kindt::Inst, "java::Generic"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
+        const typet &type_argument_2 =
+          generic_return.generic_type_arguments().at(1);
+        require_type::require_java_generic_type(
+          type_argument_2,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -1057,15 +1388,20 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_return =
+          require_type::require_java_generic_type(
+            function_call.return_type(),
+            {{require_type::type_argument_kindt::Inst,
+               "java::Generic"},
+             {require_type::type_argument_kindt::Inst,
+               "java::Interface_Implementation"}});
+
+        const typet &type_argument_1 =
+          generic_return.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          function_call.return_type(),
-          {{require_type::type_parameter_kindt::Inst,
-             "java::Generic"},
-           {require_type::type_parameter_kindt::Inst,
-             "java::Interface_Implementation"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -1091,15 +1427,26 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_return =
+          require_type::require_java_generic_type(
+            function_call.return_type(),
+            {{require_type::type_argument_kindt::Inst,
+               "java::Generic"},
+             {require_type::type_argument_kindt::Inst,
+               "java::Interface_Implementation"}});
+
+        const typet &type_argument_1 =
+          generic_return.generic_type_arguments().at(0);
+        const java_generic_typet &generic_type_argument_1 =
+          require_type::require_java_generic_type(
+            type_argument_1,
+            {{require_type::type_argument_kindt::Inst, "java::Generic"}});
+        const typet &type_argument_1_1 =
+          generic_type_argument_1.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          function_call.return_type(),
-          {{require_type::type_parameter_kindt::Inst,
-             "java::Generic"},
-           {require_type::type_parameter_kindt::Inst,
-             "java::Interface_Implementation"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
@@ -1125,13 +1472,20 @@ SCENARIO(
 
       THEN("The pointer should be generic")
       {
+        const java_generic_typet &generic_return =
+          require_type::require_java_generic_type(
+            function_call.return_type(),
+            {{require_type::type_argument_kindt::Inst, "java::GenericTwoParam"},
+             {require_type::type_argument_kindt::Inst, "java::Generic"}});
+
+        const typet &type_argument_1 =
+          generic_return.generic_type_arguments().at(0);
         require_type::require_java_generic_type(
-          function_call.return_type(),
-          {{require_type::type_parameter_kindt::Inst, "java::GenericTwoParam"},
-           {require_type::type_parameter_kindt::Inst, "java::Generic"}});
-
-        // TODO: extend tests when nested generics are parsed correctly - issue
-        // TG-1301
+          type_argument_1,
+          {{require_type::type_argument_kindt::Inst,
+             "java::Interface_Implementation"},
+           {require_type::type_argument_kindt::Inst,
+             "java::java.lang.Integer"}});
       }
     }
   }
diff --git a/unit/testing-utils/generic_utils.cpp b/unit/testing-utils/generic_utils.cpp
index c0582378ef6..e15276e7bd2 100644
--- a/unit/testing-utils/generic_utils.cpp
+++ b/unit/testing-utils/generic_utils.cpp
@@ -25,10 +25,10 @@ void generic_utils::specialise_generic(
 {
   // Should be a fully instantiated generic type
   REQUIRE(
-    std::all_of(
-      example_type.generic_type_variables().begin(),
-      example_type.generic_type_variables().end(),
-      is_java_generic_inst_parameter));
+    std::none_of(
+      example_type.generic_type_arguments().begin(),
+      example_type.generic_type_arguments().end(),
+      is_java_generic_parameter));
 
   namespacet ns(new_symbol_table);
   const typet &class_type = ns.follow(example_type.subtype());
diff --git a/unit/testing-utils/require_type.cpp b/unit/testing-utils/require_type.cpp
index 8c338d29629..597b3c034e0 100644
--- a/unit/testing-utils/require_type.cpp
+++ b/unit/testing-utils/require_type.cpp
@@ -93,26 +93,32 @@ code_typet::parametert require_type::require_parameter(
   return *param;
 }
 
-/// Helper function for testing that java_generic_parametert types match
+/// Helper function for testing that java generic type arguments match
 /// a given expectation.
-/// \param param The generic parameter to test
-/// \param expected The expected value of the parameter
-/// \return true if the generic parameter type meets the expectations
-bool require_java_generic_parametert_expectation(
-  const java_generic_parametert &param,
-  const require_type::expected_type_parametert &expected)
+/// \param type_argument The generic type argument to test
+/// \param expected The expected value of the argument
+/// \return true if the generic type argument meets the expectations
+bool require_java_generic_type_argument_expectation(
+  const reference_typet &type_argument,
+  const require_type::expected_type_argumentt &expected)
 {
   switch(expected.kind)
   {
-  case require_type::type_parameter_kindt::Var:
-    REQUIRE(!is_java_generic_inst_parameter((param)));
-    REQUIRE(param.type_variable().get_identifier() == expected.description);
+  case require_type::type_argument_kindt::Var:
+  {
+    REQUIRE(is_java_generic_parameter((type_argument)));
+    java_generic_parametert parameter =
+      to_java_generic_parameter(type_argument);
+    REQUIRE(parameter.type_variable().get_identifier() == expected.description);
     return true;
-  case require_type::type_parameter_kindt::Inst:
-    REQUIRE(is_java_generic_inst_parameter((param)));
-    REQUIRE(param.subtype() == symbol_typet(expected.description));
+  }
+  case require_type::type_argument_kindt::Inst:
+  {
+    REQUIRE(!is_java_generic_parameter(type_argument));
+    REQUIRE(type_argument.subtype() == symbol_typet(expected.description));
     return true;
   }
+  }
   // Should be unreachable...
   REQUIRE(false);
   return false;
@@ -128,39 +134,38 @@ java_generic_typet require_type::require_java_generic_type(const typet &type)
 }
 
 /// Verify a given type is a java_generic_type, checking
-/// that it's associated type variables match a given set of identifiers.
+/// that it's associated type arguments match a given set of identifiers.
 /// Expected usage is something like this:
 ///
 /// require_java_generic_type(type,
-///   {{require_type::type_parameter_kindt::Inst, "java::java.lang.Integer"},
-///    {require_type::type_parameter_kindt::Var, "T"}})
+///   {{require_type::type_argument_kindt::Inst, "java::java.lang.Integer"},
+///    {require_type::type_argument_kindt::Var, "T"}})
 ///
 /// \param type The type to check
-/// \param type_expectations A set of type variable kinds
-/// and identifiers which should be expected as the type parameters of the
-/// given generic type.
+/// \param type_expectations A set of type argument kinds and identifiers
+///  which should be expected as the type arguments of the given generic type.
 /// \return The given type, cast to a java_generic_typet
 java_generic_typet require_type::require_java_generic_type(
   const typet &type,
-  const require_type::expected_type_parameterst &type_expectations)
+  const require_type::expected_type_argumentst &type_expectations)
 {
   const java_generic_typet &generic_type =
     require_type::require_java_generic_type(type);
 
-  const java_generic_typet::generic_type_variablest &generic_type_vars =
-    generic_type.generic_type_variables();
-  REQUIRE(generic_type_vars.size() == type_expectations.size());
+  const java_generic_typet::generic_type_argumentst &generic_type_arguments =
+    generic_type.generic_type_arguments();
+  REQUIRE(generic_type_arguments.size() == type_expectations.size());
   REQUIRE(
     std::equal(
-      generic_type_vars.begin(),
-      generic_type_vars.end(),
+      generic_type_arguments.begin(),
+      generic_type_arguments.end(),
       type_expectations.begin(),
-      require_java_generic_parametert_expectation));
+      require_java_generic_type_argument_expectation));
 
   return generic_type;
 }
 
-/// Verify a given type is a java_generic_parameter
+/// Verify a given type is a java_generic_parameter, e.g., `T`
 /// \param type The type to check
 /// \return The type, cast to a java_generic_parametert
 java_generic_parametert
@@ -170,32 +175,22 @@ require_type::require_java_generic_parameter(const typet &type)
   return to_java_generic_parameter(type);
 }
 
-/// Verify a given type is a java_generic_parameter, checking
-/// that it's associated type variables match a given set of expectations.
+/// Verify a given type is a java_generic_parametert with the given name.
 /// Expected usage is something like this:
-///
-/// require_java_generic_parameter(parameter,
-///     {require_type::type_parameter_kindt::Inst,"java::java.lang.Integer"})
-///
-/// or
-///
-/// require_java_generic_parameter(parameter,
-///     {require_type::type_parameter_kindt::Var,"T"})
-///
+/// require_java_generic_parameter(parameter, "java::Generic::T")
 /// \param type The type to check
-/// \param type_expectation A description of the identifiers/kinds
-/// which / should be expected as the type parameter of the generic parameter.
+/// \param parameter String with the parameter name.
 /// \return The given type, cast to a java_generic_parametert
 java_generic_parametert require_type::require_java_generic_parameter(
   const typet &type,
-  const require_type::expected_type_parametert &type_expectation)
+  const irep_idt &parameter)
 {
   const java_generic_parametert &generic_param =
     require_type::require_java_generic_parameter(type);
 
   REQUIRE(
-    require_java_generic_parametert_expectation(
-      generic_param, type_expectation));
+    require_java_generic_type_argument_expectation(
+      generic_param, {require_type::type_argument_kindt::Var, parameter}));
 
   return generic_param;
 }
@@ -211,7 +206,6 @@ const typet &require_type::require_java_non_generic_type(
 {
   REQUIRE(!is_java_generic_parameter(type));
   REQUIRE(!is_java_generic_type(type));
-  REQUIRE(!is_java_generic_inst_parameter(type));
   if(expect_subtype)
     REQUIRE(type.subtype() == expect_subtype.value());
   return type;
@@ -269,7 +263,7 @@ java_generic_class_typet require_type::require_java_generic_class(
       generic_type_vars.begin(),
       [](const irep_idt &type_var_name, const java_generic_parametert &param)
       {
-        REQUIRE(!is_java_generic_inst_parameter((param)));
+        REQUIRE(is_java_generic_parameter(param));
         return param.type_variable().get_identifier() == type_var_name;
       }));
 
diff --git a/unit/testing-utils/require_type.h b/unit/testing-utils/require_type.h
index d2fb0504077..bf9da4c2bfb 100644
--- a/unit/testing-utils/require_type.h
+++ b/unit/testing-utils/require_type.h
@@ -39,32 +39,32 @@ require_parameter(const code_typet &function_type, const irep_idt &param_name);
 
 code_typet require_code(const typet &type, const size_t num_params);
 
-// A mini DSL for describing an expected set of type parameters for a
+// A mini DSL for describing an expected set of type arguments for a
 // java_generic_typet
-enum class type_parameter_kindt
+enum class type_argument_kindt
 {
   Inst,
   Var
 };
-struct expected_type_parametert
+struct expected_type_argumentt
 {
-  type_parameter_kindt kind;
+  type_argument_kindt kind;
   irep_idt description;
 };
-typedef std::initializer_list<expected_type_parametert>
-  expected_type_parameterst;
+typedef std::initializer_list<expected_type_argumentt>
+  expected_type_argumentst;
 
 java_generic_typet require_java_generic_type(const typet &type);
 
 java_generic_typet require_java_generic_type(
   const typet &type,
-  const require_type::expected_type_parameterst &type_expectations);
+  const require_type::expected_type_argumentst &type_expectations);
 
 java_generic_parametert require_java_generic_parameter(const typet &type);
 
 java_generic_parametert require_java_generic_parameter(
   const typet &type,
-  const require_type::expected_type_parametert &type_expectation);
+  const irep_idt &parameter);
 
 const typet &require_java_non_generic_type(
   const typet &type,
@@ -74,7 +74,7 @@ java_generic_class_typet require_java_generic_class(const typet &class_type);
 
 java_generic_class_typet require_java_generic_class(
   const typet &class_type,
-  const std::initializer_list<irep_idt> &type_variables);
+  const std::initializer_list<irep_idt> &type_parameters);
 
 java_class_typet require_java_non_generic_class(const typet &class_type);
 }