JVM_IR fix special bridges in mixed Java/Kotlin hierarchies

KT-50257 KT-50476
2021-12-22 15:30:09 +03:00
parent 3f056bc086
commit 5946242d75
34 changed files with 1632 additions and 102 deletions
@@ -0,0 +1,22 @@
+// TARGET_BACKEND: JVM
+
+import java.util.AbstractList
+
+class A : AbstractList<String>() {
+    override fun get(index: Int): String = ""
+    override val size: Int get() = 0
+}
+
+fun box(): String {
+    val a = A()
+    val b = A()
+
+    a.addAll(b)
+    a.addAll(0, b)
+    a.removeAll(b)
+    a.retainAll(b)
+    a.clear()
+    a.remove("")
+
+    return "OK"
+}
@@ -0,0 +1,24 @@
+// TARGET_BACKEND: JVM
+
+import java.util.AbstractMap
+import java.util.Collections
+
+class A : AbstractMap<Int, String>() {
+    override val entries: MutableSet<MutableMap.MutableEntry<Int, String>> get() = Collections.emptySet()
+}
+
+fun box(): String {
+    val a = A()
+    val b = A()
+
+    a.remove(0)
+
+    a.putAll(b)
+    a.clear()
+
+    a.keys
+    a.values
+    a.entries
+
+    return "OK"
+}
@@ -0,0 +1,22 @@
+// IGNORE_BACKEND: WASM
+// WASM_MUTE_REASON: STDLIB_COLLECTION_INHERITANCE
+// KJS_WITH_FULL_RUNTIME
+// IGNORE_BACKEND: NATIVE
+class A : HashSet<Long>()
+
+fun box(): String {
+    val a = A()
+    val b = A()
+
+    a.iterator()
+
+    a.add(0L)
+    a.remove(0L)
+
+    a.addAll(b)
+    a.removeAll(b)
+    a.retainAll(b)
+    a.clear()
+
+    return "OK"
+}
@@ -0,0 +1,25 @@
+// IGNORE_BACKEND: WASM
+// WASM_MUTE_REASON: STDLIB_COLLECTION_INHERITANCE
+// KJS_WITH_FULL_RUNTIME
+// KT-6042 java.lang.UnsupportedOperationException with ArrayList
+// IGNORE_BACKEND: NATIVE
+class A : ArrayList<String>()
+
+fun box(): String {
+    val a = A()
+    val b = A()
+
+    a.addAll(b)
+    a.addAll(0, b)
+    a.removeAll(b)
+    a.retainAll(b)
+    a.clear()
+
+    a.add("")
+    a.set(0, "")
+    a.add(0, "")
+    a.removeAt(0)
+    a.remove("")
+
+    return "OK"
+}
@@ -0,0 +1,61 @@
+// TARGET_BACKEND: JVM
+// FULL_JDK
+
+// FILE: charSequenceGetOverriddenInJavaSuperClass.kt
+abstract class KACharSequence : JACharSequence()
+
+class Test(s: String) : JCharSequence(s)
+
+fun box(): String {
+    val t = Test("OK")
+    return "" + t[0] + t[1]
+}
+
+// FILE: JACharSequence.java
+public abstract class JACharSequence implements CharSequence {
+    @Override
+    public char charAt(int index) {
+        return myCharAt(index);
+    }
+
+    protected abstract char myCharAt(int index);
+}
+
+// FILE: JCharSequence.java
+import org.jetbrains.annotations.NotNull;
+
+import java.util.stream.IntStream;
+
+public class JCharSequence extends KACharSequence {
+    private final CharSequence d;
+
+    public JCharSequence(CharSequence d) {
+        this.d = d;
+    }
+
+    @Override
+    public char myCharAt(int index) {
+        return d.charAt(index);
+    }
+
+    public int getLength() {
+        return d.length();
+    }
+
+    @NotNull
+    @Override
+    public CharSequence subSequence(int start, int end) {
+        return d.subSequence(start, end);
+    }
+
+    @Override
+    public String toString() {
+        return d.toString();
+    }
+
+    @NotNull
+    @Override
+    public IntStream codePoints() {
+        return d.codePoints();
+    }
+}
@@ -0,0 +1,13 @@
+// WITH_STDLIB
+// IGNORE_BACKEND: WASM
+// WASM_MUTE_REASON: STDLIB_COLLECTION_INHERITANCE
+
+open class A : ArrayList<String>()
+
+class B : A()
+
+fun box(): String {
+    val b = B()
+    b += "OK"
+    return b.single()
+}
@@ -0,0 +1,22 @@
+// IGNORE_BACKEND: WASM
+// WASM_MUTE_REASON: STDLIB_COLLECTION_INHERITANCE
+// KJS_WITH_FULL_RUNTIME
+// IGNORE_BACKEND: NATIVE
+class A : HashMap<String, Double>()
+
+fun box(): String {
+    val a = A()
+    val b = A()
+
+    a.put("", 0.0)
+    a.remove("")
+
+    a.putAll(b)
+    a.clear()
+
+    a.keys
+    a.values
+    a.entries
+
+    return "OK"
+}
@@ -0,0 +1,22 @@
+// IGNORE_BACKEND: WASM
+// WASM_MUTE_REASON: STDLIB_COLLECTION_INHERITANCE
+// KJS_WITH_FULL_RUNTIME
+// IGNORE_BACKEND: NATIVE
+class A : HashSet<Long>()
+
+fun box(): String {
+    val a = A()
+    val b = A()
+
+    a.iterator()
+
+    a.add(0L)
+    a.remove(0L)
+
+    a.addAll(b)
+    a.removeAll(b)
+    a.retainAll(b)
+    a.clear()
+
+    return "OK"
+}
@@ -0,0 +1,30 @@
+// TARGET_BACKEND: JVM
+
+// FILE: Test.java
+
+import java.lang.*;
+import java.util.*;
+
+public class Test {
+    public static class MapEntryImpl implements Map.Entry<String, String> {
+        public String getKey() { return null; }
+        public String getValue() { return null; }
+        public String setValue(String s) { return null; }
+    }
+}
+
+// FILE: main.kt
+
+//class MyIterable : Test.IterableImpl()
+//class MyIterator : Test.IteratorImpl()
+class MyMapEntry : Test.MapEntryImpl()
+
+fun box(): String {
+
+    val b = MyMapEntry()
+    b.key
+    b.value
+    b.setValue(null)
+
+    return "OK"
+}
@@ -0,0 +1,41 @@
+// TARGET_BACKEND: JVM
+// FULL_JDK
+// WITH_STDLIB
+
+// FILE: numberMixedHierarchy.kt
+import kotlin.test.assertEquals
+
+abstract class KANumber0 : JANumber0() {
+    // toInt()/intValue() implemented in JANumber0
+    override fun toByte(): Byte = 0
+    override fun toChar(): Char = 0.toChar()
+    override fun toShort(): Short = 0
+    override fun toLong() = 0L
+    override fun toFloat() = 0.0f
+    override fun toDouble() = 0.0
+}
+
+class Test : JNumber0()
+
+fun box(): String {
+    val t = Test()
+    assertEquals(0.toByte(), t.toByte())
+    assertEquals(0.toShort(), t.toShort())
+    assertEquals(0, t.toInt())
+    assertEquals(0L, t.toLong())
+    assertEquals(0.0f, t.toFloat())
+    assertEquals(0.0, t.toDouble())
+    return "OK"
+}
+
+// FILE: JANumber0.java
+public abstract class JANumber0 extends Number {
+    @Override
+    public int intValue() {
+        return 0;
+    }
+}
+
+// FILE: JNumber0.java
+public class JNumber0 extends KANumber0 {
+}
@@ -0,0 +1,152 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SKIP_JDK6
+// FULL_JDK
+
+// FILE: removeAtBridgeToJavaClass.kt
+class Test : IntArrayList()
+
+fun box(): String {
+    val t = Test()
+    t.add(1)
+    try {
+        t.removeAt(0)
+        return "Failed: should throw UOE"
+    } catch (e: java.lang.UnsupportedOperationException) {
+        return "OK"
+    }
+}
+
+// FILE: IntArrayList.java
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+
+public class IntArrayList implements List<Integer> {
+    private final ArrayList<Integer> data = new ArrayList<>();
+
+    public IntArrayList() {
+        super();
+    }
+
+    @Override
+    public Integer remove(int index) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public int size() {
+        return data.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return data.isEmpty();
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        return data.contains(o);
+    }
+
+    @NotNull
+    @Override
+    public Iterator<Integer> iterator() {
+        return data.iterator();
+    }
+
+    @NotNull
+    @Override
+    public Object[] toArray() {
+        return data.toArray();
+    }
+
+    @NotNull
+    @Override
+    public <T> T[] toArray(@NotNull T[] a) {
+        return data.toArray(a);
+    }
+
+    @Override
+    public boolean add(Integer integer) {
+        return data.add(integer);
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        return data.remove(o);
+    }
+
+    @Override
+    public boolean containsAll(@NotNull Collection<?> c) {
+        return data.containsAll(c);
+    }
+
+    @Override
+    public boolean addAll(@NotNull Collection<? extends Integer> c) {
+        return data.addAll(c);
+    }
+
+    @Override
+    public boolean addAll(int index, @NotNull Collection<? extends Integer> c) {
+        return data.addAll(index, c);
+    }
+
+    @Override
+    public boolean removeAll(@NotNull Collection<?> c) {
+        return data.removeAll(c);
+    }
+
+    @Override
+    public boolean retainAll(@NotNull Collection<?> c) {
+        return data.retainAll(c);
+    }
+
+    @Override
+    public void clear() {
+        data.clear();
+    }
+
+    @Override
+    public Integer get(int index) {
+        return data.get(index);
+    }
+
+    @Override
+    public Integer set(int index, Integer element) {
+        return data.set(index, element);
+    }
+
+    @Override
+    public void add(int index, Integer element) {
+        data.add(index, element);
+    }
+
+    @Override
+    public int indexOf(Object o) {
+        return data.indexOf(o);
+    }
+
+    @Override
+    public int lastIndexOf(Object o) {
+        return data.lastIndexOf(o);
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<Integer> listIterator() {
+        return data.listIterator();
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<Integer> listIterator(int index) {
+        return data.listIterator(index);
+    }
+
+    @NotNull
+    @Override
+    public List<Integer> subList(int fromIndex, int toIndex) {
+        return data.subList(fromIndex, toIndex);
+    }
+}
@@ -0,0 +1,171 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SKIP_JDK6
+// FULL_JDK
+
+// IGNORE_BACKEND_FIR: JVM_IR
+// FIR_STATUS: java.lang.StackOverflowError
+//    at Test.remove(removeAtBridgeToJavaDefault.kt:7)
+//    at Test.remove(removeAtBridgeToJavaDefault.kt:7)
+//    at Test.remove(removeAtBridgeToJavaDefault.kt:7)
+
+// FILE: removeAtBridgeToJavaDefault.kt
+class Test : IntArrayList()
+
+fun box(): String {
+    val t = Test()
+    t.add(1)
+    try {
+        t.removeAt(0)
+        return "Failed: should throw UOE"
+    } catch (e: java.lang.UnsupportedOperationException) {
+        return "OK"
+    }
+}
+
+// FILE: IntList.java
+import java.util.List;
+
+public interface IntList extends List<Integer> {
+    default Integer remove(int index) {
+        return Integer.valueOf(removeInt(index));
+    }
+
+    int removeInt(int index);
+}
+
+// FILE: AbstractIntList.java
+public abstract class AbstractIntList implements IntList {
+    public int removeInt(int index) {
+        throw new UnsupportedOperationException();
+    }
+}
+
+// FILE: IntArrayList.java
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+
+public class IntArrayList extends AbstractIntList {
+    private final ArrayList<Integer> data = new ArrayList<>();
+
+    public IntArrayList() {
+        super();
+    }
+
+    @Override
+    public int size() {
+        return data.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return data.isEmpty();
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        return data.contains(o);
+    }
+
+    @NotNull
+    @Override
+    public Iterator<Integer> iterator() {
+        return data.iterator();
+    }
+
+    @NotNull
+    @Override
+    public Object[] toArray() {
+        return data.toArray();
+    }
+
+    @NotNull
+    @Override
+    public <T> T[] toArray(@NotNull T[] a) {
+        return data.toArray(a);
+    }
+
+    @Override
+    public boolean add(Integer integer) {
+        return data.add(integer);
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        return data.remove(o);
+    }
+
+    @Override
+    public boolean containsAll(@NotNull Collection<?> c) {
+        return data.containsAll(c);
+    }
+
+    @Override
+    public boolean addAll(@NotNull Collection<? extends Integer> c) {
+        return data.addAll(c);
+    }
+
+    @Override
+    public boolean addAll(int index, @NotNull Collection<? extends Integer> c) {
+        return data.addAll(index, c);
+    }
+
+    @Override
+    public boolean removeAll(@NotNull Collection<?> c) {
+        return data.removeAll(c);
+    }
+
+    @Override
+    public boolean retainAll(@NotNull Collection<?> c) {
+        return data.retainAll(c);
+    }
+
+    @Override
+    public void clear() {
+        data.clear();
+    }
+
+    @Override
+    public Integer get(int index) {
+        return data.get(index);
+    }
+
+    @Override
+    public Integer set(int index, Integer element) {
+        return data.set(index, element);
+    }
+
+    @Override
+    public void add(int index, Integer element) {
+        data.add(index, element);
+    }
+
+    @Override
+    public int indexOf(Object o) {
+        return data.indexOf(o);
+    }
+
+    @Override
+    public int lastIndexOf(Object o) {
+        return data.lastIndexOf(o);
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<Integer> listIterator() {
+        return data.listIterator();
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<Integer> listIterator(int index) {
+        return data.listIterator(index);
+    }
+
+    @NotNull
+    @Override
+    public List<Integer> subList(int fromIndex, int toIndex) {
+        return data.subList(fromIndex, toIndex);
+    }
+}
@@ -0,0 +1,167 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SKIP_JDK6
+// FULL_JDK
+
+// IGNORE_BACKEND_FIR: JVM_IR
+// FIR_STATUS: java.lang.StackOverflowError
+//    at Test.remove(removeAtBridgeToJavaSuperClass.kt:7)
+//    at Test.remove(removeAtBridgeToJavaSuperClass.kt:7)
+//    at Test.remove(removeAtBridgeToJavaSuperClass.kt:7)
+
+// FILE: removeAtBridgeToJavaSuperClass.kt
+class Test : IntArrayList()
+
+fun box(): String {
+    val t = Test()
+    t.add(1)
+    try {
+        t.removeAt(0)
+        return "Failed: should throw UOE"
+    } catch (e: java.lang.UnsupportedOperationException) {
+        return "OK"
+    }
+}
+
+// FILE: AbstractIntList.java
+import java.util.List;
+
+public abstract class AbstractIntList implements List<Integer> {
+    @Override
+    public Integer remove(int index) {
+        return removeInt(index);
+    }
+
+    public int removeInt(int index) {
+        throw new UnsupportedOperationException();
+    }
+}
+
+// FILE: IntArrayList.java
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+
+public class IntArrayList extends AbstractIntList {
+    private final ArrayList<Integer> data = new ArrayList<>();
+
+    public IntArrayList() {
+        super();
+    }
+
+    @Override
+    public int size() {
+        return data.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return data.isEmpty();
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        return data.contains(o);
+    }
+
+    @NotNull
+    @Override
+    public Iterator<Integer> iterator() {
+        return data.iterator();
+    }
+
+    @NotNull
+    @Override
+    public Object[] toArray() {
+        return data.toArray();
+    }
+
+    @NotNull
+    @Override
+    public <T> T[] toArray(@NotNull T[] a) {
+        return data.toArray(a);
+    }
+
+    @Override
+    public boolean add(Integer integer) {
+        return data.add(integer);
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        return data.remove(o);
+    }
+
+    @Override
+    public boolean containsAll(@NotNull Collection<?> c) {
+        return data.containsAll(c);
+    }
+
+    @Override
+    public boolean addAll(@NotNull Collection<? extends Integer> c) {
+        return data.addAll(c);
+    }
+
+    @Override
+    public boolean addAll(int index, @NotNull Collection<? extends Integer> c) {
+        return data.addAll(index, c);
+    }
+
+    @Override
+    public boolean removeAll(@NotNull Collection<?> c) {
+        return data.removeAll(c);
+    }
+
+    @Override
+    public boolean retainAll(@NotNull Collection<?> c) {
+        return data.retainAll(c);
+    }
+
+    @Override
+    public void clear() {
+        data.clear();
+    }
+
+    @Override
+    public Integer get(int index) {
+        return data.get(index);
+    }
+
+    @Override
+    public Integer set(int index, Integer element) {
+        return data.set(index, element);
+    }
+
+    @Override
+    public void add(int index, Integer element) {
+        data.add(index, element);
+    }
+
+    @Override
+    public int indexOf(Object o) {
+        return data.indexOf(o);
+    }
+
+    @Override
+    public int lastIndexOf(Object o) {
+        return data.lastIndexOf(o);
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<Integer> listIterator() {
+        return data.listIterator();
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<Integer> listIterator(int index) {
+        return data.listIterator(index);
+    }
+
+    @NotNull
+    @Override
+    public List<Integer> subList(int fromIndex, int toIndex) {
+        return data.subList(fromIndex, toIndex);
+    }
+}
@@ -0,0 +1,156 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SKIP_JDK6
+// FULL_JDK
+
+// FILE: superCallToFakeRemoveAt.kt
+class Test : IntArrayList() {
+    override fun removeAt(index: Int): Int {
+        return super.removeAt(index)
+    }
+}
+
+fun box(): String {
+    val t = Test()
+    t.add(1)
+    t.removeAt(0)
+    // Just check that there's no exception (e.g., NSME)
+    return "OK"
+}
+
+// FILE: IntArrayListBase.java
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+
+public class IntArrayListBase implements List<Integer> {
+    private final ArrayList<Integer> data = new ArrayList<>();
+
+    public IntArrayListBase() {
+        super();
+    }
+
+    @Override
+    public Integer remove(int index) {
+        return data.remove(index);
+    }
+
+    @Override
+    public int size() {
+        return data.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return data.isEmpty();
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        return data.contains(o);
+    }
+
+    @NotNull
+    @Override
+    public Iterator<Integer> iterator() {
+        return data.iterator();
+    }
+
+    @NotNull
+    @Override
+    public Object[] toArray() {
+        return data.toArray();
+    }
+
+    @NotNull
+    @Override
+    public <T> T[] toArray(@NotNull T[] a) {
+        return data.toArray(a);
+    }
+
+    @Override
+    public boolean add(Integer integer) {
+        return data.add(integer);
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        return data.remove(o);
+    }
+
+    @Override
+    public boolean containsAll(@NotNull Collection<?> c) {
+        return data.containsAll(c);
+    }
+
+    @Override
+    public boolean addAll(@NotNull Collection<? extends Integer> c) {
+        return data.addAll(c);
+    }
+
+    @Override
+    public boolean addAll(int index, @NotNull Collection<? extends Integer> c) {
+        return data.addAll(index, c);
+    }
+
+    @Override
+    public boolean removeAll(@NotNull Collection<?> c) {
+        return data.removeAll(c);
+    }
+
+    @Override
+    public boolean retainAll(@NotNull Collection<?> c) {
+        return data.retainAll(c);
+    }
+
+    @Override
+    public void clear() {
+        data.clear();
+    }
+
+    @Override
+    public Integer get(int index) {
+        return data.get(index);
+    }
+
+    @Override
+    public Integer set(int index, Integer element) {
+        return data.set(index, element);
+    }
+
+    @Override
+    public void add(int index, Integer element) {
+        data.add(index, element);
+    }
+
+    @Override
+    public int indexOf(Object o) {
+        return data.indexOf(o);
+    }
+
+    @Override
+    public int lastIndexOf(Object o) {
+        return data.lastIndexOf(o);
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<Integer> listIterator() {
+        return data.listIterator();
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<Integer> listIterator(int index) {
+        return data.listIterator(index);
+    }
+
+    @NotNull
+    @Override
+    public List<Integer> subList(int fromIndex, int toIndex) {
+        return data.subList(fromIndex, toIndex);
+    }
+}
+
+// FILE: IntArrayList.java
+public class IntArrayList extends IntArrayListBase {}
@@ -0,0 +1,153 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SKIP_JDK6
+// FULL_JDK
+
+// FILE: superCallToRemoveAt.kt
+class Test : IntArrayList() {
+    override fun removeAt(index: Int): Int {
+        return super.removeAt(index)
+    }
+}
+
+fun box(): String {
+    val t = Test()
+    t.add(1)
+    t.removeAt(0)
+    // Just check that there's no exception (e.g., NSME)
+    return "OK"
+}
+
+// FILE: IntArrayList.java
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+
+public class IntArrayList implements List<Integer> {
+    private final ArrayList<Integer> data = new ArrayList<>();
+
+    public IntArrayList() {
+        super();
+    }
+
+    @Override
+    public Integer remove(int index) {
+        return data.remove(index);
+    }
+
+    @Override
+    public int size() {
+        return data.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return data.isEmpty();
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        return data.contains(o);
+    }
+
+    @NotNull
+    @Override
+    public Iterator<Integer> iterator() {
+        return data.iterator();
+    }
+
+    @NotNull
+    @Override
+    public Object[] toArray() {
+        return data.toArray();
+    }
+
+    @NotNull
+    @Override
+    public <T> T[] toArray(@NotNull T[] a) {
+        return data.toArray(a);
+    }
+
+    @Override
+    public boolean add(Integer integer) {
+        return data.add(integer);
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        return data.remove(o);
+    }
+
+    @Override
+    public boolean containsAll(@NotNull Collection<?> c) {
+        return data.containsAll(c);
+    }
+
+    @Override
+    public boolean addAll(@NotNull Collection<? extends Integer> c) {
+        return data.addAll(c);
+    }
+
+    @Override
+    public boolean addAll(int index, @NotNull Collection<? extends Integer> c) {
+        return data.addAll(index, c);
+    }
+
+    @Override
+    public boolean removeAll(@NotNull Collection<?> c) {
+        return data.removeAll(c);
+    }
+
+    @Override
+    public boolean retainAll(@NotNull Collection<?> c) {
+        return data.retainAll(c);
+    }
+
+    @Override
+    public void clear() {
+        data.clear();
+    }
+
+    @Override
+    public Integer get(int index) {
+        return data.get(index);
+    }
+
+    @Override
+    public Integer set(int index, Integer element) {
+        return data.set(index, element);
+    }
+
+    @Override
+    public void add(int index, Integer element) {
+        data.add(index, element);
+    }
+
+    @Override
+    public int indexOf(Object o) {
+        return data.indexOf(o);
+    }
+
+    @Override
+    public int lastIndexOf(Object o) {
+        return data.lastIndexOf(o);
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<Integer> listIterator() {
+        return data.listIterator();
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<Integer> listIterator(int index) {
+        return data.listIterator(index);
+    }
+
+    @NotNull
+    @Override
+    public List<Integer> subList(int fromIndex, int toIndex) {
+        return data.subList(fromIndex, toIndex);
+    }
+}
@@ -0,0 +1,167 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SKIP_JDK6
+// FULL_JDK
+
+// IGNORE_BACKEND_FIR: JVM_IR
+// FIR_STATUS: java.lang.NoSuchMethodError: IntArrayList.removeAt(I)Ljava/lang/Integer;
+
+// FILE: superCallToRemoveAtInJavaDefault.kt
+class Test : IntArrayList() {
+    override fun removeAt(index: Int): Int {
+        return super.removeAt(index)
+    }
+}
+
+fun box(): String {
+    val t = Test()
+    t.add(1)
+    t.removeAt(0)
+    // Just check that there's no exception (e.g., NSME)
+    return "OK"
+}
+
+// FILE: IntList.java
+import java.util.List;
+
+public interface IntList extends List<Integer> {
+    default Integer remove(int index) {
+        return removeInt(index);
+    }
+
+    int removeInt(int index);
+}
+
+// FILE: IntArrayList.java
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+
+public class IntArrayList implements IntList {
+    private final ArrayList<Integer> data = new ArrayList<>();
+
+    public IntArrayList() {
+        super();
+    }
+
+    @Override
+    public int removeInt(int index) {
+        return data.remove(index);
+    }
+
+    @Override
+    public int size() {
+        return data.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return data.isEmpty();
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        return data.contains(o);
+    }
+
+    @NotNull
+    @Override
+    public Iterator<Integer> iterator() {
+        return data.iterator();
+    }
+
+    @NotNull
+    @Override
+    public Object[] toArray() {
+        return data.toArray();
+    }
+
+    @NotNull
+    @Override
+    public <T> T[] toArray(@NotNull T[] a) {
+        return data.toArray(a);
+    }
+
+    @Override
+    public boolean add(Integer integer) {
+        return data.add(integer);
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        return data.remove(o);
+    }
+
+    @Override
+    public boolean containsAll(@NotNull Collection<?> c) {
+        return data.containsAll(c);
+    }
+
+    @Override
+    public boolean addAll(@NotNull Collection<? extends Integer> c) {
+        return data.addAll(c);
+    }
+
+    @Override
+    public boolean addAll(int index, @NotNull Collection<? extends Integer> c) {
+        return data.addAll(index, c);
+    }
+
+    @Override
+    public boolean removeAll(@NotNull Collection<?> c) {
+        return data.removeAll(c);
+    }
+
+    @Override
+    public boolean retainAll(@NotNull Collection<?> c) {
+        return data.retainAll(c);
+    }
+
+    @Override
+    public void clear() {
+        data.clear();
+    }
+
+    @Override
+    public Integer get(int index) {
+        return data.get(index);
+    }
+
+    @Override
+    public Integer set(int index, Integer element) {
+        return data.set(index, element);
+    }
+
+    @Override
+    public void add(int index, Integer element) {
+        data.add(index, element);
+    }
+
+    @Override
+    public int indexOf(Object o) {
+        return data.indexOf(o);
+    }
+
+    @Override
+    public int lastIndexOf(Object o) {
+        return data.lastIndexOf(o);
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<Integer> listIterator() {
+        return data.listIterator();
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<Integer> listIterator(int index) {
+        return data.listIterator(index);
+    }
+
+    @NotNull
+    @Override
+    public List<Integer> subList(int fromIndex, int toIndex) {
+        return data.subList(fromIndex, toIndex);
+    }
+}