Reorganized SAM-related test data.

compiler/testData/loadJava/compiledJava/sam/Comparator.java

@@ -0,0 +1,7 @@
+package test;
+
+public interface Comparator<T> {
+    int compare(T o1, T o2);
+
+    boolean equals(Object obj);
+}

compiler/testData/loadJava/compiledJava/sam/Comparator.txt

@@ -0,0 +1,7 @@
+package test
+
+public /*synthesized*/ fun </*0*/ T> Comparator(/*0*/ function: (T?, T?) -> jet.Int): test.Comparator<T>
+
+public trait Comparator</*0*/ T> : java.lang.Object {
+    public abstract fun compare(/*0*/ p0: T?, /*1*/ p1: T?): jet.Int
+}

compiler/testData/loadJava/compiledJava/sam/FilenameFilter.java

@@ -0,0 +1,7 @@
+package test;
+
+import java.io.File;
+
+public interface FilenameFilter {
+    boolean accept(File dir, String name);
+}

compiler/testData/loadJava/compiledJava/sam/FilenameFilter.txt

@@ -0,0 +1,7 @@
+package test
+
+public /*synthesized*/ fun FilenameFilter(/*0*/ function: (java.io.File?, jet.String?) -> jet.Boolean): test.FilenameFilter
+
+public trait FilenameFilter : java.lang.Object {
+    public abstract fun accept(/*0*/ p0: java.io.File?, /*1*/ p1: jet.String?): jet.Boolean
+}

compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParameterWithSelfBound.java

@@ -0,0 +1,7 @@
+package test;
+
+import java.util.List;
+
+public interface GenericInterfaceParameterWithSelfBound<T extends GenericInterfaceParameterWithSelfBound<T>> {
+    T method(T t);
+}

compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParameterWithSelfBound.txt

@@ -0,0 +1,7 @@
+package test
+
+public /*synthesized*/ fun </*0*/ T : test.GenericInterfaceParameterWithSelfBound<T>?> GenericInterfaceParameterWithSelfBound(/*0*/ function: (T?) -> T?): test.GenericInterfaceParameterWithSelfBound<T>
+
+public trait GenericInterfaceParameterWithSelfBound</*0*/ T : test.GenericInterfaceParameterWithSelfBound<T>?> : java.lang.Object {
+    public abstract fun method(/*0*/ p0: T?): T?
+}

compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParametersWithBounds.java

@@ -0,0 +1,7 @@
+package test;
+
+import java.util.List;
+
+public interface GenericInterfaceParametersWithBounds<A extends Comparable<A> & Cloneable, B extends List<A>> {
+    void method(A[] a, B b);
+}

compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParametersWithBounds.txt

@@ -0,0 +1,7 @@
+package test
+
+public /*synthesized*/ fun </*0*/ A : jet.Comparable<A>?, /*1*/ B : jet.List<A>?> GenericInterfaceParametersWithBounds(/*0*/ function: (jet.Array<out A>?, B?) -> jet.Unit): test.GenericInterfaceParametersWithBounds<A, B> where A : java.lang.Cloneable?
+
+public trait GenericInterfaceParametersWithBounds</*0*/ A : jet.Comparable<A>?, /*1*/ B : jet.List<A>?> : java.lang.Object where A : java.lang.Cloneable? {
+    public abstract fun method(/*0*/ p0: jet.Array<out A>?, /*1*/ p1: B?): jet.Unit
+}

compiler/testData/loadJava/compiledJava/sam/GenericMethodParameters.java

@@ -0,0 +1,7 @@
+package test;
+
+import java.util.List;
+
+public interface GenericMethodParameters {
+    <A extends CharSequence, B extends List<A>> void method(A[] a, B b);
+}

compiler/testData/loadJava/compiledJava/sam/GenericMethodParameters.txt

