Merge pull request #1763 from jeannielynnmoulton/base_class_info_tg1287

[TG-1287] Parsing generic information of base classes

Author: Thomas Kiley

src/java_bytecode/java_bytecode_convert_class.cpp

@@ -27,6 +27,7 @@ Author: Daniel Kroening, kroening@kroening.com
 #include <util/std_expr.h>
 
 #include <linking/zero_initializer.h>
+#include <util/suffix.h>
 
 class java_bytecode_convert_classt:public messaget
 {
@@ -85,6 +86,83 @@ class java_bytecode_convert_classt:public messaget
   static void add_array_types(symbol_tablet &symbol_table);
 };
 
+/// Auxiliary function to extract the generic superclass reference from the
+/// class signature. If the signature is empty or the superclass is not generic
+/// it returns empty.
+/// Example:
+/// - class: A<T> extends B<T, Integer> implements C, D<T>
+/// - signature: <T:Ljava/lang/Object;>B<TT;Ljava/lang/Integer;>;LC;LD<TT;>;
+/// - returned superclass reference: B<TT;Ljava/lang/Integer;>;
+/// \param signature Signature of the class
+/// \return Reference of the generic superclass, or empty if the superclass
+/// is not generic
+static optionalt<std::string>
+extract_generic_superclass_reference(const optionalt<std::string> &signature)
+{
+  if(signature.has_value())
+  {
+    // skip the (potential) list of generic parameters at the beginning of the
+    // signature
+    const size_t start =
+      signature.value().front() == '<'
+        ? find_closing_delimiter(signature.value(), 0, '<', '>') + 1
+        : 0;
+
+    // extract the superclass reference
+    const size_t end =
+      find_closing_semi_colon_for_reference_type(signature.value(), start);
+    const std::string superclass_ref =
+      signature.value().substr(start, (end - start) + 1);
+
+    // if the superclass is generic then the reference is of form
+    // Lsuperclass-name<generic-types;>;
+    if(has_suffix(superclass_ref, ">;"))
+      return superclass_ref;
+  }
+  return {};
+}
+
+/// Auxiliary function to extract the generic interface reference of an
+/// interface with the specified name from the class signature. If the
+/// signature is empty or the interface is not generic it returns empty.
+/// Example:
+/// - class: A<T> extends B<T, Integer> implements C, D<T>
+/// - signature: <T:Ljava/lang/Object;>B<TT;Ljava/lang/Integer;>;LC;LD<TT;>;
+/// - returned interface reference for C: LC;
+/// - returned interface reference for D: LD<TT;>;
+/// \param signature Signature of the class
+/// \param interface_name The interface name
+/// \return Reference of the generic interface, or empty if the interface
+/// is not generic
+static optionalt<std::string> extract_generic_interface_reference(
+  const optionalt<std::string> &signature,
+  const std::string &interface_name)
+{
+  if(signature.has_value())
+  {
+    // skip the (potential) list of generic parameters at the beginning of the
+    // signature
+    size_t start =
+      signature.value().front() == '<'
+        ? find_closing_delimiter(signature.value(), 0, '<', '>') + 1
+        : 0;
+
+    // skip the superclass reference (if there is at least one interface
+    // reference in the signature, then there is a superclass reference)
+    start =
+      find_closing_semi_colon_for_reference_type(signature.value(), start) + 1;
+
+    start = signature.value().find("L" + interface_name + "<", start);
+    if(start != std::string::npos)
+    {
+      const size_t &end =
+        find_closing_semi_colon_for_reference_type(signature.value(), start);
+      return signature.value().substr(start, (end - start) + 1);
+    }
+  }
+  return {};
+}
+
 void java_bytecode_convert_classt::convert(const classt &c)
 {
   std::string qualified_classname="java::"+id2string(c.name);
@@ -145,10 +223,26 @@ void java_bytecode_convert_classt::convert(const classt &c)
 
   if(!c.extends.empty())
   {
-    symbol_typet base("java::"+id2string(c.extends));
-    class_type.add_base(base);
+    const symbol_typet base("java::" + id2string(c.extends));
+
+    // if the superclass is generic then the class has the superclass reference
+    // including the generic info in its signature
+    // e.g., signature for class 'A<T>' that extends
+    // 'Generic<Integer>' is '<T:Ljava/lang/Object;>LGeneric<LInteger;>;'
+    const optionalt<std::string> &superclass_ref =
+      extract_generic_superclass_reference(c.signature);
+    if(superclass_ref.has_value())
+    {
+      const java_generic_symbol_typet generic_base(
+        base, superclass_ref.value(), qualified_classname);
+      class_type.add_base(generic_base);
+    }
+    else
+    {
+      class_type.add_base(base);
+    }
     class_typet::componentt base_class_field;
-    base_class_field.type()=base;
+    base_class_field.type() = class_type.bases().at(0).type();
     base_class_field.set_name("@"+id2string(c.extends));
     base_class_field.set_base_name("@"+id2string(c.extends));
     base_class_field.set_pretty_name("@"+id2string(c.extends));
@@ -158,8 +252,24 @@ void java_bytecode_convert_classt::convert(const classt &c)
   // interfaces are recorded as bases
   for(const auto &interface : c.implements)
   {
-    symbol_typet base("java::"+id2string(interface));
-    class_type.add_base(base);
+    const symbol_typet base("java::" + id2string(interface));
+
+    // if the interface is generic then the class has the interface reference
+    // including the generic info in its signature
+    // e.g., signature for class 'A implements GenericInterface<Integer>' is
+    // 'Ljava/lang/Object;LGenericInterface<LInteger;>;'
+    const optionalt<std::string> interface_ref =
+      extract_generic_interface_reference(c.signature, id2string(interface));
+    if(interface_ref.has_value())
+    {
+      const java_generic_symbol_typet generic_base(
+        base, interface_ref.value(), qualified_classname);
+      class_type.add_base(generic_base);
+    }
+    else
+    {
+      class_type.add_base(base);
+    }
   }
 
   // produce class symbol
@@ -598,6 +708,15 @@ static void find_and_replace_parameters(
       find_and_replace_parameters(argument, replacement_parameters);
     }
   }
+  else if(is_java_generic_symbol_type(type))
+  {
+    java_generic_symbol_typet &generic_base = to_java_generic_symbol_type(type);
+    std::vector<reference_typet> &gen_types = generic_base.generic_types();
+    for(auto &gen_type : gen_types)
+    {
+      find_and_replace_parameters(gen_type, replacement_parameters);
+    }
+  }
 }
 
 /// Checks if the class is implicitly generic, i.e., it is an inner class of
