Introduce experimental -Xuse-javac compilation mode

In this mode, javac AST and Symbol files are used during
Kotlin compilation instead of PSI / binary stuff.
Later, they are reused for Java file compilation.
javac in this mode is integrated into kotlinc.

compiler/testData/compileKotlinAgainstJava/AbstractClass.java

@@ -0,0 +1,7 @@
+package test;
+
+public abstract class AbstractClass {
+
+    public abstract void implementMe();
+
+}

compiler/testData/compileKotlinAgainstJava/AbstractClass.kt

@@ -0,0 +1,7 @@
+package test
+
+class AbstractClassImpl : AbstractClass() {
+
+    override fun implementMe() {}
+
+}

compiler/testData/compileKotlinAgainstJava/AbstractClass.txt

@@ -0,0 +1,11 @@
+package test
+
+public abstract class AbstractClass {
+    public constructor AbstractClass()
+    public abstract fun implementMe(): kotlin.Unit
+}
+
+public final class AbstractClassImpl : test.AbstractClass {
+    public constructor AbstractClassImpl()
+    public open fun implementMe(): kotlin.Unit
+}

compiler/testData/compileKotlinAgainstJava/AbstractEnum.java

@@ -0,0 +1,12 @@
+package test;
+
+public enum AbstractEnum {
+
+    ONE {
+        @Override
+        String getString() { return null; }
+    };
+
+    abstract String getString();
+
+}

compiler/testData/compileKotlinAgainstJava/AbstractEnum.kt

@@ -0,0 +1,3 @@
+package test
+
+fun useEnum() = AbstractEnum.ONE.getString()

compiler/testData/compileKotlinAgainstJava/AbstractEnum.txt

@@ -0,0 +1,22 @@
+package test
+
+public fun useEnum(): kotlin.String!
+
+public abstract enum class AbstractEnum : kotlin.Enum<test.AbstractEnum!> {
+    enum entry ONE
+
+    private constructor AbstractEnum()
+    public final /*fake_override*/ val name: kotlin.String
+    public final /*fake_override*/ val ordinal: kotlin.Int
+    protected final /*fake_override*/ fun clone(): kotlin.Any
+    public final /*fake_override*/ fun compareTo(/*0*/ test.AbstractEnum!): kotlin.Int
+    protected/*protected and package*/ final /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun finalize(): kotlin.Unit
+    public final /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun getDeclaringClass(): java.lang.Class<test.AbstractEnum!>!
+    public/*package*/ abstract fun getString(): kotlin.String!
+
+    // Static members
+    public final /*synthesized*/ fun valueOf(/*0*/ kotlin.String): test.AbstractEnum
+    public open fun valueOf(/*0*/ kotlin.String!): test.AbstractEnum!
+    public open fun values(): kotlin.Array<(out) test.AbstractEnum!>!
+    public final /*synthesized*/ fun values(): kotlin.Array<test.AbstractEnum>
+}

compiler/testData/compileKotlinAgainstJava/AnnotationWithArguments.java

@@ -0,0 +1,12 @@
+package test;
+
+import java.lang.annotation.*;
+
+@Target(value=ElementType.TYPE)
+public @interface AnnotationWithArguments {
+
+    String name();
+
+    String arg() default "default";
+
+}

compiler/testData/compileKotlinAgainstJava/AnnotationWithArguments.kt

@@ -0,0 +1,7 @@
+package test
+
+@AnnotationWithArguments(name="withDefault")
+class ClassWithDefault
+
+@AnnotationWithArguments(name="withoutDefault", arg="non")
+class ClassWithoutDefault

compiler/testData/compileKotlinAgainstJava/AnnotationWithArguments.txt

@@ -0,0 +1,15 @@
+package test
+
+@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FILE}) public final annotation class AnnotationWithArguments : kotlin.Annotation {
+    public constructor AnnotationWithArguments(/*0*/ kotlin.String, /*1*/ kotlin.String = ...)
+    public final val arg: kotlin.String
+    public final val name: kotlin.String
+}
+
+@test.AnnotationWithArguments(name = "withDefault") public final class ClassWithDefault {
+    public constructor ClassWithDefault()
+}
+
+@test.AnnotationWithArguments(arg = "non", name = "withoutDefault") public final class ClassWithoutDefault {
+    public constructor ClassWithoutDefault()
+}

compiler/testData/compileKotlinAgainstJava/AnnotationWithField.java

@@ -0,0 +1,9 @@
+package test;
+
+public @interface AnnotationWithField {
+
+    String text();
+
+    int ANSWER = 42;
+
+}

compiler/testData/compileKotlinAgainstJava/AnnotationWithField.kt

@@ -0,0 +1,4 @@
+package test
+
+@AnnotationWithField(text="desc")
+class SomeClass

compiler/testData/compileKotlinAgainstJava/AnnotationWithField.txt

@@ -0,0 +1,13 @@
+package test
+
+public final annotation class AnnotationWithField : kotlin.Annotation {
+    public constructor AnnotationWithField(/*0*/ kotlin.String)
+    public final val text: kotlin.String
+
+    // Static members
+    public const final val ANSWER: kotlin.Int
+}
+
+@test.AnnotationWithField(text = "desc") public final class SomeClass {
+    public constructor SomeClass()
+}

compiler/testData/compileKotlinAgainstJava/AsteriskInImport.java

@@ -0,0 +1,9 @@
+package test;
+
+import java.util.*;
+
+public class AsteriskInImport {
+
+    public static List<String> getStrings() { return null; }
+
+}

compiler/testData/compileKotlinAgainstJava/AsteriskInImport.kt

@@ -0,0 +1,3 @@
+package test
+
+fun getStrings() = AsteriskInImport.getStrings()

compiler/testData/compileKotlinAgainstJava/AsteriskInImport.txt

@@ -0,0 +1,10 @@
+package test
+
+public fun getStrings(): kotlin.collections.(Mutable)List<kotlin.String!>!
+
+public open class AsteriskInImport {
+    public constructor AsteriskInImport()
+
+    // Static members
+    public open fun getStrings(): kotlin.collections.(Mutable)List<kotlin.String!>!
+}

compiler/testData/compileKotlinAgainstJava/CheckKotlinStub.java

@@ -0,0 +1,7 @@
+package test;
+
+import test2.*;
+
+public class CheckKotlinStub {
+    public KotlinStub getKotlinStub() { return null; }
+}

compiler/testData/compileKotlinAgainstJava/CheckKotlinStub.kt

@@ -0,0 +1,7 @@
+package test2
+
+import test.*
+
+class KotlinStub
+
+fun checkKotlinStub() = CheckKotlinStub().getKotlinStub()

compiler/testData/compileKotlinAgainstJava/CheckKotlinStub.txt

@@ -0,0 +1,6 @@
+package test
+
+public open class CheckKotlinStub {
+    public constructor CheckKotlinStub()
+    public open fun getKotlinStub(): test2.KotlinStub!
+}

compiler/testData/compileKotlinAgainstJava/CheckNotNull.java

@@ -0,0 +1,10 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+
+public class CheckNotNull {
+
+    @NotNull
+    public String returnNotNull() { return "42"; }
+
+}

compiler/testData/compileKotlinAgainstJava/CheckNotNull.kt

@@ -0,0 +1,3 @@
+package test
+
+fun notNullable(): String = CheckNotNull().returnNotNull()

compiler/testData/compileKotlinAgainstJava/CheckNotNull.txt

@@ -0,0 +1,8 @@
+package test
+
+public fun notNullable(): kotlin.String
+
+public open class CheckNotNull {
+    public constructor CheckNotNull()
+    @org.jetbrains.annotations.NotNull public open fun returnNotNull(): kotlin.String
+}

compiler/testData/compileKotlinAgainstJava/Class.java

