From ba87e98243be6f36b8a49361a4ce3d168461544d Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Wed, 30 Sep 2015 16:41:12 +0300 Subject: [PATCH] Split ProtoBuf.Callable to three messages: constructor, function, property Serialize both at the moment, will drop the old one after bootstrap Original commit: ad735cd7885d978288e2800b47fa7fdc3bca5f71 --- .../jps/incremental/ProtoCompareGenerated.kt | 298 +++++++++++++++++- .../jps/incremental/protoDifferenceUtils.kt | 133 +++++--- 2 files changed, 394 insertions(+), 37 deletions(-) diff --git a/jps/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/ProtoCompareGenerated.kt b/jps/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/ProtoCompareGenerated.kt index 2b7e42dfdc8..f6ae431add2 100644 --- a/jps/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/ProtoCompareGenerated.kt +++ b/jps/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/ProtoCompareGenerated.kt @@ -37,10 +37,19 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi open fun checkEquals(old: ProtoBuf.Package, new: ProtoBuf.Package): Boolean { if (!checkEqualsPackageMember(old, new)) return false + if (!checkEqualsPackageConstructor(old, new)) return false + + if (!checkEqualsPackageFunction(old, new)) return false + + if (!checkEqualsPackageProperty(old, new)) return false + return true } public enum class ProtoBufPackageKind { - MEMBER_LIST + MEMBER_LIST, + CONSTRUCTOR_LIST, + FUNCTION_LIST, + PROPERTY_LIST } public fun difference(old: ProtoBuf.Package, new: ProtoBuf.Package): EnumSet { @@ -48,6 +57,12 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi if (!checkEqualsPackageMember(old, new)) result.add(ProtoBufPackageKind.MEMBER_LIST) + if (!checkEqualsPackageConstructor(old, new)) result.add(ProtoBufPackageKind.CONSTRUCTOR_LIST) + + if (!checkEqualsPackageFunction(old, new)) result.add(ProtoBufPackageKind.FUNCTION_LIST) + + if (!checkEqualsPackageProperty(old, new)) result.add(ProtoBufPackageKind.PROPERTY_LIST) + return result } @@ -70,6 +85,12 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi if (!checkEqualsClassNestedClassName(old, new)) return false + if (!checkEqualsClassConstructor(old, new)) return false + + if (!checkEqualsClassFunction(old, new)) return false + + if (!checkEqualsClassProperty(old, new)) return false + if (!checkEqualsClassMember(old, new)) return false if (!checkEqualsClassEnumEntry(old, new)) return false @@ -96,6 +117,9 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi TYPE_PARAMETER_LIST, SUPERTYPE_LIST, NESTED_CLASS_NAME_LIST, + CONSTRUCTOR_LIST, + FUNCTION_LIST, + PROPERTY_LIST, MEMBER_LIST, ENUM_ENTRY_LIST, PRIMARY_CONSTRUCTOR, @@ -124,6 +148,12 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi if (!checkEqualsClassNestedClassName(old, new)) result.add(ProtoBufClassKind.NESTED_CLASS_NAME_LIST) + if (!checkEqualsClassConstructor(old, new)) result.add(ProtoBufClassKind.CONSTRUCTOR_LIST) + + if (!checkEqualsClassFunction(old, new)) result.add(ProtoBufClassKind.FUNCTION_LIST) + + if (!checkEqualsClassProperty(old, new)) result.add(ProtoBufClassKind.PROPERTY_LIST) + if (!checkEqualsClassMember(old, new)) result.add(ProtoBufClassKind.MEMBER_LIST) if (!checkEqualsClassEnumEntry(old, new)) result.add(ProtoBufClassKind.ENUM_ENTRY_LIST) @@ -191,6 +221,74 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi return true } + open fun checkEquals(old: ProtoBuf.Constructor, new: ProtoBuf.Constructor): Boolean { + if (old.hasFlags() != new.hasFlags()) return false + if (old.hasFlags()) { + if (old.flags != new.flags) return false + } + + if (!checkEqualsConstructorValueParameter(old, new)) return false + + return true + } + + open fun checkEquals(old: ProtoBuf.Function, new: ProtoBuf.Function): Boolean { + if (old.hasFlags() != new.hasFlags()) return false + if (old.hasFlags()) { + if (old.flags != new.flags) return false + } + + if (!checkStringEquals(old.name, new.name)) return false + + if (!checkEquals(old.returnType, new.returnType)) return false + + if (!checkEqualsFunctionTypeParameter(old, new)) return false + + if (old.hasReceiverType() != new.hasReceiverType()) return false + if (old.hasReceiverType()) { + if (!checkEquals(old.receiverType, new.receiverType)) return false + } + + if (!checkEqualsFunctionValueParameter(old, new)) return false + + return true + } + + open fun checkEquals(old: ProtoBuf.Property, new: ProtoBuf.Property): Boolean { + if (old.hasFlags() != new.hasFlags()) return false + if (old.hasFlags()) { + if (old.flags != new.flags) return false + } + + if (!checkStringEquals(old.name, new.name)) return false + + if (!checkEquals(old.returnType, new.returnType)) return false + + if (!checkEqualsPropertyTypeParameter(old, new)) return false + + if (old.hasReceiverType() != new.hasReceiverType()) return false + if (old.hasReceiverType()) { + if (!checkEquals(old.receiverType, new.receiverType)) return false + } + + if (old.hasSetterValueParameter() != new.hasSetterValueParameter()) return false + if (old.hasSetterValueParameter()) { + if (!checkEquals(old.setterValueParameter, new.setterValueParameter)) return false + } + + if (old.hasGetterFlags() != new.hasGetterFlags()) return false + if (old.hasGetterFlags()) { + if (old.getterFlags != new.getterFlags) return false + } + + if (old.hasSetterFlags() != new.hasSetterFlags()) return false + if (old.hasSetterFlags()) { + if (old.setterFlags != new.setterFlags) return false + } + + return true + } + open fun checkEquals(old: ProtoBuf.TypeParameter, new: ProtoBuf.TypeParameter): Boolean { if (old.id != new.id) return false @@ -416,6 +514,36 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi return true } + open fun checkEqualsPackageConstructor(old: ProtoBuf.Package, new: ProtoBuf.Package): Boolean { + if (old.constructorCount != new.constructorCount) return false + + for(i in 0..old.constructorCount - 1) { + if (!checkEquals(old.getConstructor(i), new.getConstructor(i))) return false + } + + return true + } + + open fun checkEqualsPackageFunction(old: ProtoBuf.Package, new: ProtoBuf.Package): Boolean { + if (old.functionCount != new.functionCount) return false + + for(i in 0..old.functionCount - 1) { + if (!checkEquals(old.getFunction(i), new.getFunction(i))) return false + } + + return true + } + + open fun checkEqualsPackageProperty(old: ProtoBuf.Package, new: ProtoBuf.Package): Boolean { + if (old.propertyCount != new.propertyCount) return false + + for(i in 0..old.propertyCount - 1) { + if (!checkEquals(old.getProperty(i), new.getProperty(i))) return false + } + + return true + } + open fun checkEqualsClassTypeParameter(old: ProtoBuf.Class, new: ProtoBuf.Class): Boolean { if (old.typeParameterCount != new.typeParameterCount) return false @@ -446,6 +574,36 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi return true } + open fun checkEqualsClassConstructor(old: ProtoBuf.Class, new: ProtoBuf.Class): Boolean { + if (old.constructorCount != new.constructorCount) return false + + for(i in 0..old.constructorCount - 1) { + if (!checkEquals(old.getConstructor(i), new.getConstructor(i))) return false + } + + return true + } + + open fun checkEqualsClassFunction(old: ProtoBuf.Class, new: ProtoBuf.Class): Boolean { + if (old.functionCount != new.functionCount) return false + + for(i in 0..old.functionCount - 1) { + if (!checkEquals(old.getFunction(i), new.getFunction(i))) return false + } + + return true + } + + open fun checkEqualsClassProperty(old: ProtoBuf.Class, new: ProtoBuf.Class): Boolean { + if (old.propertyCount != new.propertyCount) return false + + for(i in 0..old.propertyCount - 1) { + if (!checkEquals(old.getProperty(i), new.getProperty(i))) return false + } + + return true + } + open fun checkEqualsClassMember(old: ProtoBuf.Class, new: ProtoBuf.Class): Boolean { if (old.memberCount != new.memberCount) return false @@ -496,6 +654,46 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi return true } + open fun checkEqualsConstructorValueParameter(old: ProtoBuf.Constructor, new: ProtoBuf.Constructor): Boolean { + if (old.valueParameterCount != new.valueParameterCount) return false + + for(i in 0..old.valueParameterCount - 1) { + if (!checkEquals(old.getValueParameter(i), new.getValueParameter(i))) return false + } + + return true + } + + open fun checkEqualsFunctionTypeParameter(old: ProtoBuf.Function, new: ProtoBuf.Function): Boolean { + if (old.typeParameterCount != new.typeParameterCount) return false + + for(i in 0..old.typeParameterCount - 1) { + if (!checkEquals(old.getTypeParameter(i), new.getTypeParameter(i))) return false + } + + return true + } + + open fun checkEqualsFunctionValueParameter(old: ProtoBuf.Function, new: ProtoBuf.Function): Boolean { + if (old.valueParameterCount != new.valueParameterCount) return false + + for(i in 0..old.valueParameterCount - 1) { + if (!checkEquals(old.getValueParameter(i), new.getValueParameter(i))) return false + } + + return true + } + + open fun checkEqualsPropertyTypeParameter(old: ProtoBuf.Property, new: ProtoBuf.Property): Boolean { + if (old.typeParameterCount != new.typeParameterCount) return false + + for(i in 0..old.typeParameterCount - 1) { + if (!checkEquals(old.getTypeParameter(i), new.getTypeParameter(i))) return false + } + + return true + } + open fun checkEqualsTypeParameterUpperBound(old: ProtoBuf.TypeParameter, new: ProtoBuf.TypeParameter): Boolean { if (old.upperBoundCount != new.upperBoundCount) return false @@ -574,6 +772,18 @@ public fun ProtoBuf.Package.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: hashCode = 31 * hashCode + getMember(i).hashCode(stringIndexes, fqNameIndexes) } + for(i in 0..constructorCount - 1) { + hashCode = 31 * hashCode + getConstructor(i).hashCode(stringIndexes, fqNameIndexes) + } + + for(i in 0..functionCount - 1) { + hashCode = 31 * hashCode + getFunction(i).hashCode(stringIndexes, fqNameIndexes) + } + + for(i in 0..propertyCount - 1) { + hashCode = 31 * hashCode + getProperty(i).hashCode(stringIndexes, fqNameIndexes) + } + return hashCode } @@ -602,6 +812,18 @@ public fun ProtoBuf.Class.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: ( hashCode = 31 * hashCode + stringIndexes(getNestedClassName(i)) } + for(i in 0..constructorCount - 1) { + hashCode = 31 * hashCode + getConstructor(i).hashCode(stringIndexes, fqNameIndexes) + } + + for(i in 0..functionCount - 1) { + hashCode = 31 * hashCode + getFunction(i).hashCode(stringIndexes, fqNameIndexes) + } + + for(i in 0..propertyCount - 1) { + hashCode = 31 * hashCode + getProperty(i).hashCode(stringIndexes, fqNameIndexes) + } + for(i in 0..memberCount - 1) { hashCode = 31 * hashCode + getMember(i).hashCode(stringIndexes, fqNameIndexes) } @@ -671,6 +893,80 @@ public fun ProtoBuf.Callable.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes return hashCode } +public fun ProtoBuf.Constructor.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int) -> Int): Int { + var hashCode = 1 + + if (hasFlags()) { + hashCode = 31 * hashCode + flags + } + + for(i in 0..valueParameterCount - 1) { + hashCode = 31 * hashCode + getValueParameter(i).hashCode(stringIndexes, fqNameIndexes) + } + + return hashCode +} + +public fun ProtoBuf.Function.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int) -> Int): Int { + var hashCode = 1 + + if (hasFlags()) { + hashCode = 31 * hashCode + flags + } + + hashCode = 31 * hashCode + stringIndexes(name) + + hashCode = 31 * hashCode + returnType.hashCode(stringIndexes, fqNameIndexes) + + for(i in 0..typeParameterCount - 1) { + hashCode = 31 * hashCode + getTypeParameter(i).hashCode(stringIndexes, fqNameIndexes) + } + + if (hasReceiverType()) { + hashCode = 31 * hashCode + receiverType.hashCode(stringIndexes, fqNameIndexes) + } + + for(i in 0..valueParameterCount - 1) { + hashCode = 31 * hashCode + getValueParameter(i).hashCode(stringIndexes, fqNameIndexes) + } + + return hashCode +} + +public fun ProtoBuf.Property.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int) -> Int): Int { + var hashCode = 1 + + if (hasFlags()) { + hashCode = 31 * hashCode + flags + } + + hashCode = 31 * hashCode + stringIndexes(name) + + hashCode = 31 * hashCode + returnType.hashCode(stringIndexes, fqNameIndexes) + + for(i in 0..typeParameterCount - 1) { + hashCode = 31 * hashCode + getTypeParameter(i).hashCode(stringIndexes, fqNameIndexes) + } + + if (hasReceiverType()) { + hashCode = 31 * hashCode + receiverType.hashCode(stringIndexes, fqNameIndexes) + } + + if (hasSetterValueParameter()) { + hashCode = 31 * hashCode + setterValueParameter.hashCode(stringIndexes, fqNameIndexes) + } + + if (hasGetterFlags()) { + hashCode = 31 * hashCode + getterFlags + } + + if (hasSetterFlags()) { + hashCode = 31 * hashCode + setterFlags + } + + return hashCode +} + public fun ProtoBuf.TypeParameter.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int) -> Int): Int { var hashCode = 1 diff --git a/jps/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/protoDifferenceUtils.kt b/jps/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/protoDifferenceUtils.kt index d123201c3e4..33b4b30916f 100644 --- a/jps/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/protoDifferenceUtils.kt +++ b/jps/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/protoDifferenceUtils.kt @@ -16,7 +16,10 @@ package org.jetbrains.kotlin.jps.incremental +import com.google.protobuf.MessageLite import org.jetbrains.kotlin.descriptors.Visibilities +import org.jetbrains.kotlin.jps.incremental.ProtoCompareGenerated.ProtoBufClassKind +import org.jetbrains.kotlin.jps.incremental.ProtoCompareGenerated.ProtoBufPackageKind import org.jetbrains.kotlin.serialization.Flags import org.jetbrains.kotlin.serialization.ProtoBuf import org.jetbrains.kotlin.serialization.deserialization.Deserialization @@ -52,17 +55,16 @@ private abstract class DifferenceCalculator() { protected fun membersOrNone(names: Collection): DifferenceKind = if (names.isEmpty()) DifferenceKind.NONE else DifferenceKind.MEMBERS(names) - protected fun calcDifferenceForMembers( - oldList: List, - newList: List - ): Collection { + protected fun calcDifferenceForMembers(oldList: List, newList: List): Collection { val result = hashSetOf() - val oldMap = oldList.groupBy { it.hashCode({ compareObject.oldGetIndexOfString(it) }, { compareObject.oldGetIndexOfClassId(it) } )} - val newMap = newList.groupBy { it.hashCode({ compareObject.newGetIndexOfString(it) }, { compareObject.newGetIndexOfClassId(it) } )} + fun List.names(nameResolver: NameResolver): List = + map { it.name(nameResolver) } - fun List.names(nameResolver: NameResolver): List = - map { nameResolver.getString(it.name) } + val oldMap = + oldList.groupBy { it.getHashCode({ compareObject.oldGetIndexOfString(it) }, { compareObject.oldGetIndexOfClassId(it) }) } + val newMap = + newList.groupBy { it.getHashCode({ compareObject.newGetIndexOfString(it) }, { compareObject.newGetIndexOfClassId(it) }) } val hashes = oldMap.keySet() + newMap.keySet() for (hash in hashes) { @@ -81,8 +83,8 @@ private abstract class DifferenceCalculator() { } private fun calcDifferenceForEqualHashes( - oldList: List, - newList: List + oldList: List, + newList: List ): Collection { val result = hashSetOf() val newSet = HashSet(newList) @@ -93,12 +95,12 @@ private abstract class DifferenceCalculator() { newSet.remove(newMember) } else { - result.add(compareObject.oldNameResolver.getString(oldMember.name)) + result.add(oldMember.name(compareObject.oldNameResolver)) } } newSet.forEach { newMember -> - result.add(compareObject.newNameResolver.getString(newMember.name)) + result.add(newMember.name(compareObject.newNameResolver)) } return result @@ -113,8 +115,45 @@ private abstract class DifferenceCalculator() { return HashSetUtil.symmetricDifference(oldNames, newNames) } - protected val ProtoBuf.Callable.isPrivate: Boolean - get() = Visibilities.isPrivate(Deserialization.visibility(Flags.VISIBILITY.get(flags))) + protected val MessageLite.isPrivate: Boolean + get() = Visibilities.isPrivate(Deserialization.visibility( + when (this) { + is ProtoBuf.Callable -> Flags.VISIBILITY.get(flags) + is ProtoBuf.Constructor -> Flags.VISIBILITY.get(flags) + is ProtoBuf.Function -> Flags.VISIBILITY.get(flags) + is ProtoBuf.Property -> Flags.VISIBILITY.get(flags) + else -> error("Unknown message: $this") + })) + + private fun MessageLite.getHashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int) -> Int): Int { + return when (this) { + is ProtoBuf.Callable -> hashCode(stringIndexes, fqNameIndexes) + is ProtoBuf.Constructor -> hashCode(stringIndexes, fqNameIndexes) + is ProtoBuf.Function -> hashCode(stringIndexes, fqNameIndexes) + is ProtoBuf.Property -> hashCode(stringIndexes, fqNameIndexes) + else -> error("Unknown message: $this") + } + } + + private fun MessageLite.name(nameResolver: NameResolver): String { + return when (this) { + is ProtoBuf.Callable -> nameResolver.getString(name) + is ProtoBuf.Constructor -> "" + is ProtoBuf.Function -> nameResolver.getString(name) + is ProtoBuf.Property -> nameResolver.getString(name) + else -> error("Unknown message: $this") + } + } + + private fun ProtoCompareGenerated.checkEquals(old: MessageLite, new: MessageLite): Boolean { + return when { + old is ProtoBuf.Callable && new is ProtoBuf.Callable -> checkEquals(old, new) + old is ProtoBuf.Constructor && new is ProtoBuf.Constructor -> checkEquals(old, new) + old is ProtoBuf.Function && new is ProtoBuf.Function -> checkEquals(old, new) + old is ProtoBuf.Property && new is ProtoBuf.Property -> checkEquals(old, new) + else -> error("Unknown message: $this") + } + } } private class DifferenceCalculatorForClass(oldData: ProtoMapValue, newData: ProtoMapValue) : DifferenceCalculator() { @@ -122,11 +161,11 @@ private class DifferenceCalculatorForClass(oldData: ProtoMapValue, newData: Prot private val CONSTRUCTOR = "" private val CLASS_SIGNATURE_ENUMS = EnumSet.of( - ProtoCompareGenerated.ProtoBufClassKind.FLAGS, - ProtoCompareGenerated.ProtoBufClassKind.FQ_NAME, - ProtoCompareGenerated.ProtoBufClassKind.TYPE_PARAMETER_LIST, - ProtoCompareGenerated.ProtoBufClassKind.SUPERTYPE_LIST, - ProtoCompareGenerated.ProtoBufClassKind.CLASS_ANNOTATION_LIST + ProtoBufClassKind.FLAGS, + ProtoBufClassKind.FQ_NAME, + ProtoBufClassKind.TYPE_PARAMETER_LIST, + ProtoBufClassKind.SUPERTYPE_LIST, + ProtoBufClassKind.CLASS_ANNOTATION_LIST ) } @@ -155,34 +194,43 @@ private class DifferenceCalculatorForClass(oldData: ProtoMapValue, newData: Prot fun Int.oldToNames() = names.add(oldNameResolver.getString(this)) fun Int.newToNames() = names.add(newNameResolver.getString(this)) + fun calcDifferenceForNonPrivateMembers(members: (ProtoBuf.Class) -> List): Collection { + val oldMembers = members(oldProto).filterNot { it.isPrivate } + val newMembers = members(newProto).filterNot { it.isPrivate } + return calcDifferenceForMembers(oldMembers, newMembers) + } + for (kind in diff) { when (kind!!) { - ProtoCompareGenerated.ProtoBufClassKind.COMPANION_OBJECT_NAME -> { + ProtoBufClassKind.COMPANION_OBJECT_NAME -> { if (oldProto.hasCompanionObjectName()) oldProto.companionObjectName.oldToNames() if (newProto.hasCompanionObjectName()) newProto.companionObjectName.newToNames() } - ProtoCompareGenerated.ProtoBufClassKind.NESTED_CLASS_NAME_LIST -> + ProtoBufClassKind.NESTED_CLASS_NAME_LIST -> names.addAll(calcDifferenceForNames(oldProto.nestedClassNameList, newProto.nestedClassNameList)) - ProtoCompareGenerated.ProtoBufClassKind.MEMBER_LIST -> { - val oldMembers = oldProto.memberList.filter { !it.isPrivate } - val newMembers = newProto.memberList.filter { !it.isPrivate } - names.addAll(calcDifferenceForMembers(oldMembers, newMembers)) - } - ProtoCompareGenerated.ProtoBufClassKind.ENUM_ENTRY_LIST -> + ProtoBufClassKind.CONSTRUCTOR_LIST -> + names.addAll(calcDifferenceForNonPrivateMembers(ProtoBuf.Class::getConstructorList)) + ProtoBufClassKind.FUNCTION_LIST -> + names.addAll(calcDifferenceForNonPrivateMembers(ProtoBuf.Class::getFunctionList)) + ProtoBufClassKind.PROPERTY_LIST -> + names.addAll(calcDifferenceForNonPrivateMembers(ProtoBuf.Class::getPropertyList)) + ProtoBufClassKind.MEMBER_LIST -> + names.addAll(calcDifferenceForNonPrivateMembers(ProtoBuf.Class::getMemberList)) + ProtoBufClassKind.ENUM_ENTRY_LIST -> names.addAll(calcDifferenceForNames(oldProto.enumEntryList, newProto.enumEntryList)) - ProtoCompareGenerated.ProtoBufClassKind.PRIMARY_CONSTRUCTOR -> + ProtoBufClassKind.PRIMARY_CONSTRUCTOR -> if (areNonPrivatePrimaryConstructorsDifferent()) { names.add(CONSTRUCTOR) } - ProtoCompareGenerated.ProtoBufClassKind.SECONDARY_CONSTRUCTOR_LIST -> + ProtoBufClassKind.SECONDARY_CONSTRUCTOR_LIST -> if (areNonPrivateSecondaryConstructorsDifferent()) { names.add(CONSTRUCTOR) } - ProtoCompareGenerated.ProtoBufClassKind.FLAGS, - ProtoCompareGenerated.ProtoBufClassKind.FQ_NAME, - ProtoCompareGenerated.ProtoBufClassKind.TYPE_PARAMETER_LIST, - ProtoCompareGenerated.ProtoBufClassKind.SUPERTYPE_LIST, - ProtoCompareGenerated.ProtoBufClassKind.CLASS_ANNOTATION_LIST -> + ProtoBufClassKind.FLAGS, + ProtoBufClassKind.FQ_NAME, + ProtoBufClassKind.TYPE_PARAMETER_LIST, + ProtoBufClassKind.SUPERTYPE_LIST, + ProtoBufClassKind.CLASS_ANNOTATION_LIST -> throw IllegalArgumentException("Unexpected kind: $kind") else -> throw IllegalArgumentException("Unsupported kind: $kind") @@ -237,14 +285,27 @@ private class DifferenceCalculatorForPackageFacade(oldData: ProtoMapValue, newDa private fun getChangedMembersNames(): Set { val names = hashSetOf() + fun calcDifferenceForNonPrivateMembers(members: (ProtoBuf.Package) -> List): Collection { + val oldMembers = members(oldProto).filterNot { it.isPrivate } + val newMembers = members(newProto).filterNot { it.isPrivate } + return calcDifferenceForMembers(oldMembers, newMembers) + } + for (kind in diff) { when (kind!!) { - ProtoCompareGenerated.ProtoBufPackageKind.MEMBER_LIST -> - names.addAll(calcDifferenceForMembers(oldProto.memberList.filter { !it.isPrivate }, newProto.memberList.filter { !it.isPrivate })) + ProtoBufPackageKind.CONSTRUCTOR_LIST -> + names.addAll(calcDifferenceForNonPrivateMembers(ProtoBuf.Package::getConstructorList)) + ProtoBufPackageKind.FUNCTION_LIST -> + names.addAll(calcDifferenceForNonPrivateMembers(ProtoBuf.Package::getFunctionList)) + ProtoBufPackageKind.PROPERTY_LIST -> + names.addAll(calcDifferenceForNonPrivateMembers(ProtoBuf.Package::getPropertyList)) + ProtoBufPackageKind.MEMBER_LIST -> + names.addAll(calcDifferenceForNonPrivateMembers(ProtoBuf.Package::getMemberList)) else -> throw IllegalArgumentException("Unsupported kind: $kind") } } + return names } }