Support property parameters in constructors

ast-model/src/org/jetbrains/dukat/astModel/CallableParameterModel.kt

@@ -1,6 +1,8 @@
 package org.jetbrains.dukat.astModel
 
-interface CallableParameterModel {
+import org.jetbrains.dukat.astCommon.Entity
+
+interface CallableParameterModel : Entity {
     val name: String?
     val type: TypeModel
 }

ast-model/src/org/jetbrains/dukat/astModel/ConstructorModel.kt

@@ -1,6 +1,6 @@
 package org.jetbrains.dukat.astModel
 
 data class ConstructorModel(
-        val parameters: List<ParameterModel>,
+        val parameters: List<CallableParameterModel>,
         val typeParameters: List<TypeParameterModel>
 ) : MemberModel

ast-model/src/org/jetbrains/dukat/astModel/PropertyParameterModel.kt

@@ -0,0 +1,11 @@
+package org.jetbrains.dukat.astModel
+
+import org.jetbrains.dukat.astModel.modifiers.VisibilityModifierModel
+import org.jetbrains.dukat.astModel.statements.StatementModel
+
+data class PropertyParameterModel(
+    override val name: String,
+    override val type: TypeModel,
+    val initializer: StatementModel?,
+    val visibilityModifier: VisibilityModifierModel
+): CallableParameterModel

compiler/test/data/typescript/class/constructor/withPropertyDeclaration.d.kt → compiler/test/data/typescriptBodies/constructorWithPropertyDeclaration.kt

@@ -1,4 +1,4 @@
-// [test] withPropertyDeclaration.kt
+// [test] constructorWithPropertyDeclaration.kt
 @file:Suppress("INTERFACE_WITH_SUPERCLASS", "OVERRIDING_FINAL_MEMBER", "RETURN_TYPE_MISMATCH_ON_OVERRIDE", "CONFLICTING_OVERLOADS", "EXTERNAL_DELEGATION")
 
 import kotlin.js.*
@@ -16,11 +16,6 @@ import org.w3c.performance.*
 import org.w3c.workers.*
 import org.w3c.xhr.*
 
-external open class Foo(x: Any) {
-    open var x: Any
-}
+open class Foo(var x: Any)
 
-external open class Bar(n: Number, a: Any) {
-    open var n: Number
-    open var a: Any
-}
+open class Bar(var n: Number, var a: Any)

compiler/test/data/typescriptBodies/constructorWithPropertyDeclaration.ts

@@ -0,0 +1,11 @@
+export class Foo {
+    constructor(public x) {
+
+    }
+}
+
+export class Bar {
+    constructor(public n: number, public a) {
+
+    }
+}

descriptors/src/org/jetbrains/dukat/descriptors/DescriptorTranslator.kt

@@ -561,7 +561,7 @@ private class DescriptorTranslator(val context: DescriptorContext) {
                 SourceElement.NO_SOURCE
         )
         constructorDescriptor.initialize(
-                translateParameters(constructorModel.parameters, constructorDescriptor),
+                translateParameters(constructorModel.parameters.filterIsInstance<ParameterModel>(), constructorDescriptor),
                 visibility
         )
         constructorDescriptor.returnType = LazyWrappedType(LockBasedStorageManager.NO_LOCKS) {

javascript/js-type-analysis/src/org/jetbrains/dukat/js/type/analysis/members.kt

@@ -9,13 +9,14 @@ import org.jetbrains.dukat.tsmodel.ConstructorDeclaration
 import org.jetbrains.dukat.tsmodel.FunctionDeclaration
 import org.jetbrains.dukat.tsmodel.MemberDeclaration
 import org.jetbrains.dukat.tsmodel.ModifierDeclaration
+import org.jetbrains.dukat.tsmodel.ParameterDeclaration
 import org.jetbrains.dukat.tsmodel.PropertyDeclaration
 import org.jetbrains.dukat.tsmodel.types.TypeDeclaration
 
 fun ConstructorDeclaration.addTo(owner: ClassConstraint) {
     owner.constructorConstraint = FunctionDeclaration(
             name = "",
-            parameters = parameters,
+            parameters = parameters.filterIsInstance<ParameterDeclaration>(),
             type = TypeDeclaration(
                     value = IdentifierEntity("Unit"),
                     params = emptyList()

model-lowerings-common/src/org/jetbrains/dukat/model/commonLowerings/ModelWithOwnerLowering.kt

@@ -1,23 +1,36 @@
 package org.jetbrains.dukat.model.commonLowerings
 
+import org.jetbrains.dukat.astModel.CallableParameterModel
 import org.jetbrains.dukat.astModel.FunctionTypeModel
 import org.jetbrains.dukat.astModel.LambdaParameterModel
 import org.jetbrains.dukat.astModel.MemberModel
 import org.jetbrains.dukat.astModel.ModuleModel
 import org.jetbrains.dukat.astModel.ParameterModel
+import org.jetbrains.dukat.astModel.PropertyParameterModel
 import org.jetbrains.dukat.astModel.TypeModel
 import org.jetbrains.dukat.astModel.TypeParameterModel
 import org.jetbrains.dukat.astModel.TypeValueModel
 import org.jetbrains.dukat.astModel.statements.BlockStatementModel
 import org.jetbrains.dukat.astModel.statements.StatementModel
 import org.jetbrains.dukat.ownerContext.NodeOwner
+import org.jetbrains.dukat.ownerContext.OwnerContext
 
 interface ModelWithOwnerLowering : TopLevelModelLowering {
     fun lowerFunctionTypeModel(ownerContext: NodeOwner<FunctionTypeModel>): FunctionTypeModel
     fun lowerLambdaParameterModel(ownerContext: NodeOwner<LambdaParameterModel>): LambdaParameterModel
     fun lowerParameterModel(ownerContext: NodeOwner<ParameterModel>): ParameterModel
+    fun lowerPropertyParameterModel(ownerContext: NodeOwner<PropertyParameterModel>): PropertyParameterModel
     fun lowerMemberModel(ownerContext: NodeOwner<MemberModel>, parentModule: ModuleModel): MemberModel?
 
+    fun lowerCallableParameterModel(ownerContext: NodeOwner<CallableParameterModel>): CallableParameterModel {
+        return when (val declaration = ownerContext.node) {
+            is ParameterModel -> lowerParameterModel(NodeOwner(declaration, ownerContext))
+            is LambdaParameterModel -> lowerLambdaParameterModel(NodeOwner(declaration, ownerContext))
+            is PropertyParameterModel -> lowerPropertyParameterModel(NodeOwner(declaration, ownerContext))
+            else -> declaration
+        }
+    }
+
     fun lowerTypeParameterModel(ownerContext: NodeOwner<TypeParameterModel>): TypeParameterModel {
         val typeParameterModel = ownerContext.node
         return typeParameterModel.copy(

model-lowerings-common/src/org/jetbrains/dukat/model/commonLowerings/ModelWithOwnerTypeLowering.kt

@@ -1,5 +1,6 @@
 package org.jetbrains.dukat.model.commonLowerings
 
+import org.jetbrains.dukat.astModel.CallableParameterModel
 import org.jetbrains.dukat.astModel.ClassLikeModel
 import org.jetbrains.dukat.astModel.ClassModel
 import org.jetbrains.dukat.astModel.ConstructorModel
@@ -17,6 +18,7 @@ import org.jetbrains.dukat.astModel.PropertyModel
 import org.jetbrains.dukat.astModel.TypeAliasModel
 import org.jetbrains.dukat.astModel.VariableModel
 import org.jetbrains.dukat.astModel.LambdaParameterModel
+import org.jetbrains.dukat.astModel.PropertyParameterModel
 import org.jetbrains.dukat.astModel.expressions.AsExpressionModel
 import org.jetbrains.dukat.astModel.expressions.BinaryExpressionModel
 import org.jetbrains.dukat.astModel.expressions.CallExpressionModel
@@ -113,6 +115,11 @@ interface ModelWithOwnerTypeLowering : ModelWithOwnerLowering {
         return declaration.copy(type = lowerTypeModel(NodeOwner(declaration.type, ownerContext)))
     }
 
+    override fun lowerPropertyParameterModel(ownerContext: NodeOwner<PropertyParameterModel>): PropertyParameterModel {
+        val declaration = ownerContext.node
+        return declaration.copy(type = lowerTypeModel(NodeOwner(declaration.type, ownerContext)))
+    }
+
     override fun lowerParameterModel(ownerContext: NodeOwner<ParameterModel>): ParameterModel {
         val declaration = ownerContext.node
         return declaration.copy(type = lowerTypeModel(NodeOwner(declaration.type, ownerContext)))
@@ -163,7 +170,7 @@ interface ModelWithOwnerTypeLowering : ModelWithOwnerLowering {
     fun lowerConstructorModel(ownerContext: NodeOwner<ConstructorModel>): ConstructorModel {
         val declaration = ownerContext.node
         return declaration.copy(
-                parameters = declaration.parameters.map { parameter -> lowerParameterModel(NodeOwner(parameter, ownerContext)) }
+                parameters = declaration.parameters.map { parameter -> lowerCallableParameterModel(NodeOwner(parameter, ownerContext)) }
         )
     }
 
@@ -179,7 +186,7 @@ interface ModelWithOwnerTypeLowering : ModelWithOwnerLowering {
         val declaration = ownerContext.node
         return declaration.copy(
                 primaryConstructor = declaration.primaryConstructor?.let { constructorModel ->
-                    constructorModel.copy(parameters = constructorModel.parameters.map { lowerParameterModel(ownerContext.wrap(it)) })
+                    constructorModel.copy(parameters = constructorModel.parameters.map { lowerCallableParameterModel(ownerContext.wrap(it)) })
                 },
                 members = declaration.members.mapNotNull { member -> lowerMemberModel(NodeOwner(member, ownerContext), parentModule) },
                 typeParameters = declaration.typeParameters.map { typeParameterModel ->  lowerTypeParameterModel(ownerContext.wrap(typeParameterModel)) },

model-lowerings-common/src/org/jetbrains/dukat/model/commonLowerings/resolveTopLevelVisibility.kt

@@ -1,5 +1,6 @@
 package org.jetbrains.dukat.model.commonLowerings
 
+import org.jetbrains.dukat.astModel.CallableParameterModel
 import org.jetbrains.dukat.astModel.ClassModel
 import org.jetbrains.dukat.astModel.EnumModel
 import org.jetbrains.dukat.astModel.FunctionModel
@@ -10,6 +11,7 @@ import org.jetbrains.dukat.astModel.MemberModel
 import org.jetbrains.dukat.astModel.ModuleModel
 import org.jetbrains.dukat.astModel.ObjectModel
 import org.jetbrains.dukat.astModel.ParameterModel
+import org.jetbrains.dukat.astModel.PropertyParameterModel
 import org.jetbrains.dukat.astModel.SourceSetModel
 import org.jetbrains.dukat.astModel.TypeAliasModel
 import org.jetbrains.dukat.astModel.VariableModel
@@ -46,6 +48,10 @@ private class ModifyVisibility(private val visibility: VisibilityModifierModel)
         return ownerContext.node.copy(visibilityModifier = visibility)
     }
 
+    override fun lowerPropertyParameterModel(ownerContext: NodeOwner<PropertyParameterModel>): PropertyParameterModel {
+        return ownerContext.node.copy(visibilityModifier = visibility)
+    }
+
     override fun lowerLambdaParameterModel(ownerContext: NodeOwner<LambdaParameterModel>) = ownerContext.node
     override fun lowerParameterModel(ownerContext: NodeOwner<ParameterModel>): ParameterModel = ownerContext.node
 

translator-string/src/org/jetbrains/dukat/translatorString/StringTranslator.kt

@@ -1,9 +1,11 @@
 package org.jetbrains.dukat.translatorString
 
+import org.jetbrains.dukat.astModel.PropertyParameterModel
 import org.jetbrains.dukat.astCommon.CommentEntity
 import org.jetbrains.dukat.astCommon.IdentifierEntity
 import org.jetbrains.dukat.astCommon.SimpleCommentEntity
 import org.jetbrains.dukat.astModel.AnnotationModel
+import org.jetbrains.dukat.astModel.CallableParameterModel
 import org.jetbrains.dukat.astModel.ClassLikeReferenceModel
 import org.jetbrains.dukat.astModel.ClassModel
 import org.jetbrains.dukat.astModel.ConstructorModel
@@ -75,7 +77,6 @@ import org.jetbrains.dukat.astModel.statements.ThrowStatementModel
 import org.jetbrains.dukat.astModel.statements.WhenStatementModel
 import org.jetbrains.dukat.astModel.statements.WhileStatementModel
 import org.jetbrains.dukat.panic.raiseConcern
-import org.jetbrains.dukat.stdlib.TSLIBROOT
 import org.jetbrains.dukat.translator.ModelVisitor
 import org.jetbrains.dukat.translator.ROOT_PACKAGENAME
 
@@ -163,33 +164,52 @@ fun TypeModel.translate(): String {
     }
 }
 
-private fun ParameterModel.translate(needsMeta: Boolean = true): String {
+private fun CallableParameterModel.translate(needsMeta: Boolean = true): String {
     var res = name + ": " + type.translate()
-    if (vararg) {
-        res = "vararg $res"
-    }
+    return when (this) {
+        is ParameterModel -> {
+            if (vararg) {
+                res = "vararg $res"
+            }
 
-    modifier?.let {
-        val modifierTranslated = when (it) {
-            ParameterModifierModel.NOINLINE -> "noinline"
-            ParameterModifierModel.CROSSINLINE -> "crossinline"
-        }
+            modifier?.let {
+                val modifierTranslated = when (it) {
+                    ParameterModifierModel.NOINLINE -> "noinline"
+                    ParameterModifierModel.CROSSINLINE -> "crossinline"
+                }
 
-        res = "$modifierTranslated $res"
-    }
+                res = "$modifierTranslated $res"
+            }
 
-    if (needsMeta) {
-        res += type.translateMeta()
-    }
+            if (needsMeta) {
+                res += type.translateMeta()
+            }
+
+            initializer?.let {
+                res += " = ${it.translateAsOneLine()}"
+                if (needsMeta) {
+                    res += it.translateMeta()
+                }
+            }
 
-    initializer?.let {
-        res += " = ${it.translateAsOneLine()}"
-        if (needsMeta) {
-            res += it.translateMeta()
+            res
         }
-    }
+        is PropertyParameterModel -> {
+            if (needsMeta) {
+                res += type.translateMeta()
+            }
 
-    return res
+            initializer?.let {
+                res += " = ${it.translateAsOneLine()}"
+                if (needsMeta) {
+                    res += it.translateMeta()
+                }
+            }
+
+            "${visibilityModifier.asClause()}var $res"
+        }
+        else -> res
+    }
 }
 
 private fun translateTypeParameters(typeParameters: List<TypeParameterModel>): String {
@@ -224,7 +244,7 @@ private fun translateTypeArguments(typeParameters: List<TypeModel>): String {
 }
 
 
-private fun translateParameters(parameters: List<ParameterModel>, needsMeta: Boolean = true): String {
+private fun translateParameters(parameters: List<CallableParameterModel>, needsMeta: Boolean = true): String {
     return parameters
         .map { parameter -> parameter.translate(needsMeta) }
         .joinToString(", ")
@@ -253,7 +273,7 @@ private fun CallExpressionModel.translate(): String {
 
 private fun LiteralExpressionModel.translate(): String {
     return when (this) {
-        is StringLiteralExpressionModel -> "\"$value\""
+        is StringLiteralExpressionModel -> "\"${value.replace("\"", "\\\"")}\""
         is NumericLiteralExpressionModel -> value.toString()
         is BooleanLiteralExpressionModel -> value.toString()
         is NullLiteralExpressionModel -> "null"

typescript/ts-converter/src/AstConverter.ts

@@ -29,6 +29,7 @@ import {ExportContext, resolveDeclarations} from "./ExportContext";
 import {tsInternals} from "./TsInternals";
 import {
   CaseDeclarationProto,
+  ConstructorParameterDeclarationProto,
   ModifierDeclarationProto,
   ModuleDeclarationProto,
   ReferenceClauseDeclarationProto,
@@ -571,6 +572,25 @@ export class AstConverter {
     );
   }
 
+  convertPropertyParameterDeclaration(param: ts.ParameterDeclaration, index: number): ConstructorParameterDeclarationProto {
+    let initializer: Expression | null = null;
+
+    if (param.initializer != null) {
+      initializer = this.astExpressionConverter.convertExpression(param.initializer)
+    }
+
+    let paramType = this.convertType(param.type);
+
+    let name = ts.isIdentifier(param.name) ? param.name.getText() : `__${index}`;
+
+    return this.astFactory.createPropertyParameterDeclaration(
+        name,
+        paramType,
+        initializer,
+        this.convertModifiers(param.modifiers)
+    );
+  }
+
   convertPropertySignature(node: ts.PropertySignature): MemberDeclaration | null {
     let name = this.convertName(node.name);
 
@@ -689,24 +709,24 @@ export class AstConverter {
   }
 
   convertConstructorDeclaration(constructorDeclaration: ts.ConstructorDeclaration): Array<MemberDeclaration> {
-    let params: Array<ParameterDeclaration> = [];
+    let params: Array<ConstructorParameterDeclarationProto> = [];
 
     let res: Array<MemberDeclaration> = [];
 
     constructorDeclaration.parameters.forEach((parameter, count) => {
-      if (parameter.modifiers) {
-        let isField = parameter.modifiers.some(modifier => modifier.kind == ts.SyntaxKind.PublicKeyword);
-        if (isField) {
-          let convertedVariable = this.convertPropertyDeclaration(
-            parameter as ts.ParameterDeclaration
-          );
-          if (convertedVariable != null) {
-            res.push(convertedVariable)
-          }
-        }
+      if (parameter.modifiers && parameter.modifiers.some(modifier =>
+          modifier.kind == ts.SyntaxKind.PublicKeyword ||
+          modifier.kind == ts.SyntaxKind.ProtectedKeyword ||
+          modifier.kind == ts.SyntaxKind.PrivateKeyword
+      )) {
+        params.push(this.convertPropertyParameterDeclaration(
+            parameter, count
+        ));
+      } else {
+        params.push(this.astFactory.createSimpleConstructorParameterDeclaration(
+            this.convertParameterDeclaration(parameter, count))
+        );
       }
-
-      params.push(this.convertParameterDeclaration(parameter, count));
     });
 
     res.push(this.astFactory.createConstructorDeclaration(