@@ -0,0 +1,5 @@
+package test
+
+public trait GenericMethodParameters : java.lang.Object {
+    public abstract fun </*0*/ A : jet.CharSequence?, /*1*/ B : jet.List<A>?> method(/*0*/ p0: jet.Array<out A>?, /*1*/ p1: B?): jet.Unit
+}

compiler/testData/loadJava/compiledJava/sam/InterfaceWithObjectMethod.java

@@ -0,0 +1,5 @@
+package test;
+
+public interface InterfaceWithObjectMethod {
+    String toString();
+}

compiler/testData/loadJava/compiledJava/sam/InterfaceWithObjectMethod.txt

@@ -0,0 +1,4 @@
+package test
+
+public trait InterfaceWithObjectMethod : java.lang.Object {
+}

compiler/testData/loadJava/compiledJava/sam/Nested.java

@@ -0,0 +1,22 @@
+package test;
+
+public interface Nested {
+
+    public interface Runnable {
+        void run();
+    }
+
+    public interface Deeper1 {
+        public interface Runnable {
+            void run();
+            void run2();
+        }
+    }
+
+    public interface Deeper2 {
+        public interface Runnable {
+            void run();
+            String toString();
+        }
+    }
+}

compiler/testData/loadJava/compiledJava/sam/Nested.txt

@@ -0,0 +1,31 @@
+package test
+
+public trait Nested : java.lang.Object {
+    
+    public trait Deeper1 : java.lang.Object {
+        
+        public trait Runnable : java.lang.Object {
+            public abstract fun run(): jet.Unit
+            public abstract fun run2(): jet.Unit
+        }
+    }
+    
+    public trait Deeper2 : java.lang.Object {
+        
+        public trait Runnable : java.lang.Object {
+            public abstract fun run(): jet.Unit
+        }
+    }
+    
+    public trait Runnable : java.lang.Object {
+        public abstract fun run(): jet.Unit
+    }
+}
+
+package Nested {
+    public /*synthesized*/ fun Runnable(/*0*/ function: () -> jet.Unit): test.Nested.Runnable
+    
+    package Deeper2 {
+        public /*synthesized*/ fun Runnable(/*0*/ function: () -> jet.Unit): test.Nested.Deeper2.Runnable
+    }
+}

compiler/testData/loadJava/compiledJava/sam/Runnable.java

@@ -0,0 +1,5 @@
+package test;
+
+public interface Runnable {
+    void run();
+}

compiler/testData/loadJava/compiledJava/sam/Runnable.txt

@@ -0,0 +1,7 @@
+package test
+
+public /*synthesized*/ fun Runnable(/*0*/ function: () -> jet.Unit): test.Runnable
+
+public trait Runnable : java.lang.Object {
+    public abstract fun run(): jet.Unit
+}

compiler/testData/loadJava/compiledJava/sam/SamSubinterfaceOfTwo.java

@@ -0,0 +1,14 @@
+package test;
+
+public interface SamSubinterfaceOfTwo {
+    public interface Super1 {
+        CharSequence f();
+    }
+
+    public interface Super2<T> {
+        T f();
+    }
+
+    public interface Sub extends Super1, Super2<String> {
+    }
+}

compiler/testData/loadJava/compiledJava/sam/SamSubinterfaceOfTwo.txt

@@ -0,0 +1,22 @@
+package test
+
+public trait SamSubinterfaceOfTwo : java.lang.Object {
+    
+    public trait Sub : test.SamSubinterfaceOfTwo.Super1, test.SamSubinterfaceOfTwo.Super2<jet.String> {
+        public abstract override /*2*/ /*fake_override*/ fun f(): jet.CharSequence?
+    }
+    
+    public trait Super1 : java.lang.Object {
+        public abstract fun f(): jet.CharSequence?
+    }
+    
+    public trait Super2</*0*/ T> : java.lang.Object {
+        public abstract fun f(): T?
+    }
+}
+
+package SamSubinterfaceOfTwo {
+    public /*synthesized*/ fun Sub(/*0*/ function: () -> jet.String?): test.SamSubinterfaceOfTwo.Sub
+    public /*synthesized*/ fun Super1(/*0*/ function: () -> jet.CharSequence?): test.SamSubinterfaceOfTwo.Super1
+    public /*synthesized*/ fun </*0*/ T> Super2(/*0*/ function: () -> T?): test.SamSubinterfaceOfTwo.Super2<T>
+}