@@ -0,0 +1,11 @@
+package test;
+
+public class Class {
+
+    private final String str;
+
+    public Class(String str) {
+        this.str = str;
+    }
+
+}

compiler/testData/compileKotlinAgainstJava/Class.kt

@@ -0,0 +1,3 @@
+package test
+
+fun useClass() = Class("Hello")

compiler/testData/compileKotlinAgainstJava/Class.txt

@@ -0,0 +1,8 @@
+package test
+
+public fun useClass(): test.Class
+
+public open class Class {
+    public constructor Class(/*0*/ kotlin.String!)
+    private final val str: kotlin.String!
+}

compiler/testData/compileKotlinAgainstJava/ClassWithNestedEnum.java

@@ -0,0 +1,9 @@
+package test;
+
+public class ClassWithNestedEnum {
+
+    public enum NestedEnum {
+        ONE, TWO, THREE;
+    }
+
+}

compiler/testData/compileKotlinAgainstJava/ClassWithNestedEnum.kt

@@ -0,0 +1,3 @@
+package test
+
+fun test() = ClassWithNestedEnum.NestedEnum.ONE

compiler/testData/compileKotlinAgainstJava/ClassWithNestedEnum.txt

@@ -0,0 +1,29 @@
+package test
+
+public fun test(): test.ClassWithNestedEnum.NestedEnum
+
+public open class ClassWithNestedEnum {
+    public constructor ClassWithNestedEnum()
+
+    public final enum class NestedEnum : kotlin.Enum<test.ClassWithNestedEnum.NestedEnum!> {
+        enum entry ONE
+
+        enum entry TWO
+
+        enum entry THREE
+
+        private constructor NestedEnum()
+        public final /*fake_override*/ val name: kotlin.String
+        public final /*fake_override*/ val ordinal: kotlin.Int
+        protected final /*fake_override*/ fun clone(): kotlin.Any
+        public final /*fake_override*/ fun compareTo(/*0*/ test.ClassWithNestedEnum.NestedEnum!): kotlin.Int
+        protected/*protected and package*/ final /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun finalize(): kotlin.Unit
+        public final /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun getDeclaringClass(): java.lang.Class<test.ClassWithNestedEnum.NestedEnum!>!
+
+        // Static members
+        public final /*synthesized*/ fun valueOf(/*0*/ kotlin.String): test.ClassWithNestedEnum.NestedEnum
+        public open fun valueOf(/*0*/ kotlin.String!): test.ClassWithNestedEnum.NestedEnum!
+        public open fun values(): kotlin.Array<(out) test.ClassWithNestedEnum.NestedEnum!>!
+        public final /*synthesized*/ fun values(): kotlin.Array<test.ClassWithNestedEnum.NestedEnum>
+    }
+}

compiler/testData/compileKotlinAgainstJava/ClassWithTypeParameter.java

@@ -0,0 +1,7 @@
+package test;
+
+public class ClassWithTypeParameter<T extends KotlinInterface> {
+
+    public ClassWithTypeParameter(T kotlinInterface) {}
+
+}

compiler/testData/compileKotlinAgainstJava/ClassWithTypeParameter.kt

@@ -0,0 +1,15 @@
+package test
+
+interface KotlinInterface
+
+class Impl1 : KotlinInterface
+
+class Impl2 : KotlinInterface
+
+class Impl3 : KotlinInterface
+
+fun getProducer1() = Impl1().let(::ClassWithTypeParameter)
+
+fun getProducer2() = Impl2().let(::ClassWithTypeParameter)
+
+fun getProducer3() = Impl3().let(::ClassWithTypeParameter)

compiler/testData/compileKotlinAgainstJava/ClassWithTypeParameter.txt

@@ -0,0 +1,24 @@
+package test
+
+public fun getProducer1(): test.ClassWithTypeParameter<test.Impl1>
+public fun getProducer2(): test.ClassWithTypeParameter<test.Impl2>
+public fun getProducer3(): test.ClassWithTypeParameter<test.Impl3>
+
+public open class ClassWithTypeParameter</*0*/ T : test.KotlinInterface!> {
+    public constructor ClassWithTypeParameter</*0*/ T : test.KotlinInterface!>(/*0*/ T!)
+}
+
+public final class Impl1 : test.KotlinInterface {
+    public constructor Impl1()
+}
+
+public final class Impl2 : test.KotlinInterface {
+    public constructor Impl2()
+}
+
+public final class Impl3 : test.KotlinInterface {
+    public constructor Impl3()
+}
+
+public interface KotlinInterface {
+}

compiler/testData/compileKotlinAgainstJava/CyclicDependencies.java

@@ -0,0 +1,13 @@
+package test;
+
+public class CyclicDependencies {
+
+    public KotlinClass useKotlinClass() {
+        return new KotlinClass().getKotlinClass();
+    }
+
+    public KotlinClass2 useKotlinClass2(KotlinClass kotlinClass) {
+        return new KotlinClass2();
+    }
+
+}

compiler/testData/compileKotlinAgainstJava/CyclicDependencies.kt

@@ -0,0 +1,13 @@
+package test
+
+class KotlinClass {
+    fun getKotlinClass() = KotlinClass()
+}
+
+class KotlinClass2 {
+    val str = "HELLO"
+}
+
+fun useJavaClass() = CyclicDependencies().apply {
+    useKotlinClass().let { useKotlinClass2(it) }
+}.let { it.useKotlinClass2(it.useKotlinClass()) }

compiler/testData/compileKotlinAgainstJava/CyclicDependencies.txt

@@ -0,0 +1,19 @@
+package test
+
+public fun useJavaClass(): test.KotlinClass2!
+
+public open class CyclicDependencies {
+    public constructor CyclicDependencies()
+    public open fun useKotlinClass(): test.KotlinClass!
+    public open fun useKotlinClass2(/*0*/ test.KotlinClass!): test.KotlinClass2!
+}
+
+public final class KotlinClass {
+    public constructor KotlinClass()
+    public final fun getKotlinClass(): test.KotlinClass
+}
+
+public final class KotlinClass2 {
+    public constructor KotlinClass2()
+    public final val str: kotlin.String
+}

compiler/testData/compileKotlinAgainstJava/DefaultModifier.java

@@ -0,0 +1,11 @@
+package test;
+
+public class DefaultModifier implements WithDefault {
+
+}
+
+interface WithDefault {
+
+    default String getString() { return "str"; }
+
+}

compiler/testData/compileKotlinAgainstJava/DefaultModifier.kt

@@ -0,0 +1,3 @@
+package test
+
+fun useDefaultMethod() = DefaultModifier().getString()

compiler/testData/compileKotlinAgainstJava/DefaultModifier.txt

@@ -0,0 +1,12 @@
+package test
+
+public fun useDefaultMethod(): kotlin.String!
+
+public open class DefaultModifier : test.WithDefault {
+    public constructor DefaultModifier()
+    public open /*fake_override*/ fun getString(): kotlin.String!
+}
+
+public/*package*/ interface WithDefault {
+    public open fun getString(): kotlin.String!
+}

compiler/testData/compileKotlinAgainstJava/EnclosingClassInner.java

@@ -0,0 +1,22 @@
+package test;
+
+class InterfaceImpl implements Interface {
+
+    interface BuilderImpl extends Interface.Builder {
+        @Override
+        Builder setKind(Kind kind);
+    }
+
+    Builder getBuilder() { return null; }
+
+}
+
+interface Interface {
+
+    enum Kind { DECLARATION; }
+
+    interface Builder {
+        Builder setKind(Kind kind);
+    }
+
+}

compiler/testData/compileKotlinAgainstJava/EnclosingClassInner.kt

@@ -0,0 +1,7 @@
+package test
+
+private class Impl : InterfaceImpl() {
+
+    private fun kind(kind: Interface.Kind) = getBuilder().setKind(kind)
+
+}

compiler/testData/compileKotlinAgainstJava/EnclosingClassInner.txt

