Allow generating constructors for child classes (#337)

Author: Paweł Płazieński

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

@@ -48,6 +48,7 @@ public enum TransformationPhase {
         BeforeTsModel,
         BeforeEnums,
         BeforeSymbolResolution,
+        AfterDeclarationSorting,
     }
 
     public TsModel javaToTypeScript(Model model) {
@@ -108,6 +109,7 @@ public TsModel javaToTypeScript(Model model) {
         symbolTable.resolveSymbolNames();
         tsModel = removeDeclarationsImportedFromDependencies(symbolTable, tsModel);
         tsModel = sortDeclarations(symbolTable, tsModel);
+        tsModel = applyExtensionTransformers(symbolTable, tsModel, TransformationPhase.AfterDeclarationSorting, extensionTransformers);
         return tsModel;
     }
 

typescript-generator-core/src/main/java/cz/habarta/typescript/generator/ext/RequiredPropertyConstructorExtension.java

@@ -10,6 +10,7 @@
 import cz.habarta.typescript.generator.emitter.EmitterExtensionFeatures;
 import cz.habarta.typescript.generator.emitter.TsAssignmentExpression;
 import cz.habarta.typescript.generator.emitter.TsBeanModel;
+import cz.habarta.typescript.generator.emitter.TsCallExpression;
 import cz.habarta.typescript.generator.emitter.TsConstructorModel;
 import cz.habarta.typescript.generator.emitter.TsEnumModel;
 import cz.habarta.typescript.generator.emitter.TsExpression;
@@ -22,10 +23,12 @@
 import cz.habarta.typescript.generator.emitter.TsPropertyModel;
 import cz.habarta.typescript.generator.emitter.TsStatement;
 import cz.habarta.typescript.generator.emitter.TsStringLiteral;
+import cz.habarta.typescript.generator.emitter.TsSuperExpression;
 import cz.habarta.typescript.generator.emitter.TsThisExpression;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -55,38 +58,60 @@ public void setConfiguration(Map<String, String> configuration) throws RuntimeEx
 
     @Override
     public List<TransformerDefinition> getTransformers() {
-        return Arrays.asList(new TransformerDefinition(ModelCompiler.TransformationPhase.BeforeSymbolResolution, new ModelTransformer() {
+        return Arrays.asList(new TransformerDefinition(ModelCompiler.TransformationPhase.AfterDeclarationSorting, new ModelTransformer() {
             @Override
             public TsModel transformModel(SymbolTable symbolTable, TsModel model) {
                 List<TsBeanModel> beans = new ArrayList<>();
+                Map<String, TsConstructorModel> generatedConstructors = new HashMap<>();
                 for (TsBeanModel bean : model.getBeans()) {
-                    TsBeanModel newBean = transformBean(bean, model);
+                    TsBeanModel newBean = transformBean(bean, model, generatedConstructors);
                     beans.add(newBean);
                 }
                 return model.withBeans(beans);
             }
         }));
     }
 
-    private TsBeanModel transformBean(TsBeanModel bean, TsModel model) {
+    private TsBeanModel transformBean(TsBeanModel bean, TsModel model,
+                                             Map<String, TsConstructorModel> generatedConstructors) {
         if (!bean.isClass() || bean.getConstructor() != null) {
             return bean;
         }
-        Optional<TsConstructorModel> constructorOption = createConstructor(bean, model);
+        Optional<TsConstructorModel> constructorOption = createConstructor(bean, model, generatedConstructors);
         if (!constructorOption.isPresent()) {
             return bean;
         }
         if (classes != null && !classes.contains(bean.getOrigin().getCanonicalName())) {
             return bean;
         }
-        return bean.withConstructor(constructorOption.get());
+        TsConstructorModel constructor = constructorOption.get();
+        generatedConstructors.put(bean.getName().getFullName(), constructor);
+        return bean.withConstructor(constructor);
     }
 
-    private static Optional<TsConstructorModel> createConstructor(TsBeanModel bean, TsModel model) {
+    private static Optional<TsConstructorModel> createConstructor(TsBeanModel bean, TsModel model,
+                                                                  Map<String, TsConstructorModel> generatedConstructors) {
         List<TsParameterModel> parameters = new ArrayList<>();
         List<TsStatement> body = new ArrayList<>();
-        if (bean.getParent() != null) {
-            throw new IllegalStateException("Creating constructors for inherited beans is not currently supported");
+        TsType parent = bean.getParent();
+        if (parent != null) {
+            if (!(parent instanceof TsType.ReferenceType)) {
+                throw new IllegalStateException("Generating constructor for non-reference parent types is not currently supported");
+            }
+            TsType.ReferenceType referenceParent = (TsType.ReferenceType) parent;
+            TsConstructorModel parentConstructor = generatedConstructors.get(referenceParent.symbol.getFullName());
+            if (parentConstructor == null) {
+                throw new IllegalStateException("Generating constructor for class with non-generated constructor is not currently supported");
+            }
+            List<TsParameterModel> parentParameters = parentConstructor.getParameters();
+            TsIdentifierReference[] callParameters = new TsIdentifierReference[parentParameters.size()];
+            int i = 0;
+            for (TsParameterModel parentParameter : parentParameters) {
+                parameters.add(parentParameter);
+                callParameters[i] = new TsIdentifierReference(parentParameter.name);
+                i++;
+            }
+            body.add(new TsExpressionStatement(new TsCallExpression(new TsSuperExpression(), callParameters)));
         }
         for (TsPropertyModel property : bean.getProperties()) {
             if (!property.modifiers.isReadonly) {

typescript-generator-core/src/test/java/cz/habarta/typescript/generator/ext/RequiredPropertyConstructorExtensionTest.java

@@ -58,9 +58,8 @@ static class PolymorphicClass implements SuperInterface {
         public int field1;
     }
 
-    @JsonTypeName("class-c")
-    static class SecondClass extends PolymorphicClass {
-        public int field2;
+    static class SecondClass extends SimpleClass {
+        public int field3;
     }
 
     @Test
@@ -118,13 +117,10 @@ public void testInheritance() {
         Settings settings = createBaseSettings();
         settings.declarePropertiesAsReadOnly = true;
 
-        try {
-            generateTypeScript(settings, SecondClass.class);
-            Assert.fail("Expected exception");
-        }
-        catch (IllegalStateException expected) {
-            Assert.assertEquals("Creating constructors for inherited beans is not currently supported", expected.getMessage());
-        }
+        String result = generateTypeScript(settings, SecondClass.class);
+
+        String expected = readResource("inheritance.ts");
+        Assert.assertEquals(expected, result);
     }
 
     private static String generateTypeScript(Settings settings, Type... types) {

typescript-generator-core/src/test/resources/ext/RequiredPropertyConstructorExtensionTest-inheritance.ts

@@ -0,0 +1,34 @@
+/* tslint:disable */
+
+export class PolymorphicClass implements SuperInterface {
+    readonly discriminator: "class-b";
+    readonly field1: number;
+
+    constructor(field1: number) {
+        this.discriminator = "class-b";
+        this.field1 = field1;
+    }
+}
+
+export class SimpleClass {
+    readonly field1: string;
+    readonly field2: PolymorphicClass;
+
+    constructor(field1: string, field2: PolymorphicClass) {
+        this.field1 = field1;
+        this.field2 = field2;
+    }
+}
+
+export class SecondClass extends SimpleClass {
+    readonly field3: number;
+
+    constructor(field1: string, field2: PolymorphicClass, field3: number) {
+        super(field1, field2);
+        this.field3 = field3;
+    }
+}
+
+export interface SuperInterface {
+    readonly discriminator: "class-b";
+}