Fix for #181 - Correctly handling parameterized interfaces

typescript-generator-core/src/main/java/cz/habarta/typescript/generator/compiler/ModelCompiler.java

@@ -119,10 +119,12 @@ private Map<Type, List<BeanModel>> createChildrenMap(Model model) {
         final Map<Type, List<BeanModel>> children = new LinkedHashMap<>();
         for (BeanModel bean : model.getBeans()) {
             for (Type ancestor : bean.getParentAndInterfaces()) {
-                if (!children.containsKey(ancestor)) {
-                    children.put(ancestor, new ArrayList<BeanModel>());
+                Type processedAncestor = processTypeForDescendantLookup(ancestor);
+
+                if (!children.containsKey(processedAncestor)) {
+                    children.put(processedAncestor, new ArrayList<BeanModel>());
                 }
-                children.get(ancestor).add(bean);
+                children.get(processedAncestor).add(bean);
             }
         }
         return children;
@@ -186,10 +188,21 @@ private List<TsPropertyModel> processProperties(SymbolTable symbolTable, Model m
         return properties;
     }
 
+    /**
+     * Given a type, returns the type that should be used for the purpose of looking up implementations of that type.
+     */
+    private static Type processTypeForDescendantLookup(Type type) {
+        if (type instanceof ParameterizedType) {
+            return ((ParameterizedType) type).getRawType();
+        } else {
+            return type;
+        }
+    }
+
     private static List<BeanModel> getSelfAndDescendants(BeanModel bean, Map<Type, List<BeanModel>> children) {
         final List<BeanModel> descendants = new ArrayList<>();
         descendants.add(bean);
-        final List<BeanModel> directDescendants = children.get(bean.getOrigin());
+        final List<BeanModel> directDescendants = children.get(processTypeForDescendantLookup(bean.getOrigin()));
         if (directDescendants != null) {
             for (BeanModel descendant : directDescendants) {
                 descendants.addAll(getSelfAndDescendants(descendant, children));

typescript-generator-core/src/test/java/cz/habarta/typescript/generator/ModelCompilerTest.java

@@ -1,10 +1,20 @@
 
 package cz.habarta.typescript.generator;
 
-import java.lang.reflect.*;
-import java.util.*;
-import org.junit.*;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import cz.habarta.typescript.generator.compiler.ModelCompiler;
+import cz.habarta.typescript.generator.emitter.TsModel;
+import cz.habarta.typescript.generator.parser.Jackson2Parser;
+import cz.habarta.typescript.generator.parser.Model;
+import org.hamcrest.CoreMatchers;
+import org.junit.Assert;
+import org.junit.Test;
 
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
 
 public class ModelCompilerTest {
 
@@ -37,6 +47,46 @@ public void testExclusionPattern() throws Exception {
         Assert.assertEquals("{ [index: string]: any }[]", TestUtils.compileType(settings, javaType).toString());
     }
 
+    @Test
+    public void testIntermediateInterfacesWithoutTypeParams() throws Exception {
+        final Settings settings = TestUtils.settings();
+
+        final Jackson2Parser jacksonParser = new Jackson2Parser(settings, new DefaultTypeProcessor());
+        final Model model = jacksonParser.parseModel(Implementation.class);
+        final ModelCompiler modelCompiler = new TypeScriptGenerator(settings).getModelCompiler();
+
+        final TsModel result = modelCompiler.javaToTypeScript(model);
+
+        Assert.assertThat(
+          result.getBean(WithoutTypeParam.class).getProperties().get(0).tsType,
+          CoreMatchers.instanceOf(TsType.UnionType.class)
+        );
+    }
+
+    @Test
+    public void testIntermediateInterfacesWithTypeParams() throws Exception {
+        final Settings settings = TestUtils.settings();
+
+        final Jackson2Parser jacksonParser = new Jackson2Parser(settings, new DefaultTypeProcessor());
+        final Model model = jacksonParser.parseModel(Implementation.class);
+        final ModelCompiler modelCompiler = new TypeScriptGenerator(settings).getModelCompiler();
+
+        final TsModel result = modelCompiler.javaToTypeScript(model);
+
+        Assert.assertThat(
+          result.getBean(WithTypeParam.class).getProperties().get(0).tsType,
+          CoreMatchers.instanceOf(TsType.UnionType.class)
+        );
+    }
+
+    @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY)
+    private static interface WithoutTypeParam {}
+
+    @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY)
+    private static interface WithTypeParam<T> {}
+
+    private static class Implementation implements WithTypeParam<Integer>, WithoutTypeParam {}
+
     private static Settings getTestSettings(String... excludedClassNames) {
         final Settings settings = TestUtils.settings();
         settings.mapDate = DateMapping.asString;