@@ -675,5 +794,11 @@ void mark_java_implicitly_generic_class_type(
       find_and_replace_parameters(
         field.type(), implicit_generic_type_parameters);
     }
+
+    for(auto &base : class_type.bases())
+    {
+      find_and_replace_parameters(
+        base.type(), implicit_generic_type_parameters);
+    }
   }
 }

src/java_bytecode/java_types.h

@@ -522,6 +522,65 @@ to_java_specialized_generic_class_type(typet &type)
   return static_cast<const java_specialized_generic_class_typet &>(type);
 }
 
+/// Type for a generic symbol, extends symbol_typet with a
+/// vector of java generic types.
+/// This is used to store the type of generic superclasses and interfaces.
+class java_generic_symbol_typet : public symbol_typet
+{
+public:
+  typedef std::vector<reference_typet> generic_typest;
+
+  java_generic_symbol_typet(
+    const symbol_typet &type,
+    const std::string &base_ref,
+    const std::string &class_name_prefix)
+    : symbol_typet(type)
+  {
+    set(ID_C_java_generic_symbol, true);
+    const typet &base_type = java_type_from_string(base_ref, class_name_prefix);
+    PRECONDITION(is_java_generic_type(base_type));
+    const java_generic_typet gen_base_type = to_java_generic_type(base_type);
+    generic_types().insert(
+      generic_types().end(),
+      gen_base_type.generic_type_arguments().begin(),
+      gen_base_type.generic_type_arguments().end());
+  }
+
+  const generic_typest &generic_types() const
+  {
+    return (const generic_typest &)(find(ID_generic_types).get_sub());
+  }
+
+  generic_typest &generic_types()
+  {
+    return (generic_typest &)(add(ID_generic_types).get_sub());
+  }
+};
+
+/// \param type: the type to check
+/// \return true if the type is a symbol type with generics
+inline bool is_java_generic_symbol_type(const typet &type)
+{
+  return type.get_bool(ID_C_java_generic_symbol);
+}
+
+/// \param type: the type to convert
+/// \return the converted type
+inline const java_generic_symbol_typet &
+to_java_generic_symbol_type(const typet &type)
+{
+  PRECONDITION(is_java_generic_symbol_type(type));
+  return static_cast<const java_generic_symbol_typet &>(type);
+}
+
+/// \param type: the type to convert
+/// \return the converted type
+inline java_generic_symbol_typet &to_java_generic_symbol_type(typet &type)
+{
+  PRECONDITION(is_java_generic_symbol_type(type));
+  return static_cast<java_generic_symbol_typet &>(type);
+}
+
 /// Take a signature string and remove everything in angle brackets allowing for
 /// the type to be parsed normally, for example
 /// `java.util.HashSet<java.lang.Integer>` will be turned into

