From d10e8552b800b06e4198d963768d3ee35fc03474 Mon Sep 17 00:00:00 2001 From: Alexey Trilis Date: Mon, 15 Jun 2020 19:07:21 +0300 Subject: [PATCH 1/3] Support property parameters in constructors --- .../dukat/astModel/CallableParameterModel.kt | 4 +- .../dukat/astModel/ConstructorModel.kt | 2 +- .../dukat/astModel/PropertyParameterModel.kt | 11 ++++ .../constructor/withPropertyDeclaration.d.kt | 9 +-- .../dukat/descriptors/DescriptorTranslator.kt | 2 +- .../dukat/js/type/analysis/members.kt | 3 +- .../commonLowerings/ModelWithOwnerLowering.kt | 13 ++++ .../ModelWithOwnerTypeLowering.kt | 9 ++- .../resolveTopLevelVisibility.kt | 6 ++ .../translatorString/StringTranslator.kt | 66 ++++++++++++------- typescript/ts-converter/src/AstConverter.ts | 46 +++++++++---- typescript/ts-converter/src/ast/AstFactory.ts | 24 ++++++- .../dukat/tsLowerings/DeclarationLowering.kt | 18 ++++- .../mergeDuplicates/mergeDuplicates.kt | 12 ++++ .../tsLowerings/mergeDuplicates/normalize.kt | 13 ++++ .../ts-model-proto/src/Declarations.proto | 16 ++++- .../dukat/tsmodel/ConstructorDeclaration.kt | 2 +- .../ConstructorParameterDeclaration.kt | 11 ++++ .../dukat/tsmodel/ParameterDeclaration.kt | 8 +-- .../tsmodel/PropertyParameterDeclaration.kt | 11 ++++ .../dukat/tsmodel/factory/convertProtobuf.kt | 23 +++++++ .../dukat/nodeIntroduction/introduceNodes.kt | 26 +++++++- .../dukat/nodeLowering/NodeTypeLowering.kt | 10 ++- .../nodeLowering/NodeWithOwnerLowering.kt | 11 ++++ .../nodeLowering/NodeWithOwnerTypeLowering.kt | 11 +++- .../nodeLowering/TopLevelNodeLowering.kt | 12 ++++ .../nodeLowering/lowerings/introduceModels.kt | 37 +++++++++++ .../lowerings/specifyUnionType.kt | 21 +++--- .../dukat/ast/model/nodes/ConstructorNode.kt | 2 +- .../model/nodes/ConstructorParameterNode.kt | 25 +++++++ .../dukat/ast/model/nodes/ParameterNode.kt | 10 ++- .../ast/model/nodes/PropertyParameterNode.kt | 7 ++ 32 files changed, 407 insertions(+), 74 deletions(-) create mode 100644 ast-model/src/org/jetbrains/dukat/astModel/PropertyParameterModel.kt create mode 100644 typescript/ts-model/src/org/jetbrains/dukat/tsmodel/ConstructorParameterDeclaration.kt create mode 100644 typescript/ts-model/src/org/jetbrains/dukat/tsmodel/PropertyParameterDeclaration.kt create mode 100644 typescript/ts-nodes/src/org/jetbrains/dukat/ast/model/nodes/ConstructorParameterNode.kt create mode 100644 typescript/ts-nodes/src/org/jetbrains/dukat/ast/model/nodes/PropertyParameterNode.kt diff --git a/ast-model/src/org/jetbrains/dukat/astModel/CallableParameterModel.kt b/ast-model/src/org/jetbrains/dukat/astModel/CallableParameterModel.kt index a90371d75..989c677da 100644 --- a/ast-model/src/org/jetbrains/dukat/astModel/CallableParameterModel.kt +++ b/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 } \ No newline at end of file diff --git a/ast-model/src/org/jetbrains/dukat/astModel/ConstructorModel.kt b/ast-model/src/org/jetbrains/dukat/astModel/ConstructorModel.kt index d7b38f437..008f2a8df 100644 --- a/ast-model/src/org/jetbrains/dukat/astModel/ConstructorModel.kt +++ b/ast-model/src/org/jetbrains/dukat/astModel/ConstructorModel.kt @@ -1,6 +1,6 @@ package org.jetbrains.dukat.astModel data class ConstructorModel( - val parameters: List, + val parameters: List, val typeParameters: List ) : MemberModel \ No newline at end of file diff --git a/ast-model/src/org/jetbrains/dukat/astModel/PropertyParameterModel.kt b/ast-model/src/org/jetbrains/dukat/astModel/PropertyParameterModel.kt new file mode 100644 index 000000000..aa5c59636 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/compiler/test/data/typescript/class/constructor/withPropertyDeclaration.d.kt b/compiler/test/data/typescript/class/constructor/withPropertyDeclaration.d.kt index 6d214925b..a286f2b74 100644 --- a/compiler/test/data/typescript/class/constructor/withPropertyDeclaration.d.kt +++ b/compiler/test/data/typescript/class/constructor/withPropertyDeclaration.d.kt @@ -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 -} +external open class Foo(var x: Any) -external open class Bar(n: Number, a: Any) { - open var n: Number - open var a: Any -} \ No newline at end of file +external open class Bar(var n: Number, var a: Any) \ No newline at end of file diff --git a/descriptors/src/org/jetbrains/dukat/descriptors/DescriptorTranslator.kt b/descriptors/src/org/jetbrains/dukat/descriptors/DescriptorTranslator.kt index 3436b136b..f96c18b82 100644 --- a/descriptors/src/org/jetbrains/dukat/descriptors/DescriptorTranslator.kt +++ b/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(), constructorDescriptor), visibility ) constructorDescriptor.returnType = LazyWrappedType(LockBasedStorageManager.NO_LOCKS) { diff --git a/javascript/js-type-analysis/src/org/jetbrains/dukat/js/type/analysis/members.kt b/javascript/js-type-analysis/src/org/jetbrains/dukat/js/type/analysis/members.kt index c2e612d1f..5baa6cf26 100644 --- a/javascript/js-type-analysis/src/org/jetbrains/dukat/js/type/analysis/members.kt +++ b/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(), type = TypeDeclaration( value = IdentifierEntity("Unit"), params = emptyList() diff --git a/model-lowerings-common/src/org/jetbrains/dukat/model/commonLowerings/ModelWithOwnerLowering.kt b/model-lowerings-common/src/org/jetbrains/dukat/model/commonLowerings/ModelWithOwnerLowering.kt index cd4e03b00..7d11dc353 100644 --- a/model-lowerings-common/src/org/jetbrains/dukat/model/commonLowerings/ModelWithOwnerLowering.kt +++ b/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 fun lowerLambdaParameterModel(ownerContext: NodeOwner): LambdaParameterModel fun lowerParameterModel(ownerContext: NodeOwner): ParameterModel + fun lowerPropertyParameterModel(ownerContext: NodeOwner): PropertyParameterModel fun lowerMemberModel(ownerContext: NodeOwner, parentModule: ModuleModel): MemberModel? + fun lowerCallableParameterModel(ownerContext: NodeOwner): 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 { val typeParameterModel = ownerContext.node return typeParameterModel.copy( diff --git a/model-lowerings-common/src/org/jetbrains/dukat/model/commonLowerings/ModelWithOwnerTypeLowering.kt b/model-lowerings-common/src/org/jetbrains/dukat/model/commonLowerings/ModelWithOwnerTypeLowering.kt index 161befc31..5f4995a16 100644 --- a/model-lowerings-common/src/org/jetbrains/dukat/model/commonLowerings/ModelWithOwnerTypeLowering.kt +++ b/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 { + val declaration = ownerContext.node + return declaration.copy(type = lowerTypeModel(NodeOwner(declaration.type, ownerContext))) + } + override fun lowerParameterModel(ownerContext: NodeOwner): 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 { 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)) } ) } diff --git a/model-lowerings-common/src/org/jetbrains/dukat/model/commonLowerings/resolveTopLevelVisibility.kt b/model-lowerings-common/src/org/jetbrains/dukat/model/commonLowerings/resolveTopLevelVisibility.kt index 6966340c1..5c17c4d98 100644 --- a/model-lowerings-common/src/org/jetbrains/dukat/model/commonLowerings/resolveTopLevelVisibility.kt +++ b/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 { + return ownerContext.node.copy(visibilityModifier = visibility) + } + override fun lowerLambdaParameterModel(ownerContext: NodeOwner) = ownerContext.node override fun lowerParameterModel(ownerContext: NodeOwner): ParameterModel = ownerContext.node diff --git a/translator-string/src/org/jetbrains/dukat/translatorString/StringTranslator.kt b/translator-string/src/org/jetbrains/dukat/translatorString/StringTranslator.kt index f114f69ea..d3d0266f4 100644 --- a/translator-string/src/org/jetbrains/dukat/translatorString/StringTranslator.kt +++ b/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): String { @@ -224,7 +244,7 @@ private fun translateTypeArguments(typeParameters: List): String { } -private fun translateParameters(parameters: List, needsMeta: Boolean = true): String { +private fun translateParameters(parameters: List, 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" diff --git a/typescript/ts-converter/src/AstConverter.ts b/typescript/ts-converter/src/AstConverter.ts index 2f8400edc..09be05364 100644 --- a/typescript/ts-converter/src/AstConverter.ts +++ b/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 { - let params: Array = []; + let params: Array = []; let res: Array = []; 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( diff --git a/typescript/ts-converter/src/ast/AstFactory.ts b/typescript/ts-converter/src/ast/AstFactory.ts index 68d038241..3fcdfb51b 100644 --- a/typescript/ts-converter/src/ast/AstFactory.ts +++ b/typescript/ts-converter/src/ast/AstFactory.ts @@ -33,6 +33,7 @@ import { CaseDeclarationProto, ClassDeclarationProto, ConstructorDeclarationProto, + ConstructorParameterDeclarationProto, ContinueStatementDeclarationProto, DefinitionInfoDeclarationProto, EnumDeclarationProto, @@ -63,6 +64,7 @@ import { ParameterDeclarationProto, ParameterValueDeclarationProto, PropertyDeclarationProto, + PropertyParameterDeclarationProto, QualifierDeclarationProto, ReferenceClauseDeclarationProto, ReferenceDeclarationProto, @@ -159,7 +161,7 @@ export class AstFactory { return topLevelDeclaration; } - createConstructorDeclaration(parameters: Array, typeParams: Array, modifiers: Array, body: Block | null): MemberDeclaration { + createConstructorDeclaration(parameters: Array, typeParams: Array, modifiers: Array, body: Block | null): MemberDeclaration { let constructorDeclaration = new ConstructorDeclarationProto(); constructorDeclaration.setParametersList(parameters); @@ -530,6 +532,26 @@ export class AstFactory { return paramValueDeclaration; } + createSimpleConstructorParameterDeclaration(parameter: ParameterDeclaration): ConstructorParameterDeclarationProto { + let constructorParameterDeclaration = new ConstructorParameterDeclarationProto(); + constructorParameterDeclaration.setParameter(parameter); + return constructorParameterDeclaration + } + + createPropertyParameterDeclaration(name: string, type: TypeDeclaration, initializer: Expression | null, modifiers: Array): ConstructorParameterDeclarationProto { + let parameterDeclaration = new PropertyParameterDeclarationProto(); + parameterDeclaration.setName(name); + parameterDeclaration.setType(type); + if (initializer != null) { + parameterDeclaration.setInitializer(initializer); + } + parameterDeclaration.setModifiersList(modifiers); + + let constructorParameterDeclaration = new ConstructorParameterDeclarationProto(); + constructorParameterDeclaration.setPropertyparameter(parameterDeclaration); + return constructorParameterDeclaration + } + createParameterDeclaration(name: string, type: TypeDeclaration, initializer: Expression | null, vararg: boolean, optional: boolean): ParameterDeclaration { let parameterDeclaration = new ParameterDeclarationProto(); parameterDeclaration.setName(name); diff --git a/typescript/ts-lowerings/src/org/jetbrains/dukat/tsLowerings/DeclarationLowering.kt b/typescript/ts-lowerings/src/org/jetbrains/dukat/tsLowerings/DeclarationLowering.kt index afc0c6d01..7555a55a8 100644 --- a/typescript/ts-lowerings/src/org/jetbrains/dukat/tsLowerings/DeclarationLowering.kt +++ b/typescript/ts-lowerings/src/org/jetbrains/dukat/tsLowerings/DeclarationLowering.kt @@ -7,6 +7,7 @@ import org.jetbrains.dukat.tsmodel.CallSignatureDeclaration import org.jetbrains.dukat.tsmodel.ClassDeclaration import org.jetbrains.dukat.tsmodel.ClassLikeDeclaration import org.jetbrains.dukat.tsmodel.ConstructorDeclaration +import org.jetbrains.dukat.tsmodel.ConstructorParameterDeclaration import org.jetbrains.dukat.tsmodel.Declaration import org.jetbrains.dukat.tsmodel.FunctionDeclaration import org.jetbrains.dukat.tsmodel.FunctionOwnerDeclaration @@ -20,6 +21,7 @@ import org.jetbrains.dukat.tsmodel.ModuleDeclaration import org.jetbrains.dukat.tsmodel.ParameterDeclaration import org.jetbrains.dukat.tsmodel.ParameterOwnerDeclaration import org.jetbrains.dukat.tsmodel.PropertyDeclaration +import org.jetbrains.dukat.tsmodel.PropertyParameterDeclaration import org.jetbrains.dukat.tsmodel.TypeAliasDeclaration import org.jetbrains.dukat.tsmodel.TypeParameterDeclaration import org.jetbrains.dukat.tsmodel.VariableDeclaration @@ -46,7 +48,7 @@ interface DeclarationLowering : TopLevelDeclarationLowering { fun lowerConstructorDeclaration(declaration: ConstructorDeclaration, owner: NodeOwner?): ConstructorDeclaration { return declaration.copy( - parameters = declaration.parameters.map { parameter -> lowerParameterDeclaration(parameter, owner?.wrap(declaration)) }, + parameters = declaration.parameters.map { parameter -> lowerConstructorParameterDeclaration(parameter, owner?.wrap(declaration)) }, typeParameters = declaration.typeParameters.map { typeParameter -> typeParameter.copy(constraints = typeParameter.constraints.map { constraint -> lowerParameterValue(constraint, owner?.wrap(declaration)) }) } @@ -138,12 +140,26 @@ interface DeclarationLowering : TopLevelDeclarationLowering { ) } + fun lowerConstructorParameterDeclaration(declaration: ConstructorParameterDeclaration, owner: NodeOwner?) : ConstructorParameterDeclaration { + return when (declaration) { + is ParameterDeclaration -> lowerParameterDeclaration(declaration, owner) + is PropertyParameterDeclaration -> lowerPropertyParameter(declaration, owner) + else -> declaration + } + } + fun lowerParameterDeclaration(declaration: ParameterDeclaration, owner: NodeOwner?): ParameterDeclaration { return declaration.copy( type = lowerParameterValue(declaration.type, owner) ) } + fun lowerPropertyParameter(declaration: PropertyParameterDeclaration, owner: NodeOwner?): PropertyParameterDeclaration { + return declaration.copy( + type = lowerParameterValue(declaration.type, owner) + ) + } + override fun lowerVariableDeclaration(declaration: VariableDeclaration, owner: NodeOwner?): VariableDeclaration { return declaration.copy( type = lowerParameterValue(declaration.type, owner?.wrap(declaration)) diff --git a/typescript/ts-lowerings/src/org/jetbrains/dukat/tsLowerings/mergeDuplicates/mergeDuplicates.kt b/typescript/ts-lowerings/src/org/jetbrains/dukat/tsLowerings/mergeDuplicates/mergeDuplicates.kt index 7fa7443df..e6580497c 100644 --- a/typescript/ts-lowerings/src/org/jetbrains/dukat/tsLowerings/mergeDuplicates/mergeDuplicates.kt +++ b/typescript/ts-lowerings/src/org/jetbrains/dukat/tsLowerings/mergeDuplicates/mergeDuplicates.kt @@ -4,11 +4,13 @@ import org.jetbrains.dukat.panic.raiseConcern import org.jetbrains.dukat.tsmodel.CallSignatureDeclaration import org.jetbrains.dukat.tsmodel.ClassDeclaration import org.jetbrains.dukat.tsmodel.ConstructorDeclaration +import org.jetbrains.dukat.tsmodel.ConstructorParameterDeclaration import org.jetbrains.dukat.tsmodel.FunctionDeclaration import org.jetbrains.dukat.tsmodel.FunctionLikeDeclaration import org.jetbrains.dukat.tsmodel.MemberDeclaration import org.jetbrains.dukat.tsmodel.ModuleDeclaration import org.jetbrains.dukat.tsmodel.ParameterDeclaration +import org.jetbrains.dukat.tsmodel.PropertyParameterDeclaration import org.jetbrains.dukat.tsmodel.SourceFileDeclaration import org.jetbrains.dukat.tsmodel.SourceSetDeclaration import org.jetbrains.dukat.tsmodel.TopLevelDeclaration @@ -151,6 +153,16 @@ private fun ParameterDeclaration.mergeDuplicates() = copy( type = type.mergeDuplicates() ) +private fun PropertyParameterDeclaration.mergeDuplicates() = copy( + type = type.mergeDuplicates() +) + +private fun ConstructorParameterDeclaration.mergeDuplicates() = when (this) { + is ParameterDeclaration -> mergeDuplicates() + is PropertyParameterDeclaration -> mergeDuplicates() + else -> this +} + private fun ConstructorDeclaration.mergeDuplicates() = copy( parameters = parameters.map { it.mergeDuplicates() } ) diff --git a/typescript/ts-lowerings/src/org/jetbrains/dukat/tsLowerings/mergeDuplicates/normalize.kt b/typescript/ts-lowerings/src/org/jetbrains/dukat/tsLowerings/mergeDuplicates/normalize.kt index cc8ad4794..28bebc01a 100644 --- a/typescript/ts-lowerings/src/org/jetbrains/dukat/tsLowerings/mergeDuplicates/normalize.kt +++ b/typescript/ts-lowerings/src/org/jetbrains/dukat/tsLowerings/mergeDuplicates/normalize.kt @@ -2,9 +2,11 @@ package org.jetbrains.dukat.tsLowerings.mergeDuplicates import org.jetbrains.dukat.tsmodel.CallSignatureDeclaration import org.jetbrains.dukat.tsmodel.ConstructorDeclaration +import org.jetbrains.dukat.tsmodel.ConstructorParameterDeclaration import org.jetbrains.dukat.tsmodel.FunctionDeclaration import org.jetbrains.dukat.tsmodel.MemberDeclaration import org.jetbrains.dukat.tsmodel.ParameterDeclaration +import org.jetbrains.dukat.tsmodel.PropertyParameterDeclaration import org.jetbrains.dukat.tsmodel.types.FunctionTypeDeclaration import org.jetbrains.dukat.tsmodel.types.ObjectLiteralDeclaration import org.jetbrains.dukat.tsmodel.types.ParameterValueDeclaration @@ -17,6 +19,17 @@ internal fun ParameterDeclaration.normalize(name: String = "") = copy( type = type.normalize() ) +internal fun PropertyParameterDeclaration.normalize(name: String = "") = copy( + name = name, + type = type.normalize() +) + +private fun ConstructorParameterDeclaration.normalize(name: String = "") = when (this) { + is ParameterDeclaration -> normalize(name) + is PropertyParameterDeclaration -> normalize(name) + else -> this +} + internal fun CallSignatureDeclaration.normalize(substituteType: ParameterValueDeclaration? = null) = copy( parameters = parameters.map { parameter -> parameter.normalize(parameter.name) }, type = substituteType ?: type.normalize() diff --git a/typescript/ts-model-proto/src/Declarations.proto b/typescript/ts-model-proto/src/Declarations.proto index 32fa8550f..164771826 100644 --- a/typescript/ts-model-proto/src/Declarations.proto +++ b/typescript/ts-model-proto/src/Declarations.proto @@ -101,7 +101,7 @@ message CallSignatureDeclarationProto { } message ConstructorDeclarationProto { - repeated ParameterDeclarationProto parameters = 1; + repeated ConstructorParameterDeclarationProto parameters = 1; repeated TypeParameterDeclarationProto typeParameters = 2; repeated ModifierDeclarationProto modifiers = 3; BlockDeclarationProto body = 6; @@ -421,6 +421,20 @@ message ThrowStatementDeclarationProto { ExpressionDeclarationProto expression = 1; } +message ConstructorParameterDeclarationProto { + oneof type { + ParameterDeclarationProto parameter = 1; + PropertyParameterDeclarationProto propertyParameter = 2; + } +} + +message PropertyParameterDeclarationProto { + string name = 1; + ParameterValueDeclarationProto type = 2; + ExpressionDeclarationProto initializer = 3; + repeated ModifierDeclarationProto modifiers = 4; +} + message ParameterDeclarationProto { string name = 1; ParameterValueDeclarationProto type = 2; diff --git a/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/ConstructorDeclaration.kt b/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/ConstructorDeclaration.kt index c83829f40..670066426 100644 --- a/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/ConstructorDeclaration.kt +++ b/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/ConstructorDeclaration.kt @@ -1,7 +1,7 @@ package org.jetbrains.dukat.tsmodel data class ConstructorDeclaration( - val parameters: List, + val parameters: List, val typeParameters: List, override val modifiers: Set, val body: BlockDeclaration? diff --git a/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/ConstructorParameterDeclaration.kt b/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/ConstructorParameterDeclaration.kt new file mode 100644 index 000000000..2b7d3a71b --- /dev/null +++ b/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/ConstructorParameterDeclaration.kt @@ -0,0 +1,11 @@ +package org.jetbrains.dukat.tsmodel + +import org.jetbrains.dukat.astCommon.Entity +import org.jetbrains.dukat.tsmodel.expression.ExpressionDeclaration +import org.jetbrains.dukat.tsmodel.types.ParameterValueDeclaration + +interface ConstructorParameterDeclaration : Entity { + val name: String + val type: ParameterValueDeclaration + val initializer: ExpressionDeclaration? +} \ No newline at end of file diff --git a/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/ParameterDeclaration.kt b/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/ParameterDeclaration.kt index 2e050a282..ed3ff3425 100644 --- a/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/ParameterDeclaration.kt +++ b/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/ParameterDeclaration.kt @@ -5,10 +5,10 @@ import org.jetbrains.dukat.tsmodel.expression.ExpressionDeclaration import org.jetbrains.dukat.tsmodel.types.ParameterValueDeclaration data class ParameterDeclaration( - val name: String, - val type: ParameterValueDeclaration, - val initializer: ExpressionDeclaration?, + override val name: String, + override val type: ParameterValueDeclaration, + override val initializer: ExpressionDeclaration?, val vararg: Boolean, val optional: Boolean -) : Entity \ No newline at end of file +) : ConstructorParameterDeclaration \ No newline at end of file diff --git a/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/PropertyParameterDeclaration.kt b/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/PropertyParameterDeclaration.kt new file mode 100644 index 000000000..4d5e49b37 --- /dev/null +++ b/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/PropertyParameterDeclaration.kt @@ -0,0 +1,11 @@ +package org.jetbrains.dukat.tsmodel + +import org.jetbrains.dukat.tsmodel.expression.ExpressionDeclaration +import org.jetbrains.dukat.tsmodel.types.ParameterValueDeclaration + +data class PropertyParameterDeclaration( + override val name: String, + override val type: ParameterValueDeclaration, + override val initializer: ExpressionDeclaration?, + val modifiers: Set +): ConstructorParameterDeclaration \ No newline at end of file diff --git a/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/factory/convertProtobuf.kt b/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/factory/convertProtobuf.kt index eb75af90b..9a58ddb89 100644 --- a/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/factory/convertProtobuf.kt +++ b/typescript/ts-model/src/org/jetbrains/dukat/tsmodel/factory/convertProtobuf.kt @@ -12,6 +12,7 @@ import org.jetbrains.dukat.tsmodel.CallSignatureDeclaration import org.jetbrains.dukat.tsmodel.CaseDeclaration import org.jetbrains.dukat.tsmodel.ClassDeclaration import org.jetbrains.dukat.tsmodel.ConstructorDeclaration +import org.jetbrains.dukat.tsmodel.ConstructorParameterDeclaration import org.jetbrains.dukat.tsmodel.ContinueStatementDeclaration import org.jetbrains.dukat.tsmodel.DefinitionInfoDeclaration import org.jetbrains.dukat.tsmodel.EnumDeclaration @@ -34,6 +35,7 @@ import org.jetbrains.dukat.tsmodel.ModuleDeclarationKind import org.jetbrains.dukat.tsmodel.expression.NonNullExpressionDeclaration import org.jetbrains.dukat.tsmodel.ParameterDeclaration import org.jetbrains.dukat.tsmodel.PropertyDeclaration +import org.jetbrains.dukat.tsmodel.PropertyParameterDeclaration import org.jetbrains.dukat.tsmodel.ReferenceDeclaration import org.jetbrains.dukat.tsmodel.ReferenceKindDeclaration import org.jetbrains.dukat.tsmodel.ReferenceOriginDeclaration @@ -110,6 +112,7 @@ import org.jetbrains.dukat.tsmodelproto.CaseDeclarationProto import org.jetbrains.dukat.tsmodelproto.ClassDeclarationProto import org.jetbrains.dukat.tsmodelproto.ConditionalExpressionDeclarationProto import org.jetbrains.dukat.tsmodelproto.ConstructorDeclarationProto +import org.jetbrains.dukat.tsmodelproto.ConstructorParameterDeclarationProto import org.jetbrains.dukat.tsmodelproto.ContinueStatementDeclarationProto import org.jetbrains.dukat.tsmodelproto.DefinitionInfoDeclarationProto import org.jetbrains.dukat.tsmodelproto.ElementAccessExpressionDeclarationProto @@ -143,6 +146,7 @@ import org.jetbrains.dukat.tsmodelproto.ParameterValueDeclarationProto import org.jetbrains.dukat.tsmodelproto.ParenthesizedExpressionDeclarationProto import org.jetbrains.dukat.tsmodelproto.PropertyAccessExpressionDeclarationProto import org.jetbrains.dukat.tsmodelproto.PropertyDeclarationProto +import org.jetbrains.dukat.tsmodelproto.PropertyParameterDeclarationProto import org.jetbrains.dukat.tsmodelproto.QualifierDeclarationProto import org.jetbrains.dukat.tsmodelproto.ReferenceClauseDeclarationProto import org.jetbrains.dukat.tsmodelproto.ReferenceDeclarationProto @@ -503,6 +507,25 @@ fun MemberDeclarationProto.convert(): MemberDeclaration { } } +fun PropertyParameterDeclarationProto.convert(): PropertyParameterDeclaration { + return PropertyParameterDeclaration( + name, + type.convert(), + if (hasInitializer()) { + initializer.convert() + } else null, + modifiersList.mapNotNull { it.convert() }.toSet() + ) +} + +fun ConstructorParameterDeclarationProto.convert(): ConstructorParameterDeclaration { + return when { + hasParameter() -> parameter.convert() + hasPropertyParameter() -> propertyParameter.convert() + else -> throw Exception("unknown ConstructorParameterDeclarationProto: $this") + } +} + fun ConstructorDeclarationProto.convert(): ConstructorDeclaration { return ConstructorDeclaration( parametersList.map { it.convert() }, diff --git a/typescript/ts-node-introduction/src/org/jetbrains/dukat/nodeIntroduction/introduceNodes.kt b/typescript/ts-node-introduction/src/org/jetbrains/dukat/nodeIntroduction/introduceNodes.kt index 5b278fe2a..405a2c33b 100644 --- a/typescript/ts-node-introduction/src/org/jetbrains/dukat/nodeIntroduction/introduceNodes.kt +++ b/typescript/ts-node-introduction/src/org/jetbrains/dukat/nodeIntroduction/introduceNodes.kt @@ -3,6 +3,7 @@ package org.jetbrains.dukat.nodeIntroduction import org.jetbrains.dukat.ast.model.makeNullable import org.jetbrains.dukat.ast.model.nodes.ClassNode import org.jetbrains.dukat.ast.model.nodes.ConstructorNode +import org.jetbrains.dukat.ast.model.nodes.ConstructorParameterNode import org.jetbrains.dukat.ast.model.nodes.EnumNode import org.jetbrains.dukat.ast.model.nodes.EnumTokenNode import org.jetbrains.dukat.ast.model.nodes.ExportAssignmentNode @@ -24,6 +25,7 @@ import org.jetbrains.dukat.ast.model.nodes.ReferenceOriginNode import org.jetbrains.dukat.ast.model.nodes.SourceFileNode import org.jetbrains.dukat.ast.model.nodes.SourceSetNode import org.jetbrains.dukat.ast.model.nodes.LiteralUnionNode +import org.jetbrains.dukat.ast.model.nodes.PropertyParameterNode import org.jetbrains.dukat.ast.model.nodes.TopLevelNode import org.jetbrains.dukat.ast.model.nodes.TupleTypeNode import org.jetbrains.dukat.ast.model.nodes.TypeAliasNode @@ -52,6 +54,7 @@ import org.jetbrains.dukat.stdlib.TSLIBROOT import org.jetbrains.dukat.tsmodel.CallSignatureDeclaration import org.jetbrains.dukat.tsmodel.ClassDeclaration import org.jetbrains.dukat.tsmodel.ConstructorDeclaration +import org.jetbrains.dukat.tsmodel.ConstructorParameterDeclaration import org.jetbrains.dukat.tsmodel.EnumDeclaration import org.jetbrains.dukat.tsmodel.FunctionDeclaration import org.jetbrains.dukat.tsmodel.GeneratedInterfaceDeclaration @@ -65,6 +68,7 @@ import org.jetbrains.dukat.tsmodel.ModuleDeclaration import org.jetbrains.dukat.tsmodel.ModuleDeclarationKind import org.jetbrains.dukat.tsmodel.ParameterDeclaration import org.jetbrains.dukat.tsmodel.PropertyDeclaration +import org.jetbrains.dukat.tsmodel.PropertyParameterDeclaration import org.jetbrains.dukat.tsmodel.ReferenceOriginDeclaration import org.jetbrains.dukat.tsmodel.SourceFileDeclaration import org.jetbrains.dukat.tsmodel.SourceSetDeclaration @@ -132,6 +136,16 @@ private fun ParameterDeclaration.convertToNode(context: PARAMETER_CONTEXT = PARA ) } +private fun PropertyParameterDeclaration.convertToNode(): PropertyParameterNode { + return PropertyParameterNode( + name = name, + type = type.convertToNode(), + initializer = if (initializer != null) { + TypeValueNode(IdentifierEntity("definedExternally"), emptyList()) + } else null + ) +} + private fun UnionTypeDeclaration.canBeTranslatedAsStringLiteral(): Boolean { return params.all { it is StringLiteralDeclaration } } @@ -300,6 +314,16 @@ private class LowerDeclarationsToNodes( return parameters.map { param -> param.convertToNode() } } + private fun convertConstructorParameters(parameters: List): List { + return parameters.mapNotNull { param -> + when (param) { + is ParameterDeclaration -> param.convertToNode() + is PropertyParameterDeclaration -> param.convertToNode() + else -> null + } + } + } + private fun convertTypeParameters(typeParams: List): List { return typeParams.map { typeParam -> TypeValueNode( @@ -453,7 +477,7 @@ private class LowerDeclarationsToNodes( private fun ConstructorDeclaration.convert(): ConstructorNode { return ConstructorNode( - convertParameters(parameters), + convertConstructorParameters(parameters), convertTypeParameters(typeParameters) ) } diff --git a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/NodeTypeLowering.kt b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/NodeTypeLowering.kt index 133aeb738..f223a3fcc 100644 --- a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/NodeTypeLowering.kt +++ b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/NodeTypeLowering.kt @@ -12,6 +12,7 @@ import org.jetbrains.dukat.ast.model.nodes.MethodNode import org.jetbrains.dukat.ast.model.nodes.ObjectNode import org.jetbrains.dukat.ast.model.nodes.ParameterNode import org.jetbrains.dukat.ast.model.nodes.PropertyNode +import org.jetbrains.dukat.ast.model.nodes.PropertyParameterNode import org.jetbrains.dukat.ast.model.nodes.TupleTypeNode import org.jetbrains.dukat.ast.model.nodes.TypeAliasNode import org.jetbrains.dukat.ast.model.nodes.TypeNode @@ -142,6 +143,13 @@ interface NodeTypeLowering : TopLevelNodeLowering { ) } + override fun lowerPropertyParameterNode(declaration: PropertyParameterNode): PropertyParameterNode { + return declaration.copy( + name = lowerIdentificator(declaration.name), + type = lowerType(declaration.type) + ) + } + override fun lowerVariableNode(declaration: VariableNode): VariableNode { return declaration.copy(name = lowerIdentificator(declaration.name), type = lowerType(declaration.type)) } @@ -175,7 +183,7 @@ interface NodeTypeLowering : TopLevelNodeLowering { fun lowerConstructorNode(declaration: ConstructorNode): ConstructorNode { return declaration.copy( - parameters = declaration.parameters.map { parameter -> lowerParameterNode(parameter) }, + parameters = declaration.parameters.map { parameter -> lowerConstructorParameterNode(parameter) }, typeParameters = declaration.typeParameters.map { typeParameter -> lowerTypeParameter(typeParameter) } diff --git a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/NodeWithOwnerLowering.kt b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/NodeWithOwnerLowering.kt index 926e56a6c..f7d68076c 100644 --- a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/NodeWithOwnerLowering.kt +++ b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/NodeWithOwnerLowering.kt @@ -3,6 +3,7 @@ package org.jetrbains.dukat.nodeLowering import org.jetbrains.dukat.ast.model.duplicate import org.jetbrains.dukat.ast.model.nodes.ClassLikeNode import org.jetbrains.dukat.ast.model.nodes.ClassNode +import org.jetbrains.dukat.ast.model.nodes.ConstructorParameterNode import org.jetbrains.dukat.ast.model.nodes.ModuleNode import org.jetbrains.dukat.ast.model.nodes.FunctionNode import org.jetbrains.dukat.ast.model.nodes.FunctionTypeNode @@ -10,6 +11,7 @@ import org.jetbrains.dukat.ast.model.nodes.InterfaceNode import org.jetbrains.dukat.ast.model.nodes.MemberNode import org.jetbrains.dukat.ast.model.nodes.ObjectNode import org.jetbrains.dukat.ast.model.nodes.ParameterNode +import org.jetbrains.dukat.ast.model.nodes.PropertyParameterNode import org.jetbrains.dukat.ast.model.nodes.TopLevelNode import org.jetbrains.dukat.ast.model.nodes.TypeAliasNode import org.jetbrains.dukat.ast.model.nodes.TypeValueNode @@ -25,6 +27,7 @@ interface NodeWithOwnerLowering { fun lowerInterfaceNode(owner: NodeOwner): InterfaceNode fun lowerParameterNode(owner: NodeOwner): ParameterNode + fun lowerPropertyParameterNode(owner: NodeOwner): PropertyParameterNode fun lowerTypeParameter(owner: NodeOwner): TypeValueNode fun lowerMemberNode(owner: NodeOwner): MemberNode fun lowerTypeAliasNode(owner: NodeOwner): TypeAliasNode @@ -34,6 +37,14 @@ interface NodeWithOwnerLowering { fun lowerFunctionTypeNode(owner: NodeOwner): T fun lowerUnionTypeNode(owner: NodeOwner): T + fun lowerConstructorParameterNode(owner: NodeOwner): ConstructorParameterNode { + return when (val declaration = owner.node) { + is ParameterNode -> lowerParameterNode(owner.wrap(declaration)) + is PropertyParameterNode -> lowerPropertyParameterNode(owner.wrap(declaration)) + else -> declaration + } + } + fun lowerClassLikeNode(owner: NodeOwner): ClassLikeNode { val declaration = owner.node return when (declaration) { diff --git a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/NodeWithOwnerTypeLowering.kt b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/NodeWithOwnerTypeLowering.kt index 4e11cf2eb..e58805bf2 100644 --- a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/NodeWithOwnerTypeLowering.kt +++ b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/NodeWithOwnerTypeLowering.kt @@ -11,6 +11,7 @@ import org.jetbrains.dukat.ast.model.nodes.MethodNode import org.jetbrains.dukat.ast.model.nodes.ObjectNode import org.jetbrains.dukat.ast.model.nodes.ParameterNode import org.jetbrains.dukat.ast.model.nodes.PropertyNode +import org.jetbrains.dukat.ast.model.nodes.PropertyParameterNode import org.jetbrains.dukat.ast.model.nodes.TypeAliasNode import org.jetbrains.dukat.ast.model.nodes.TypeNode import org.jetbrains.dukat.ast.model.nodes.TypeValueNode @@ -135,6 +136,14 @@ interface NodeWithOwnerTypeLowering : NodeWithOwnerLowering): PropertyParameterNode { + val declaration = owner.node + return declaration.copy( + name = lowerIdentificator(declaration.name), + type = lowerType(owner.wrap(declaration.type)) + ) + } + override fun lowerVariableNode(owner: NodeOwner): VariableNode { val declaration = owner.node return declaration.copy( @@ -177,7 +186,7 @@ interface NodeWithOwnerTypeLowering : NodeWithOwnerLowering): ConstructorNode { val declaration = owner.node return declaration.copy( - parameters = declaration.parameters.map { parameter -> lowerParameterNode(owner.wrap(parameter)) }, + parameters = declaration.parameters.map { parameter -> lowerConstructorParameterNode(owner.wrap(parameter)) }, typeParameters = declaration.typeParameters.map { typeParameter -> typeParameter.copy(params = typeParameter.params.map { param -> lowerType(owner.wrap(param)) }) } diff --git a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/TopLevelNodeLowering.kt b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/TopLevelNodeLowering.kt index 8f5cb7ca6..48f355fbe 100644 --- a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/TopLevelNodeLowering.kt +++ b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/TopLevelNodeLowering.kt @@ -3,11 +3,15 @@ package org.jetrbains.dukat.nodeLowering import org.jetbrains.dukat.ast.model.duplicate import org.jetbrains.dukat.ast.model.nodes.ClassLikeNode import org.jetbrains.dukat.ast.model.nodes.ClassNode +import org.jetbrains.dukat.ast.model.nodes.ConstructorParameterNode +import org.jetbrains.dukat.ast.model.nodes.ModuleNode import org.jetbrains.dukat.ast.model.nodes.EnumNode import org.jetbrains.dukat.ast.model.nodes.FunctionNode import org.jetbrains.dukat.ast.model.nodes.InterfaceNode import org.jetbrains.dukat.ast.model.nodes.ModuleNode import org.jetbrains.dukat.ast.model.nodes.ObjectNode +import org.jetbrains.dukat.ast.model.nodes.ParameterNode +import org.jetbrains.dukat.ast.model.nodes.PropertyParameterNode import org.jetbrains.dukat.ast.model.nodes.TopLevelNode import org.jetbrains.dukat.ast.model.nodes.TypeAliasNode import org.jetbrains.dukat.ast.model.nodes.VariableNode @@ -21,6 +25,14 @@ interface TopLevelNodeLowering { fun lowerEnumNode(declaration: EnumNode, owner: ModuleNode): EnumNode = declaration fun lowerTypeAliasNode(declaration: TypeAliasNode, owner: ModuleNode): TypeAliasNode = declaration + fun lowerConstructorParameterNode(declaration: ConstructorParameterNode): ConstructorParameterNode { + return when (declaration) { + is ParameterNode -> lowerParameterNode(declaration) + is PropertyParameterNode -> lowerPropertyParameterNode(declaration) + else -> declaration + } + } + fun lowerClassLikeNode(declaration: ClassLikeNode, owner: ModuleNode): ClassLikeNode { return when (declaration) { is InterfaceNode -> lowerInterfaceNode(declaration) diff --git a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/lowerings/introduceModels.kt b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/lowerings/introduceModels.kt index 3a36d819e..bccc6cf2a 100644 --- a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/lowerings/introduceModels.kt +++ b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/lowerings/introduceModels.kt @@ -4,6 +4,7 @@ import org.jetbrains.dukat.ast.model.nodes.ClassLikeNode import org.jetbrains.dukat.ast.model.nodes.ClassLikeReferenceNode import org.jetbrains.dukat.ast.model.nodes.ClassNode import org.jetbrains.dukat.ast.model.nodes.ConstructorNode +import org.jetbrains.dukat.ast.model.nodes.ConstructorParameterNode import org.jetbrains.dukat.ast.model.nodes.EnumNode import org.jetbrains.dukat.ast.model.nodes.FunctionFromCallSignature import org.jetbrains.dukat.ast.model.nodes.FunctionFromMethodSignatureDeclaration @@ -23,6 +24,7 @@ import org.jetbrains.dukat.ast.model.nodes.PropertyNode import org.jetbrains.dukat.ast.model.nodes.ReferenceOriginNode import org.jetbrains.dukat.ast.model.nodes.SourceSetNode import org.jetbrains.dukat.ast.model.nodes.LiteralUnionNode +import org.jetbrains.dukat.ast.model.nodes.PropertyParameterNode import org.jetbrains.dukat.ast.model.nodes.TupleTypeNode import org.jetbrains.dukat.ast.model.nodes.TypeAliasNode import org.jetbrains.dukat.ast.model.nodes.TypeNode @@ -44,6 +46,7 @@ import org.jetbrains.dukat.astCommon.TopLevelEntity import org.jetbrains.dukat.astCommon.appendLeft import org.jetbrains.dukat.astCommon.rightMost 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 @@ -61,6 +64,7 @@ import org.jetbrains.dukat.astModel.ModuleModel import org.jetbrains.dukat.astModel.ObjectModel import org.jetbrains.dukat.astModel.ParameterModel import org.jetbrains.dukat.astModel.PropertyModel +import org.jetbrains.dukat.astModel.PropertyParameterModel import org.jetbrains.dukat.astModel.SourceFileModel import org.jetbrains.dukat.astModel.SourceSetModel import org.jetbrains.dukat.astModel.TopLevelModel @@ -390,6 +394,39 @@ internal class DocumentConverter(private val moduleNode: ModuleNode, private val ) } + private fun PropertyParameterNode.process(context: TranslationContext = TranslationContext.IRRELEVANT): PropertyParameterModel { + return PropertyParameterModel( + type = type.process(context), + name = name, + initializer = initializer?.let { + ExpressionStatementModel( + IdentifierExpressionModel( + initializer!!.value + ) + ) + }, + visibilityModifier = VisibilityModifierModel.DEFAULT + ) + } + + private fun ConstructorParameterNode.process(): CallableParameterModel { + return when (this) { + is ParameterNode -> process() + is PropertyParameterNode -> process() + else -> raiseConcern("unable to process ConstructorParameterNode ${this}") { + LambdaParameterModel( + null, + TypeValueModel( + IdentifierEntity("ERROR"), + listOf(), + null, + null + ) + ) + } + } + } + private fun ParameterValueDeclaration?.processMeta(): String? { return when (this) { is ThisTypeInGeneratedInterfaceMetaData -> "this" diff --git a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/lowerings/specifyUnionType.kt b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/lowerings/specifyUnionType.kt index e07f98926..aa12a063b 100644 --- a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/lowerings/specifyUnionType.kt +++ b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/lowerings/specifyUnionType.kt @@ -5,6 +5,8 @@ import org.jetbrains.dukat.ast.model.duplicate import org.jetbrains.dukat.ast.model.makeNullable import org.jetbrains.dukat.ast.model.nodes.ClassNode import org.jetbrains.dukat.ast.model.nodes.ConstructorNode +import org.jetbrains.dukat.ast.model.nodes.ConstructorParameterNode +import org.jetbrains.dukat.ast.model.nodes.ModuleNode import org.jetbrains.dukat.ast.model.nodes.FunctionNode import org.jetbrains.dukat.ast.model.nodes.InterfaceNode import org.jetbrains.dukat.ast.model.nodes.MethodNode @@ -16,12 +18,14 @@ import org.jetbrains.dukat.ast.model.nodes.TopLevelNode import org.jetbrains.dukat.ast.model.nodes.TypeAliasNode import org.jetbrains.dukat.ast.model.nodes.UnionTypeNode import org.jetbrains.dukat.ast.model.nodes.VariableNode +import org.jetbrains.dukat.ast.model.nodes.changeName +import org.jetbrains.dukat.ast.model.nodes.changeType import org.jetbrains.dukat.ast.model.nodes.transform import org.jetrbains.dukat.nodeLowering.TopLevelNodeLowering const val COMPLEXITY_THRESHOLD = 15 -private fun specifyArguments(params: List): List> { +private fun specifyArguments(params: List): List> { var currentComplexity = 1 @@ -31,7 +35,7 @@ private fun specifyArguments(params: List): List - parameterDeclaration.copy(type = (if (type.nullable) param.makeNullable() else param)) + parameterDeclaration.changeType(if (type.nullable) param.makeNullable() else param) } } else { listOf(parameterDeclaration) @@ -46,7 +50,7 @@ private fun specifyArguments(params: List): List): Pair>, Boolean> { + fun generateParams(params: List): Pair>, Boolean> { val specifyParams = specifyArguments(params) val hasUnrolledParams = specifyParams.any { it.size > 1 } @@ -60,14 +64,14 @@ private class SpecifyUnionTypeLowering : TopLevelNodeLowering { fun generateMethods(declaration: MethodNode): List { val generatedParams = generateParams(declaration.parameters) return generatedParams.first.map { params -> - declaration.copy(parameters = params, meta = MethodNodeMeta(generated = generatedParams.second)) + declaration.copy(parameters = params.filterIsInstance(), meta = MethodNodeMeta(generated = generatedParams.second)) } } fun generateFunctionNodes(declaration: FunctionNode): List { return generateParams(declaration.parameters).first.map { params -> - declaration.copy(parameters = params) + declaration.copy(parameters = params.filterIsInstance()) }.distinctBy { node -> node.copy( parameters = node.parameters.mapIndexed { index, param -> @@ -91,9 +95,10 @@ private class SpecifyUnionTypeLowering : TopLevelNodeLowering { }.distinctBy { node -> node.copy( parameters = node.parameters.mapIndexed { index, param -> - val paramCopy = param.copy( - name = "p${index}", - type = param.type.duplicate() + val paramCopy = param.changeType( + param.type.duplicate() + ).changeName( + "p${index}" ) paramCopy.type.meta = null diff --git a/typescript/ts-nodes/src/org/jetbrains/dukat/ast/model/nodes/ConstructorNode.kt b/typescript/ts-nodes/src/org/jetbrains/dukat/ast/model/nodes/ConstructorNode.kt index f89db971d..56499cfab 100644 --- a/typescript/ts-nodes/src/org/jetbrains/dukat/ast/model/nodes/ConstructorNode.kt +++ b/typescript/ts-nodes/src/org/jetbrains/dukat/ast/model/nodes/ConstructorNode.kt @@ -1,7 +1,7 @@ package org.jetbrains.dukat.ast.model.nodes data class ConstructorNode( - val parameters: List, + val parameters: List, val typeParameters: List, val generated: Boolean = false diff --git a/typescript/ts-nodes/src/org/jetbrains/dukat/ast/model/nodes/ConstructorParameterNode.kt b/typescript/ts-nodes/src/org/jetbrains/dukat/ast/model/nodes/ConstructorParameterNode.kt new file mode 100644 index 000000000..9c99d62dc --- /dev/null +++ b/typescript/ts-nodes/src/org/jetbrains/dukat/ast/model/nodes/ConstructorParameterNode.kt @@ -0,0 +1,25 @@ +package org.jetbrains.dukat.ast.model.nodes + +import org.jetbrains.dukat.astCommon.Entity + +interface ConstructorParameterNode : Entity { + val name: String + val type: TypeNode + val initializer: TypeValueNode? +} + +fun ConstructorParameterNode.changeType(newType: TypeNode): ConstructorParameterNode { + return when (this) { + is ParameterNode -> copy(type = newType) + is PropertyParameterNode -> copy(type = newType) + else -> this + } +} + +fun ConstructorParameterNode.changeName(newName: String): ConstructorParameterNode { + return when (this) { + is ParameterNode -> copy(name = newName) + is PropertyParameterNode -> copy(name = newName) + else -> this + } +} diff --git a/typescript/ts-nodes/src/org/jetbrains/dukat/ast/model/nodes/ParameterNode.kt b/typescript/ts-nodes/src/org/jetbrains/dukat/ast/model/nodes/ParameterNode.kt index 979696332..56ac2eddc 100644 --- a/typescript/ts-nodes/src/org/jetbrains/dukat/ast/model/nodes/ParameterNode.kt +++ b/typescript/ts-nodes/src/org/jetbrains/dukat/ast/model/nodes/ParameterNode.kt @@ -1,13 +1,11 @@ package org.jetbrains.dukat.ast.model.nodes -import org.jetbrains.dukat.astCommon.Entity - data class ParameterNode( - val name: String, - val type: TypeNode, - val initializer: TypeValueNode?, + override val name: String, + override val type: TypeNode, + override val initializer: TypeValueNode?, val meta: String?, val vararg: Boolean, val optional: Boolean -) : Entity \ No newline at end of file +) : ConstructorParameterNode \ No newline at end of file diff --git a/typescript/ts-nodes/src/org/jetbrains/dukat/ast/model/nodes/PropertyParameterNode.kt b/typescript/ts-nodes/src/org/jetbrains/dukat/ast/model/nodes/PropertyParameterNode.kt new file mode 100644 index 000000000..f17483c8f --- /dev/null +++ b/typescript/ts-nodes/src/org/jetbrains/dukat/ast/model/nodes/PropertyParameterNode.kt @@ -0,0 +1,7 @@ +package org.jetbrains.dukat.ast.model.nodes + +data class PropertyParameterNode( + override val name: String, + override val type: TypeNode, + override val initializer: TypeValueNode? +) : ConstructorParameterNode \ No newline at end of file From d341b263c005a742ede447400fb3a8d8481cf7ef Mon Sep 17 00:00:00 2001 From: Alexey Trilis Date: Thu, 18 Jun 2020 14:12:56 +0300 Subject: [PATCH 2/3] Add test --- .../class/constructor/withPropertyDeclaration.d.ts | 7 ------- .../constructorWithPropertyDeclaration.kt} | 4 ++-- .../constructorWithPropertyDeclaration.ts | 11 +++++++++++ 3 files changed, 13 insertions(+), 9 deletions(-) delete mode 100644 compiler/test/data/typescript/class/constructor/withPropertyDeclaration.d.ts rename compiler/test/data/{typescript/class/constructor/withPropertyDeclaration.d.kt => typescriptBodies/constructorWithPropertyDeclaration.kt} (86%) create mode 100644 compiler/test/data/typescriptBodies/constructorWithPropertyDeclaration.ts diff --git a/compiler/test/data/typescript/class/constructor/withPropertyDeclaration.d.ts b/compiler/test/data/typescript/class/constructor/withPropertyDeclaration.d.ts deleted file mode 100644 index 81d99da9c..000000000 --- a/compiler/test/data/typescript/class/constructor/withPropertyDeclaration.d.ts +++ /dev/null @@ -1,7 +0,0 @@ -declare class Foo { - constructor(public x); -} - -declare class Bar { - constructor(public n: number, public a); -} diff --git a/compiler/test/data/typescript/class/constructor/withPropertyDeclaration.d.kt b/compiler/test/data/typescriptBodies/constructorWithPropertyDeclaration.kt similarity index 86% rename from compiler/test/data/typescript/class/constructor/withPropertyDeclaration.d.kt rename to compiler/test/data/typescriptBodies/constructorWithPropertyDeclaration.kt index a286f2b74..7549f5b09 100644 --- a/compiler/test/data/typescript/class/constructor/withPropertyDeclaration.d.kt +++ b/compiler/test/data/typescriptBodies/constructorWithPropertyDeclaration.kt @@ -16,6 +16,6 @@ import org.w3c.performance.* import org.w3c.workers.* import org.w3c.xhr.* -external open class Foo(var x: Any) +open class Foo(var x: Any) -external open class Bar(var n: Number, var a: Any) \ No newline at end of file +open class Bar(var n: Number, var a: Any) \ No newline at end of file diff --git a/compiler/test/data/typescriptBodies/constructorWithPropertyDeclaration.ts b/compiler/test/data/typescriptBodies/constructorWithPropertyDeclaration.ts new file mode 100644 index 000000000..72b1e6514 --- /dev/null +++ b/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) { + + } +} From 638d8f7b1eb9daa609d423f1c4d44bb27b0bd995 Mon Sep 17 00:00:00 2001 From: Alexey Trilis Date: Thu, 18 Jun 2020 14:29:43 +0300 Subject: [PATCH 3/3] Fixes after rebase --- .../constructorWithPropertyDeclaration.kt | 2 +- .../commonLowerings/ModelWithOwnerTypeLowering.kt | 2 +- .../jetrbains/dukat/nodeLowering/NodeTypeLowering.kt | 11 ++++++++++- .../dukat/nodeLowering/TopLevelNodeLowering.kt | 12 ------------ .../dukat/nodeLowering/lowerings/introduceModels.kt | 2 +- .../dukat/nodeLowering/lowerings/specifyUnionType.kt | 1 - 6 files changed, 13 insertions(+), 17 deletions(-) diff --git a/compiler/test/data/typescriptBodies/constructorWithPropertyDeclaration.kt b/compiler/test/data/typescriptBodies/constructorWithPropertyDeclaration.kt index 7549f5b09..1cffe6937 100644 --- a/compiler/test/data/typescriptBodies/constructorWithPropertyDeclaration.kt +++ b/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.* diff --git a/model-lowerings-common/src/org/jetbrains/dukat/model/commonLowerings/ModelWithOwnerTypeLowering.kt b/model-lowerings-common/src/org/jetbrains/dukat/model/commonLowerings/ModelWithOwnerTypeLowering.kt index 5f4995a16..32ddcd428 100644 --- a/model-lowerings-common/src/org/jetbrains/dukat/model/commonLowerings/ModelWithOwnerTypeLowering.kt +++ b/model-lowerings-common/src/org/jetbrains/dukat/model/commonLowerings/ModelWithOwnerTypeLowering.kt @@ -186,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)) }, diff --git a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/NodeTypeLowering.kt b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/NodeTypeLowering.kt index f223a3fcc..83d5c8ee7 100644 --- a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/NodeTypeLowering.kt +++ b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/NodeTypeLowering.kt @@ -2,6 +2,7 @@ package org.jetrbains.dukat.nodeLowering import org.jetbrains.dukat.ast.model.nodes.ClassNode import org.jetbrains.dukat.ast.model.nodes.ConstructorNode +import org.jetbrains.dukat.ast.model.nodes.ConstructorParameterNode import org.jetbrains.dukat.ast.model.nodes.ModuleNode import org.jetbrains.dukat.ast.model.nodes.FunctionNode import org.jetbrains.dukat.ast.model.nodes.FunctionTypeNode @@ -143,13 +144,21 @@ interface NodeTypeLowering : TopLevelNodeLowering { ) } - override fun lowerPropertyParameterNode(declaration: PropertyParameterNode): PropertyParameterNode { + fun lowerPropertyParameterNode(declaration: PropertyParameterNode): PropertyParameterNode { return declaration.copy( name = lowerIdentificator(declaration.name), type = lowerType(declaration.type) ) } + fun lowerConstructorParameterNode(declaration: ConstructorParameterNode): ConstructorParameterNode { + return when (declaration) { + is ParameterNode -> lowerParameterNode(declaration) + is PropertyParameterNode -> lowerPropertyParameterNode(declaration) + else -> declaration + } + } + override fun lowerVariableNode(declaration: VariableNode): VariableNode { return declaration.copy(name = lowerIdentificator(declaration.name), type = lowerType(declaration.type)) } diff --git a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/TopLevelNodeLowering.kt b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/TopLevelNodeLowering.kt index 48f355fbe..8f5cb7ca6 100644 --- a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/TopLevelNodeLowering.kt +++ b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/TopLevelNodeLowering.kt @@ -3,15 +3,11 @@ package org.jetrbains.dukat.nodeLowering import org.jetbrains.dukat.ast.model.duplicate import org.jetbrains.dukat.ast.model.nodes.ClassLikeNode import org.jetbrains.dukat.ast.model.nodes.ClassNode -import org.jetbrains.dukat.ast.model.nodes.ConstructorParameterNode -import org.jetbrains.dukat.ast.model.nodes.ModuleNode import org.jetbrains.dukat.ast.model.nodes.EnumNode import org.jetbrains.dukat.ast.model.nodes.FunctionNode import org.jetbrains.dukat.ast.model.nodes.InterfaceNode import org.jetbrains.dukat.ast.model.nodes.ModuleNode import org.jetbrains.dukat.ast.model.nodes.ObjectNode -import org.jetbrains.dukat.ast.model.nodes.ParameterNode -import org.jetbrains.dukat.ast.model.nodes.PropertyParameterNode import org.jetbrains.dukat.ast.model.nodes.TopLevelNode import org.jetbrains.dukat.ast.model.nodes.TypeAliasNode import org.jetbrains.dukat.ast.model.nodes.VariableNode @@ -25,14 +21,6 @@ interface TopLevelNodeLowering { fun lowerEnumNode(declaration: EnumNode, owner: ModuleNode): EnumNode = declaration fun lowerTypeAliasNode(declaration: TypeAliasNode, owner: ModuleNode): TypeAliasNode = declaration - fun lowerConstructorParameterNode(declaration: ConstructorParameterNode): ConstructorParameterNode { - return when (declaration) { - is ParameterNode -> lowerParameterNode(declaration) - is PropertyParameterNode -> lowerPropertyParameterNode(declaration) - else -> declaration - } - } - fun lowerClassLikeNode(declaration: ClassLikeNode, owner: ModuleNode): ClassLikeNode { return when (declaration) { is InterfaceNode -> lowerInterfaceNode(declaration) diff --git a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/lowerings/introduceModels.kt b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/lowerings/introduceModels.kt index bccc6cf2a..f01c90e00 100644 --- a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/lowerings/introduceModels.kt +++ b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/lowerings/introduceModels.kt @@ -337,7 +337,7 @@ internal class DocumentConverter(private val moduleNode: ModuleNode, private val // TODO: how ClassModel end up here? return when (this) { is ConstructorNode -> ConstructorModel( - parameters = parameters.map { param -> param.process().copy() }, + parameters = parameters.map { param -> param.process() }, typeParameters = convertTypeParams(typeParameters) ) is MethodNode -> process() diff --git a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/lowerings/specifyUnionType.kt b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/lowerings/specifyUnionType.kt index aa12a063b..28ad1714d 100644 --- a/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/lowerings/specifyUnionType.kt +++ b/typescript/ts-node-lowering/src/org/jetrbains/dukat/nodeLowering/lowerings/specifyUnionType.kt @@ -6,7 +6,6 @@ import org.jetbrains.dukat.ast.model.makeNullable import org.jetbrains.dukat.ast.model.nodes.ClassNode import org.jetbrains.dukat.ast.model.nodes.ConstructorNode import org.jetbrains.dukat.ast.model.nodes.ConstructorParameterNode -import org.jetbrains.dukat.ast.model.nodes.ModuleNode import org.jetbrains.dukat.ast.model.nodes.FunctionNode import org.jetbrains.dukat.ast.model.nodes.InterfaceNode import org.jetbrains.dukat.ast.model.nodes.MethodNode