Supported complex cases of SAM adapters inheritance/overriding.

compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/AdapterDoesntOverrideDeclaration.java

@@ -0,0 +1,11 @@
+package test;
+
+public interface AdapterDoesntOverrideDeclaration {
+    public interface Super {
+        void foo(jet.Function0<jet.Unit> r);
+    }
+
+    public interface Sub extends Super {
+        void foo(Runnable r);
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/AdapterDoesntOverrideDeclaration.txt

@@ -0,0 +1,18 @@
+package test
+
+public trait AdapterDoesntOverrideDeclaration : java.lang.Object {
+    
+    public trait Sub : test.AdapterDoesntOverrideDeclaration.Super {
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract /*synthesized*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract fun foo(/*0*/ p0: java.lang.Runnable?): jet.Unit
+    }
+    
+    public trait Super : java.lang.Object {
+        public abstract fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+    }
+}
+
+package AdapterDoesntOverrideDeclaration {
+    public /*synthesized*/ fun Super(/*0*/ function: ((() -> jet.Unit)?) -> jet.Unit): test.AdapterDoesntOverrideDeclaration.Super
+}

compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAdapterAndDeclaration.java

@@ -0,0 +1,11 @@
+package test;
+
+public interface InheritedAdapterAndDeclaration {
+    public interface Super {
+        void foo(Runnable r);
+        void foo(jet.Function0<jet.Unit> r);
+    }
+
+    public interface Sub extends Super {
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAdapterAndDeclaration.txt

@@ -0,0 +1,16 @@
+package test
+
+public trait InheritedAdapterAndDeclaration : java.lang.Object {
+    
+    public trait Sub : test.InheritedAdapterAndDeclaration.Super {
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: java.lang.Runnable?): jet.Unit
+    }
+    
+    public trait Super : java.lang.Object {
+        public abstract fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract /*synthesized*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract fun foo(/*0*/ p0: java.lang.Runnable?): jet.Unit
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAmbiguousAdapters.java

@@ -0,0 +1,13 @@
+package test;
+
+import java.io.Closeable;
+
+public interface InheritedAmbiguousAdapters {
+    public interface Super {
+        void foo(Runnable r);
+        void foo(Closeable r);
+    }
+
+    public interface Sub extends Super {
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAmbiguousAdapters.txt

@@ -0,0 +1,18 @@
+package test
+
+public trait InheritedAmbiguousAdapters : java.lang.Object {
+    
+    public trait Sub : test.InheritedAmbiguousAdapters.Super {
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: java.io.Closeable?): jet.Unit
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: java.lang.Runnable?): jet.Unit
+    }
+    
+    public trait Super : java.lang.Object {
+        public abstract /*synthesized*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract /*synthesized*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract fun foo(/*0*/ p0: java.io.Closeable?): jet.Unit
+        public abstract fun foo(/*0*/ p0: java.lang.Runnable?): jet.Unit
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAndOverriddenAmbiguousAdapters.java

@@ -0,0 +1,14 @@
+package test;
+
+import java.io.Closeable;
+
+public interface InheritedAndOverriddenAmbiguousAdapters {
+    public interface Super {
+        void foo(Runnable r);
+        void foo(Closeable r);
+    }
+
+    public interface Sub extends Super {
+        void foo(Runnable r);
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAndOverriddenAmbiguousAdapters.txt

@@ -0,0 +1,18 @@
+package test
+
+public trait InheritedAndOverriddenAmbiguousAdapters : java.lang.Object {
+    
+    public trait Sub : test.InheritedAndOverriddenAmbiguousAdapters.Super {
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract override /*1*/ /*synthesized*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: java.io.Closeable?): jet.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0: java.lang.Runnable?): jet.Unit
+    }
+    
+    public trait Super : java.lang.Object {
+        public abstract /*synthesized*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract /*synthesized*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract fun foo(/*0*/ p0: java.io.Closeable?): jet.Unit
+        public abstract fun foo(/*0*/ p0: java.lang.Runnable?): jet.Unit
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSameAdapters.java

@@ -0,0 +1,14 @@
+package test;
+
+public interface InheritedSameAdapters {
+    public interface Super1 {
+        void foo(Runnable r);
+    }
+
+    public interface Super2 {
+        void foo(Runnable r);
+    }
+
+    public interface Sub extends Super1, Super2 {
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSameAdapters.txt

@@ -0,0 +1,25 @@
+package test
+
+public trait InheritedSameAdapters : java.lang.Object {
+    
+    public trait Sub : test.InheritedSameAdapters.Super1, test.InheritedSameAdapters.Super2 {
+        public abstract override /*2*/ /*fake_override*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract override /*2*/ /*fake_override*/ fun foo(/*0*/ p0: java.lang.Runnable?): jet.Unit
+    }
+    
+    public trait Super1 : java.lang.Object {
+        public abstract /*synthesized*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract fun foo(/*0*/ p0: java.lang.Runnable?): jet.Unit
+    }
+    
+    public trait Super2 : java.lang.Object {
+        public abstract /*synthesized*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract fun foo(/*0*/ p0: java.lang.Runnable?): jet.Unit
+    }
+}
+
+package InheritedSameAdapters {
+    public /*synthesized*/ fun Sub(/*0*/ function: (java.lang.Runnable?) -> jet.Unit): test.InheritedSameAdapters.Sub
+    public /*synthesized*/ fun Super1(/*0*/ function: (java.lang.Runnable?) -> jet.Unit): test.InheritedSameAdapters.Super1
+    public /*synthesized*/ fun Super2(/*0*/ function: (java.lang.Runnable?) -> jet.Unit): test.InheritedSameAdapters.Super2
+}

compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSameAdaptersWithSubstitution.java

@@ -0,0 +1,19 @@
+package test;
+
+import java.util.Comparator;
+
+public interface InheritedSameAdaptersWithSubstitution {
+    public interface Super1 {
+        void foo(Comparator<String> r);
+    }
+
+    public interface Super2<T> {
+        void foo(Comparator<T> r);
+    }
+
+    public interface Super2Substituted extends Super2<String> {
+    }
+
+    public interface Sub extends Super1, Super2Substituted {
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSameAdaptersWithSubstitution.txt

@@ -0,0 +1,31 @@
+package test
+
+public trait InheritedSameAdaptersWithSubstitution : java.lang.Object {
+    
+    public trait Sub : test.InheritedSameAdaptersWithSubstitution.Super1, test.InheritedSameAdaptersWithSubstitution.Super2Substituted {
+        public abstract override /*2*/ /*fake_override*/ fun foo(/*0*/ p0: ((jet.String, jet.String) -> jet.Int)?): jet.Unit
+        public abstract override /*2*/ /*fake_override*/ fun foo(/*0*/ p0: java.util.Comparator<jet.String>?): jet.Unit
+    }
+    
+    public trait Super1 : java.lang.Object {
+        public abstract /*synthesized*/ fun foo(/*0*/ p0: ((jet.String, jet.String) -> jet.Int)?): jet.Unit
+        public abstract fun foo(/*0*/ p0: java.util.Comparator<jet.String>?): jet.Unit
+    }
+    
+    public trait Super2</*0*/ T> : java.lang.Object {
+        public abstract /*synthesized*/ fun foo(/*0*/ p0: ((T, T) -> jet.Int)?): jet.Unit
+        public abstract fun foo(/*0*/ p0: java.util.Comparator<T>?): jet.Unit
+    }
+    
+    public trait Super2Substituted : test.InheritedSameAdaptersWithSubstitution.Super2<jet.String> {
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: ((jet.String, jet.String) -> jet.Int)?): jet.Unit
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: java.util.Comparator<jet.String>?): jet.Unit
+    }
+}
+
+package InheritedSameAdaptersWithSubstitution {
+    public /*synthesized*/ fun Sub(/*0*/ function: (java.util.Comparator<jet.String>?) -> jet.Unit): test.InheritedSameAdaptersWithSubstitution.Sub
+    public /*synthesized*/ fun Super1(/*0*/ function: (java.util.Comparator<jet.String>?) -> jet.Unit): test.InheritedSameAdaptersWithSubstitution.Super1
+    public /*synthesized*/ fun </*0*/ T> Super2(/*0*/ function: (java.util.Comparator<T>?) -> jet.Unit): test.InheritedSameAdaptersWithSubstitution.Super2<T>
+    public /*synthesized*/ fun Super2Substituted(/*0*/ function: (java.util.Comparator<jet.String>?) -> jet.Unit): test.InheritedSameAdaptersWithSubstitution.Super2Substituted
+}

compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSimple.java

@@ -7,4 +7,4 @@ public interface InheritedSimple {
 
     public interface Sub extends Super {
     }
-}
+}

compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/OverriddenAmbiguousAdapters.java

@@ -0,0 +1,14 @@
+package test;
+
+import java.io.Closeable;
+
+public interface OverriddenAmbiguousAdapters {
+    public interface Super {
+        void foo(Runnable r);
+        void foo(Closeable r);
+    }
+
+    public interface Sub extends Super {
+        void foo(jet.Function0<jet.Unit> r);
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/OverriddenAmbiguousAdapters.txt

@@ -0,0 +1,17 @@
+package test
+
+public trait OverriddenAmbiguousAdapters : java.lang.Object {
+    
+    public trait Sub : test.OverriddenAmbiguousAdapters.Super {
+        public abstract override /*2*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: java.io.Closeable?): jet.Unit
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: java.lang.Runnable?): jet.Unit
+    }
+    
+    public trait Super : java.lang.Object {
+        public abstract /*synthesized*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract /*synthesized*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+        public abstract fun foo(/*0*/ p0: java.io.Closeable?): jet.Unit
+        public abstract fun foo(/*0*/ p0: java.lang.Runnable?): jet.Unit
+    }
+}