fix broken generic cases; add root type generics resolution from bounds

Author: xvik

CHANGELOG.md

@@ -1,3 +1,6 @@
+* Root class generics now resolved (from generic bounds)
+* Support broken hierarchies parsing (when root class generic passed or when target class did not set generics (as with root generics resolved from signature))
+
 ### 1.1.0 (2014-12-15)
 
 * Add wildcards support

README.md

@@ -67,7 +67,8 @@ Class hierarchy needs to be parsed to properly resolve all generics:
 GenericsContext context = GenericsResolver.resolve(Root.class)
 ```
 
-If root class also contains generics, they will not be resolved (it's impossible).
+If root class also contains generics, they are resolved by generic bound (e.g. `<T extends Model>` will be resolved as T=Model.class, and
+resolved as Object.class when no bounds set)
 
 Resolved class hierarchy is cached internally, so it's cheap to resolve single class few times.
 
@@ -104,7 +105,7 @@ All classes in root class hierarchy may be obtained like this:
 context.getGenericsInfo().getComposingTypes()
 ```
 
-This will be all classes (and interfaces) in hierarchy, even if they not contain generics.
+This will be all classes and interfaces in hierarchy (including root class), even if they not contain generics.
 
 #### Obtaining class generics
 

src/main/java/ru/vyarus/java/generics/resolver/GenericsResolver.java

@@ -15,8 +15,8 @@ private GenericsResolver() {
     }
 
     /**
-     * By default returned context set on root class, which can't be introspected (because only parent class hods
-     * generics information for current class). To use it switch context to required type from hierarchy:
+     * By default returned context set on root class (but generic types for root class will be resolved from specified
+     * generics bounds). To use it switch context to required type from hierarchy:
      * {@code returnedContext.type(SomeTypeFromHierarchy.class)}.
      * <p>Note: when ignore classes provided, produced {@code GenericsInfo} instance will not be cached
      * (and full version from cache will not be used also)</p>

src/main/java/ru/vyarus/java/generics/resolver/context/GenericsContext.java

@@ -38,8 +38,7 @@ public GenericsContext(final GenericsInfo genericsInfo, final Class<?> type) {
         this.genericsInfo = genericsInfo;
         this.currentType = type;
         // collection resolved for fail fast on wrong type
-        typeGenerics = type == genericsInfo.getRootClass() ? Collections.<String, Type>emptyMap()
-                : genericsInfo.getTypeGenerics(type);
+        typeGenerics = genericsInfo.getTypeGenerics(type);
     }
 
     /**

src/main/java/ru/vyarus/java/generics/resolver/util/GenericInfoUtils.java

@@ -14,8 +14,10 @@
  * @author Vyacheslav Rusakov
  * @since 15.12.2014
  */
+// LinkedHashMap used instead of usual map to avoid accidental simple map usage (order is important!)
+@SuppressWarnings("PMD.LooseCoupling")
 public final class GenericInfoUtils {
-    @SuppressWarnings("PMD.LooseCoupling")
+
     private static final LinkedHashMap<String, Type> EMPTY_MAP = new LinkedHashMap<String, Type>(0);
     private static final String GROOVY_OBJECT = "GroovyObject";
 
@@ -25,6 +27,12 @@ private GenericInfoUtils() {
     public static GenericsInfo create(final Class<?> type, final Class<?>... ignoreClasses) {
         final Map<Class<?>, LinkedHashMap<String, Type>> generics =
                 new HashMap<Class<?>, LinkedHashMap<String, Type>>();
+        if (type.getTypeParameters().length > 0) {
+            // special case: root class also contains generics
+            generics.put(type, resolveRawGenerics(type.getTypeParameters()));
+        } else {
+            generics.put(type, EMPTY_MAP);
+        }
         analyzeType(generics, type, Arrays.asList(ignoreClasses));
         return new GenericsInfo(type, generics);
     }
@@ -63,6 +71,9 @@ private static void analyzeInterface(final Map<Class<?>, LinkedHashMap<String, T
                                     + "can't properly resolve generics.", interfaceType.getName()));
                 }
                 types.put(interfaceType, generics);
