From 21fe0e80ff721baa6af22ed1da84e080c4e872da Mon Sep 17 00:00:00 2001 From: Vsevolod Tolstopyatov Date: Tue, 17 Jan 2023 09:46:25 +0000 Subject: [PATCH] [K2] Report CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_ERROR for class hierarchies Previously it wasn't reported in FIR for ConcurrentHashMap inheritors because the receiver id hasn't matched CHM.contains id Fixed by unwrapping origin of the call in case of fake overrides ^KT-55606 fixed --- ...InconsistentOperatorFromJavaCallChecker.kt | 22 ++- ...InconsistentOperatorFromJavaCallChecker.kt | 7 +- .../java/concurrentHashMapContainsError.kt | 138 +++++++++----- .../java/concurrentHashMapContainsError.txt | 180 ++++++++++++++++++ 4 files changed, 291 insertions(+), 56 deletions(-) diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmInconsistentOperatorFromJavaCallChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmInconsistentOperatorFromJavaCallChecker.kt index fcb6bbfceaf..0f949fb5443 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmInconsistentOperatorFromJavaCallChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmInconsistentOperatorFromJavaCallChecker.kt @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.containingClassLookupTag import org.jetbrains.kotlin.fir.expressions.FirFunctionCall import org.jetbrains.kotlin.fir.expressions.FirFunctionCallOrigin +import org.jetbrains.kotlin.fir.originalOrSelf import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol @@ -27,30 +28,39 @@ import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.util.OperatorNameConventions +/** + * This checker detects if a call by operator 'contains' convention to a Java method violates the expected contract: + * * "key in map" commonly resolves to stdlib extension that calls Map.containsKey(), + * but there's a member in ConcurrentHashMap with acceptable signature that delegates to `containsValue` instead, + * leading to an unexpected result. See KT-18053 + */ object FirJvmInconsistentOperatorFromJavaCallChecker : FirFunctionCallChecker() { private val CONCURRENT_HASH_MAP_CALLABLE_ID = CallableId( ClassId.fromString("java/util/concurrent/ConcurrentHashMap"), - Name.identifier("contains") + OperatorNameConventions.CONTAINS ) override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) { + // Filter out non-operators + if (expression.origin != FirFunctionCallOrigin.Operator) return val callableSymbol = expression.calleeReference.toResolvedCallableSymbol() as? FirNamedFunctionSymbol ?: return + // Filter out non-contains if (callableSymbol.name != OperatorNameConventions.CONTAINS) return val valueParameterSymbol = callableSymbol.valueParameterSymbols.singleOrNull() ?: return val type = valueParameterSymbol.resolvedReturnTypeRef.coneType.lowerBoundIfFlexible() + // Filter out handrolled contains with non-Any type if (!type.isAny && !type.isNullableAny) return - - if (expression.origin != FirFunctionCallOrigin.Operator || expression.origin.ordinal != 2) return - callableSymbol.check(expression.calleeReference.source, context, reporter) } - fun FirNamedFunctionSymbol.check(source: KtSourceElement?, context: CheckerContext, reporter: DiagnosticReporter): Boolean { - if (callableId == CONCURRENT_HASH_MAP_CALLABLE_ID) { + private fun FirNamedFunctionSymbol.check(source: KtSourceElement?, context: CheckerContext, reporter: DiagnosticReporter): Boolean { + // Unwrap SubstitutionOverride origin if necessary + if (originalOrSelf().callableId == CONCURRENT_HASH_MAP_CALLABLE_ID) { reporter.reportOn(source, FirJvmErrors.CONCURRENT_HASH_MAP_CONTAINS_OPERATOR, context) return true } + // Check explicitly overridden contains val containingClass = containingClassLookupTag()?.toFirRegularClassSymbol(context.session) ?: return false val overriddenFunctions = overriddenFunctions(containingClass, context) for (overriddenFunction in overriddenFunctions) { diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InconsistentOperatorFromJavaCallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InconsistentOperatorFromJavaCallChecker.kt index 2e3b44bdc83..274e13007ca 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InconsistentOperatorFromJavaCallChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InconsistentOperatorFromJavaCallChecker.kt @@ -20,9 +20,10 @@ import org.jetbrains.kotlin.types.typeUtil.isAnyOrNullableAny import org.jetbrains.kotlin.util.OperatorNameConventions /** - * This checker detects if call by operator convention to a Java method violates some expected contract: - * - "key in map" commonly resolves to an stdlib extension that calls Map.containsKey(), - * but there's a member in ConcurrentHashMap with acceptable signature that delegates to `containsValue` instead + * This checker detects if a call by operator 'contains' convention to a Java method violates the expected contract: + * * "key in map" commonly resolves to stdlib extension that calls Map.containsKey(), + * but there's a member in ConcurrentHashMap with acceptable signature that delegates to `containsValue` instead, + * leading to an unexpected result. See KT-18053 */ object InconsistentOperatorFromJavaCallChecker : CallChecker { private val CONCURRENT_HASH_MAP_FQ_NAME = FqName("java.util.concurrent.ConcurrentHashMap") diff --git a/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.kt b/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.kt index 81e154b28db..53d010cd170 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.kt @@ -17,63 +17,107 @@ class C : java.util.concurrent.ConcurrentHashMap() { } } +open class D : java.util.concurrent.ConcurrentHashMap() + +class E : D() + fun main() { - val hm = java.util.concurrent.ConcurrentHashMap() - "" in hm - "" !in hm - 1 !in hm - 2 in hm + run { // CHM test + val hm = java.util.concurrent.ConcurrentHashMap() + "" in hm + "" !in hm + 1 !in hm + 2 in hm - hm.contains("") - hm.contains(1) + hm.contains("") + hm.contains(1) - "" in (hm as Map) - "" !in (hm as Map) - 1 in (hm as Map) - 1 !in (hm as Map) + "" in (hm as Map) + "" !in (hm as Map) + 1 in (hm as Map) + 1 !in (hm as Map) + } - val a = A() - "" in a - "" !in a - 1 !in a - 2 in a + run { // A : CHM test + val a = A() + "" in a + "" !in a + 1 !in a + 2 in a - ' ' in a - ' ' !in a - a.contains("") - a.contains(1) + ' ' in a + ' ' !in a + a.contains("") + a.contains(1) - "" in (a as Map) - "" !in (a as Map) - 1 in (a as Map) - 1 !in (a as Map) + "" in (a as Map) + "" !in (a as Map) + 1 in (a as Map) + 1 !in (a as Map) + } - val b = B() - "" in b - "" !in b - 1 !in b - 2 in b + run { // B : CHM test + val b = B() + "" in b + "" !in b + 1 !in b + 2 in b - b.contains("") - b.contains(1) + b.contains("") + b.contains(1) - "" in (b as Map) - "" !in (b as Map) - 1 in (b as Map) - 1 !in (b as Map) + "" in (b as Map) + "" !in (b as Map) + 1 in (b as Map) + 1 !in (b as Map) + } - // Actually, we could've allow calls here because the owner explicitly declared as operator, but semantics is still weird - val c = C() - "" in c - "" !in c - 1 !in c - 2 in c + run { // C : CHM + // Actually, we could've allow calls here because the owner explicitly declared as operator, but semantics is still weird + val c = C() + "" in c + "" !in c + 1 !in c + 2 in c - c.contains("") - c.contains(1) + c.contains("") + c.contains(1) - "" in (c as Map) - "" !in (c as Map) - 1 in (c as Map) - 1 !in (c as Map) + "" in (c as Map) + "" !in (c as Map) + 1 in (c as Map) + 1 !in (c as Map) + } + + run { // D : CHM + val d = D() + "" in d + "" !in d + 1 !in d + 2 in d + + d.contains("") + d.contains(1) + + "" in (d as Map) + "" !in (d as Map) + 1 in (d as Map) + 1 !in (d as Map) + } + + run { // E : D + val e = E() + "" in e + "" !in e + 1 !in e + 2 in e + + e.contains("") + e.contains(1) + + "" in (e as Map) + "" !in (e as Map) + 1 in (e as Map) + 1 !in (e as Map) + } } diff --git a/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.txt b/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.txt index 22104206676..e27bb523638 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.txt @@ -273,3 +273,183 @@ public final class C : java.util.concurrent.ConcurrentHashMap : java.util.concurrent.ConcurrentHashMap { + public constructor D() + invisible_fake final override /*1*/ /*fake_override*/ var baseCount: kotlin.Long + invisible_fake final override /*1*/ /*fake_override*/ var cellsBusy: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var counterCells: kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.CounterCell!>! + public open override /*1*/ /*fake_override*/ val entries: kotlin.collections.MutableSet> + invisible_fake final override /*1*/ /*fake_override*/ var entrySet: java.util.concurrent.ConcurrentHashMap.EntrySetView! + invisible_fake final override /*1*/ /*fake_override*/ var keySet: java.util.concurrent.ConcurrentHashMap.KeySetView! + public open override /*1*/ /*fake_override*/ val keys: java.util.concurrent.ConcurrentHashMap.KeySetView + invisible_fake final override /*1*/ /*fake_override*/ var nextTable: kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.Node!>! + public open override /*1*/ /*fake_override*/ val size: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var sizeCtl: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var table: kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.Node!>! + invisible_fake final override /*1*/ /*fake_override*/ var transferIndex: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var values: java.util.concurrent.ConcurrentHashMap.ValuesView! + public open override /*1*/ /*fake_override*/ val values: kotlin.collections.MutableCollection + invisible_fake final override /*1*/ /*fake_override*/ fun addCount(/*0*/ p0: kotlin.Long, /*1*/ p1: kotlin.Int): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun batchFor(/*0*/ p0: kotlin.Long): kotlin.Int + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any! + public open override /*1*/ /*fake_override*/ fun compute(/*0*/ p0: K, /*1*/ p1: java.util.function.BiFunction): V? + public open override /*1*/ /*fake_override*/ fun computeIfAbsent(/*0*/ p0: K, /*1*/ p1: java.util.function.Function): V + public open override /*1*/ /*fake_override*/ fun computeIfPresent(/*0*/ p0: K, /*1*/ p1: java.util.function.BiFunction): V? + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ p0: kotlin.Any!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsKey(/*0*/ key: K): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsValue(/*0*/ value: V): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun elements(): java.util.Enumeration! + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun forEach(/*0*/ p0: java.util.function.BiConsumer): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEach(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.BiConsumer!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEach(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.BiFunction!, /*2*/ p2: java.util.function.Consumer!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEachEntry(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Consumer!>!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEachEntry(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!, out U!>!, /*2*/ p2: java.util.function.Consumer!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEachKey(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Consumer!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEachKey(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!, /*2*/ p2: java.util.function.Consumer!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEachValue(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Consumer!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEachValue(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!, /*2*/ p2: java.util.function.Consumer!): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun fullAddCount(/*0*/ p0: kotlin.Long, /*1*/ p1: kotlin.Boolean): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun get(/*0*/ key: K): V? + public open override /*1*/ /*fake_override*/ fun getOrDefault(/*0*/ key: K, /*1*/ defaultValue: V): V + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ fun helpTransfer(/*0*/ p0: kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.Node!>!, /*1*/ p1: java.util.concurrent.ConcurrentHashMap.Node!): kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.Node!>! + invisible_fake final override /*1*/ /*fake_override*/ fun initTable(): kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.Node!>! + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun keySet(/*0*/ p0: V!): java.util.concurrent.ConcurrentHashMap.KeySetView! + public open override /*1*/ /*fake_override*/ fun keys(): java.util.Enumeration! + public open override /*1*/ /*fake_override*/ fun mappingCount(): kotlin.Long + public open override /*1*/ /*fake_override*/ fun merge(/*0*/ p0: K, /*1*/ p1: V, /*2*/ p2: java.util.function.BiFunction): V? + public open override /*1*/ /*fake_override*/ fun put(/*0*/ key: K, /*1*/ value: V): V? + public open override /*1*/ /*fake_override*/ fun putAll(/*0*/ from: kotlin.collections.Map): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun putIfAbsent(/*0*/ p0: K, /*1*/ p1: V): V? + invisible_fake final override /*1*/ /*fake_override*/ fun putVal(/*0*/ p0: K!, /*1*/ p1: V!, /*2*/ p2: kotlin.Boolean): V! + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun reduce(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.BiFunction!, /*2*/ p2: java.util.function.BiFunction!): U! + public open override /*1*/ /*fake_override*/ fun reduceEntries(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.BiFunction!, kotlin.collections.(Mutable)Map.(Mutable)Entry!, out kotlin.collections.(Mutable)Map.(Mutable)Entry!>!): kotlin.collections.(Mutable)Map.(Mutable)Entry! + public open override /*1*/ /*fake_override*/ fun reduceEntries(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!, out U!>!, /*2*/ p2: java.util.function.BiFunction!): U! + public open override /*1*/ /*fake_override*/ fun reduceEntriesToDouble(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToDoubleFunction!>!, /*2*/ p2: kotlin.Double, /*3*/ p3: java.util.function.DoubleBinaryOperator!): kotlin.Double + public open override /*1*/ /*fake_override*/ fun reduceEntriesToInt(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToIntFunction!>!, /*2*/ p2: kotlin.Int, /*3*/ p3: java.util.function.IntBinaryOperator!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun reduceEntriesToLong(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToLongFunction!>!, /*2*/ p2: kotlin.Long, /*3*/ p3: java.util.function.LongBinaryOperator!): kotlin.Long + public open override /*1*/ /*fake_override*/ fun reduceKeys(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.BiFunction!): K! + public open override /*1*/ /*fake_override*/ fun reduceKeys(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!, /*2*/ p2: java.util.function.BiFunction!): U! + public open override /*1*/ /*fake_override*/ fun reduceKeysToDouble(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToDoubleFunction!, /*2*/ p2: kotlin.Double, /*3*/ p3: java.util.function.DoubleBinaryOperator!): kotlin.Double + public open override /*1*/ /*fake_override*/ fun reduceKeysToInt(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToIntFunction!, /*2*/ p2: kotlin.Int, /*3*/ p3: java.util.function.IntBinaryOperator!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun reduceKeysToLong(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToLongFunction!, /*2*/ p2: kotlin.Long, /*3*/ p3: java.util.function.LongBinaryOperator!): kotlin.Long + public open override /*1*/ /*fake_override*/ fun reduceToDouble(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToDoubleBiFunction!, /*2*/ p2: kotlin.Double, /*3*/ p3: java.util.function.DoubleBinaryOperator!): kotlin.Double + public open override /*1*/ /*fake_override*/ fun reduceToInt(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToIntBiFunction!, /*2*/ p2: kotlin.Int, /*3*/ p3: java.util.function.IntBinaryOperator!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun reduceToLong(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToLongBiFunction!, /*2*/ p2: kotlin.Long, /*3*/ p3: java.util.function.LongBinaryOperator!): kotlin.Long + public open override /*1*/ /*fake_override*/ fun reduceValues(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.BiFunction!): V! + public open override /*1*/ /*fake_override*/ fun reduceValues(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!, /*2*/ p2: java.util.function.BiFunction!): U! + public open override /*1*/ /*fake_override*/ fun reduceValuesToDouble(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToDoubleFunction!, /*2*/ p2: kotlin.Double, /*3*/ p3: java.util.function.DoubleBinaryOperator!): kotlin.Double + public open override /*1*/ /*fake_override*/ fun reduceValuesToInt(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToIntFunction!, /*2*/ p2: kotlin.Int, /*3*/ p3: java.util.function.IntBinaryOperator!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun reduceValuesToLong(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToLongFunction!, /*2*/ p2: kotlin.Long, /*3*/ p3: java.util.function.LongBinaryOperator!): kotlin.Long + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ key: K): V? + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ key: K, /*1*/ value: V): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun replace(/*0*/ p0: K, /*1*/ p1: V): V? + public open override /*1*/ /*fake_override*/ fun replace(/*0*/ p0: K, /*1*/ p1: V, /*2*/ p2: V): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun replaceAll(/*0*/ p0: java.util.function.BiFunction): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun replaceNode(/*0*/ p0: kotlin.Any!, /*1*/ p1: V!, /*2*/ p2: kotlin.Any!): V! + public open override /*1*/ /*fake_override*/ fun search(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.BiFunction!): U! + public open override /*1*/ /*fake_override*/ fun searchEntries(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!, out U!>!): U! + public open override /*1*/ /*fake_override*/ fun searchKeys(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!): U! + public open override /*1*/ /*fake_override*/ fun searchValues(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!): U! + invisible_fake final override /*1*/ /*fake_override*/ fun sumCount(): kotlin.Long + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + invisible_fake final override /*1*/ /*fake_override*/ fun transfer(/*0*/ p0: kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.Node!>!, /*1*/ p1: kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.Node!>!): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun treeifyBin(/*0*/ p0: kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.Node!>!, /*1*/ p1: kotlin.Int): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun tryPresize(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit +} + +public final class E : D { + public constructor E() + invisible_fake final override /*1*/ /*fake_override*/ var baseCount: kotlin.Long + invisible_fake final override /*1*/ /*fake_override*/ var cellsBusy: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var counterCells: kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.CounterCell!>! + public open override /*1*/ /*fake_override*/ val entries: kotlin.collections.MutableSet> + invisible_fake final override /*1*/ /*fake_override*/ var entrySet: java.util.concurrent.ConcurrentHashMap.EntrySetView! + invisible_fake final override /*1*/ /*fake_override*/ var keySet: java.util.concurrent.ConcurrentHashMap.KeySetView! + public open override /*1*/ /*fake_override*/ val keys: java.util.concurrent.ConcurrentHashMap.KeySetView + invisible_fake final override /*1*/ /*fake_override*/ var nextTable: kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.Node!>! + public open override /*1*/ /*fake_override*/ val size: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var sizeCtl: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var table: kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.Node!>! + invisible_fake final override /*1*/ /*fake_override*/ var transferIndex: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var values: java.util.concurrent.ConcurrentHashMap.ValuesView! + public open override /*1*/ /*fake_override*/ val values: kotlin.collections.MutableCollection + invisible_fake final override /*1*/ /*fake_override*/ fun addCount(/*0*/ p0: kotlin.Long, /*1*/ p1: kotlin.Int): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun batchFor(/*0*/ p0: kotlin.Long): kotlin.Int + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any! + public open override /*1*/ /*fake_override*/ fun compute(/*0*/ p0: kotlin.String, /*1*/ p1: java.util.function.BiFunction): kotlin.Int? + public open override /*1*/ /*fake_override*/ fun computeIfAbsent(/*0*/ p0: kotlin.String, /*1*/ p1: java.util.function.Function): kotlin.Int + public open override /*1*/ /*fake_override*/ fun computeIfPresent(/*0*/ p0: kotlin.String, /*1*/ p1: java.util.function.BiFunction): kotlin.Int? + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ p0: kotlin.Any!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsKey(/*0*/ key: kotlin.String): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsValue(/*0*/ value: kotlin.Int): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun elements(): java.util.Enumeration! + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun forEach(/*0*/ p0: java.util.function.BiConsumer): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEach(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.BiConsumer!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEach(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.BiFunction!, /*2*/ p2: java.util.function.Consumer!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEachEntry(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Consumer!>!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEachEntry(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!, out U!>!, /*2*/ p2: java.util.function.Consumer!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEachKey(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Consumer!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEachKey(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!, /*2*/ p2: java.util.function.Consumer!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEachValue(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Consumer!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEachValue(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!, /*2*/ p2: java.util.function.Consumer!): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun fullAddCount(/*0*/ p0: kotlin.Long, /*1*/ p1: kotlin.Boolean): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun get(/*0*/ key: kotlin.String): kotlin.Int? + public open override /*1*/ /*fake_override*/ fun getOrDefault(/*0*/ key: kotlin.String, /*1*/ defaultValue: kotlin.Int): kotlin.Int + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ fun helpTransfer(/*0*/ p0: kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.Node!>!, /*1*/ p1: java.util.concurrent.ConcurrentHashMap.Node!): kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.Node!>! + invisible_fake final override /*1*/ /*fake_override*/ fun initTable(): kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.Node!>! + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun keySet(/*0*/ p0: kotlin.Int!): java.util.concurrent.ConcurrentHashMap.KeySetView! + public open override /*1*/ /*fake_override*/ fun keys(): java.util.Enumeration! + public open override /*1*/ /*fake_override*/ fun mappingCount(): kotlin.Long + public open override /*1*/ /*fake_override*/ fun merge(/*0*/ p0: kotlin.String, /*1*/ p1: kotlin.Int, /*2*/ p2: java.util.function.BiFunction): kotlin.Int? + public open override /*1*/ /*fake_override*/ fun put(/*0*/ key: kotlin.String, /*1*/ value: kotlin.Int): kotlin.Int? + public open override /*1*/ /*fake_override*/ fun putAll(/*0*/ from: kotlin.collections.Map): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun putIfAbsent(/*0*/ p0: kotlin.String, /*1*/ p1: kotlin.Int): kotlin.Int? + invisible_fake final override /*1*/ /*fake_override*/ fun putVal(/*0*/ p0: kotlin.String!, /*1*/ p1: kotlin.Int!, /*2*/ p2: kotlin.Boolean): kotlin.Int! + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun reduce(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.BiFunction!, /*2*/ p2: java.util.function.BiFunction!): U! + public open override /*1*/ /*fake_override*/ fun reduceEntries(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.BiFunction!, kotlin.collections.(Mutable)Map.(Mutable)Entry!, out kotlin.collections.(Mutable)Map.(Mutable)Entry!>!): kotlin.collections.(Mutable)Map.(Mutable)Entry! + public open override /*1*/ /*fake_override*/ fun reduceEntries(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!, out U!>!, /*2*/ p2: java.util.function.BiFunction!): U! + public open override /*1*/ /*fake_override*/ fun reduceEntriesToDouble(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToDoubleFunction!>!, /*2*/ p2: kotlin.Double, /*3*/ p3: java.util.function.DoubleBinaryOperator!): kotlin.Double + public open override /*1*/ /*fake_override*/ fun reduceEntriesToInt(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToIntFunction!>!, /*2*/ p2: kotlin.Int, /*3*/ p3: java.util.function.IntBinaryOperator!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun reduceEntriesToLong(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToLongFunction!>!, /*2*/ p2: kotlin.Long, /*3*/ p3: java.util.function.LongBinaryOperator!): kotlin.Long + public open override /*1*/ /*fake_override*/ fun reduceKeys(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.BiFunction!): kotlin.String! + public open override /*1*/ /*fake_override*/ fun reduceKeys(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!, /*2*/ p2: java.util.function.BiFunction!): U! + public open override /*1*/ /*fake_override*/ fun reduceKeysToDouble(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToDoubleFunction!, /*2*/ p2: kotlin.Double, /*3*/ p3: java.util.function.DoubleBinaryOperator!): kotlin.Double + public open override /*1*/ /*fake_override*/ fun reduceKeysToInt(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToIntFunction!, /*2*/ p2: kotlin.Int, /*3*/ p3: java.util.function.IntBinaryOperator!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun reduceKeysToLong(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToLongFunction!, /*2*/ p2: kotlin.Long, /*3*/ p3: java.util.function.LongBinaryOperator!): kotlin.Long + public open override /*1*/ /*fake_override*/ fun reduceToDouble(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToDoubleBiFunction!, /*2*/ p2: kotlin.Double, /*3*/ p3: java.util.function.DoubleBinaryOperator!): kotlin.Double + public open override /*1*/ /*fake_override*/ fun reduceToInt(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToIntBiFunction!, /*2*/ p2: kotlin.Int, /*3*/ p3: java.util.function.IntBinaryOperator!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun reduceToLong(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToLongBiFunction!, /*2*/ p2: kotlin.Long, /*3*/ p3: java.util.function.LongBinaryOperator!): kotlin.Long + public open override /*1*/ /*fake_override*/ fun reduceValues(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.BiFunction!): kotlin.Int! + public open override /*1*/ /*fake_override*/ fun reduceValues(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!, /*2*/ p2: java.util.function.BiFunction!): U! + public open override /*1*/ /*fake_override*/ fun reduceValuesToDouble(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToDoubleFunction!, /*2*/ p2: kotlin.Double, /*3*/ p3: java.util.function.DoubleBinaryOperator!): kotlin.Double + public open override /*1*/ /*fake_override*/ fun reduceValuesToInt(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToIntFunction!, /*2*/ p2: kotlin.Int, /*3*/ p3: java.util.function.IntBinaryOperator!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun reduceValuesToLong(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.ToLongFunction!, /*2*/ p2: kotlin.Long, /*3*/ p3: java.util.function.LongBinaryOperator!): kotlin.Long + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ key: kotlin.String): kotlin.Int? + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ key: kotlin.String, /*1*/ value: kotlin.Int): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun replace(/*0*/ p0: kotlin.String, /*1*/ p1: kotlin.Int): kotlin.Int? + public open override /*1*/ /*fake_override*/ fun replace(/*0*/ p0: kotlin.String, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun replaceAll(/*0*/ p0: java.util.function.BiFunction): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun replaceNode(/*0*/ p0: kotlin.Any!, /*1*/ p1: kotlin.Int!, /*2*/ p2: kotlin.Any!): kotlin.Int! + public open override /*1*/ /*fake_override*/ fun search(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.BiFunction!): U! + public open override /*1*/ /*fake_override*/ fun searchEntries(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!, out U!>!): U! + public open override /*1*/ /*fake_override*/ fun searchKeys(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!): U! + public open override /*1*/ /*fake_override*/ fun searchValues(/*0*/ p0: kotlin.Long, /*1*/ p1: java.util.function.Function!): U! + invisible_fake final override /*1*/ /*fake_override*/ fun sumCount(): kotlin.Long + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + invisible_fake final override /*1*/ /*fake_override*/ fun transfer(/*0*/ p0: kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.Node!>!, /*1*/ p1: kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.Node!>!): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun treeifyBin(/*0*/ p0: kotlin.Array<(out) java.util.concurrent.ConcurrentHashMap.Node!>!, /*1*/ p1: kotlin.Int): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun tryPresize(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit +} +