Resolve conflict overload for types with generalized type params

This fixes #279
Kotlin · Jun 4, 2020 · fb5d04e · fb5d04e
1 parent ce4d2ff
commit fb5d04e
Show file tree

Hide file tree

Showing 3 changed files with 49 additions and 10 deletions.
diff --git a/compiler/test/data/typescript/class/override/conflictingOverloads.d.kt b/compiler/test/data/typescript/class/override/conflictingOverloads.d.kt
@@ -26,4 +26,30 @@ external interface Ping {
     fun ping(a: Boolean)
 }
 
-external fun addListener(event: String /* "disconnect" | "online" */, listener: (worker: Ping) -> Unit): Message
+external fun addListener(event: String /* "disconnect" | "online" */, listener: (worker: Ping) -> Unit): Message
+
+external interface Options<A, B>
+
+external interface Result<T>
+
+external interface `T$0` {
+    var publicKey: String
+    var privateKey: String
+}
+
+external fun generate(options: Options<String /* 'pem' | 'der' | 'der' */, String /* 'pem' | 'der' | 'pem' | 'der' */>): dynamic /* Result */
+
+external interface `T$1` {
+    var publicKey: String
+    var privateKey: Any
+}
+
+external interface `T$2` {
+    var publicKey: Any
+    var privateKey: String
+}
+
+external interface `T$3` {
+    var publicKey: Any
+    var privateKey: Any
+}
diff --git a/compiler/test/data/typescript/class/override/conflictingOverloads.d.ts b/compiler/test/data/typescript/class/override/conflictingOverloads.d.ts
@@ -18,3 +18,10 @@ declare interface Ping {
 declare function addListener(event: "disconnect", listener: (worker: Ping) => void): Message;
 declare function addListener(event: "online", listener: (worker: Ping) => void): Message;
 
+interface Options<A, B> {}
+interface Result<T> {}
+
+declare function generate(options: Options<'pem', 'pem'>): Result<{ publicKey: string, privateKey: string }>;
+declare function generate(options: Options<'pem', 'der'>): Result<{ publicKey: string, privateKey: Buffer }>;
+declare function generate(options: Options<'der', 'pem'>): Result<{ publicKey: Buffer, privateKey: string }>;
+declare function generate(options: Options<'der', 'der'>): Result<{ publicKey: Buffer, privateKey: Buffer }>;
diff --git a/...erings-common/src/org/jetbrains/dukat/model/commonLowerings/removeConflictingOverloads.kt b/...erings-common/src/org/jetbrains/dukat/model/commonLowerings/removeConflictingOverloads.kt
@@ -10,13 +10,15 @@ import org.jetbrains.dukat.astModel.InterfaceModel
 import org.jetbrains.dukat.astModel.MemberModel
 import org.jetbrains.dukat.astModel.MethodModel
 import org.jetbrains.dukat.astModel.ModuleModel
+import org.jetbrains.dukat.astModel.ParameterModel
 import org.jetbrains.dukat.astModel.TypeModel
+import org.jetbrains.dukat.astModel.TypeParameterModel
 import org.jetbrains.dukat.astModel.TypeValueModel
 import org.jetbrains.dukat.ownerContext.NodeOwner
 
 private fun TypeModel.withoutMeta(): TypeModel {
     return when (this) {
-        is TypeValueModel -> copy(metaDescription = null)
+        is TypeValueModel -> copy(metaDescription = null, params = params.map { param -> param.copy(type = param.type.withoutMeta()) })
         else -> this
     }
 }
@@ -42,7 +44,7 @@ private fun mergeTypeModels(a: TypeModel, b: TypeModel): TypeModel {
                 it.joinToString(" | ")
             }
         }
-        a.copy(metaDescription = metaDescription)
+        a.copy(metaDescription = metaDescription, params = mergeTypeParams(a.params, b.params))
     } else {
         a
     }
@@ -60,20 +62,24 @@ private fun mergeTypeModelsAsReturn(a: TypeModel, b: TypeModel): TypeModel {
     }
 }
 
-private fun mergeMethodModels(a: MethodModel, b: MethodModel): MethodModel {
-    val paramsMerged = a.parameters.zip(b.parameters).map { (paramA, paramB) ->
+private fun mergeTypeParams(a: List<TypeParameterModel>, b: List<TypeParameterModel>): List<TypeParameterModel> {
+    return a.zip(b).map { (paramA, paramB) ->
         paramA.copy(type = mergeTypeModels(paramA.type, paramB.type))
     }
-
-    return a.copy(parameters = paramsMerged, type = mergeTypeModelsAsReturn(a.type, b.type))
 }
 
-private fun mergeFunctionModels(a: FunctionModel, b: FunctionModel): FunctionModel {
-    val paramsMerged = a.parameters.zip(b.parameters).map { (paramA, paramB) ->
+private fun mergeParams(a: List<ParameterModel>, b: List<ParameterModel>): List<ParameterModel> {
+    return a.zip(b).map { (paramA, paramB) ->
         paramA.copy(type = mergeTypeModels(paramA.type, paramB.type))
     }
+}
 
-    return a.copy(parameters = paramsMerged, type = mergeTypeModelsAsReturn(a.type, b.type))
+private fun mergeMethodModels(a: MethodModel, b: MethodModel): MethodModel {
+    return a.copy(parameters = mergeParams(a.parameters, b.parameters), type = mergeTypeModelsAsReturn(a.type, b.type))
+}
+
+private fun mergeFunctionModels(a: FunctionModel, b: FunctionModel): FunctionModel {
+    return a.copy(parameters = mergeParams(a.parameters, b.parameters), type = mergeTypeModelsAsReturn(a.type, b.type))
 }
 
 typealias CallableKey = Triple<NameEntity, List<TypeModel>, List<TypeModel>>