Refine type arguments resolution and rendering

In case of type constructors captured parameters from outer classes

 #KT-5510 Fixed
 #KT-3112 Fixed
 #KT-6325 Fixed
 #KT-408  Fixed
 #KT-6337 Fixed

compiler/testData/diagnostics/tests/generics/genericsInType.kt

@@ -19,18 +19,18 @@ fun test() {
     a<Foo.Bar<String>>()
     a<Foo.Bar.Baz>()
 
-    <!GENERICS_IN_CONTAINING_TYPE_NOT_ALLOWED!>Foo<String>.Bar<!>::class
-    <!GENERICS_IN_CONTAINING_TYPE_NOT_ALLOWED!>Foo<<!DEBUG_INFO_MISSING_UNRESOLVED!>String<!>>.Bar.Baz<!>::class
+    Foo<String>.<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Bar<!>::class
+    Foo<!TYPE_ARGUMENTS_FOR_OUTER_CLASS_WHEN_NESTED_REFERENCED!><String><!>.Bar.Baz::class
 
-    a<<!GENERICS_IN_CONTAINING_TYPE_NOT_ALLOWED, WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo<String>.Bar<!>>()
-    a<<!GENERICS_IN_CONTAINING_TYPE_NOT_ALLOWED!>Foo<<!DEBUG_INFO_MISSING_UNRESOLVED!>String<!>>.Bar.Baz<!>>()
+    a<Foo<String>.<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Bar<!>>()
+    a<Foo<!TYPE_ARGUMENTS_FOR_OUTER_CLASS_WHEN_NESTED_REFERENCED!><String><!>.Bar.Baz>()
 
     a<Foo.Bar<Int>>()
-    a<<!GENERICS_IN_CONTAINING_TYPE_NOT_ALLOWED!>Foo.Bar<Int>.Baz<!>>()
+    a<Foo.Bar<!TYPE_ARGUMENTS_FOR_OUTER_CLASS_WHEN_NESTED_REFERENCED!><Int><!>.Baz>()
 }
 
 fun <T: Foo<String.<!UNRESOLVED_REFERENCE!>Bar<!>>> x() {}
-fun <!GENERICS_IN_CONTAINING_TYPE_NOT_ALLOWED, WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo<String>.Bar<!>.ext() {}
+fun Foo<String>.<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Bar<!>.ext() {}
 