compiler/testData/loadJava/compiledJava/sam/SamSubinterfaceOverridding.java

@@ -0,0 +1,5 @@
+package test;
+
+public interface SamSubinterfaceOverridding extends Runnable {
+    void run();
+}

compiler/testData/loadJava/compiledJava/sam/SamSubinterfaceOverridding.txt

@@ -0,0 +1,7 @@
+package test
+
+public /*synthesized*/ fun SamSubinterfaceOverridding(/*0*/ function: () -> jet.Unit): test.SamSubinterfaceOverridding
+
+public trait SamSubinterfaceOverridding : java.lang.Runnable {
+    public abstract override /*1*/ fun run(): jet.Unit
+}

compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterface.java

@@ -0,0 +1,6 @@
+package test;
+
+import java.util.Comparator;
+
+public interface SubstitutedSamInterface extends Comparator<String> {
+}

compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterface.txt

@@ -0,0 +1,7 @@
+package test
+
+public /*synthesized*/ fun SubstitutedSamInterface(/*0*/ function: (jet.String, jet.String) -> jet.Int): test.SubstitutedSamInterface
+
+public trait SubstitutedSamInterface : java.util.Comparator<jet.String> {
+    public abstract override /*1*/ /*fake_override*/ fun compare(/*0*/ p0: jet.String, /*1*/ p1: jet.String): jet.Int
+}

compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterfaceSubclassOfBuiltin.java

@@ -0,0 +1,4 @@
+package test;
+
+public interface SubstitutedSamInterfaceSubclassOfBuiltin extends Comparable<SubstitutedSamInterfaceSubclassOfBuiltin> {
+}

compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterfaceSubclassOfBuiltin.txt

@@ -0,0 +1,7 @@
+package test
+
+public /*synthesized*/ fun SubstitutedSamInterfaceSubclassOfBuiltin(/*0*/ function: (test.SubstitutedSamInterfaceSubclassOfBuiltin) -> jet.Int): test.SubstitutedSamInterfaceSubclassOfBuiltin
+
+public trait SubstitutedSamInterfaceSubclassOfBuiltin : jet.Comparable<test.SubstitutedSamInterfaceSubclassOfBuiltin> {
+    public abstract override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: test.SubstitutedSamInterfaceSubclassOfBuiltin): jet.Int
+}

compiler/testData/loadJava/compiledJava/sam/VarargParameter.java

@@ -0,0 +1,5 @@
+package test;
+
+public interface VarargParameter {
+    void f(String... strings);
+}

compiler/testData/loadJava/compiledJava/sam/VarargParameter.txt

@@ -0,0 +1,7 @@
+package test
+
+public /*synthesized*/ fun VarargParameter(/*0*/ function: (jet.Array<jet.String?>) -> jet.Unit): test.VarargParameter
+
+public trait VarargParameter : java.lang.Object {
+    public abstract fun f(/*0*/ vararg p0: jet.String? /*jet.Array<jet.String?>*/): jet.Unit
+}

compiler/testData/loadJava/compiledJava/sam/adapters/AmbiguousAdapters.java