+            } else if (interfaceType.getTypeParameters().length > 0) {
+                // root class didn't declare generics
+                types.put(interfaceType, resolveRawGenerics(interfaceType.getTypeParameters()));
             } else if (!GROOVY_OBJECT.equals(interfaceType.getSimpleName())) {
                 // avoid groovy specific interface (all groovy objects implements it)
                 types.put(interfaceType, EMPTY_MAP);
@@ -71,20 +82,20 @@ private static void analyzeInterface(final Map<Class<?>, LinkedHashMap<String, T
         }
     }
 
-    // LinkedHashMap used instead of usual map to avoid accidental simple map usage (order is important!)
-    @SuppressWarnings("PMD.LooseCoupling")
     private static LinkedHashMap<String, Type> analyzeParent(final Class type,
                                                              final Map<String, Type> rootGenerics) {
         LinkedHashMap<String, Type> generics = null;
         final Class parent = type.getSuperclass();
         if (!type.isInterface() && parent != null && parent != Object.class
                 && type.getGenericSuperclass() instanceof ParameterizedType) {
             generics = resolveGenerics((ParameterizedType) type.getGenericSuperclass(), rootGenerics);
+        } else if (parent != null && parent.getTypeParameters().length > 0) {
+            // root class didn't declare generics
+            generics = resolveRawGenerics(parent.getTypeParameters());
         }
         return generics == null ? EMPTY_MAP : generics;
     }
 
-    @SuppressWarnings("PMD.LooseCoupling")
     private static LinkedHashMap<String, Type> resolveGenerics(final ParameterizedType type,
                                                                final Map<String, Type> rootGenerics) {
         final LinkedHashMap<String, Type> generics = new LinkedHashMap<String, Type>();
@@ -130,4 +141,13 @@ private static Type[] resolve(final Type[] types, final Map<String, Type> rootGe
         }
         return resolved;
     }
+
+    private static LinkedHashMap<String, Type> resolveRawGenerics(
+            final TypeVariable... declaredGenerics) {
+        final LinkedHashMap<String, Type> generics = new LinkedHashMap<String, Type>();
+        for (TypeVariable type : declaredGenerics) {
+            generics.put(type.getName(), resolveActualType(type.getBounds()[0], Collections.<String, Type>emptyMap()));
+        }
+        return generics;
+    }
 }

src/test/groovy/ru/vyarus/java/generics/resolver/BrokenHierarchyTest.groovy

@@ -0,0 +1,47 @@
+package ru.vyarus.java.generics.resolver
+
+import ru.vyarus.java.generics.resolver.context.GenericsContext
+import ru.vyarus.java.generics.resolver.support.brokenhieararchy.BrokenHierarchyBase
+import ru.vyarus.java.generics.resolver.support.brokenhieararchy.BrokenHierarchyInterface
+import ru.vyarus.java.generics.resolver.support.brokenhieararchy.BrokenHierarchyRoot
+import ru.vyarus.java.generics.resolver.support.brokenhieararchy.BypassGenericRoot
+import spock.lang.Specification
+
+import java.util.concurrent.Callable
+
+
+/**
+ * @author Vyacheslav Rusakov 
+ * @since 11.02.2015
+ */
+class BrokenHierarchyTest extends Specification {
+    def "Check broken hierarchy resolution"() {
+
+        when: "resolving class with no generics set"
+        GenericsContext context = GenericsResolver.resolve(BrokenHierarchyRoot).type(BrokenHierarchyBase)
+        then: "generics resolved just from generic bound"
+        context.generic("T") == Callable
+        context.generic("K") == Object
+
+        when: "resolving interface with no generics set"
+        context = context.type(BrokenHierarchyInterface)
+        then: "generics resolved just from generic bound"
+        context.generic("T") == Callable
+        context.generic("K") == Object
+    }
+
+    def "Check bypass generic case"() {
+
+        when: "root class bypass it's own generics"
+        GenericsContext context = GenericsResolver.resolve(BypassGenericRoot).type(BrokenHierarchyBase)
+        then: "generic resolved from root generic bound, but generic bound become lower"
+        context.generic("T") == Callable
+        context.generic("K") == Object
+
+        when: "resolving interface with no generics set"
+        context = context.type(BrokenHierarchyInterface)
+        then: "generics resolved just from generic bound"
+        context.generic("T") == Callable
+        context.generic("K") == Object
+    }
+}