@@ -0,0 +1,41 @@
+package test
+
+private final class Impl : test.InterfaceImpl {
+    public constructor Impl()
+    public/*package*/ open /*fake_override*/ fun getBuilder(): test.Interface.Builder!
+    private final fun kind(/*0*/ test.Interface.Kind): test.Interface.Builder!
+}
+
+public/*package*/ interface Interface {
+
+    public interface Builder {
+        public abstract fun setKind(/*0*/ test.Interface.Kind!): test.Interface.Builder!
+    }
+
+    public final enum class Kind : kotlin.Enum<test.Interface.Kind!> {
+        enum entry DECLARATION
+
+        private constructor Kind()
+        public final /*fake_override*/ val name: kotlin.String
+        public final /*fake_override*/ val ordinal: kotlin.Int
+        protected final /*fake_override*/ fun clone(): kotlin.Any
+        public final /*fake_override*/ fun compareTo(/*0*/ test.Interface.Kind!): kotlin.Int
+        protected/*protected and package*/ final /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun finalize(): kotlin.Unit
+        public final /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun getDeclaringClass(): java.lang.Class<test.Interface.Kind!>!
+
+        // Static members
+        public final /*synthesized*/ fun valueOf(/*0*/ kotlin.String): test.Interface.Kind
+        public open fun valueOf(/*0*/ kotlin.String!): test.Interface.Kind!
+        public open fun values(): kotlin.Array<(out) test.Interface.Kind!>!
+        public final /*synthesized*/ fun values(): kotlin.Array<test.Interface.Kind>
+    }
+}
+
+public/*package*/ open class InterfaceImpl : test.Interface {
+    public/*package*/ constructor InterfaceImpl()
+    public/*package*/ open fun getBuilder(): test.Interface.Builder!
+
+    public/*package*/ interface BuilderImpl : test.Interface.Builder {
+        public abstract fun setKind(/*0*/ test.Interface.Kind!): test.Interface.Builder!
+    }
+}

compiler/testData/compileKotlinAgainstJava/Enum.java

@@ -0,0 +1,5 @@
+package test;
+
+public enum Enum {
+    NORTH, SOUTH, WEST, EAST;
+}

compiler/testData/compileKotlinAgainstJava/Enum.kt

@@ -0,0 +1,8 @@
+package test
+
+fun checkEnum(e: Enum) = when(e) {
+	Enum.SOUTH -> println(1)
+	Enum.NORTH -> println(2)
+	Enum.WEST -> println(3)
+	Enum.EAST -> println(42)
+}

compiler/testData/compileKotlinAgainstJava/Enum.txt

@@ -0,0 +1,27 @@
+package test
+
+public fun checkEnum(/*0*/ test.Enum): kotlin.Unit
+
+public final enum class Enum : kotlin.Enum<test.Enum!> {
+    enum entry NORTH
+
+    enum entry SOUTH
+
+    enum entry WEST
+
+    enum entry EAST
+
+    private constructor Enum()
+    public final /*fake_override*/ val name: kotlin.String
+    public final /*fake_override*/ val ordinal: kotlin.Int
+    protected final /*fake_override*/ fun clone(): kotlin.Any
+    public final /*fake_override*/ fun compareTo(/*0*/ test.Enum!): kotlin.Int
+    protected/*protected and package*/ final /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun finalize(): kotlin.Unit
+    public final /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun getDeclaringClass(): java.lang.Class<test.Enum!>!
+
+    // Static members
+    public final /*synthesized*/ fun valueOf(/*0*/ kotlin.String): test.Enum
+    public open fun valueOf(/*0*/ kotlin.String!): test.Enum!
+    public open fun values(): kotlin.Array<(out) test.Enum!>!
+    public final /*synthesized*/ fun values(): kotlin.Array<test.Enum>
+}

compiler/testData/compileKotlinAgainstJava/EnumName.java

@@ -0,0 +1,5 @@
+package test;
+
+public enum EnumName {
+    FIRST, SECOND;
+}

compiler/testData/compileKotlinAgainstJava/EnumName.kt

@@ -0,0 +1,3 @@
+package test
+
+fun func(enum: EnumName) = enum.name

compiler/testData/compileKotlinAgainstJava/EnumName.txt

@@ -0,0 +1,23 @@
+package test
+
+public fun func(/*0*/ test.EnumName): kotlin.String
+
+public final enum class EnumName : kotlin.Enum<test.EnumName!> {
+    enum entry FIRST
+
+    enum entry SECOND
+
+    private constructor EnumName()
+    public final /*fake_override*/ val name: kotlin.String
+    public final /*fake_override*/ val ordinal: kotlin.Int
+    protected final /*fake_override*/ fun clone(): kotlin.Any
+    public final /*fake_override*/ fun compareTo(/*0*/ test.EnumName!): kotlin.Int
+    protected/*protected and package*/ final /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun finalize(): kotlin.Unit
+    public final /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun getDeclaringClass(): java.lang.Class<test.EnumName!>!
+
+    // Static members
+    public final /*synthesized*/ fun valueOf(/*0*/ kotlin.String): test.EnumName
+    public open fun valueOf(/*0*/ kotlin.String!): test.EnumName!
+    public open fun values(): kotlin.Array<(out) test.EnumName!>!
+    public final /*synthesized*/ fun values(): kotlin.Array<test.EnumName>
+}

compiler/testData/compileKotlinAgainstJava/Inheritance.java

@@ -0,0 +1,25 @@
+package test;
+
+public class Inheritance extends AbstractInheritance { }
+
+abstract class AbstractInheritance implements Interface {
+
+    @Override public int getAnswer() { return 42; }
+
+}
+
+interface Interface extends I {
+    @Override
+    int getAnswer();
+}
+
+interface I {
+    int getAnswer();
+}
+
+interface I2 extends I {
+
+    @Override
+    int getAnswer();
+
+}

compiler/testData/compileKotlinAgainstJava/Inheritance.kt

@@ -0,0 +1,3 @@
+package test
+
+class InheritanceImpl : Inheritance(), I2

compiler/testData/compileKotlinAgainstJava/Inheritance.txt

@@ -0,0 +1,28 @@
+package test
+
+public/*package*/ abstract class AbstractInheritance : test.Interface {
+    public/*package*/ constructor AbstractInheritance()
+    public open fun getAnswer(): kotlin.Int
+}
+
+public/*package*/ interface I {
+    public abstract fun getAnswer(): kotlin.Int
+}
+
+public/*package*/ interface I2 : test.I {
+    public abstract fun getAnswer(): kotlin.Int
+}
+
+public open class Inheritance : test.AbstractInheritance {
+    public constructor Inheritance()
+    public open /*fake_override*/ fun getAnswer(): kotlin.Int
+}
+
+public final class InheritanceImpl : test.Inheritance, test.I2 {
+    public constructor InheritanceImpl()
+    public open /*fake_override*/ fun getAnswer(): kotlin.Int
+}
+
+public/*package*/ interface Interface : test.I {
+    public abstract fun getAnswer(): kotlin.Int
+}

compiler/testData/compileKotlinAgainstJava/InheritedInner.java

@@ -0,0 +1,17 @@
+package test;
+
+public class InheritedInner {
+
+    public Third.Second getSecond() { return null; }
+
+    public static class First {
+
+        public static class Second {}
+
+    }
+
+    public static class Third extends First {
+
+    } 
+
+}

compiler/testData/compileKotlinAgainstJava/InheritedInner.kt

@@ -0,0 +1,3 @@
+package test
+
+fun getSecond(): InheritedInner.First.Second = InheritedInner().getSecond()

compiler/testData/compileKotlinAgainstJava/InheritedInner.txt

