Support abstract readonly properties

Author: epabst

src/main/kotlin/ts2kt/TsClassifierToKt.kt

@@ -77,7 +77,7 @@ abstract class TsClassifierToKt(
         return this
     }
 
-    open fun needsNoImpl(node: PropertyDeclaration): Boolean = true
+    open fun needsNoImpl(node: PropertyDeclaration): Boolean = !isAbstract(node)
     open fun isNullable(node: PropertyDeclaration): Boolean = false
     open fun isLambda(node: PropertyDeclaration): Boolean = false
 
@@ -97,6 +97,8 @@ abstract class TsClassifierToKt(
                 name,
                 type = varType.copy(isNullable = varType.isNullable || isNullable(node)),
                 isOverride = isOverride,
+                isVar = !isReadonly(node),
+                isAbstract = isAbstract(node),
                 needsNoImpl = needsNoImpl(node)
         )
     }

src/main/kotlin/ts2kt/TsInterfaceToKtExtensions.kt

@@ -57,13 +57,13 @@ class TsInterfaceToKtExtensions(
         super.translateGetterAndSetter(node, extendsType = cachedExtendsType)
     }
 
-    override fun addVariable(symbol: Symbol?, name: String, type: KtType, extendsType: KtType?, typeParams: List<KtTypeParam>?, isVar: Boolean, needsNoImpl: Boolean, additionalAnnotations: List<KtAnnotation>, isOverride: Boolean) {
+    override fun addVariable(symbol: Symbol?, name: String, type: KtType, extendsType: KtType?, typeParams: List<KtTypeParam>?, isVar: Boolean, isAbstract: Boolean, needsNoImpl: Boolean, additionalAnnotations: List<KtAnnotation>, isOverride: Boolean) {
         val typeParamsWithoutClashes = this.typeParams.fixIfClashWith(typeParams)
         val actualExtendsType = if (typeParamsWithoutClashes === this.typeParams) cachedExtendsType else getExtendsType(typeParamsWithoutClashes)
         val annotations = additionalAnnotations.withNativeAnnotation()
 
         super.addVariable(symbol, name, type, actualExtendsType, typeParamsWithoutClashes merge typeParams, isVar,
-                needsNoImpl = true, additionalAnnotations = annotations, isOverride = isOverride)
+                needsNoImpl = !isAbstract, additionalAnnotations = annotations, isOverride = isOverride, isAbstract = isAbstract)
     }
 
     override fun addFunction(symbol: Symbol?, name: String, callSignature: KtCallSignature, extendsType: KtType?, needsNoImpl: Boolean, additionalAnnotations: List<KtAnnotation>, isOverride: Boolean, isOperator: Boolean, isAbstract: Boolean) {

src/main/kotlin/ts2kt/TypeScriptToKotlinBase.kt

@@ -16,9 +16,9 @@ abstract class TypeScriptToKotlinBase(
 
     open val defaultAnnotations: List<KtAnnotation> = listOf()
 
-    open fun addVariable(symbol: Symbol?, name: String, type: KtType, extendsType: KtType? = null, typeParams: List<KtTypeParam>? = null, isVar: Boolean = true, needsNoImpl: Boolean = true, additionalAnnotations: List<KtAnnotation> = listOf(), isOverride: Boolean = false) {
+    open fun addVariable(symbol: Symbol?, name: String, type: KtType, extendsType: KtType? = null, typeParams: List<KtTypeParam>? = null, isVar: Boolean = true, isAbstract: Boolean = false, needsNoImpl: Boolean = !isAbstract, additionalAnnotations: List<KtAnnotation> = listOf(), isOverride: Boolean = false) {
         val annotations = defaultAnnotations + additionalAnnotations
-        addDeclaration(symbol, KtVariable(KtName(name), KtTypeAnnotation(type), extendsType?.let { KtHeritageType(it) }, annotations, typeParams, isVar = isVar, needsNoImpl = needsNoImpl, isInInterface = isInterface, isOverride = isOverride, hasOpenModifier = hasMembersOpenModifier))
+        addDeclaration(symbol, KtVariable(KtName(name), KtTypeAnnotation(type), extendsType?.let { KtHeritageType(it) }, annotations, typeParams, isVar = isVar, needsNoImpl = needsNoImpl, isInInterface = isInterface, isOverride = isOverride, hasOpenModifier = hasMembersOpenModifier && !isAbstract, isAbstract = isAbstract))
     }
 
     open fun addFunction(symbol: Symbol?, name: String, callSignature: KtCallSignature, extendsType: KtType? = null, needsNoImpl: Boolean = true, additionalAnnotations: List<KtAnnotation> = listOf(), isOverride: Boolean = false, isOperator: Boolean = false, isAbstract: Boolean = false) {
@@ -38,6 +38,10 @@ abstract class TypeScriptToKotlinBase(
         return node.modifiers?.arr?.any { it.kind == SyntaxKind.AbstractKeyword } == true
     }
 
+    fun isReadonly(node: Node): Boolean {
+        return node.modifiers?.arr?.any { it.kind == SyntaxKind.ReadonlyKeyword } == true
+    }
+
     // TODO
     open fun visitList(node: typescriptServices.ts.Node) {
         forEachChild(this, node)

src/main/kotlin/ts2kt/kotlin/ast/Stringify.kt

@@ -202,6 +202,10 @@ class Stringify(
 
             out.printIndent()
 
+            if (isAbstract) {
+                out.print("$ABSTRACT ")
+            }
+
             if (variable.extendsType == null) {
                 // TODO remove hack
                 printExternalIfNeed()

src/main/kotlin/ts2kt/kotlin/ast/ast.kt

@@ -175,7 +175,8 @@ data class KtVariable(
         override var annotations: List<KtAnnotation>,
         val typeParams: List<KtTypeParam>?,
         var isVar: Boolean,
-        val needsNoImpl: Boolean = true,
+        val isAbstract: Boolean = false,
+        val needsNoImpl: Boolean = !isAbstract,
         val isInInterface: Boolean,
         val isOverride: Boolean = false,
         val hasOpenModifier: Boolean

testData/class/abstract/abstract.d.kt

@@ -1,6 +1,7 @@
 package abstract
 
 abstract external class AbstractFoo {
+    abstract val x: Number
     open fun open(): Unit = definedExternally
     abstract fun close(): Unit
 }

testData/class/abstract/abstract.d.ts

@@ -1,4 +1,5 @@
 declare abstract class AbstractFoo {
+    abstract readonly x: number;
     open(): void
     abstract close(): void
 }