src/test/groovy/ru/vyarus/java/generics/resolver/FailTests.groovy

@@ -37,7 +37,7 @@ class FailTests extends Specification {
         when: "resolving type with duplicate Runnable interface in hierarchy"
         GenericsContext context = GenericsResolver.resolve(NoClashRoot)
         then: "context is empty, because no generics info available in hierarchy"
-        context.genericsInfo.composingTypes == [NoClashSub1, NoClashSub2, Runnable, Callable] as Set
+        context.genericsInfo.composingTypes == [NoClashRoot, NoClashSub1, NoClashSub2, Runnable, Callable] as Set
     }
 
     def "Check access with wrong name"() {

src/test/groovy/ru/vyarus/java/generics/resolver/GenericsInfoFactoryTest.groovy

@@ -22,7 +22,7 @@ class GenericsInfoFactoryTest extends Specification {
         GenericsInfo info = GenericsInfoFactory.create(Root)
         then: "correct generic values resolved"
         info.rootClass == Root
-        info.composingTypes.size() == 7
+        info.composingTypes.size() == 8
         info.getTypeGenerics(Base1) == ['T': Model]
         info.getTypeGenerics(Base2) == ['K': Model, 'P': OtherModel]
         info.getTypeGenerics(Lvl2Base1) == ['I': Model]
@@ -37,7 +37,7 @@ class GenericsInfoFactoryTest extends Specification {
         info = GenericsInfoFactory.create(BeanRoot)
         then: "correct generic values resolved"
         info.rootClass == BeanRoot
-        info.composingTypes.size() == 3
+        info.composingTypes.size() == 4
         info.getTypeGenerics(BeanBase) == ['T': Model]
         info.getTypeGenerics(Lvl2BeanBase) == ['I': Model]
         info.getTypeGenerics(Lvl2Base1) == ['I': Model]

src/test/groovy/ru/vyarus/java/generics/resolver/IgnoreTest.groovy

@@ -28,6 +28,6 @@ class IgnoreTest extends Specification {
         when: "using ignore to limit class resolution depth"
         context = GenericsResolver.resolve(BeanRoot, Lvl2BeanBase)
         then: "only root types resolved"
-        context.genericsInfo.composingTypes == [BeanBase, Lvl2Base1] as Set
+        context.genericsInfo.composingTypes == [BeanRoot, BeanBase, Lvl2Base1] as Set
     }
 }

src/test/groovy/ru/vyarus/java/generics/resolver/SingleClassResolution.groovy

@@ -0,0 +1,26 @@
+package ru.vyarus.java.generics.resolver
+
+import ru.vyarus.java.generics.resolver.context.GenericsContext
+import ru.vyarus.java.generics.resolver.support.brokenhieararchy.BrokenHierarchyInterface
+import spock.lang.Specification
+
+import java.util.concurrent.Callable
+
+
+/**
+ * @author Vyacheslav Rusakov 
+ * @since 12.02.2015
+ */
+class SingleClassResolution extends Specification {
+
+    def "Check root class generics resolved"() {
+
+        when: "resolving single class without hierarchy"
+        GenericsContext context = GenericsResolver.resolve(BrokenHierarchyInterface)
+        then: "root generics resolved from bounds"
+        context.generic("T") == Callable
+        context.generic("K") == Object
+
+
+    }
+}