Recompile all class usages when constructor is changed

jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt

@@ -753,8 +753,9 @@ private fun CompilationResult.doProcessChangesUsingLookups(
         KotlinBuilder.LOG.debug("Process $change")
 
         if (change is ChangeInfo.SignatureChanged) {
-            for (classFqName in withSubtypes(change.fqName, allCaches)) {
+            val fqNames = if (!change.areSubclassesAffected) listOf(change.fqName) else withSubtypes(change.fqName, allCaches)
 
+            for (classFqName in fqNames) {
                 assert(!classFqName.isRoot) { "classFqName is root when processing $change" }
 
                 val scope = classFqName.parent().asString()

jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt

@@ -353,8 +353,8 @@ open class IncrementalCacheImpl(
             val fqName = if (isPackage) className.packageFqName else className.fqNameForClassNameWithoutDollars
             val changeList = SmartList<ChangeInfo>()
 
-            if (difference.isClassSignatureChanged) {
-                changeList.add(ChangeInfo.SignatureChanged(fqName))
+            if (difference.isClassAffected) {
+                changeList.add(ChangeInfo.SignatureChanged(fqName, difference.areSubclassesAffected))
             }
 
             if (difference.changedMembersNames.isNotEmpty()) {
@@ -566,7 +566,7 @@ sealed class ChangeInfo(val fqName: FqName) {
 
     class Removed(fqName: FqName, names: Collection<String>) : MembersChanged(fqName, names)
 
-    class SignatureChanged(fqName: FqName) : ChangeInfo(fqName)
+    class SignatureChanged(fqName: FqName, val areSubclassesAffected: Boolean) : ChangeInfo(fqName)
 
 
     protected open fun toStringProperties(): String = "fqName = $fqName"

jps-plugin/src/org/jetbrains/kotlin/jps/incremental/protoDifferenceUtils.kt

@@ -30,12 +30,15 @@ import org.jetbrains.kotlin.utils.HashSetUtil
 import java.util.*
 
 data class Difference(
-        val isClassSignatureChanged: Boolean = false,
+        val isClassAffected: Boolean = false,
+        val areSubclassesAffected: Boolean = false,
         val changedMembersNames: Set<String> = emptySet()
 )
 
 fun difference(oldData: ProtoMapValue, newData: ProtoMapValue): Difference {
-    if (oldData.isPackageFacade != newData.isPackageFacade) return Difference(isClassSignatureChanged = true)
+    if (!oldData.isPackageFacade && newData.isPackageFacade) return Difference(isClassAffected = true, areSubclassesAffected = true)
+
+    if (oldData.isPackageFacade && !newData.isPackageFacade) return Difference(isClassAffected = true)
 
     val differenceObject =
             if (oldData.isPackageFacade) {
@@ -174,7 +177,8 @@ private class DifferenceCalculatorForClass(oldData: ProtoMapValue, newData: Prot
     val diff = compareObject.difference(oldProto, newProto)
 
     override fun difference(): Difference {
-        var isClassSignatureChanged = false
+        var isClassAffected = false
+        var areSubclassesAffected = false
         val names = hashSetOf<String>()
         val classIsSealed = newProto.isSealed && oldProto.isSealed
 
@@ -197,31 +201,37 @@ private class DifferenceCalculatorForClass(oldData: ProtoMapValue, newData: Prot
                     if (classIsSealed) {
                         // when class is sealed, adding an implementation can break exhaustive when expressions
                         // the workaround is to recompile all class usages
-                        isClassSignatureChanged = true
+                        isClassAffected = true
                     }
 
                     names.addAll(calcDifferenceForNames(oldProto.nestedClassNameList, newProto.nestedClassNameList))
                 }
-                ProtoBufClassKind.CONSTRUCTOR_LIST ->
-                    names.addAll(calcDifferenceForNonPrivateMembers(ProtoBuf.Class::getConstructorList))
+                ProtoBufClassKind.CONSTRUCTOR_LIST -> {
+                    val differentNonPrivateConstructors = calcDifferenceForNonPrivateMembers(ProtoBuf.Class::getConstructorList)
+
+                    if (differentNonPrivateConstructors.isNotEmpty()) {
+                        isClassAffected = true
+                    }
+                }
                 ProtoBufClassKind.FUNCTION_LIST ->
                     names.addAll(calcDifferenceForNonPrivateMembers(ProtoBuf.Class::getFunctionList))
                 ProtoBufClassKind.PROPERTY_LIST ->
                     names.addAll(calcDifferenceForNonPrivateMembers(ProtoBuf.Class::getPropertyList))
                 ProtoBufClassKind.ENUM_ENTRY_LIST -> {
-                    isClassSignatureChanged = true
+                    isClassAffected = true
                 }
                 ProtoBufClassKind.TYPE_TABLE -> {
                     // TODO
                 }
                 in CLASS_SIGNATURE_ENUMS -> {
-                    isClassSignatureChanged = true
+                    isClassAffected = true
+                    areSubclassesAffected = true
                 }
                 else -> throw IllegalArgumentException("Unsupported kind: $kind")
             }
         }
 
-        return Difference(isClassSignatureChanged, names)
+        return Difference(isClassAffected, areSubclassesAffected, names)
     }
 }
 
@@ -259,7 +269,7 @@ private class DifferenceCalculatorForPackageFacade(oldData: ProtoMapValue, newDa
             }
         }
 
-        return Difference(isClassSignatureChanged = false, changedMembersNames = names)
+        return Difference(changedMembersNames = names)
     }
 }