datatable: Replace wildcard type with its upper bound

When registering steps in Kotlin using Kotlin collections as an argument e.g:

```kotlin
@given("orders with an order item and the following attributes:")
fun statusFilterOrdersInEs(attributes: Map<String, Map<String, String>>)
```

This argument is translated to Java type as

```java
Map<java.lang.String, ? extends java.util.Map<java.lang.String, java.lang.String>>
```

To handle this gracefully the simplified type system used by `DataTable`
should understand upper bounds. We do this by replacing the wild card type
with its upper bound.

We can assume this is safe because when registering a transformer to
`type ? extends SomeType` the transformer is guaranteed to produce an
object that is an instance of `SomeType`.

When transforming a data table to ``? extends SomeType` a transformer that
produces `SomeType` is sufficient.

This will result in ambiguity between a transformers for `SomeType` and
transformers for ``? extends SomeType` but that seems reasonable and might be
resolved by using a more specific producer.

Author: mpkorstanje

datatable/java/datatable/src/main/java/io/cucumber/datatable/TypeFactory.java

@@ -49,7 +49,7 @@ private static JavaType constructTypeInner(Type type) {
         }
 
         if (type instanceof WildcardType) {
-            return constructWIldCardType((WildcardType) type);
+            return constructWildCardType((WildcardType) type);
         }
 
         if (type instanceof ParameterizedType) {
@@ -59,8 +59,26 @@ private static JavaType constructTypeInner(Type type) {
         return new OtherType(type);
     }
 
-    private static JavaType constructWIldCardType(WildcardType type) {
-        // We'll only care about exact matches for now.
+    private static JavaType constructWildCardType(WildcardType type) {
+        // For our simplified type system we can safely replace upper bounds
+        // When registering a transformer to type ? extends SomeType the
+        // transformer is guaranteed to produce an object that is an instance of
+        // SomeType.
+        // When transforming a data table to ? extends SomeType a transformer
+        // that produces SomeType is sufficient.
+        // This will result in ambiguity between a transformers for SomeType
+        // and transformers for ? extends SomeType but that seems reasonable and
+        // might be resolved by using a more specific producer.
+        Type[] upperBounds = type.getUpperBounds();
+        if (upperBounds.length > 0) {
+            // Not possible in Java. Scala?
+            if (upperBounds.length > 1) {
+                throw new IllegalArgumentException("Type contained more then upper lower bound " + type + ". Types may only have a single upper bound.");
+            }
+            return constructType(upperBounds[0]);
+        }
+
+        // We'll treat lower bounds as is.
         return new OtherType(type);
     }
 
@@ -94,6 +112,11 @@ static String typeName(Type type) {
         return type.getTypeName();
     }
 
+    interface JavaType extends Type {
+
+        Type getOriginal();
+    }
+
     static final class OtherType implements JavaType {
 
         private final Type original;
@@ -218,9 +241,4 @@ public Type getOriginal() {
             return original;
         }
     }
-
-    interface JavaType extends Type {
-
-        Type getOriginal();
-    }
 }

datatable/java/datatable/src/test/java/io/cucumber/datatable/TypeFactoryTest.java

@@ -21,9 +21,10 @@ class TypeFactoryTest {
     }.getType();
     private static final Type LIST_OF_LIST_OF_OBJECT = new TypeReference<List<List<Object>>>() {
     }.getType();
-
     private static final Type LIST_OF_WILD_CARD_NUMBER = new TypeReference<List<? extends Number>>() {
     }.getType();
+    private static final Type LIST_OF_NUMBER = new TypeReference<List<Number>>() {
+    }.getType();
     private static final Type MAP_OF_OBJECT_OBJECT = new TypeReference<Map<Object, Object>>() {
     }.getType();
 
@@ -146,4 +147,23 @@ <T> void type_variables_are_not_allowed() {
                 "Type contained a type variable T. Types must explicit."
         ));
     }
+
+    @Test
+    void wild_card_types_use_upper_bound_in_equality() {
+        JavaType javaType = TypeFactory.constructType(LIST_OF_WILD_CARD_NUMBER);
+        JavaType other = TypeFactory.constructType(LIST_OF_NUMBER);
+        assertThat(javaType, equalTo(other));
+        TypeFactory.ListType listType = (TypeFactory.ListType) javaType;
+        JavaType elementType = listType.getElementType();
+        assertThat(elementType.getOriginal(), equalTo(Number.class));
+    }
+
+    @Test
+    void upper_bound_of_wild_card_replaces_wild_card_type() {
+        JavaType javaType = TypeFactory.constructType(LIST_OF_WILD_CARD_NUMBER);
+        TypeFactory.ListType listType = (TypeFactory.ListType) javaType;
+        JavaType elementType = listType.getElementType();
+        assertThat(elementType.getOriginal(), equalTo(Number.class));
+    }
+
 }