@@ -0,0 +1,20 @@
+package test
+
+public fun getSecond(): test.InheritedInner.First.Second
+
+public open class InheritedInner {
+    public constructor InheritedInner()
+    public open fun getSecond(): test.InheritedInner.First.Second!
+
+    public open class First {
+        public constructor First()
+
+        public open class Second {
+            public constructor Second()
+        }
+    }
+
+    public open class Third : test.InheritedInner.First {
+        public constructor Third()
+    }
+}

compiler/testData/compileKotlinAgainstJava/InnerCanonicalName.java

@@ -0,0 +1,7 @@
+package test;
+
+public class InnerCanonicalName {
+
+    public java.util.Map.Entry getEntry() { return null; }
+
+}

compiler/testData/compileKotlinAgainstJava/InnerCanonicalName.kt

@@ -0,0 +1,3 @@
+package test
+
+fun getEntry() = InnerCanonicalName().getEntry()

compiler/testData/compileKotlinAgainstJava/InnerCanonicalName.txt

@@ -0,0 +1,8 @@
+package test
+
+public fun getEntry(): kotlin.collections.(Mutable)Map.(Mutable)Entry<(raw) kotlin.Any?, (raw) kotlin.Any?>!
+
+public open class InnerCanonicalName {
+    public constructor InnerCanonicalName()
+    public open fun getEntry(): kotlin.collections.(Mutable)Map.(Mutable)Entry<(raw) kotlin.Any?, (raw) kotlin.Any?>!
+}

compiler/testData/compileKotlinAgainstJava/InnerClass.java

@@ -0,0 +1,9 @@
+package test;
+
+public class InnerClass {
+
+    class Inner {
+        public void doNothing() {}
+    }
+
+}

compiler/testData/compileKotlinAgainstJava/InnerClass.kt

@@ -0,0 +1,3 @@
+package test
+
+fun useInnerClass() = InnerClass().Inner().doNothing()

compiler/testData/compileKotlinAgainstJava/InnerClass.txt

@@ -0,0 +1,12 @@
+package test
+
+public fun useInnerClass(): kotlin.Unit
+
+public open class InnerClass {
+    public constructor InnerClass()
+
+    public/*package*/ open inner class Inner {
+        public/*package*/ constructor Inner()
+        public open fun doNothing(): kotlin.Unit
+    }
+}

compiler/testData/compileKotlinAgainstJava/InnerClassFromAsteriskImport.java

@@ -0,0 +1,9 @@
+package test;
+
+import java.util.*;
+
+class InnerClassFromAsteriskImport {
+
+    public HashMap.Entry getEntry() { return null; }
+
+}

compiler/testData/compileKotlinAgainstJava/InnerClassFromAsteriskImport.kt

@@ -0,0 +1,3 @@
+package test
+
+fun getEntry() = InnerClassFromAsteriskImport().getEntry()

compiler/testData/compileKotlinAgainstJava/InnerClassFromAsteriskImport.txt

@@ -0,0 +1,8 @@
+package test
+
+public fun getEntry(): kotlin.collections.(Mutable)Map.(Mutable)Entry<(raw) kotlin.Any?, (raw) kotlin.Any?>!
+
+public/*package*/ open class InnerClassFromAsteriskImport {
+    public/*package*/ constructor InnerClassFromAsteriskImport()
+    public open fun getEntry(): kotlin.collections.(Mutable)Map.(Mutable)Entry<(raw) kotlin.Any?, (raw) kotlin.Any?>!
+}

compiler/testData/compileKotlinAgainstJava/InnerClassFromImport.java

@@ -0,0 +1,9 @@
+package test;
+
+import java.util.Map;
+
+public class InnerClassFromImport {
+
+    public Map.Entry getEntry() { return null; }
+
+}

compiler/testData/compileKotlinAgainstJava/InnerClassFromImport.kt

@@ -0,0 +1,3 @@
+package test
+
+fun getEntry() = InnerClassFromImport().getEntry()

compiler/testData/compileKotlinAgainstJava/InnerClassFromImport.txt

@@ -0,0 +1,8 @@
+package test
+
+public fun getEntry(): kotlin.collections.(Mutable)Map.(Mutable)Entry<(raw) kotlin.Any?, (raw) kotlin.Any?>!
+
+public open class InnerClassFromImport {
+    public constructor InnerClassFromImport()
+    public open fun getEntry(): kotlin.collections.(Mutable)Map.(Mutable)Entry<(raw) kotlin.Any?, (raw) kotlin.Any?>!
+}

compiler/testData/compileKotlinAgainstJava/Interface.java

@@ -0,0 +1,5 @@
+package test;
+
+interface Interface {
+
+}

compiler/testData/compileKotlinAgainstJava/Interface.kt

@@ -0,0 +1,5 @@
+package test
+
+class InterfaceImpl : Interface {
+
+}

compiler/testData/compileKotlinAgainstJava/Interface.txt

@@ -0,0 +1,8 @@
+package test
+
+public/*package*/ interface Interface {
+}
+
+public final class InterfaceImpl : test.Interface {
+    public constructor InterfaceImpl()
+}

compiler/testData/compileKotlinAgainstJava/InterfaceField.java

@@ -0,0 +1,9 @@
+package test;
+
+public interface InterfaceField {
+
+    String STRING = "str";
+
+    String func();
+
+}

compiler/testData/compileKotlinAgainstJava/InterfaceField.kt

@@ -0,0 +1,9 @@
+package test
+
+fun useField() = InterfaceField.STRING
+
+fun implementInterface() = object : InterfaceField {
+    override fun func() = "str"
+}
+
+fun useFunc() = implementInterface().func()

compiler/testData/compileKotlinAgainstJava/InterfaceField.txt

@@ -0,0 +1,12 @@
+package test
+
+public fun implementInterface(): test.InterfaceField
+public fun useField(): kotlin.String
+public fun useFunc(): kotlin.String!
+
+public interface InterfaceField {
+    public abstract fun func(): kotlin.String!
+
+    // Static members
+    public const final val STRING: kotlin.String
+}

compiler/testData/compileKotlinAgainstJava/InterfaceMemberClass.java

@@ -0,0 +1,9 @@
+package test;
+
+interface InterfaceMemberClass {
+    
+    class MemberClass {
+        public String func() { return "str"; }
+    }
+
+}

compiler/testData/compileKotlinAgainstJava/InterfaceMemberClass.kt

@@ -0,0 +1,3 @@
+package test
+
+private fun useInterfaceMemberClass() = InterfaceMemberClass.MemberClass().func()

compiler/testData/compileKotlinAgainstJava/InterfaceMemberClass.txt

@@ -0,0 +1,11 @@
+package test
+
+private fun useInterfaceMemberClass(): kotlin.String!
+
+public/*package*/ interface InterfaceMemberClass {
+
+    public open class MemberClass {
+        public constructor MemberClass()
+        public open fun func(): kotlin.String!
+    }
+}

compiler/testData/compileKotlinAgainstJava/InterfaceWithDefault.java

@@ -0,0 +1,7 @@
+package test;
+
+public interface InterfaceWithDefault {
+
+    default String defaultMethod() { return "str"; }
+
+}

compiler/testData/compileKotlinAgainstJava/InterfaceWithDefault.kt

@@ -0,0 +1,3 @@
+package test
+
+class InterfaceWithDefaultImpl : InterfaceWithDefault

compiler/testData/compileKotlinAgainstJava/InterfaceWithDefault.txt

@@ -0,0 +1,10 @@
+package test
+
+public interface InterfaceWithDefault {
+    public open fun defaultMethod(): kotlin.String!
+}
+
+public final class InterfaceWithDefaultImpl : test.InterfaceWithDefault {
+    public constructor InterfaceWithDefaultImpl()
+    public open /*fake_override*/ fun defaultMethod(): kotlin.String!
+}

compiler/testData/compileKotlinAgainstJava/ListImpl.java

