Alexander Udalov
1b98723b3f
The problem in the test case was that `JImpl.entrySet` was detected by
ReplaceDefaultImplsOverriddenSymbols as a class fake override, which
overrides non-abstract interface method. Thus, overriddenSymbols of
`MyMap.entrySet` were changed in
`ReplaceDefaultImplsOverriddenSymbols.visitSimpleFunction`.
Later, BridgeLowering tried to determine which special bridges to
generate for `MyMap.<get-entries>`, and for that it inspected existing
methods and their overrides.
Normally we would generate the following special bridge:
getEntries()Ljava/util/Set;
invokespecial JImpl.entrySet()Ljava/util/Set;
However, because of incorrect overrides, the generated class method was
selected here instead of the expected `Map.<get-entries>`:
https://github.com/JetBrains/kotlin/blob/06001fc0919c814e757caa494891619882fae15f/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt#L282
and since the JVM signature of the generated class method is the same as
that of the fake override in MyMap, we never got to generating the
special bridge.
The solution is to skip Java classes when looking for class methods
which override non-abstract interface methods. This logic only makes
sense for Kotlin code, because only Kotlin has DefaultImpls, and the
requirement to generate non-abstract fake overrides of interface methods
as actual methods in the bytecode, delegating to DefaultImpls.
#KT-48167 Fixed
82 lines
1.6 KiB
Kotlin
Vendored
82 lines
1.6 KiB
Kotlin
Vendored
// TARGET_BACKEND: JVM
|
|
// JVM_TARGET: 1.8
|
|
// FILE: box.kt
|
|
|
|
class MyMap<K, V> : JImpl<K, V>()
|
|
|
|
fun box(): String {
|
|
val a = MyMap<Int, String>()
|
|
a.put(42, "OK")
|
|
return a.entries.iterator().next().value
|
|
}
|
|
|
|
// FILE: J.java
|
|
|
|
import java.util.*;
|
|
|
|
public interface J<K, V> extends Map<K, V> {
|
|
@Override
|
|
default Set<Entry<K, V>> entrySet() {
|
|
return myEntrySet();
|
|
}
|
|
|
|
Set<Entry<K,V>> myEntrySet();
|
|
}
|
|
|
|
// FILE: JImpl.java
|
|
|
|
import java.util.*;
|
|
|
|
public class JImpl<K, V> implements J<K, V> {
|
|
private final Map<K, V> delegate = new HashMap<>();
|
|
|
|
@Override
|
|
public Set<Entry<K, V>> myEntrySet() {
|
|
return delegate.entrySet();
|
|
}
|
|
@Override
|
|
public int size() {
|
|
return delegate.size();
|
|
}
|
|
@Override
|
|
public boolean isEmpty() {
|
|
return delegate.isEmpty();
|
|
}
|
|
@Override
|
|
public boolean containsKey(Object key) {
|
|
return delegate.containsKey(key);
|
|
}
|
|
@Override
|
|
public boolean containsValue(Object value) {
|
|
return delegate.containsValue(value);
|
|
}
|
|
@Override
|
|
public V get(Object key) {
|
|
return delegate.get(key);
|
|
}
|
|
@Override
|
|
public V put(K key, V value) {
|
|
return delegate.put(key, value);
|
|
}
|
|
@Override
|
|
public V remove(Object key) {
|
|
return delegate.remove(key);
|
|
}
|
|
@Override
|
|
public void putAll(Map<? extends K, ? extends V> m) {
|
|
delegate.putAll(m);
|
|
}
|
|
@Override
|
|
public void clear() {
|
|
delegate.clear();
|
|
}
|
|
@Override
|
|
public Set<K> keySet() {
|
|
return delegate.keySet();
|
|
}
|
|
@Override
|
|
public Collection<V> values() {
|
|
return delegate.values();
|
|
}
|
|
}
|