@@ -0,0 +1,11 @@
+package test;
+
+import java.io.Closeable;
+
+public class AmbiguousAdapters {
+    public void foo(Runnable r) {
+    }
+
+    public void foo(Closeable c) {
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/AmbiguousAdapters.txt

@@ -0,0 +1,9 @@
+package test
+
+public open class AmbiguousAdapters : java.lang.Object {
+    public constructor AmbiguousAdapters()
+    public open /*synthesized*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+    public open /*synthesized*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+    public open fun foo(/*0*/ p0: java.io.Closeable?): jet.Unit
+    public open fun foo(/*0*/ p0: java.lang.Runnable?): jet.Unit
+}

compiler/testData/loadJava/compiledJava/sam/adapters/Basic.java

@@ -0,0 +1,9 @@
+package test;
+
+public class Basic {
+    public void foo(Runnable r) {
+    }
+
+    public static void bar(Runnable r) {
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/Basic.txt

@@ -0,0 +1,12 @@
+package test
+
+public open class Basic : java.lang.Object {
+    public constructor Basic()
+    public open /*synthesized*/ fun foo(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+    public open fun foo(/*0*/ p0: java.lang.Runnable?): jet.Unit
+}
+
+package Basic {
+    public open /*synthesized*/ fun bar(/*0*/ p0: (() -> jet.Unit)?): jet.Unit
+    public open fun bar(/*0*/ p0: java.lang.Runnable?): jet.Unit
+}

compiler/testData/loadJava/compiledJava/sam/adapters/Constructor.java

@@ -0,0 +1,6 @@
+package test;
+
+public class Constructor {
+    public Constructor(Runnable r) {
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/Constructor.txt

@@ -0,0 +1,6 @@
+package test
+
+public open class Constructor : java.lang.Object {
+    public /*synthesized*/ constructor Constructor(/*0*/ p0: (() -> jet.Unit)?)
+    public constructor Constructor(/*0*/ p0: java.lang.Runnable?)
+}

compiler/testData/loadJava/compiledJava/sam/adapters/DeepSamLoop.java

@@ -0,0 +1,12 @@
+package test;
+
+public interface DeepSamLoop {
+
+    interface Foo {
+        void foo(Bar p);
+    }
+
+    interface Bar {
+        void foo(Foo p);
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/DeepSamLoop.txt

@@ -0,0 +1,19 @@
+package test
+
+public trait DeepSamLoop : java.lang.Object {
+    
+    public trait Bar : java.lang.Object {
+        public abstract /*synthesized*/ fun foo(/*0*/ p0: ((test.DeepSamLoop.Bar?) -> jet.Unit)?): jet.Unit
+        public abstract fun foo(/*0*/ p0: test.DeepSamLoop.Foo?): jet.Unit
+    }
+    
+    public trait Foo : java.lang.Object {
+        public abstract /*synthesized*/ fun foo(/*0*/ p0: ((test.DeepSamLoop.Foo?) -> jet.Unit)?): jet.Unit
+        public abstract fun foo(/*0*/ p0: test.DeepSamLoop.Bar?): jet.Unit
+    }
+}
+
+package DeepSamLoop {
+    public /*synthesized*/ fun Bar(/*0*/ function: (test.DeepSamLoop.Foo?) -> jet.Unit): test.DeepSamLoop.Bar
+    public /*synthesized*/ fun Foo(/*0*/ function: (test.DeepSamLoop.Bar?) -> jet.Unit): test.DeepSamLoop.Foo
+}

compiler/testData/loadJava/compiledJava/sam/adapters/InheritedOverridden.java

@@ -0,0 +1,13 @@
+package test;
+
+public interface InheritedOverridden {
+    public class Super {
+        public void foo(Runnable r) {
+        }
+    }
+
+    public class Sub extends Super {
+        public void foo(Runnable r) {
+        }
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/InheritedOverridden.txt

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

compiler/testData/loadJava/compiledJava/sam/adapters/InheritedOverriddenAdapter.java

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

compiler/testData/loadJava/compiledJava/sam/adapters/InheritedOverriddenAdapter.txt

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

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

@@ -0,0 +1,10 @@
+package test;
+
+public interface InheritedSimple {
+    public interface Super {
+        void foo(Runnable r);
+    }
+
+    public interface Sub extends Super {
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/InheritedSimple.txt

@@ -0,0 +1,19 @@
+package test
+
+public trait InheritedSimple : java.lang.Object {
+    
+    public trait Sub : test.InheritedSimple.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: java.lang.Runnable?): jet.Unit
+    }
+    
+    public trait Super : 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 InheritedSimple {
+    public /*synthesized*/ fun Sub(/*0*/ function: (java.lang.Runnable?) -> jet.Unit): test.InheritedSimple.Sub
+    public /*synthesized*/ fun Super(/*0*/ function: (java.lang.Runnable?) -> jet.Unit): test.InheritedSimple.Super
+}

compiler/testData/loadJava/compiledJava/sam/adapters/NonTrivialFunctionType.java

@@ -0,0 +1,18 @@
+package test;
+
+import java.io.FilenameFilter;
+import java.util.Comparator;
+
+public class NonTrivialFunctionType {
+    public void foo(FilenameFilter filenameFilter) {
+    }
+
+    public void foo(Comparator<String> comparator) {
+    }
+
+    public void wildcardUnbound(Comparator<?> comparator) {
+    }
+
+    public void wildcardBound(Comparator<? super CharSequence> comparator) {
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/NonTrivialFunctionType.txt

@@ -0,0 +1,12 @@
+package test
+
+public open class NonTrivialFunctionType : java.lang.Object {
+    public constructor NonTrivialFunctionType()
+    public open /*synthesized*/ fun foo(/*0*/ p0: ((java.io.File, jet.String) -> jet.Boolean)?): jet.Unit
+    public open /*synthesized*/ fun foo(/*0*/ p0: ((jet.String, jet.String) -> jet.Int)?): jet.Unit
+    public open fun foo(/*0*/ p0: java.io.FilenameFilter?): jet.Unit
+    public open fun foo(/*0*/ p0: java.util.Comparator<jet.String>?): jet.Unit
+    public open /*synthesized*/ fun wildcardBound(/*0*/ p0: ((jet.CharSequence?, jet.CharSequence?) -> jet.Int)?): jet.Unit
+    public open fun wildcardBound(/*0*/ p0: java.util.Comparator<in jet.CharSequence?>?): jet.Unit
+    public open fun wildcardUnbound(/*0*/ p0: java.util.Comparator<out jet.Any?>?): jet.Unit
+}

compiler/testData/loadJava/compiledJava/sam/adapters/SelfAsParameter.java

@@ -0,0 +1,5 @@
+package test;
+
+public interface SelfAsParameter {
+    void foo(SelfAsParameter p);
+}

compiler/testData/loadJava/compiledJava/sam/adapters/SelfAsParameter.txt

@@ -0,0 +1,8 @@
+package test
+
+public /*synthesized*/ fun SelfAsParameter(/*0*/ function: (test.SelfAsParameter?) -> jet.Unit): test.SelfAsParameter
+
+public trait SelfAsParameter : java.lang.Object {
+    public abstract /*synthesized*/ fun foo(/*0*/ p0: ((test.SelfAsParameter?) -> jet.Unit)?): jet.Unit
+    public abstract fun foo(/*0*/ p0: test.SelfAsParameter?): jet.Unit
+}

compiler/testData/loadJava/compiledJava/sam/adapters/SeveralSamParameters.java

@@ -0,0 +1,9 @@
+package test;
+
+import java.util.*;
+
+public class SeveralSamParameters {
+    public static String findMaxAndInvokeCallback(Comparator<String> comparator, String a, String b, Runnable afterRunnable) {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/SeveralSamParameters.txt

@@ -0,0 +1,10 @@
+package test
+
+public open class SeveralSamParameters : java.lang.Object {
+    public constructor SeveralSamParameters()
+}
+
+package SeveralSamParameters {
+    public open /*synthesized*/ fun findMaxAndInvokeCallback(/*0*/ p0: ((jet.String, jet.String) -> jet.Int)?, /*1*/ p1: jet.String?, /*2*/ p2: jet.String?, /*3*/ p3: (() -> jet.Unit)?): jet.String?
+    public open fun findMaxAndInvokeCallback(/*0*/ p0: java.util.Comparator<jet.String>?, /*1*/ p1: jet.String?, /*2*/ p2: jet.String?, /*3*/ p3: java.lang.Runnable?): jet.String?
+}

compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfClass.java

@@ -0,0 +1,8 @@
+package test;
+
+import java.util.*;
+
+public class TypeParameterOfClass<T> {
+    public void foo(Comparator<T> comparator) {
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfClass.txt

@@ -0,0 +1,7 @@
+package test
+
+public open class TypeParameterOfClass</*0*/ T> : java.lang.Object {
+    public constructor TypeParameterOfClass</*0*/ T>()
+    public open /*synthesized*/ fun foo(/*0*/ p0: ((T, T) -> jet.Int)?): jet.Unit
+    public open fun foo(/*0*/ p0: java.util.Comparator<T>?): jet.Unit
+}

compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfMethod.java

@@ -0,0 +1,19 @@
+package test;
+
+import java.lang.UnsupportedOperationException;
+import java.util.*;
+import java.util.Comparator;
+
+public class TypeParameterOfMethod {
+    public static <T> T max(Comparator<T> comparator, T value1, T value2) {
+        return comparator.compare(value1, value2) > 0 ? value1 : value2;
+    }
+
+    public static <T extends CharSequence> T max2(Comparator<T> comparator, T value1, T value2) {
+        return comparator.compare(value1, value2) > 0 ? value1 : value2;
+    }
+
+    public static <A extends CharSequence, B extends List<A>> void method(Comparator<A> a, B b) {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfMethod.txt

@@ -0,0 +1,14 @@
+package test
+
+public open class TypeParameterOfMethod : java.lang.Object {
+    public constructor TypeParameterOfMethod()
+}
+
+package TypeParameterOfMethod {
+    public open /*synthesized*/ fun </*0*/ T> max(/*0*/ p0: ((T, T) -> jet.Int)?, /*1*/ p1: T?, /*2*/ p2: T?): T?
+    public open fun </*0*/ T> max(/*0*/ p0: java.util.Comparator<T>?, /*1*/ p1: T?, /*2*/ p2: T?): T?
+    public open /*synthesized*/ fun </*0*/ T : jet.CharSequence?> max2(/*0*/ p0: ((T, T) -> jet.Int)?, /*1*/ p1: T?, /*2*/ p2: T?): T?
+    public open fun </*0*/ T : jet.CharSequence?> max2(/*0*/ p0: java.util.Comparator<T>?, /*1*/ p1: T?, /*2*/ p2: T?): T?
+    public open /*synthesized*/ fun </*0*/ A : jet.CharSequence?, /*1*/ B : jet.List<A>?> method(/*0*/ p0: ((A, A) -> jet.Int)?, /*1*/ p1: B?): jet.Unit
+    public open fun </*0*/ A : jet.CharSequence?, /*1*/ B : jet.List<A>?> method(/*0*/ p0: java.util.Comparator<A>?, /*1*/ p1: B?): jet.Unit
+}

compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfOuterClass.java

@@ -0,0 +1,10 @@
+package test;
+
+import java.util.*;
+
+public class TypeParameterOfOuterClass<T> {
+    public class Inner {
+        public void foo(Comparator<T> comparator) {
+        }
+    }
+}

compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfOuterClass.txt

@@ -0,0 +1,11 @@
+package test
+
+public open class TypeParameterOfOuterClass</*0*/ T> : java.lang.Object {
+    public constructor TypeParameterOfOuterClass</*0*/ T>()
+    
+    public open inner class Inner : java.lang.Object {
+        public constructor Inner()
+        public open /*synthesized*/ fun foo(/*0*/ p0: ((T, T) -> jet.Int)?): jet.Unit
+        public open fun foo(/*0*/ p0: java.util.Comparator<T>?): jet.Unit
+    }
+}