@@ -0,0 +1,9 @@
+package test;
+
+import java.util.ArrayList;
+
+abstract class ListImpl extends ArrayList<String> {
+
+    public abstract int func();
+
+}

compiler/testData/compileKotlinAgainstJava/ListImpl.kt

@@ -0,0 +1,5 @@
+package test
+
+fun useListImpl() = object : ListImpl() {
+                        override fun func() = 42
+                    }.func()

compiler/testData/compileKotlinAgainstJava/ListImpl.txt

@@ -0,0 +1,66 @@
+package test
+
+public fun useListImpl(): kotlin.Int
+
+public/*package*/ abstract class ListImpl : java.util.ArrayList<kotlin.String!> {
+    public/*package*/ constructor ListImpl()
+    invisible_fake final /*fake_override*/ var elementData: kotlin.Array<(out) kotlin.Any!>!
+    protected/*protected and package*/ final /*fake_override*/ var modCount: kotlin.Int
+    invisible_fake final /*fake_override*/ var size: kotlin.Int
+    public open /*fake_override*/ val size: kotlin.Int
+    public open /*fake_override*/ fun add(/*0*/ kotlin.Int, /*1*/ kotlin.String!): kotlin.Unit
+    public open /*fake_override*/ fun add(/*0*/ kotlin.String!): kotlin.Boolean
+    public open /*fake_override*/ fun addAll(/*0*/ kotlin.Int, /*1*/ kotlin.collections.Collection<kotlin.String!>): kotlin.Boolean
+    public open /*fake_override*/ fun addAll(/*0*/ kotlin.collections.Collection<kotlin.String!>): kotlin.Boolean
+    invisible_fake open /*fake_override*/ fun batchRemove(/*0*/ kotlin.collections.(Mutable)Collection<*>!, /*1*/ kotlin.Boolean): kotlin.Boolean
+    public open /*fake_override*/ fun clear(): kotlin.Unit
+    public open /*fake_override*/ fun clone(): kotlin.Any
+    public open /*fake_override*/ fun contains(/*0*/ kotlin.String!): kotlin.Boolean
+    public open /*fake_override*/ fun containsAll(/*0*/ kotlin.collections.Collection<kotlin.String!>): kotlin.Boolean
+    invisible_fake open /*fake_override*/ fun elementData(/*0*/ kotlin.Int): kotlin.String!
+    public open /*fake_override*/ fun ensureCapacity(/*0*/ kotlin.Int): kotlin.Unit
+    invisible_fake open /*fake_override*/ fun ensureCapacityInternal(/*0*/ kotlin.Int): kotlin.Unit
+    invisible_fake open /*fake_override*/ fun ensureExplicitCapacity(/*0*/ kotlin.Int): kotlin.Unit
+    invisible_fake open /*fake_override*/ fun fastRemove(/*0*/ kotlin.Int): kotlin.Unit
+    public open /*fake_override*/ fun forEach(/*0*/ java.util.function.Consumer<in kotlin.String!>!): kotlin.Unit
+    public abstract fun func(): kotlin.Int
+    public open /*fake_override*/ fun get(/*0*/ kotlin.Int): kotlin.String!
+    invisible_fake open /*fake_override*/ fun grow(/*0*/ kotlin.Int): kotlin.Unit
+    public open /*fake_override*/ fun indexOf(/*0*/ kotlin.String!): kotlin.Int
+    public open /*fake_override*/ fun isEmpty(): kotlin.Boolean
+    public open /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator<kotlin.String!>
+    public open /*fake_override*/ fun lastIndexOf(/*0*/ kotlin.String!): kotlin.Int
+    public open /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator<kotlin.String!>
+    public open /*fake_override*/ fun listIterator(/*0*/ kotlin.Int): kotlin.collections.MutableListIterator<kotlin.String!>
+    invisible_fake open /*fake_override*/ fun outOfBoundsMsg(/*0*/ kotlin.Int): kotlin.String!
+    public open /*fake_override*/ fun parallelStream(): java.util.stream.Stream<kotlin.String!>
+    invisible_fake open /*fake_override*/ fun rangeCheck(/*0*/ kotlin.Int): kotlin.Unit
+    invisible_fake open /*fake_override*/ fun rangeCheckForAdd(/*0*/ kotlin.Int): kotlin.Unit
+    invisible_fake open /*fake_override*/ fun readObject(/*0*/ java.io.ObjectInputStream!): kotlin.Unit
+    public open /*fake_override*/ fun remove(/*0*/ kotlin.String!): kotlin.Boolean
+    public open /*fake_override*/ fun removeAll(/*0*/ kotlin.collections.Collection<kotlin.String!>): kotlin.Boolean
+    public open /*fake_override*/ fun removeAt(/*0*/ kotlin.Int): kotlin.String!
+    public open /*fake_override*/ fun removeIf(/*0*/ java.util.function.Predicate<in kotlin.String!>): kotlin.Boolean
+    protected/*protected and package*/ open /*fake_override*/ fun removeRange(/*0*/ kotlin.Int, /*1*/ kotlin.Int): kotlin.Unit
+    public open /*fake_override*/ fun replaceAll(/*0*/ java.util.function.UnaryOperator<kotlin.String!>): kotlin.Unit
+    public open /*fake_override*/ fun retainAll(/*0*/ kotlin.collections.Collection<kotlin.String!>): kotlin.Boolean
+    public open /*fake_override*/ fun set(/*0*/ kotlin.Int, /*1*/ kotlin.String!): kotlin.String!
+    public open /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun sort(/*0*/ java.util.Comparator<in kotlin.String!>!): kotlin.Unit
+    public open /*fake_override*/ fun spliterator(): java.util.Spliterator<kotlin.String!>
+    public open /*fake_override*/ fun stream(): java.util.stream.Stream<kotlin.String!>
+    public open /*fake_override*/ fun subList(/*0*/ kotlin.Int, /*1*/ kotlin.Int): kotlin.collections.MutableList<kotlin.String!>
+    public open /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>!
+    public open /*fake_override*/ fun </*0*/ T : kotlin.Any!> toArray(/*0*/ kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>!
+    public open /*fake_override*/ fun trimToSize(): kotlin.Unit
+    invisible_fake open /*fake_override*/ fun writeObject(/*0*/ java.io.ObjectOutputStream!): kotlin.Unit
+
+    // Static members
+    invisible_fake final /*fake_override*/ val DEFAULTCAPACITY_EMPTY_ELEMENTDATA: kotlin.Array<(out) kotlin.Any!>!
+    invisible_fake const final /*fake_override*/ val DEFAULT_CAPACITY: kotlin.Int
+    invisible_fake final /*fake_override*/ val EMPTY_ELEMENTDATA: kotlin.Array<(out) kotlin.Any!>!
+    invisible_fake const final /*fake_override*/ val MAX_ARRAY_SIZE: kotlin.Int
+    invisible_fake const final /*fake_override*/ val serialVersionUID: kotlin.Long
+    invisible_fake open /*fake_override*/ fun </*0*/ T : kotlin.Any!> finishToArray(/*0*/ kotlin.Array<(out) T!>!, /*1*/ kotlin.collections.(Mutable)Iterator<*>!): kotlin.Array<(out) T!>!
+    invisible_fake open /*fake_override*/ fun hugeCapacity(/*0*/ kotlin.Int): kotlin.Int
+    invisible_fake open /*fake_override*/ fun subListRangeCheck(/*0*/ kotlin.Int, /*1*/ kotlin.Int, /*2*/ kotlin.Int): kotlin.Unit
+}

compiler/testData/compileKotlinAgainstJava/MapExample.java

@@ -0,0 +1,7 @@
+package test;
+
+import java.util.HashMap;
+
+public class MapExample<K, V> extends HashMap<K, V> {
+
+}

compiler/testData/compileKotlinAgainstJava/MapExample.kt

@@ -0,0 +1,3 @@
+package test
+
+class MapImpl<V> : MapExample<String, V>(), MutableMap<String, V>

compiler/testData/compileKotlinAgainstJava/MapExample.txt

@@ -0,0 +1,125 @@
+package test
+
+public open class MapExample</*0*/ K : kotlin.Any!, /*1*/ V : kotlin.Any!> : java.util.HashMap<K!, V!> {
+    public constructor MapExample</*0*/ K : kotlin.Any!, /*1*/ V : kotlin.Any!>()
+    public open /*fake_override*/ val entries: kotlin.collections.MutableSet<kotlin.collections.MutableMap.MutableEntry<K!, V!>>
+    invisible_fake final /*fake_override*/ var entrySet: kotlin.collections.(Mutable)Set<kotlin.collections.(Mutable)Map.(Mutable)Entry<K!, V!>!>!
+    invisible_fake final /*fake_override*/ var keySet: kotlin.collections.(Mutable)Set<K!>!
+    public open /*fake_override*/ val keys: kotlin.collections.MutableSet<K!>
+    invisible_fake final /*fake_override*/ val loadFactor: kotlin.Float
+    invisible_fake final /*fake_override*/ var modCount: kotlin.Int
+    invisible_fake final /*fake_override*/ var size: kotlin.Int
+    public open /*fake_override*/ val size: kotlin.Int
+    invisible_fake final /*fake_override*/ var table: kotlin.Array<(out) java.util.HashMap.Node<K!, V!>!>!
+    invisible_fake final /*fake_override*/ var threshold: kotlin.Int
+    invisible_fake final /*fake_override*/ var values: kotlin.collections.(Mutable)Collection<V!>!
+    public open /*fake_override*/ val values: kotlin.collections.MutableCollection<V!>
+    invisible_fake open /*fake_override*/ fun afterNodeAccess(/*0*/ java.util.HashMap.Node<K!, V!>!): kotlin.Unit
+    invisible_fake open /*fake_override*/ fun afterNodeInsertion(/*0*/ kotlin.Boolean): kotlin.Unit
+    invisible_fake open /*fake_override*/ fun afterNodeRemoval(/*0*/ java.util.HashMap.Node<K!, V!>!): kotlin.Unit
+    invisible_fake final /*fake_override*/ fun capacity(): kotlin.Int
+    public open /*fake_override*/ fun clear(): kotlin.Unit
+    public open /*fake_override*/ fun clone(): kotlin.Any
+    public open /*fake_override*/ fun compute(/*0*/ K!, /*1*/ java.util.function.BiFunction<in K!, in V?, out V?>): V?
+    public open /*fake_override*/ fun computeIfAbsent(/*0*/ K!, /*1*/ java.util.function.Function<in K!, out V!>): V!
+    public open /*fake_override*/ fun computeIfPresent(/*0*/ K!, /*1*/ java.util.function.BiFunction<in K!, in V, out V?>): V?
+    public open /*fake_override*/ fun containsKey(/*0*/ K!): kotlin.Boolean
+    public open /*fake_override*/ fun containsValue(/*0*/ V!): kotlin.Boolean
+    public open /*fake_override*/ fun forEach(/*0*/ java.util.function.BiConsumer<in K!, in V!>): kotlin.Unit
+    public open /*fake_override*/ fun get(/*0*/ K!): V?
+    invisible_fake final /*fake_override*/ fun getNode(/*0*/ kotlin.Int, /*1*/ kotlin.Any!): java.util.HashMap.Node<K!, V!>!
+    public open /*fake_override*/ fun getOrDefault(/*0*/ K!, /*1*/ V!): V!
+    invisible_fake open /*fake_override*/ fun internalWriteEntries(/*0*/ java.io.ObjectOutputStream!): kotlin.Unit
+    public open /*fake_override*/ fun isEmpty(): kotlin.Boolean
+    invisible_fake final /*fake_override*/ fun loadFactor(): kotlin.Float
+    public open /*fake_override*/ fun merge(/*0*/ K!, /*1*/ V, /*2*/ java.util.function.BiFunction<in V, in V, out V?>): V?
+    invisible_fake open /*fake_override*/ fun newNode(/*0*/ kotlin.Int, /*1*/ K!, /*2*/ V!, /*3*/ java.util.HashMap.Node<K!, V!>!): java.util.HashMap.Node<K!, V!>!
+    invisible_fake open /*fake_override*/ fun newTreeNode(/*0*/ kotlin.Int, /*1*/ K!, /*2*/ V!, /*3*/ java.util.HashMap.Node<K!, V!>!): java.util.HashMap.TreeNode<K!, V!>!
+    public open /*fake_override*/ fun put(/*0*/ K!, /*1*/ V!): V?
+    public open /*fake_override*/ fun putAll(/*0*/ kotlin.collections.Map<out K!, V!>): kotlin.Unit
+    public open /*fake_override*/ fun putIfAbsent(/*0*/ K!, /*1*/ V!): V?
+    invisible_fake final /*fake_override*/ fun putMapEntries(/*0*/ (kotlin.collections.MutableMap<out K!, out V!>..kotlin.collections.Map<out K!, V!>?), /*1*/ kotlin.Boolean): kotlin.Unit
+    invisible_fake final /*fake_override*/ fun putVal(/*0*/ kotlin.Int, /*1*/ K!, /*2*/ V!, /*3*/ kotlin.Boolean, /*4*/ kotlin.Boolean): V!
+    invisible_fake open /*fake_override*/ fun readObject(/*0*/ java.io.ObjectInputStream!): kotlin.Unit
+    invisible_fake open /*fake_override*/ fun reinitialize(): kotlin.Unit
+    public open /*fake_override*/ fun remove(/*0*/ K!): V?
+    public open /*fake_override*/ fun remove(/*0*/ K!, /*1*/ V!): kotlin.Boolean
+    invisible_fake final /*fake_override*/ fun removeNode(/*0*/ kotlin.Int, /*1*/ kotlin.Any!, /*2*/ kotlin.Any!, /*3*/ kotlin.Boolean, /*4*/ kotlin.Boolean): java.util.HashMap.Node<K!, V!>!
+    public open /*fake_override*/ fun replace(/*0*/ K!, /*1*/ V!): V?
+    public open /*fake_override*/ fun replace(/*0*/ K!, /*1*/ V!, /*2*/ V!): kotlin.Boolean
+    public open /*fake_override*/ fun replaceAll(/*0*/ java.util.function.BiFunction<in K!, in V!, out V!>): kotlin.Unit
+    invisible_fake open /*fake_override*/ fun replacementNode(/*0*/ java.util.HashMap.Node<K!, V!>!, /*1*/ java.util.HashMap.Node<K!, V!>!): java.util.HashMap.Node<K!, V!>!
+    invisible_fake open /*fake_override*/ fun replacementTreeNode(/*0*/ java.util.HashMap.Node<K!, V!>!, /*1*/ java.util.HashMap.Node<K!, V!>!): java.util.HashMap.TreeNode<K!, V!>!
+    invisible_fake final /*fake_override*/ fun resize(): kotlin.Array<(out) java.util.HashMap.Node<K!, V!>!>!
+    invisible_fake final /*fake_override*/ fun treeifyBin(/*0*/ kotlin.Array<(out) java.util.HashMap.Node<K!, V!>!>!, /*1*/ kotlin.Int): kotlin.Unit
+    invisible_fake open /*fake_override*/ fun writeObject(/*0*/ java.io.ObjectOutputStream!): kotlin.Unit
+
+    // Static members
+    invisible_fake const final /*fake_override*/ val DEFAULT_INITIAL_CAPACITY: kotlin.Int
+    invisible_fake const final /*fake_override*/ val DEFAULT_LOAD_FACTOR: kotlin.Float
+    invisible_fake const final /*fake_override*/ val MAXIMUM_CAPACITY: kotlin.Int
+    invisible_fake const final /*fake_override*/ val MIN_TREEIFY_CAPACITY: kotlin.Int
+    invisible_fake const final /*fake_override*/ val TREEIFY_THRESHOLD: kotlin.Int
+    invisible_fake const final /*fake_override*/ val UNTREEIFY_THRESHOLD: kotlin.Int
+    invisible_fake const final /*fake_override*/ val serialVersionUID: kotlin.Long
+    invisible_fake open /*fake_override*/ fun comparableClassFor(/*0*/ kotlin.Any!): java.lang.Class<*>!
+    invisible_fake open /*fake_override*/ fun compareComparables(/*0*/ java.lang.Class<*>!, /*1*/ kotlin.Any!, /*2*/ kotlin.Any!): kotlin.Int
+    invisible_fake open /*fake_override*/ fun eq(/*0*/ kotlin.Any!, /*1*/ kotlin.Any!): kotlin.Boolean
+    invisible_fake final /*fake_override*/ fun hash(/*0*/ kotlin.Any!): kotlin.Int
+    invisible_fake final /*fake_override*/ fun tableSizeFor(/*0*/ kotlin.Int): kotlin.Int
+}
+
+public final class MapImpl</*0*/ V> : test.MapExample<kotlin.String, V>, kotlin.collections.MutableMap<kotlin.String, V> {
+    public constructor MapImpl</*0*/ V>()
+    public open /*fake_override*/ val entries: kotlin.collections.MutableSet<kotlin.collections.MutableMap.MutableEntry<kotlin.String!, V!>>
+    invisible_fake final /*fake_override*/ var entrySet: kotlin.collections.(Mutable)Set<kotlin.collections.(Mutable)Map.(Mutable)Entry<kotlin.String!, V!>!>!
+    invisible_fake final /*fake_override*/ var keySet: kotlin.collections.(Mutable)Set<kotlin.String!>!
+    public open /*fake_override*/ val keys: kotlin.collections.MutableSet<kotlin.String!>
+    invisible_fake final /*fake_override*/ val loadFactor: kotlin.Float
+    invisible_fake final /*fake_override*/ var modCount: kotlin.Int
+    invisible_fake final /*fake_override*/ var size: kotlin.Int
+    public open /*fake_override*/ val size: kotlin.Int
+    invisible_fake final /*fake_override*/ var table: kotlin.Array<(out) java.util.HashMap.Node<kotlin.String!, V!>!>!
+    invisible_fake final /*fake_override*/ var threshold: kotlin.Int
+    invisible_fake final /*fake_override*/ var values: kotlin.collections.(Mutable)Collection<V!>!
+    public open /*fake_override*/ val values: kotlin.collections.MutableCollection<V!>
+    invisible_fake open /*fake_override*/ fun afterNodeAccess(/*0*/ java.util.HashMap.Node<kotlin.String!, V!>!): kotlin.Unit
+    invisible_fake open /*fake_override*/ fun afterNodeInsertion(/*0*/ kotlin.Boolean): kotlin.Unit
+    invisible_fake open /*fake_override*/ fun afterNodeRemoval(/*0*/ java.util.HashMap.Node<kotlin.String!, V!>!): kotlin.Unit
+    invisible_fake final /*fake_override*/ fun capacity(): kotlin.Int
+    public open /*fake_override*/ fun clear(): kotlin.Unit
+    public open /*fake_override*/ fun clone(): kotlin.Any
+    public open /*fake_override*/ fun compute(/*0*/ kotlin.String!, /*1*/ java.util.function.BiFunction<in kotlin.String!, in V?, out V?>): V?
+    public open /*fake_override*/ fun computeIfAbsent(/*0*/ kotlin.String, /*1*/ java.util.function.Function<in kotlin.String, out V>): V
+    public open /*fake_override*/ fun computeIfPresent(/*0*/ kotlin.String!, /*1*/ java.util.function.BiFunction<in kotlin.String!, in V, out V?>): V?
+    public open /*fake_override*/ fun containsKey(/*0*/ kotlin.String!): kotlin.Boolean
+    public open /*fake_override*/ fun containsValue(/*0*/ V!): kotlin.Boolean
+    public open /*fake_override*/ fun forEach(/*0*/ java.util.function.BiConsumer<in kotlin.String!, in V!>): kotlin.Unit
+    public open /*fake_override*/ fun get(/*0*/ kotlin.String!): V?
+    invisible_fake final /*fake_override*/ fun getNode(/*0*/ kotlin.Int, /*1*/ kotlin.Any!): java.util.HashMap.Node<kotlin.String!, V!>!
+    @kotlin.SinceKotlin(version = "1.1") @kotlin.internal.PlatformDependent public open /*fake_override*/ fun getOrDefault(/*0*/ kotlin.String, /*1*/ V): V
+    invisible_fake open /*fake_override*/ fun internalWriteEntries(/*0*/ java.io.ObjectOutputStream!): kotlin.Unit
+    public open /*fake_override*/ fun isEmpty(): kotlin.Boolean
+    invisible_fake final /*fake_override*/ fun loadFactor(): kotlin.Float
+    public open /*fake_override*/ fun merge(/*0*/ kotlin.String!, /*1*/ V, /*2*/ java.util.function.BiFunction<in V, in V, out V?>): V?
+    invisible_fake open /*fake_override*/ fun newNode(/*0*/ kotlin.Int, /*1*/ kotlin.String!, /*2*/ V!, /*3*/ java.util.HashMap.Node<kotlin.String!, V!>!): java.util.HashMap.Node<kotlin.String!, V!>!
+    invisible_fake open /*fake_override*/ fun newTreeNode(/*0*/ kotlin.Int, /*1*/ kotlin.String!, /*2*/ V!, /*3*/ java.util.HashMap.Node<kotlin.String!, V!>!): java.util.HashMap.TreeNode<kotlin.String!, V!>!
+    public open /*fake_override*/ fun put(/*0*/ kotlin.String!, /*1*/ V!): V?
+    public open /*fake_override*/ fun putAll(/*0*/ kotlin.collections.Map<out kotlin.String!, V!>): kotlin.Unit
+    public open /*fake_override*/ fun putIfAbsent(/*0*/ kotlin.String!, /*1*/ V!): V?
+    invisible_fake final /*fake_override*/ fun putMapEntries(/*0*/ (kotlin.collections.MutableMap<out kotlin.String!, out V!>..kotlin.collections.Map<out kotlin.String!, V!>?), /*1*/ kotlin.Boolean): kotlin.Unit
+    invisible_fake final /*fake_override*/ fun putVal(/*0*/ kotlin.Int, /*1*/ kotlin.String!, /*2*/ V!, /*3*/ kotlin.Boolean, /*4*/ kotlin.Boolean): V!
+    invisible_fake open /*fake_override*/ fun readObject(/*0*/ java.io.ObjectInputStream!): kotlin.Unit
+    invisible_fake open /*fake_override*/ fun reinitialize(): kotlin.Unit
+    public open /*fake_override*/ fun remove(/*0*/ kotlin.String!): V?
+    public open /*fake_override*/ fun remove(/*0*/ kotlin.String!, /*1*/ V!): kotlin.Boolean
+    invisible_fake final /*fake_override*/ fun removeNode(/*0*/ kotlin.Int, /*1*/ kotlin.Any!, /*2*/ kotlin.Any!, /*3*/ kotlin.Boolean, /*4*/ kotlin.Boolean): java.util.HashMap.Node<kotlin.String!, V!>!
+    public open /*fake_override*/ fun replace(/*0*/ kotlin.String!, /*1*/ V!): V?
+    public open /*fake_override*/ fun replace(/*0*/ kotlin.String!, /*1*/ V!, /*2*/ V!): kotlin.Boolean
+    public open /*fake_override*/ fun replaceAll(/*0*/ java.util.function.BiFunction<in kotlin.String!, in V!, out V!>): kotlin.Unit
+    invisible_fake open /*fake_override*/ fun replacementNode(/*0*/ java.util.HashMap.Node<kotlin.String!, V!>!, /*1*/ java.util.HashMap.Node<kotlin.String!, V!>!): java.util.HashMap.Node<kotlin.String!, V!>!
+    invisible_fake open /*fake_override*/ fun replacementTreeNode(/*0*/ java.util.HashMap.Node<kotlin.String!, V!>!, /*1*/ java.util.HashMap.Node<kotlin.String!, V!>!): java.util.HashMap.TreeNode<kotlin.String!, V!>!
+    invisible_fake final /*fake_override*/ fun resize(): kotlin.Array<(out) java.util.HashMap.Node<kotlin.String!, V!>!>!
+    invisible_fake final /*fake_override*/ fun treeifyBin(/*0*/ kotlin.Array<(out) java.util.HashMap.Node<kotlin.String!, V!>!>!, /*1*/ kotlin.Int): kotlin.Unit
+    invisible_fake open /*fake_override*/ fun writeObject(/*0*/ java.io.ObjectOutputStream!): kotlin.Unit
+}

compiler/testData/compileKotlinAgainstJava/Method.java

@@ -0,0 +1,5 @@
+package test;
+
+class Method {
+    public static String method() { return "method()"; }
+}

compiler/testData/compileKotlinAgainstJava/Method.kt

@@ -0,0 +1,3 @@
+package test
+
+fun method() = Method.method()

compiler/testData/compileKotlinAgainstJava/Method.txt

@@ -0,0 +1,10 @@
+package test
+
+public fun method(): kotlin.String!
+
+public/*package*/ open class Method {
+    public/*package*/ constructor Method()
+
+    // Static members
+    public open fun method(): kotlin.String!
+}

compiler/testData/compileKotlinAgainstJava/MethodWithArgument.java

@@ -0,0 +1,7 @@
+package test;
+
+public class MethodWithArgument {
+
+    public static void method(KotlinClass kotlinClass) {}
+
+}

compiler/testData/compileKotlinAgainstJava/MethodWithArgument.kt

@@ -0,0 +1,5 @@
+package test
+
+class KotlinClass
+
+fun method() = MethodWithArgument.method(KotlinClass())

compiler/testData/compileKotlinAgainstJava/MethodWithArgument.txt

@@ -0,0 +1,14 @@
+package test
+
+public fun method(): kotlin.Unit
+
+public final class KotlinClass {
+    public constructor KotlinClass()
+}
+
+public open class MethodWithArgument {
+    public constructor MethodWithArgument()
+
+    // Static members
+    public open fun method(/*0*/ test.KotlinClass!): kotlin.Unit
+}

compiler/testData/compileKotlinAgainstJava/MethodWithSeveralTypeParameters.java

@@ -0,0 +1,7 @@
+package test;
+
+class MethodWithSeveralTypeParameters {
+
+    public static <T extends CharSequence, N extends Number> N  method(T str, N number) { return null; }
+
+}

compiler/testData/compileKotlinAgainstJava/MethodWithSeveralTypeParameters.kt

@@ -0,0 +1,3 @@
+package test
+
+fun func() = MethodWithSeveralTypeParameters.method("str", 15)

compiler/testData/compileKotlinAgainstJava/MethodWithSeveralTypeParameters.txt

@@ -0,0 +1,10 @@
+package test
+
+public fun func(): kotlin.Int!
+
+public/*package*/ open class MethodWithSeveralTypeParameters {
+    public/*package*/ constructor MethodWithSeveralTypeParameters()
+
+    // Static members
+    public open fun </*0*/ T : kotlin.CharSequence!, /*1*/ N : kotlin.Number!> method(/*0*/ T!, /*1*/ N!): N!
+}

compiler/testData/compileKotlinAgainstJava/MethodWithTypeParameter.java

@@ -0,0 +1,7 @@
+package test;
+
+public class MethodWithTypeParameter {
+
+    public static  <T extends KotlinInterface> void method(T t) {}
+
+}

compiler/testData/compileKotlinAgainstJava/MethodWithTypeParameter.kt

@@ -0,0 +1,7 @@
+package test
+
+interface KotlinInterface
+
+object Impl : KotlinInterface
+
+fun useMethod() = MethodWithTypeParameter.method(Impl)

compiler/testData/compileKotlinAgainstJava/MethodWithTypeParameter.txt

@@ -0,0 +1,17 @@
+package test
+
+public fun useMethod(): kotlin.Unit
+
+public object Impl : test.KotlinInterface {
+    private constructor Impl()
+}
+
+public interface KotlinInterface {
+}
+
+public open class MethodWithTypeParameter {
+    public constructor MethodWithTypeParameter()
+
+    // Static members
+    public open fun </*0*/ T : test.KotlinInterface!> method(/*0*/ T!): kotlin.Unit
+}

compiler/testData/compileKotlinAgainstJava/MethodWithWildcard.java

@@ -0,0 +1,9 @@
+package test;
+
+import java.util.Collection;
+
+public class MethodWithWildcard<V> {
+
+    public Collection<V> method(Collection<? extends V> c) { return null; }
+
+}

compiler/testData/compileKotlinAgainstJava/MethodWithWildcard.kt

@@ -0,0 +1,4 @@
+package test
+
+fun useMethodWithWildcard() = 
+    MethodWithWildcard<CharSequence>().method(emptyList<String>())

compiler/testData/compileKotlinAgainstJava/MethodWithWildcard.txt

@@ -0,0 +1,8 @@
+package test
+
+public fun useMethodWithWildcard(): kotlin.collections.(Mutable)Collection<kotlin.CharSequence!>!
+
+public open class MethodWithWildcard</*0*/ V : kotlin.Any!> {
+    public constructor MethodWithWildcard</*0*/ V : kotlin.Any!>()
+    public open fun method(/*0*/ (kotlin.collections.MutableCollection<out V!>..kotlin.collections.Collection<V!>?)): kotlin.collections.(Mutable)Collection<V!>!
+}

compiler/testData/compileKotlinAgainstJava/Nesting.java

@@ -0,0 +1,26 @@
+package test;
+
+public class Nesting {
+
+    public test.Nesting.Second.Third.FourthImpl getImpl() { return null; }
+
+    public static final class Second {
+
+        public static final class Third {
+
+            public interface Fourth {
+                public boolean isImplemented();
+            }
+
+            public static final class FourthImpl implements Fourth {
+
+                @Override
+                public boolean isImplemented() { return true; }
+
+            }
+
+        }
+
+    }
+
+}

compiler/testData/compileKotlinAgainstJava/Nesting.kt

@@ -0,0 +1,3 @@
+package test
+
+fun getImpl(): Nesting.Second.Third.Fourth = Nesting().getImpl()

compiler/testData/compileKotlinAgainstJava/Nesting.txt

@@ -0,0 +1,25 @@
+package test
+
+public fun getImpl(): test.Nesting.Second.Third.Fourth
+
+public open class Nesting {
+    public constructor Nesting()
+    public open fun getImpl(): test.Nesting.Second.Third.FourthImpl!
+
+    public final class Second {
+        public constructor Second()
+
+        public final class Third {
+            public constructor Third()
+
+            public interface Fourth {
+                public abstract fun isImplemented(): kotlin.Boolean
+            }
+
+            public final class FourthImpl : test.Nesting.Second.Third.Fourth {
+                public constructor FourthImpl()
+                public open fun isImplemented(): kotlin.Boolean
+            }
+        }
+    }
+}

compiler/testData/compileKotlinAgainstJava/RawReturnType.java

@@ -0,0 +1,9 @@
+package test;
+
+import java.util.List;
+
+public class RawReturnType {
+
+    public static List getRawList(List<String> list) { return null; }
+
+}