src/util/irep_ids.def

@@ -832,6 +832,7 @@ 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(C_specialized_generic_java_class, #specialized_generic_java_class)
 IREP_ID_TWO(C_java_implicitly_generic_class_type, #java_implicitly_generic_class_type)
+IREP_ID_TWO(C_java_generic_symbol, #java_generic_symbol)
 IREP_ID_TWO(generic_types, #generic_types)
 IREP_ID_TWO(implicit_generic_types, #implicit_generic_types)
 IREP_ID_TWO(type_variables, #type_variables)

unit/java_bytecode/java_bytecode_parse_generics/ContainsInnerClass$InnerClass.class

@@ -0,0 +1,171 @@
+public class DerivedGenerics {
+    DerivedGenericInst new1;
+    DerivedGenericInst2 new2;
+    DerivedGenericUninst<Integer> new3;
+    DerivedGenericMixed1<String> new4;
+    DerivedGenericMixed2<String> new5;
+    ContainsInnerClass new6;
+    ContainsInnerClassGeneric<String> new7;
+    ThreeHierarchy new8;
+    ImplementsInterfaceGenericSpecialised new9;
+    ImplementsInterfaceGenericUnspec<String> new10;
+    ImplementsMultipleInterfaces new11;
+    ExtendsAndImplements new12;
+    ExtendsAndImplementsGeneric new13;
+    ExtendsAndImplementsSameInterface new14;
+    ExtendsAndImplementsSameInterface2 new15;
+    ExtendsAndImplementsSameInterfaceGeneric new16;
+}
+
+class DerivedGenericInst extends Generic<Interface_Implementation>
+{
+    // This class is to test instantiating a non-generic subclass of a generic class
+    // with the base class having only one type parameter.
+}
+
+class DerivedGenericInst2 extends
+GenericTwoParam<Interface_Implementation,Integer>
+{
+    // This class is to test instantiating a non-generic subclass of a generic class
+    // with the base class having two type parameters.
+}
+
+class DerivedGenericUninst<T> extends Generic<T>
+{
+    T newField;
+
+    // This class is to test instantiating a generic subclass of a generic class
+    // with the base class having only one parameter, but the type parameter is
+    // not specialised.
+}
+
+class DerivedGenericMixed1<T> extends Generic<Interface_Implementation>
+{
+    T newField;
+
+    // This class is to test instantiating a generic subclass of a generic class
+    // with the base class having only one type parameter.
+}
+
+class DerivedGenericMixed2<T> extends GenericTwoParam<T, Integer>
+{
+    T newField;
+
+    // This class is to test instantiating a generic subclass of a generic class
+    // with the base class having two type parameters, where one is specialised
+    // and the other is not.
+}
+
+class ContainsInnerClass {
+
+    InnerClass ic;
+    InnerClassGeneric<String> icg;
+
+    // This class is to test inner classes that extend generic types.
+    class InnerClass extends Generic<Integer> {
+    }
+
+    class InnerClassGeneric<T> extends Generic<T> {
+    }
+}
+
+class ContainsInnerClassGeneric<T> {
+
+    InnerClass ic;
+
+    // This class is to test inner classes that extend generic types when the
+    // outer class in generic.
+    class InnerClass extends Generic<T> {
+    }
+}
+
+class ThreeHierarchy extends DerivedGenericMixed2<String> {
+
+    // This class extends a specialised class that extends another generic
+    // class.
+
+}
+
+class ImplementsInterfaceGenericSpecialised implements InterfaceGeneric<Integer>
+ {
+
+    public Integer someMethod() {
+        return 0;
+    }
+
+}
+
+class ImplementsInterfaceGenericUnspec<E> implements InterfaceGeneric<E> {
+
+    public E someMethod() {
+        return null;
+    }
+
+}
+
+class ImplementsMultipleInterfaces implements
+InterfaceGeneric<Integer>, Interface
+{
+
+  public Integer someMethod() {
+    return 0;
+  }
+
+  public int getX() {
+    return 0;
+  }
+}
+
+class ExtendsAndImplements extends Generic<Integer> implements Interface,
+InterfaceGeneric<Integer>
+{
+  public Integer someMethod() {
+    return 0;
+  }
+
+  public int getX() {
+    return 0;
+  }
+}
+
+class ExtendsAndImplementsGeneric<T> extends GenericTwoParam<T, Integer>
+implements Interface,
+InterfaceGeneric<T>
+{
+  T f;
+
+  public T someMethod() {
+    return f;
+  }
+
+  public int getX() {
+    return 0;
+  }
+}
+
+class ExtendsAndImplementsSameInterface extends Generic<InterfaceGeneric>
+implements InterfaceGeneric<Integer>
+{
+  public Integer someMethod() {
+      return 0;
+  }
+}
+
+class ExtendsAndImplementsSameInterface2 extends
+Generic<InterfaceGeneric<String>>
+implements InterfaceGeneric<Integer>
+{
+  public Integer someMethod() {
+      return 0;
+  }
+}
+
+class ExtendsAndImplementsSameInterfaceGeneric<T> extends
+Generic<InterfaceGeneric> implements InterfaceGeneric<T>
+{
+  T f;
+
+  public T someMethod() {
+      return f;
+  }
+}

unit/java_bytecode/java_bytecode_parse_generics/ContainsInnerClass$InnerClassGeneric.class

@@ -0,0 +1,4 @@
+interface InterfaceGeneric<E>
+{
+    E someMethod();
+}

unit/java_bytecode/java_bytecode_parse_generics/ContainsInnerClass.class

@@ -347,3 +347,50 @@ require_type::require_symbol(const typet &type, const irep_idt &identifier)
   }
   return result;
 }
+
+/// Verify a given type is a java generic symbol type
+/// \param type The type to check
+/// \param identifier The identifier to match
+/// \return The type, cast to a java_generic_symbol_typet
+java_generic_symbol_typet require_type::require_java_generic_symbol_type(
+  const typet &type,
+  const std::string &identifier)
+{
+  symbol_typet symbol_type = require_symbol(type, identifier);
+  REQUIRE(is_java_generic_symbol_type(type));
+  return to_java_generic_symbol_type(type);
+}
+
+/// Verify a given type is a java generic symbol type, checking
+/// that it's associated type arguments match a given set of identifiers.
+/// Expected usage is something like this:
+///
+/// require_java_generic_symbol_type(type, "java::Generic",
+///   {{require_type::type_argument_kindt::Inst, "java::java.lang.Integer"},
+///    {require_type::type_argument_kindt::Var, "T"}})
+///
+/// \param type The type to check
+/// \param identifier The identifier to match
+/// \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_symbol_typet
+java_generic_symbol_typet require_type::require_java_generic_symbol_type(
+  const typet &type,
+  const std::string &identifier,
+  const require_type::expected_type_argumentst &type_expectations)
+{
+  const java_generic_symbol_typet &generic_base_type =
+    require_java_generic_symbol_type(type, identifier);
+
+  const java_generic_typet::generic_type_argumentst &generic_type_arguments =
+    generic_base_type.generic_types();
+  REQUIRE(generic_type_arguments.size() == type_expectations.size());
+  REQUIRE(
+    std::equal(
+      generic_type_arguments.begin(),
+      generic_type_arguments.end(),
+      type_expectations.begin(),
+      require_java_generic_type_argument_expectation));
+
+  return generic_base_type;
+}

unit/java_bytecode/java_bytecode_parse_generics/ContainsInnerClassGeneric$InnerClass.class

@@ -84,6 +84,15 @@ java_implicitly_generic_class_typet require_java_implicitly_generic_class(
   const std::initializer_list<irep_idt> &implicit_type_variables);
 
 java_class_typet require_java_non_generic_class(const typet &class_type);
+
+java_generic_symbol_typet require_java_generic_symbol_type(
+  const typet &type,
+  const std::string &identifier);
+
+java_generic_symbol_typet require_java_generic_symbol_type(
+  const typet &type,
+  const std::string &identifier,
+  const require_type::expected_type_argumentst &type_expectations);
 }
 
 #endif // CPROVER_TESTING_UTILS_REQUIRE_TYPE_H