fix primitive types support (especially for constructors and methods) (backport)

Author: xvik

CHANGELOG.md

@@ -1,9 +1,13 @@
+* Fix failing navigation to primitive constructor or method parameter (#5)      
+* Improve javadoc mentioning primitives behaviour
+
+
 ### 3.0.1 (2019-10-10)
-- Fix cycled declarations detection (Something<T extends Something<T>)
-- Add GenericUtils.orderVariablesForResolution method for ordering type variable declarations
-- Partial (#3) fix: support reversed generics declaration order on class
-- Fix method generics resolution as types instead of classes (#4)
-- Fix constructor generics resolution as types instead of classes 
+* Fix cycled declarations detection (Something<T extends Something<T>)
+* Add GenericUtils.orderVariablesForResolution method for ordering type variable declarations
+* Partial (#3) fix: support reversed generics declaration order on class
+* Fix method generics resolution as types instead of classes (#4)
+* Fix constructor generics resolution as types instead of classes 
 
 ### 3.0.0 (2018-06-19)
 * Add constructor generics support

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

@@ -42,7 +42,7 @@
  * declared directly (e.g. field declaration: {@code Outer<String>.Inner field}) and, in this case, direct
  * declaration is used in priority.
  * <p>
- * It is impossible to to perform incorrect generics resolution through context api: it will either change context
+ * It is impossible to perform incorrect generics resolution through context api: it will either change context
  * automatically or fail with error (with detailed incompatibility explanation).
  *
  * @author Vyacheslav Rusakov
@@ -58,6 +58,10 @@ public abstract class AbstractGenericsContext {
     protected final Map<String, Type> typeGenerics;
 
     public AbstractGenericsContext(final GenericsInfo genericsInfo, final Class<?> type) {
+        if (type.isPrimitive()) {
+            throw new IllegalArgumentException(String.format(
+                    "Primitive type %s can't be used for generics context building", type.getSimpleName()));
+        }
         this.genericsInfo = genericsInfo;
         this.currentType = type;
         // fail on wrong type
@@ -306,6 +310,8 @@ public Class<?> resolveFieldClass(final Field field) {
      * Check if type containing generics, belonging to different context in current hierarchy and
      * automatically change context to properly resolve generics. Fails when it is impossible to correctly
      * resolve generics (preventing incorrect usage).
+     * <p>
+     * For primitive type empty list will be returned.
      *
      * @param type type to resolve generics
      * @return resolved generic classes or empty list if type does not use generics
@@ -339,6 +345,8 @@ public List<Class<?>> resolveFieldGenerics(final Field field) {
      * Check if type containing generics, belonging to different context in current hierarchy and
      * automatically change context to properly resolve generics. Fails when it is impossible to correctly
      * resolve generics (preventing incorrect usage).
+     * <p>
+     * For primitive type null will be returned.
      *
      * @param type type to resolve generic
      * @return first resolved generic or null if type does not use generics
@@ -354,6 +362,8 @@ public Class<?> resolveGenericOf(final Type type) {
      * Use for more informative error message on incorrect usage.
      * <p>
      * Automatically choose correct context or fail if field does not belong to current hierarchy.
+     * <p>
+     * For primitive field null will be returned.
      *
      * @param field field to resolve generic for
      * @return resolved field generic or null if field does not declare generics
@@ -369,6 +379,8 @@ public Class<?> resolveFieldGeneric(final Field field) {
      * (if T == String).
      * <p>
      * Automatically choose correct context or fail if field does not belong to current hierarchy.
+     * <p>
+     * If provided type is primitive then it will be returned as is.
      *
      * @param field field to resolve generics for
      * @return field type with resolved generic variables
@@ -390,6 +402,8 @@ public Type resolveFieldType(final Field field) {
      * Check if type containing generics, belonging to different context in current hierarchy and
      * automatically change context to properly resolve generics. Fails when it is impossible to correctly
      * resolve generics (preventing incorrect usage).
+     * <p>
+     * If provided type is primitive then it will be returned as is.
      *
      * @param type type to resolve named generics in
      * @return type without named generics (replaced by known actual types)
@@ -404,13 +418,15 @@ public Type resolveType(final Type type) {
      * {@code ParameterizedType Map<String, List<T>>} would become
      * {@code [Class String, ParameterizedType List<String>]} (assumed generic T is defined as String).
      * <p>
-     * Note: if type is Class then return raw generics definition (for consistency).
+     * Note: if type is {@code Class} then return raw generics definition (for consistency).
      * <p>
      * Useful when complete generic types are required.
      * <p>
      * Check if type containing generics, belonging to different context in current hierarchy and
      * automatically change context to properly resolve generics. Fails when it is impossible to correctly
      * resolve generics (preventing incorrect usage).
+     * <p>
+     * For primitive type empty list would be returned.
      *
      * @param type type to return resolved generics of
      * @return type generics without variables
@@ -494,6 +510,8 @@ public String toStringType(final Type type) {
      * <p>
      * Note that, in contrast to direct resolution {@code GenericsResolver.resolve(B.class)}, actual root generic
      * would be counted for hierarchy resolution.
+     * <p>
+     * If field declares primitive type then wrapper class would be used instead.
      *
      * @param field field in current class hierarchy to resolve type from (may be field from superclass, relative to
      *              currently selected, in this case context type will be automatically switched)
@@ -549,6 +567,9 @@ public GenericsContext fieldTypeAs(final Field field, final Class<?> asType) {
      * Returned context holds reference to original (root) context: {@link GenericsContext#rootContext()}.
      * <p>
      * Ignored types, used for context creation, are counted (will also be ignored for inlying context building).
+     * <p>
+     * If provided type is primitive then wrapper will be used instead (for example, {@link Integer} instead of
+     * {@link int}).
      *
      * @param type type to resolve hierarchy from (it must be generified type, resolved in current class)
      * @return generics context of type (inlying context)
@@ -573,6 +594,9 @@ public GenericsContext fieldTypeAs(final Field field, final Class<?> asType) {
      * are provided for simpler navigation: {@link #fieldTypeAs(Field, Class)},
      * {@link MethodGenericsContext#returnTypeAs(Class)}, {@link MethodGenericsContext#parameterTypeAs(int, Class)}
      * and {@link ConstructorGenericsContext#parameterTypeAs(int, Class)}.
+     * <p>
+     * If provided type is primitive then wrapper will be used instead (for example, {@link Integer} instead of
+     * {@link int}).
      *
      * @param type   type to resolve actual generics from (it must be generified type, resolved in current class)
      * @param asType required target type to build generics context for (must include declared type as base class)

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

@@ -104,6 +104,10 @@ public List<Class<?>> resolveParameters() {
      * }}</pre>
      * Resolving parameters types in context of root class:
      * {@code constructor(B.class.getConstructor(List.class)).resolveParametersTypes() == [List<Long>]}
+     * <p>
+     * Note: may return primitive because it might be important to differentiate actual value.
+     * Use {@link ru.vyarus.java.generics.resolver.util.TypeUtils#wrapPrimitive(Class)} to box possible primitive,
+     * if required.
      *
      * @return resolved constructor parameters types or empty list if constructor doesn't contain parameters
      * @see #resolveParameters()
@@ -114,6 +118,10 @@ public List<Type> resolveParametersTypes() {
     }
 
     /**
+     * Note: may return primitive because it might be important to differentiate actual value.
+     * Use {@link ru.vyarus.java.generics.resolver.util.TypeUtils#wrapPrimitive(Class)} to box possible primitive,
+     * if required.
+     *
      * @param pos parameter position (form 0)
      * @return parameter type with resolved generic variables
      * @throws IllegalArgumentException if parameter index is incorrect
@@ -135,6 +143,11 @@ public Type resolveParameterType(final int pos) {
      * <p>
      * Note that, in contrast to direct resolution {@code GenericsResolver.resolve(B.class)}, actual root generic
      * would be counted for hierarchy resolution.
+     * <p>
+     * For primitive constructor parameters wrapper class would be used (for example. if target parameter is
+     * {@code int} then returned context type would be {@link Integer}). It is not hard to detect primitives
+     * manually when required (it may be only directly declared primitive argument because it is impossible to
+     * declare primitive with generic variable).
      *
      * @param pos parameter position (from 0)
      * @return generics context of parameter type
@@ -152,6 +165,11 @@ public GenericsContext parameterType(final int pos) {
      * target type hierarchy). This is useful when analyzing object instance (introspecting actual object).
      * <p>
      * Other than target type, method is the same as {@link #parameterType(int)}.
+     * <p>
+     * For primitive constructor parameters wrapper class would be used (for example. if target parameter is
+     * {@code int} then returned context type would be {@link Integer}). It is not hard to detect primitives
+     * manually when required (it may be only directly declared primitive argument because it is impossible to
+     * declare primitive with generic variable).
      *
      * @param pos    parameter position (from 0)
      * @param asType required target type to build generics context for (must include declared type as base class)
@@ -220,7 +238,7 @@ private void checkParameter(final int pos) {
         final Type[] genericParams = ctor.getGenericParameterTypes();
         if (pos < 0 || pos >= genericParams.length) {
             throw new IllegalArgumentException(String.format(
-                    "Can't request parameter %s of constructor '%s' because it have only %s parameters",
+                    "Can't request parameter %s of constructor '%s' because it has only %s parameters",
                     pos, toStringConstructor(), genericParams.length));
         }
     }

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

@@ -138,7 +138,7 @@ public GenericDeclaration getGenericsSource() {
 
     @Override
     public GenericsContext type(final Class<?> type) {
-        return type == currentType ? this : new GenericsContext(genericsInfo, type, root);
+        return type == currentType ? this : new GenericsContext(genericsInfo, TypeUtils.wrapPrimitive(type), root);
     }
 
     @Override
@@ -162,7 +162,10 @@ public ConstructorGenericsContext constructor(final Constructor constructor) {
     public GenericsContext inlyingType(final Type type) {
         // check type compatibility
         final GenericsContext root = chooseContext(type);
-        final Class target = root.resolveClass(type);
+        // always wrap primitive because context may be build only for real class (it would require too much
+        // of additional checks to properly support primitive-based contexts; usually it could be easilly
+        // checked manually)
+        final Class target = TypeUtils.wrapPrimitive(root.resolveClass(type));
         final GenericsInfo generics;
 
         if (target.getTypeParameters().length > 0 || couldRequireKnownOuterGenerics(root, type)) {
@@ -171,9 +174,7 @@ public GenericsContext inlyingType(final Type type) {
             generics = GenericInfoUtils.create(root, type, genericsInfo.getIgnoredTypes());
         } else {
             // class without generics - use cachable context
-            generics = GenericsInfoFactory.create(
-                    // always build hierarchy for non primitive type
-                    TypeUtils.wrapPrimitive(target), genericsInfo.getIgnoredTypes());
+            generics = GenericsInfoFactory.create(target, genericsInfo.getIgnoredTypes());
         }
 
         return new GenericsContext(generics, target, root);
@@ -183,7 +184,10 @@ public GenericsContext inlyingType(final Type type) {
     public GenericsContext inlyingTypeAs(final Type type, final Class<?> asType) {
         // check type compatibility
         final GenericsContext root = chooseContext(type);
-        final Class target = root.resolveClass(type);
+        // always wrap primitive because context may be build only for real class (it would require too much
+        // of additional checks to properly support primitive-based contexts; usually it could be easilly
+        // checked manually)
+        final Class target = TypeUtils.wrapPrimitive(root.resolveClass(type));
         final GenericsInfo generics;
         if (target.getTypeParameters().length > 0
                 || couldRequireKnownOuterGenerics(root, type) || couldRequireKnownOuterGenerics(root, asType)) {
@@ -192,9 +196,7 @@ public GenericsContext inlyingTypeAs(final Type type, final Class<?> asType) {
             generics = GenericInfoUtils.create(root, type, asType, genericsInfo.getIgnoredTypes());
         } else {
             // class without generics - use cachable context
-            generics = GenericsInfoFactory.create(
-                    // always build hierarchy for non primitive type
-                    TypeUtils.wrapPrimitive(asType), genericsInfo.getIgnoredTypes());
+            generics = GenericsInfoFactory.create(asType, genericsInfo.getIgnoredTypes());
         }
         return new GenericsContext(generics, asType, root);
     }

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

@@ -121,6 +121,10 @@ public List<Class<?>> resolveParameters() {
      * }}</pre>
      * Resolving parameters types in context of root class:
      * {@code method(B.class.getMethod("doSmth", List.class)).resolveParametersTypes() == [List<Long>]}
+     * <p>
+     * Note: may return primitives because it might be important to differentiate actual value.
+     * Use {@link ru.vyarus.java.generics.resolver.util.TypeUtils#wrapPrimitive(Class)} to box possible primitives,
+     * if required.
      *
      * @return resolved method parameters types or empty list if method doesn't contain parameters
      * @see #resolveParameters()
@@ -130,6 +134,10 @@ public List<Type> resolveParametersTypes() {
     }
 
     /**
+     * Note: may return primitives because it might be important to differentiate actual value.
+     * Use {@link ru.vyarus.java.generics.resolver.util.TypeUtils#wrapPrimitive(Class)} to box possible primitives,
+     * if required.
+     *
      * @param pos parameter position (form 0)
      * @return parameter type with resolved generic variables
      * @throws IllegalArgumentException if parameter index is incorrect
@@ -151,6 +159,11 @@ public Type resolveParameterType(final int pos) {
      * <p>
      * Note that, in contrast to direct resolution {@code GenericsResolver.resolve(B.class)}, actual root generic
      * would be counted for hierarchy resolution.
+     * <p>
+     * For primitive parameters wrapper class would be used (for example. if target parameter is
+     * {@code int} then returned context type would be {@link Integer}). It is not hard to detect primitives
+     * manually when required (it may be only directly declared primitive argument because it is impossible to
+     * declare primitive with generic variable).
      *
      * @param pos parameter position (from 0)
      * @return generics context of parameter type
@@ -168,6 +181,11 @@ public GenericsContext parameterType(final int pos) {
      * target type hierarchy). This is useful when analyzing object instance (introspecting actual object).
      * <p>
      * Other than target type, method is the same as {@link #parameterType(int)}.
+     * <p>
+     * For primitive parameters wrapper class would be used (for example. if target parameter is
+     * {@code int} then returned context type would be {@link Integer}). It is not hard to detect primitives
+     * manually when required (it may be only directly declared primitive argument because it is impossible to
+     * declare primitive with generic variable).
      *
      * @param pos    parameter position (from 0)
      * @param asType required target type to build generics context for (must include declared type as base class)
@@ -212,6 +230,10 @@ public Class<?> resolveReturnTypeGeneric() {
      *      List<T> get();
      * }}</pre>.
      * {@code (context of B).method(A.class.getMethod("get")).resolveReturnType() == List<Long>}
+     * <p>
+     * Note: may return primitive because it might be important to differentiate actual value.
+     * Use {@link ru.vyarus.java.generics.resolver.util.TypeUtils#wrapPrimitive(Class)} to box possible primitive,
+     * if required.
      *
      * @return method return type with resolved generic variables
      */
@@ -230,6 +252,11 @@ public Type resolveReturnType() {
      * <p>
      * Note that, in contrast to direct resolution {@code GenericsResolver.resolve(B.class)}, actual root generic
      * would be counted for hierarchy resolution.
+     * <p>
+     * For primitive return type wrapper class would be used (for example. if target parameter is
+     * {@code int} then returned context type would be {@link Integer}). It is not hard to detect primitives
+     * manually when required (it may be only directly declared primitive argument because it is impossible to
+     * declare primitive with generic variable).
      *
      * @return generics context of return type
      * @see #inlyingType(Type)
@@ -244,6 +271,11 @@ public GenericsContext returnType() {
      * type hierarchy). This is useful when analyzing object instance (introspecting actual object).
      * <p>
      * Other than target type, method is the same as {@link #returnType()}.
+     * <p>
+     * For primitive return type wrapper class would be used (for example. if target parameter is
+     * {@code int} then returned context type would be {@link Integer}). It is not hard to detect primitives
+     * manually when required (it may be only directly declared primitive argument because it is impossible to
+     * declare primitive with generic variable).
      *
      * @param asType required target type to build generics context for (must include declared type as base class)
      * @return generics context of requested type with known return type generics
@@ -307,7 +339,7 @@ private void checkParameter(final int pos) {
         final Type[] genericParams = meth.getGenericParameterTypes();
         if (pos < 0 || pos >= genericParams.length) {
             throw new IllegalArgumentException(String.format(
-                    "Can't request parameter %s of method '%s' (%s) because it have only %s parameters",
+                    "Can't request parameter %s of method '%s' (%s) because it has only %s parameters",
                     pos, toStringMethod(), currentClass().getSimpleName(), genericParams.length));
         }
     }

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

@@ -50,6 +50,6 @@ class ConstructorIntrospectionTest extends Specification {
         context.resolveParameterType(5)
         then:
         def ex = thrown(IllegalArgumentException)
-        ex.message == "Can't request parameter 5 of constructor 'ConstructorGenerics(Comparable)' because it have only 1 parameters"
+        ex.message == "Can't request parameter 5 of constructor 'ConstructorGenerics(Comparable)' because it has only 1 parameters"
     }
 }