-fun ex1(<!UNUSED_PARAMETER!>a<!>: <!GENERICS_IN_CONTAINING_TYPE_NOT_ALLOWED!>Foo<String>.Bar<String><!>): <!GENERICS_IN_CONTAINING_TYPE_NOT_ALLOWED!>Foo<String>.Bar<String><!> {
+fun ex1(<!UNUSED_PARAMETER!>a<!>: Foo<!TYPE_ARGUMENTS_FOR_OUTER_CLASS_WHEN_NESTED_REFERENCED!><String><!>.Bar<String>): Foo<!TYPE_ARGUMENTS_FOR_OUTER_CLASS_WHEN_NESTED_REFERENCED!><String><!>.Bar<String> {
 <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

compiler/testData/diagnostics/tests/generics/genericsInType.txt

@@ -1,10 +1,10 @@
 package
 
 public fun </*0*/ T> a(): kotlin.Unit
-public fun ex1(/*0*/ a: Foo.Bar<kotlin.String>): Foo.Bar<kotlin.String>
+public fun ex1(/*0*/ a: [ERROR : Bar]<kotlin.String, kotlin.String>): [ERROR : Bar]<kotlin.String, kotlin.String>
 public fun test(): kotlin.Unit
 public fun </*0*/ T : Foo<[ERROR : String.Bar]>> x(): kotlin.Unit
-public fun [ERROR : Bar].ext(): kotlin.Unit
+public fun [ERROR : Bar]<kotlin.String>.ext(): kotlin.Unit
 
 public final class Foo</*0*/ T> {
     public constructor Foo</*0*/ T>()

compiler/testData/diagnostics/tests/generics/innerClasses/bareTypes.kt

@@ -0,0 +1,20 @@
+class Outer<E> {
+    inner class Inner<F, G> {
+        inner abstract class Inner2Base
+        inner class Inner2 : Inner2Base()
+
+        inner abstract class Inner3Base<B>
+        inner class Inner3<H> : Inner3Base<H>()
+    }
+
+    fun foo(x: Outer<*>.Inner<*, *>.Inner2Base) {
+        if (x is Inner.Inner2) return
+    }
+}
+
+fun bare(x: Outer<*>.Inner<*, *>.Inner2Base, y: Outer<*>.Inner<*, *>.Inner3Base<Int>) {
+    if (x is Outer.Inner.Inner2) return
+    if (y is Outer.Inner.Inner3) return
+    if (y is Outer<String>.Inner.<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inner3<!>) return
+    if (y is <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<!>.Inner<String, Int>.Inner3<Double>) return
+}

compiler/testData/diagnostics/tests/generics/innerClasses/bareTypes.txt

@@ -0,0 +1,46 @@
+package
+
+public fun bare(/*0*/ x: Outer<*>.Inner<*, *>.Inner2Base, /*1*/ y: Outer<*>.Inner<*, *>.Inner3Base<kotlin.Int>): kotlin.Unit
+
+public final class Outer</*0*/ E> {
+    public constructor Outer</*0*/ E>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ x: Outer<*>.Inner<*, *>.Inner2Base): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final inner class Inner</*0*/ F, /*1*/ G> {
+        public constructor Inner</*0*/ F, /*1*/ G>()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final inner class Inner2 : Outer<E>.Inner<F, G>.Inner2Base {
+            public constructor Inner2()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+
+        public abstract inner class Inner2Base {
+            public constructor Inner2Base()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+
+        public final inner class Inner3</*0*/ H> : Outer<E>.Inner<F, G>.Inner3Base<H> {
+            public constructor Inner3</*0*/ H>()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+
+        public abstract inner class Inner3Base</*0*/ B> {
+            public constructor Inner3Base</*0*/ B>()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/checkBoundsOuter.kt

@@ -0,0 +1,5 @@
+class Outer<E : Any> {
+    inner class Inner<F, G>
+}
+
+val x: Outer<<!UPPER_BOUND_VIOLATED!>String?<!>>.Inner<String, Int> = null!!

compiler/testData/diagnostics/tests/generics/innerClasses/checkBoundsOuter.txt

@@ -0,0 +1,17 @@
+package
+
+public val x: Outer<kotlin.String?>.Inner<kotlin.String, kotlin.Int>
+
+public final class Outer</*0*/ E : kotlin.Any> {
+    public constructor Outer</*0*/ E : kotlin.Any>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final inner class Inner</*0*/ F, /*1*/ G> {
+        public constructor Inner</*0*/ F, /*1*/ G>()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/importedInner.kt

@@ -0,0 +1,16 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+import Outer.Inner
+
+
+class Outer<E> {
+    inner class Inner
+
+    fun foo() {
+        class E
+        val x: Inner = Inner()
+    }
+}
+
+class E
+
+fun bar(x: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Inner<!>) {}

compiler/testData/diagnostics/tests/generics/innerClasses/importedInner.txt

@@ -0,0 +1,25 @@
+package
+
+public fun bar(/*0*/ x: [ERROR : Inner]): kotlin.Unit
+
+public final class E {
+    public constructor E()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class Outer</*0*/ E> {
+    public constructor Outer</*0*/ E>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final inner class Inner /*captured type parameters: /*0*/ E*/ {
+        public constructor Inner()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.kt

@@ -0,0 +1,41 @@
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER
+
+class Outer<E> {
+    inner class Inner<F> {
+        fun foo() = this
+        fun baz(): Inner<String> = null!!
+    }
+
+    fun innerFactory(): Outer<E>.Inner<String> = null!!
+
+    fun bar() = Inner<E>()
+    fun set(inner: Inner<out E>) {}
+
+    fun inside() {
+        innerFactory().checkType { _<Inner<String>>() }
+    }
+}
+
+fun factoryString(): Outer<String>.Inner<String> = null!!
+
+fun <T, Y> infer(x: T, y: Y): Outer<T>.Inner<Y> = null!!
+val infered = infer("", 1)
+
+fun main() {
+    val outer = Outer<String>()
+
+    checkSubtype<Outer<String>.Inner<String>>(outer.bar())
+    checkSubtype<Outer<String>.Inner<Int>>(outer.Inner<Int>())
+    checkSubtype<Outer<*>.Inner<*>>(outer.bar())
+    checkSubtype<Outer<*>.Inner<*>>(outer.Inner<Int>())
+
+    checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!TYPE_MISMATCH!>outer.bar()<!>)
+    checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(outer.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>Inner()<!>)
+
+    outer.set(outer.bar())
+    outer.set(outer.Inner())
+
+    val x: Outer<String>.Inner<String> = factoryString()
+    outer.set(x)
+}

compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.txt

@@ -0,0 +1,26 @@
+package
+
+public val infered: Outer<kotlin.String>.Inner<kotlin.Int>
+public fun factoryString(): Outer<kotlin.String>.Inner<kotlin.String>
+public fun </*0*/ T, /*1*/ Y> infer(/*0*/ x: T, /*1*/ y: Y): Outer<T>.Inner<Y>
+public fun main(): kotlin.Unit
+
+public final class Outer</*0*/ E> {
+    public constructor Outer</*0*/ E>()
+    public final fun bar(): Outer<E>.Inner<E>
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final fun innerFactory(): Outer<E>.Inner<kotlin.String>
+    public final fun inside(): kotlin.Unit
+    public final fun set(/*0*/ inner: Outer<E>.Inner<out E>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final inner class Inner</*0*/ F> {
+        public constructor Inner</*0*/ F>()
+        public final fun baz(): Outer<E>.Inner<kotlin.String>
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final fun foo(): Outer<E>.Inner<F>
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/innerUncheckedCast.kt

@@ -0,0 +1,31 @@
+// !CHECK_TYPE
+
+class Outer<E> {
+    inner open class InnerBase<F>
+    inner class Inner<H> : InnerBase<H>() {
+        val prop: E = null!!
+    }
+
+    fun foo(x: InnerBase<String>, y: Any?, z: Outer<*>.InnerBase<String>) {
+        if (x is Inner) {
+            <!DEBUG_INFO_SMARTCAST!>x<!>.prop.checkType { _<E>() }
+        }
+
+        if (y is <!NO_TYPE_ARGUMENTS_ON_RHS!>Inner<!>) return
+
+        if (z is Inner) {
+            <!DEBUG_INFO_SMARTCAST!>z<!>.prop.checkType { _<Any?>() }
+            return
+        }
+
+        if (y is Outer<*>.Inner<*>) {
+            <!DEBUG_INFO_SMARTCAST!>y<!>.prop.checkType { _<Any?>() }
+        }
+    }
+
+    fun bar(x: InnerBase<String>, y: Any?, z: Outer<*>.InnerBase<String>) {
+        x as Inner
+        y as <!NO_TYPE_ARGUMENTS_ON_RHS!>Inner<!>
+        z as Inner
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/innerUncheckedCast.txt

@@ -0,0 +1,25 @@
+package
+
+public final class Outer</*0*/ E> {
+    public constructor Outer</*0*/ E>()
+    public final fun bar(/*0*/ x: Outer<E>.InnerBase<kotlin.String>, /*1*/ y: kotlin.Any?, /*2*/ z: Outer<*>.InnerBase<kotlin.String>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ x: Outer<E>.InnerBase<kotlin.String>, /*1*/ y: kotlin.Any?, /*2*/ z: Outer<*>.InnerBase<kotlin.String>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final inner class Inner</*0*/ H> : Outer<E>.InnerBase<H> {
+        public constructor Inner</*0*/ H>()
+        public final val prop: E
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open inner class InnerBase</*0*/ F> {
+        public constructor InnerBase</*0*/ F>()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/innerVariance.kt

@@ -0,0 +1,14 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class Outer<out E, in F> {
+    inner class Inner {
+        fun unsafe1(x: <!TYPE_VARIANCE_CONFLICT!>E<!>) {}
+        fun unsafe2(x: Collection<<!TYPE_VARIANCE_CONFLICT!>E?<!>>) {}
+        fun unsafe3(): <!TYPE_VARIANCE_CONFLICT!>F?<!> = null
+        fun unsafe4(): Collection<<!TYPE_VARIANCE_CONFLICT!>F<!>>? = null
+    }
+
+    // Should be errors
+    // Refinement of variance checker is needed
+    fun foo(x: Inner) {}
+    fun bar(): Inner? = null
+}

compiler/testData/diagnostics/tests/generics/innerClasses/innerVariance.txt

@@ -0,0 +1,21 @@
+package
+
+public final class Outer</*0*/ out E, /*1*/ in F> {
+    public constructor Outer</*0*/ out E, /*1*/ in F>()
+    public final fun bar(): Outer<E, F>.Inner?
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ x: Outer<E, F>.Inner): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final inner class Inner {
+        public constructor Inner()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        public final fun unsafe1(/*0*/ x: E): kotlin.Unit
+        public final fun unsafe2(/*0*/ x: kotlin.Collection<E?>): kotlin.Unit
+        public final fun unsafe3(): F?
+        public final fun unsafe4(): kotlin.Collection<F>?
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt

@@ -0,0 +1,35 @@
+// !CHECK_TYPE
+// !DIAGNOSTICS: -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_VARIABLE
+import java.util.*
+
+class A<T> : AbstractCollection<T>() {
+    override fun iterator(): MyIt = MyIt()
+
+    override val size: Int
+        get() = 1
+
+    inner class MyIt : MutableIterator<T> {
+        override fun next(): T {
+            throw UnsupportedOperationException()
+        }
+
+        override fun hasNext(): Boolean {
+            throw UnsupportedOperationException()
+        }
+
+        override fun remove() {
+            throw UnsupportedOperationException()
+        }
+    }
+}
+
+fun <E> commonSupertype(x: E, y: E): E = x
+
+fun foo() {
+    var myIt = A<String>().iterator()
+    myIt = <!TYPE_MISMATCH!>A<Int>().iterator()<!>
+
+    val csIt: Iterator<CharSequence> = A<String>().iterator()
+
+    commonSupertype(A<String>().iterator(), A<Int>().iterator()).checkType { _<A<out Any>.MyIt>() }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/iterator.txt

@@ -0,0 +1,34 @@
+package
+
+public fun </*0*/ E> commonSupertype(/*0*/ x: E, /*1*/ y: E): E
+public fun foo(): kotlin.Unit
+
+public final class A</*0*/ T> : java.util.AbstractCollection<T> {
+    public constructor A</*0*/ T>()
+    public open override /*1*/ val size: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: T!): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.Collection<T!>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: T!): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.Collection<T!>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
+    public open override /*1*/ fun iterator(): A<T>.MyIt
+    public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: T!): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.Collection<T!>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.Collection<T!>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>!
+    public open override /*1*/ /*fake_override*/ fun </*0*/ T : kotlin.Any!> toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>!
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final inner class MyIt : kotlin.MutableIterator<T> {
+        public constructor MyIt()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ fun hasNext(): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ fun next(): T
+        public open override /*1*/ fun remove(): kotlin.Unit
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/j+k.kt

@@ -0,0 +1,28 @@
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER
+// FILE: Outer.java
+
+public class Outer<E> {
+    public class Inner<F> {
+        E foo() {}
+        F bar() {}
+
+        Outer<E> outer() {}
+    }
+
+    Inner<E> baz() { }
+    void set(Inner<String> x) {}
+}
+
+// FILE: main.kt
+
+fun main() {
+    var outerStr: Outer<String> = Outer()
+    outerStr.baz().checkType { _<Outer<String>.Inner<String>>() }
+
+    val strInt: Outer<String>.Inner<Int> = outerStr.Inner()
+
+    strInt.foo().checkType { _<String>() }
+    strInt.bar().checkType { _<Int>() }
+    strInt.outer().checkType { _<Outer<String>>() }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/j+k.txt

@@ -0,0 +1,22 @@
+package
+
+public fun main(): kotlin.Unit
+
+public open class Outer</*0*/ E : kotlin.Any!> {
+    public constructor Outer</*0*/ E : kotlin.Any!>()
+    public/*package*/ open fun baz(): Outer<E!>.Inner<E!>!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public/*package*/ open fun set(/*0*/ x: Outer<kotlin.String!>.Inner<E!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open inner class Inner</*0*/ F : kotlin.Any!> {
+        public constructor Inner</*0*/ F : kotlin.Any!>()
+        public/*package*/ open fun bar(): F!
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public/*package*/ open fun foo(): E!
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public/*package*/ open fun outer(): Outer<E!>!
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/kt408.kt

@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+interface T<E> {
+    fun f() : E = null!!
+}
+open class A<X>() {
+    inner class B() : T<X> {}
+}
+
+fun test() {
+    val a = A<Int>()
+    val b : A<Int>.B = a.B()
+}

compiler/testData/diagnostics/tests/generics/innerClasses/kt408.txt

@@ -0,0 +1,25 @@
+package
+
+public fun test(): kotlin.Unit
+
+public open class A</*0*/ X> {
+    public constructor A</*0*/ X>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final inner class B : T<X> {
+        public constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun f(): X
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public interface T</*0*/ E> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun f(): E
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/generics/innerClasses/kt6325.kt

@@ -0,0 +1,21 @@
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE
+
+class Outer<T> {
+    inner class Inner<R> {
+        fun <S> newInner(): Inner<S> = Inner()
+        //type mismatch
+        fun <U, S> newOuterInner(): Outer<U>.Inner<S> = Outer<U>().Inner<S>()
+        //^ U here is not analyzed
+        fun foo(t: T, r: R) {}
+    }
+}
+
+fun test0() {
+    val inner: Outer<Int>.Inner<String> = Outer<Int>().Inner<String>()
+    Outer<Int>().Inner<String>().foo(1, "") // type mismatch on second argument
+}
+
+
+fun test1() {
+    Outer<Int>().Inner<String>().newOuterInner<Double, Boolean>().foo(1.0, true) // type mismatch on 1.0
+}

compiler/testData/diagnostics/tests/generics/innerClasses/kt6325.txt

@@ -0,0 +1,21 @@
+package
+
+public fun test0(): kotlin.Unit
+public fun test1(): kotlin.Unit
+
+public final class Outer</*0*/ T> {
+    public constructor Outer</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final inner class Inner</*0*/ R> {
+        public constructor Inner</*0*/ R>()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final fun foo(/*0*/ t: T, /*1*/ r: R): kotlin.Unit
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final fun </*0*/ S> newInner(): Outer<T>.Inner<S>
+        public final fun </*0*/ U, /*1*/ S> newOuterInner(): Outer<U>.Inner<S>
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/parameterShadowing.kt

@@ -0,0 +1,18 @@
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER
+
+class Outer<E> {
+    inner class Inner<E> {
+        fun foo(): E = null!!
+        fun outerE() = baz()
+    }
+
+    fun baz(): E = null!!
+}
+
+fun main() {
+    val inner = Outer<String>().Inner<Int>()
+
+    inner.foo().checkType { _<Int>() }
+    inner.outerE().checkType { _<String>() }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/parameterShadowing.txt

@@ -0,0 +1,20 @@
+package
+
+public fun main(): kotlin.Unit
+
+public final class Outer</*0*/ E> {
+    public constructor Outer</*0*/ E>()
+    public final fun baz(): E
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final inner class Inner</*0*/ E> {
+        public constructor Inner</*0*/ E>()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final fun foo(): E
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final fun outerE(): E
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.kt

@@ -0,0 +1,23 @@
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VALUE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE
+
+class Outer<T> {
+    inner class Inner
+    fun foo(x: Outer<String>.Inner, y: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<!>.Inner, z: Inner) {
+        var inner = Inner()
+        x.checkType { <!TYPE_MISMATCH!>_<!><Inner>() }
+        x.checkType { _<Outer<String>.Inner>() }
+        z.checkType { _<Inner>() }
+        z.checkType { _<Outer<T>.Inner>() }
+
+        inner = <!TYPE_MISMATCH!>x<!>
+    }
+
+    class Nested
+    fun bar(x: Outer.Nested) {
+        var nested = Nested()
+        nested = x
+
+        x.checkType { _<Nested>() }
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.txt

@@ -0,0 +1,24 @@
+package
+
+public final class Outer</*0*/ T> {
+    public constructor Outer</*0*/ T>()
+    public final fun bar(/*0*/ x: Outer.Nested): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ x: Outer<kotlin.String>.Inner, /*1*/ y: [ERROR : Inner], /*2*/ z: Outer<T>.Inner): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final inner class Inner {
+        public constructor Inner()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public final class Nested {
+        public constructor Nested()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedTypesResolution.kt

@@ -0,0 +1,51 @@
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER
+// FILE: test.kt
+
+package test
+
+class Outer<E> {
+    inner class Inner<F, G> {
+        inner class Inner2
+        inner class Inner3<H>
+    }
+
+    class Nested<I> {
+        inner class Inner4<K>
+    }
+
+    object Obj {
+        class Nested2<J> {
+            inner class Inner5<L>
+        }
+    }
+}
+
+// FILE: main.kt
+
+import test.*;
+
+class A
+class B
+class C
+class D
+
+fun ok1(): Outer<A>.Inner<B, C>.Inner2 = null!!
+fun ok2(): Outer<A>.Inner<B, C>.Inner2 = null!!
+fun ok22(): test.Outer<A>.Inner<B, C>.Inner3<D> = null!!
+fun ok3(): Outer.Nested<A>.Inner4<B> = null!!
+fun ok4(): Outer.Obj.Nested2<A>.Inner5<B> = null!!
+fun ok5(): test.Outer.Obj.Nested2<A>.Inner5<B> = null!!
+
+// All arguments are resolved
+fun errorTypeWithArguments(): <!UNRESOLVED_REFERENCE!>Q<!><A>.<!DEBUG_INFO_MISSING_UNRESOLVED!>W<!><B, C, D>.<!DEBUG_INFO_MISSING_UNRESOLVED!>R<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>M<!> = null!!
+
+fun error1(): Outer<A>.Inner<B>.Inner3<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><C, D><!> = null!!
+fun error2(): Outer<A>.Inner<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><B, C, D><!>.Inner2 = null!!
+fun error3(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<!>.Inner<A, B>.Inner3<C> = null!!
+
+fun error4(): Outer<!TYPE_ARGUMENTS_FOR_OUTER_CLASS_WHEN_NESTED_REFERENCED!><A><!>.Nested<B>.Inner4<C> = null!!
+fun error5(): Outer<!TYPE_ARGUMENTS_FOR_OUTER_CLASS_WHEN_NESTED_REFERENCED!><A><!>.Obj.Nested2<B>.Inner5<C> = null!!
+fun error6(): Outer.Obj<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><A><!>.Nested2<B>.Inner5<C> = null!!
+
+fun error7(): test<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><String><!>.Outer.Obj.Nested2<A>.Inner5<B> = null!!

compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedTypesResolution.txt

@@ -0,0 +1,110 @@
+package
+
+public fun error1(): [ERROR : Inner3]<A, B, C, D>
+public fun error2(): [ERROR : Inner2]<A, B, C, D>
+public fun error3(): [ERROR : Inner3]<A, B, C>
+public fun error4(): [ERROR : Inner4]<A, B, C>
+public fun error5(): [ERROR : Inner5]<A, B, C>
+public fun error6(): [ERROR : Inner5]<A, B, C>
+public fun error7(): [ERROR : Inner5]<kotlin.String, A, B>
+public fun errorTypeWithArguments(): [ERROR : Q<A>.W<B, C, D>.R.M]<A, B, C, D>
+public fun ok1(): test.Outer<A>.Inner<B, C>.Inner2
+public fun ok2(): test.Outer<A>.Inner<B, C>.Inner2
+public fun ok22(): test.Outer<A>.Inner<B, C>.Inner3<D>
+public fun ok3(): test.Outer.Nested<A>.Inner4<B>
+public fun ok4(): test.Outer.Obj.Nested2<A>.Inner5<B>
+public fun ok5(): test.Outer.Obj.Nested2<A>.Inner5<B>
+
+public final class A {
+    public constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class B {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C {
+    public constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class D {
+    public constructor D()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+package test {
+
+    public final class Outer</*0*/ E> {
+        public constructor Outer</*0*/ E>()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final inner class Inner</*0*/ F, /*1*/ G> {
+            public constructor Inner</*0*/ F, /*1*/ G>()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final inner class Inner2 {
+                public constructor Inner2()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+
+            public final inner class Inner3</*0*/ H> {
+                public constructor Inner3</*0*/ H>()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class Nested</*0*/ I> {
+            public constructor Nested</*0*/ I>()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final inner class Inner4</*0*/ K> {
+                public constructor Inner4</*0*/ K>()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public object Obj {
+            private constructor Obj()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class Nested2</*0*/ J> {
+                public constructor Nested2</*0*/ J>()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+                public final inner class Inner5</*0*/ L> {
+                    public constructor Inner5</*0*/ L>()
+                    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+                }
+            }
+        }
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/simple.kt

@@ -0,0 +1,36 @@
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER
+
+class Outer<E> {
+    inner class Inner {
+        fun foo() = this
+        fun baz(): Inner = this
+    }
+
+    fun bar() = Inner()
+
+    fun set(inner: Inner) {}
+}
+
+fun factoryString(): Outer<String>.Inner = null!!
+
+fun <T> infer(x: T): Outer<T>.Inner = null!!
+val infered = infer("")
+
+fun main() {
+    val outer = Outer<String>()
+
+    checkSubtype<Outer<String>.Inner>(outer.bar())
+    checkSubtype<Outer<String>.Inner>(outer.Inner())
+    checkSubtype<Outer<*>.Inner>(outer.bar())
+    checkSubtype<Outer<*>.Inner>(outer.Inner())
+
+    checkSubtype<Outer<CharSequence>.Inner>(<!TYPE_MISMATCH!>outer.bar()<!>)
+    checkSubtype<Outer<CharSequence>.Inner>(<!TYPE_MISMATCH!>outer.Inner()<!>)
+
+    outer.set(outer.bar())
+    outer.set(outer.Inner())
+
+    val x: Outer<String>.Inner = factoryString()
+    outer.set(x)
+}

compiler/testData/diagnostics/tests/generics/innerClasses/simple.txt

@@ -0,0 +1,24 @@
+package
+
+public val infered: Outer<kotlin.String>.Inner
+public fun factoryString(): Outer<kotlin.String>.Inner
+public fun </*0*/ T> infer(/*0*/ x: T): Outer<T>.Inner
+public fun main(): kotlin.Unit
+
+public final class Outer</*0*/ E> {
+    public constructor Outer</*0*/ E>()
+    public final fun bar(): Outer<E>.Inner
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final fun set(/*0*/ inner: Outer<E>.Inner): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final inner class Inner {
+        public constructor Inner()
+        public final fun baz(): Outer<E>.Inner
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final fun foo(): Outer<E>.Inner
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/simpleIn.kt

@@ -0,0 +1,40 @@
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER
+
+class Outer<in E> {
+    inner class Inner {
+        fun foo() = this
+        fun baz(): Inner = this
+    }
+
+    fun bar() = Inner()
+
+    fun set(inner: Inner) {}
+}
+
+fun factoryString(): Outer<String>.Inner = null!!
+
+fun <T> infer(x: T): Outer<T>.Inner = null!!
+val infered = infer("")
+
+fun main() {
+    val outer = Outer<CharSequence>()
+
+    checkSubtype<Outer<CharSequence>.Inner>(outer.bar())
+    checkSubtype<Outer<CharSequence>.Inner>(outer.Inner())
+    checkSubtype<Outer<*>.Inner>(outer.bar())
+    checkSubtype<Outer<*>.Inner>(outer.Inner())
+
+    checkSubtype<Outer<String>.Inner>(outer.bar())
+    checkSubtype<Outer<String>.Inner>(outer.Inner())
+
+    outer.set(outer.bar())
+    outer.set(outer.Inner())
+
+    val x: Outer<String>.Inner = factoryString()
+    outer.set(<!TYPE_MISMATCH!>x<!>)
+    val y: Outer<CharSequence>.Inner = infer<CharSequence>("")
+    outer.set(y)
+
+    outer.set(infer<Any>(""))
+}

compiler/testData/diagnostics/tests/generics/innerClasses/simpleIn.txt

@@ -0,0 +1,24 @@
+package
+
+public val infered: Outer<kotlin.String>.Inner
+public fun factoryString(): Outer<kotlin.String>.Inner
+public fun </*0*/ T> infer(/*0*/ x: T): Outer<T>.Inner
+public fun main(): kotlin.Unit
+
+public final class Outer</*0*/ in E> {
+    public constructor Outer</*0*/ in E>()
+    public final fun bar(): Outer<E>.Inner
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final fun set(/*0*/ inner: Outer<E>.Inner): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final inner class Inner {
+        public constructor Inner()
+        public final fun baz(): Outer<E>.Inner
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final fun foo(): Outer<E>.Inner
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/simpleOut.kt

@@ -0,0 +1,37 @@
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER
+
+class Outer<out E> {
+    inner class Inner {
+        fun foo() = this
+        fun baz(): Inner = this
+    }
+
+    fun bar() = Inner()
+
+    // Should be unsafe variance error here
+    fun set(inner: Inner) {}
+}
+
+fun factoryString(): Outer<String>.Inner = null!!
+
+fun <T> infer(x: T): Outer<T>.Inner = null!!
+val infered = infer("")
+
+fun main() {
+    val outer = Outer<String>()
+
+    checkSubtype<Outer<String>.Inner>(outer.bar())
+    checkSubtype<Outer<String>.Inner>(outer.Inner())
+    checkSubtype<Outer<*>.Inner>(outer.bar())
+    checkSubtype<Outer<*>.Inner>(outer.Inner())
+
+    checkSubtype<Outer<CharSequence>.Inner>(outer.bar())
+    checkSubtype<Outer<CharSequence>.Inner>(outer.Inner())
+
+    outer.set(outer.bar())
+    outer.set(outer.Inner())
+
+    val x: Outer<String>.Inner = factoryString()
+    outer.set(x)
+}

compiler/testData/diagnostics/tests/generics/innerClasses/simpleOut.txt

@@ -0,0 +1,24 @@
+package
+
+public val infered: Outer<kotlin.String>.Inner
+public fun factoryString(): Outer<kotlin.String>.Inner
+public fun </*0*/ T> infer(/*0*/ x: T): Outer<T>.Inner
+public fun main(): kotlin.Unit
+
+public final class Outer</*0*/ out E> {
+    public constructor Outer</*0*/ out E>()
+    public final fun bar(): Outer<E>.Inner
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final fun set(/*0*/ inner: Outer<E>.Inner): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final inner class Inner {
+        public constructor Inner()
+        public final fun baz(): Outer<E>.Inner
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final fun foo(): Outer<E>.Inner
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/simpleOutUseSite.kt

@@ -0,0 +1,37 @@
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER
+
+class Outer<E> {
+    inner class Inner {
+        fun foo() = this
+        fun baz(): Inner = this
+    }
+
+    fun bar() = Inner()
+
+    fun set(inner: Inner) {}
+}
+
+fun factoryString(): Outer<String>.Inner = null!!
+
+fun <T> infer(x: T): Outer<T>.Inner = null!!
+val infered = infer("")
+
+fun main() {
+    val outer: Outer<out String> = Outer<String>()
+
+    checkSubtype<Outer<out String>.Inner>(outer.bar())
+    checkSubtype<Outer<out String>.Inner>(outer.Inner())
+    checkSubtype<Outer<*>.Inner>(outer.bar())
+    checkSubtype<Outer<*>.Inner>(outer.Inner())
+
+    checkSubtype<Outer<out CharSequence>.Inner>(outer.bar())
+    checkSubtype<Outer<out CharSequence>.Inner>(outer.Inner())
+
+    // Should not actually work as in Java (captured constructor type mismatch)
+    outer.set(outer.bar())
+    outer.set(outer.Inner())
+
+    val x: Outer<String>.Inner = factoryString()
+    outer.set(x)
+}

compiler/testData/diagnostics/tests/generics/innerClasses/simpleOutUseSite.txt

@@ -0,0 +1,24 @@
+package
+
+public val infered: Outer<kotlin.String>.Inner
+public fun factoryString(): Outer<kotlin.String>.Inner
+public fun </*0*/ T> infer(/*0*/ x: T): Outer<T>.Inner
+public fun main(): kotlin.Unit
+
+public final class Outer</*0*/ E> {
+    public constructor Outer</*0*/ E>()
+    public final fun bar(): Outer<E>.Inner
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final fun set(/*0*/ inner: Outer<E>.Inner): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final inner class Inner {
+        public constructor Inner()
+        public final fun baz(): Outer<E>.Inner
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final fun foo(): Outer<E>.Inner
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/generics/innerClasses/substitutedMemberScope.kt

@@ -0,0 +1,49 @@
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER
+
+class Outer<E> {
+    inner class Inner<F> {
+        fun instance() = this@Outer
+        fun foo(): E = null!!
+        fun bar(e: E, f: F) {}
+        fun baz(): F = null!!
+
+        fun act() {
+            foo().checkType { _<E>() }
+            outerE().checkType { _<E>() }
+            instance().checkType { _<Outer<E>>() }
+            instance().outerE().checkType { _<E>() }
+
+            bar(foo(), baz())
+            bar(outerE(), baz())
+            bar(instance().outerE(), baz())
+
+            bar(topLevel().Inner<E>().baz(), <!TYPE_MISMATCH!>topLevel().Inner<E>().baz()<!>)
+            bar(<!TYPE_MISMATCH!>topLevel().Inner<E>().foo()<!>, <!TYPE_MISMATCH!>topLevel().Inner<E>().baz()<!>)
+
+            setE(foo())
+        }
+    }
+
+    fun outerE(): E = null!!
+
+    fun setE(e: E) {}
+    fun setInner(inner: Inner<Int>) {}
+}
+
+fun topLevel(): Outer<String> = null!!
+
+fun foo() {
+    val strInt: Outer<String>.Inner<Int> = Outer<String>().Inner()
+
+    strInt.foo().checkType { _<String>() }
+    strInt.baz().checkType { _<Int>() }
+
+    strInt.instance().setE("")
+    strInt.instance().outerE().checkType { _<String>() }
+
+    strInt.instance().Inner<Double>().checkType { _<Outer<String>.Inner<Double>>() }
+
+    Outer<String>().setInner(strInt)
+    Outer<CharSequence>().setInner(<!TYPE_MISMATCH!>strInt<!>)
+}

compiler/testData/diagnostics/tests/generics/innerClasses/substitutedMemberScope.txt

@@ -0,0 +1,26 @@
+package
+
+public fun foo(): kotlin.Unit
+public fun topLevel(): Outer<kotlin.String>
+
+public final class Outer</*0*/ E> {
+    public constructor Outer</*0*/ E>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final fun outerE(): E
+    public final fun setE(/*0*/ e: E): kotlin.Unit
+    public final fun setInner(/*0*/ inner: Outer<E>.Inner<kotlin.Int>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final inner class Inner</*0*/ F> {
+        public constructor Inner</*0*/ F>()
+        public final fun act(): kotlin.Unit
+        public final fun bar(/*0*/ e: E, /*1*/ f: F): kotlin.Unit
+        public final fun baz(): F
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final fun foo(): E
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final fun instance(): Outer<E>
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/generics/kt5508.txt

@@ -7,16 +7,16 @@ public abstract class A</*0*/ T> {
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 
-    public abstract inner class B</*0*/ S> : A<A.B<S>> {
+    public abstract inner class B</*0*/ S> : A<A<T>.B<S>> {
         public constructor B</*0*/ S>()
-        public abstract override /*1*/ /*fake_override*/ fun Foo(/*0*/ x: A.B<S>): kotlin.Unit
+        public abstract override /*1*/ /*fake_override*/ fun Foo(/*0*/ x: A<T>.B<S>): kotlin.Unit
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 
-        public final inner class C</*0*/ U> : A.B<A.B.C<U>> {
+        public final inner class C</*0*/ U> : A<T>.B<A<T>.B<S>.C<U>> {
             public constructor C</*0*/ U>()
-            public open override /*1*/ fun Foo(/*0*/ x: A.B<A.B.C<U>>): kotlin.Unit
+            public open override /*1*/ fun Foo(/*0*/ x: A<T>.B<A<T>.B<S>.C<U>>): kotlin.Unit
             public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
             public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
             public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String