[FIR-TEST] Add new testdata generated after changes in previous commit

2019-12-11 16:16:22 +03:00
parent e9c02a1cca
commit 2536fa0cd5
4578 changed files with 104067 additions and 1 deletions
@@ -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.Inner3) return
+    if (y is Outer.Inner<String, Int>.Inner3<Double>) return
+}
@@ -0,0 +1,14 @@
+open class SuperOuter<E> {
+    inner open class SuperInner<F>
+}
+
+class DerivedOuter<G> : SuperOuter<G>() {
+    inner class DerivedInner<H> : SuperOuter<G>.SuperInner<H>()
+}
+
+fun bare(x: SuperOuter<*>.SuperInner<*>, y: Any?) {
+    if (x is SuperOuter.SuperInner) return
+    if (y is SuperOuter.SuperInner) {
+        return
+    }
+}
@@ -0,0 +1,5 @@
+class Outer<E : Any> {
+    inner class Inner<F, G>
+}
+
+val x: Outer<String?>.Inner<String, Int> = null!!
@@ -0,0 +1,22 @@
+// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+open class Outer<E> {
+    inner class Inner<F>
+
+}
+
+class Derived : Outer<String>() {
+    // Inner<Int> here means Outer<String>.Inner<Int>
+    fun foo(x: Inner<Int>) {}
+}
+
+class A {
+    companion object : Outer<String>()
+
+    // Does not work, could be Outer<String>.Inner<Int>
+    // TODO: Should work?
+    fun foo(x: Inner<Int>) {
+        // Inner<Char>() call use companion as implicit receiver
+        val y: Outer<String>.Inner<Char> = Inner<Char>()
+    }
+}
@@ -0,0 +1,22 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+open class Outer<E> {
+    inner class Inner<F>
+
+}
+
+class Derived : Outer<String>() {
+    // Inner<Int> here means Outer<String>.Inner<Int>
+    fun foo(x: Inner<Int>) {}
+}
+
+class A {
+    companion object : Outer<String>()
+
+    // Does not work, could be Outer<String>.Inner<Int>
+    // TODO: Should work?
+    fun foo(x: Inner<Int>) {
+        // Inner<Char>() call use companion as implicit receiver
+        val y: Outer<String>.Inner<Char> = Inner<Char>()
+    }
+}
@@ -0,0 +1,15 @@
+class A<T> {
+    fun foo() {
+        val q = object {
+            open inner class B
+            inner class C : B()
+
+            // No WRONG_NUMBER_OF_TYPE_ARGUMENTS should be reported on these types
+            val x: B = B()
+            val y: C = C()
+        }
+
+        q.x
+        q.y
+    }
+}
@@ -0,0 +1,26 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -TOPLEVEL_TYPEALIASES_ONLY
+// !CHECK_TYPE
+open class Outer<X, Y> {
+    inner class Inner<Z>
+    typealias Alias<W> = Map<W, X>
+}
+
+class Derived : Outer<String, Int>() {
+    fun foo(): Inner<Char> = null!!
+    fun baz(): Alias<Char> = null!!
+}
+
+
+class A : Outer<Double, Short>() {
+    class B : Outer<Float, Long>() {
+        fun bar(): Inner<String> = null!!
+        fun x(): Alias<String> = null!!
+    }
+}
+
+fun foo() {
+    Derived().foo() checkType { <!UNRESOLVED_REFERENCE!>_<!><Outer<String, Int>.Inner<Char>>() }
+    Derived().baz() checkType { <!UNRESOLVED_REFERENCE!>_<!><Map<Char, String>>() }
+    A.B().bar() checkType { <!UNRESOLVED_REFERENCE!>_<!><Outer<Float, Long>.Inner<String>>() }
+    A.B().x() checkType { <!UNRESOLVED_REFERENCE!>_<!><Map<String, Float>>() }
+}
@@ -0,0 +1,55 @@
+// !WITH_NEW_INFERENCE
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_VALUE -VARIABLE_WITH_REDUNDANT_INITIALIZER -TOPLEVEL_TYPEALIASES_ONLY
+
+class A<R1, R2, R3, R4>
+
+private fun <E> foobar() = {
+    open class LocalOuter<X, Y> {
+        inner class LocalInner<Z> {
+            fun a() = A<E, X, Y, Z>()
+        }
+
+        typealias LocalAlias<W> = A<E, X, Y, W>
+    }
+
+    class Derived : LocalOuter<Double, Short>() {
+        fun foo(): LocalInner<Long> = null!!
+        fun bar(): LocalAlias<Char> = null!!
+    }
+
+    Derived()
+}
+
+private fun noParameters() = {
+    open class LocalOuter2<X, Y> {
+        inner class LocalInner2<Z> {
+            fun a() = A<Any, X, Y, Z>()
+        }
+
+        typealias LocalAlias2<W> = A<Any, X, Y, W>
+    }
+
+    class Derived2 : LocalOuter2<Double, Short>() {
+        fun foo(): LocalInner2<Long> = null!!
+        fun bar(): LocalAlias2<Char> = null!!
+    }
+
+    Derived2()
+}
+
+fun test() {
+    var x = foobar<String>()
+    x = foobar<String>()
+
+    x().foo().a() checkType { <!UNRESOLVED_REFERENCE!>_<!><A<String, Double, Short, Long>>() }
+    x().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><A<String, Double, Short, Char>>() }
+
+    x = foobar<Int>()
+
+    var y = noParameters()
+    y = noParameters()
+
+    y().foo().a() checkType { <!UNRESOLVED_REFERENCE!>_<!><A<Any, Double, Short, Long>>() }
+    y().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><A<Any, Double, Short, Char>>() }
+}
@@ -0,0 +1,59 @@
+// !WITH_NEW_INFERENCE
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_VALUE -VARIABLE_WITH_REDUNDANT_INITIALIZER -TOPLEVEL_TYPEALIASES_ONLY
+
+class A<R1, R2, R3, R4, R5, R6>
+
+class Outer<T> {
+    inner class Inner<F> {
+        private fun <E> foobar() = {
+            open class LocalOuter<X, Y> {
+                inner class LocalInner<Z> {
+                    fun a() = A<T, F, E, X, Y, Z>()
+                }
+
+                typealias LocalAlias<W> = A<T, F, E, X, Y, W>
+            }
+
+            class Derived : LocalOuter<Double, Short>() {
+                fun foo(): LocalInner<Long> = null!!
+                fun bar(): LocalAlias<Char> = null!!
+            }
+
+            Derived()
+        }
+
+        private fun noParameters() = {
+            open class LocalOuter2<X, Y> {
+                inner class LocalInner2<Z> {
+                    fun a() = A<T, F, Any, X, Y, Z>()
+                }
+
+                typealias LocalAlias2<W> = A<T, F, Any, X, Y, W>
+            }
+
+            class Derived2 : LocalOuter2<Double, Short>() {
+                fun foo(): LocalInner2<Long> = null!!
+                fun bar(): LocalAlias2<Char> = null!!
+            }
+            Derived2()
+        }
+
+        fun test(z: Outer<String>.Inner<F>) {
+            var x = foobar<String>()
+            x = foobar<String>()
+
+            x().foo().a() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, String, Double, Short, Long>>() }
+            x().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, String, Double, Short, Char>>() }
+
+            x = foobar<Int>()
+            x = z.foobar<String>()
+
+            var y = noParameters()
+            y = noParameters()
+
+            y().foo().a() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, Any, Double, Short, Long>>() }
+            y().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, Any, Double, Short, Char>>() }
+        }
+    }
+}
@@ -0,0 +1,19 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -TOPLEVEL_TYPEALIASES_ONLY
+// !CHECK_TYPE
+open class Outer<X, Y> {
+    inner class Inner<Z>
+    typealias Alias<W> = Map<W, X>
+}
+
+open class BaseDerived1<E, F> : Outer<F, E>()
+open class BaseDerived2<X> : BaseDerived1<String, X>()
+
+class Derived : BaseDerived2<Int>() {
+    fun foo(): Inner<Char> = null!!
+    fun baz(): Alias<Char> = null!!
+}
+
+fun foo() {
+    Derived().foo() checkType { <!UNRESOLVED_REFERENCE!>_<!><Outer<Int, String>.Inner<Char>>() }
+    Derived().baz() checkType { <!UNRESOLVED_REFERENCE!>_<!><Map<Char, Int>>() }
+}
@@ -0,0 +1,7 @@
+interface Inv<X>
+class Outer<E> {
+    inner class Inner
+
+    class Nested : Inv<Inner>
+    object Obj : Inv<Inner>
+}
@@ -0,0 +1,18 @@
+// !CHECK_TYPE
+open class Outer<E> {
+    inner open class Inner<F> {
+        inner class Inner2<D> {
+
+        }
+    }
+}
+
+class DerivedOuter : Outer<String>() {
+    inner class DerivedInner : Inner<Int>() {
+        fun foo(): Inner2<Char> = null!!
+    }
+}
+
+fun foo() {
+    DerivedOuter().DerivedInner().foo() checkType { <!UNRESOLVED_REFERENCE!>_<!><Outer<String>.Inner<Int>.Inner2<Char>>() }
+}
@@ -0,0 +1,20 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+import Outer.Inner
+
+
+class Outer<E> {
+    inner class Inner
+
+    fun foo() {
+        class E
+        val x: Inner = Inner()
+    }
+
+    class Nested {
+        fun bar(x: Inner) {}
+    }
+}
+
+class E
+
+fun bar(x: Inner) {}
@@ -0,0 +1,9 @@
+open class Super<T> {
+    inner open class Inner {
+    }
+}
+
+class Sub : Super<String>() {
+    // TODO: it would be nice to have a possibility to omit explicit type argument in supertype
+    inner class SubInner : Super<String>.Inner() {}
+}
@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+open class Super<T> {
+    inner open class Inner {
+    }
+}
+
+class Sub : Super<String>() {
+    inner class SubInner : Super<String>.Inner {
+        constructor()
+        constructor(x: Int) : super() {}
+    }
+}
@@ -0,0 +1,42 @@
+// !WITH_NEW_INFERENCE
+// !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 { <!INAPPLICABLE_CANDIDATE!>_<!><Inner<String>>() }
+    }
+}
+
+fun factoryString(): Outer<String>.Inner<String> = null!!
+
+fun <T, Y> infer(x: T, y: Y): Outer<T>.Inner<Y> = null!!
+val inferred = infer("", 1)
+
+fun main() {
+    val outer = Outer<String>()
+
+    checkSubtype<Outer<String>.Inner<String>>(outer.bar())
+    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Outer<String>.Inner<Int>>(outer.Inner<Int>())
+    checkSubtype<Outer<*>.Inner<*>>(outer.bar())
+    checkSubtype<Outer<*>.Inner<*>>(outer.Inner<Int>())
+
+    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Outer<CharSequence>.Inner<CharSequence>>(outer.bar())
+    checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(outer.Inner())
+
+    outer.set(outer.bar())
+    outer.set(outer.Inner())
+
+    val x: Outer<String>.Inner<String> = factoryString()
+    outer.set(x)
+}
@@ -0,0 +1,32 @@
+// !WITH_NEW_INFERENCE
+// !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) {
+            x.prop.checkType { _<E>() }
+        }
+
+        if (y is Inner) return
+
+        if (z is Inner) {
+            z.prop.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
+            return
+        }
+
+        if (y is Outer<*>.Inner<*>) {
+            y.prop.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
+        }
+    }
+
+    fun bar(x: InnerBase<String>, y: Any?, z: Outer<*>.InnerBase<String>) {
+        x as Inner
+        y as Inner
+        z as Inner
+    }
+}
@@ -0,0 +1,14 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class Outer<out E, in F> {
+    inner class Inner {
+        fun unsafe1(x: E) {}
+        fun unsafe2(x: Collection<E?>) {}
+        fun unsafe3(): F? = null
+        fun unsafe4(): Collection<F>? = null
+    }
+
+    // Should be errors
+    // Refinement of variance checker is needed
+    fun foo(x: Inner) {}
+    fun bar(): Inner? = null
+}
@@ -0,0 +1,37 @@
+// !WITH_NEW_INFERENCE
+// !CHECK_TYPE
+// !DIAGNOSTICS: -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_VARIABLE
+// JAVAC_EXPECTED_FILE
+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 = A<Int>().iterator()
+
+    val csIt: Iterator<CharSequence> = A<String>().iterator()
+
+    commonSupertype(A<String>().iterator(), A<Int>().iterator()).checkType { _<A<out Any>.MyIt>() }
+}
@@ -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 { <!INAPPLICABLE_CANDIDATE!>_<!><Outer<String>.Inner<String>>() }
+
+    val strInt: Outer<String>.Inner<Int> = outerStr.Inner()
+
+    strInt.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    strInt.bar().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    strInt.outer().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Outer<String>>() }
+}
@@ -0,0 +1,35 @@
+// !CHECK_TYPE
+// FILE: BaseOuter.java
+// See KT-10285
+public class BaseOuter<H> {
+    abstract public class BaseInner<E, F> {
+        public H foo1() {
+            return null;
+        }
+
+        public E foo2() {
+            return null;
+        }
+
+        public F foo3() {
+            return null;
+        }
+    }
+}
+
+// FILE: Outer.java
+public class Outer<H> extends BaseOuter<H> {
+    public BaseInner<Double, String> bar() { return null; }
+    public class Inner extends BaseOuter<H>.BaseInner<Double, String> {}
+}
+
+// FILE: main.kt
+fun foo(x1: Outer<Int>, x2: Outer<Int>.Inner) {
+    x1.bar().foo1().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    x1.bar().foo2().checkType { _<Double>() }
+    x1.bar().foo3().checkType { _<String>() }
+
+    x2.foo1().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    x2.foo2().checkType { _<Double>() }
+    x2.foo3().checkType { _<String>() }
+}
@@ -0,0 +1,18 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+open class Super<T> {
+    inner open class Inner {
+        open fun getOuter(): Super<T> = throw UnsupportedOperationException()
+    }
+}
+
+class Sub<T1>(): Super<T1>() {
+    inner class SubInner : Super<T1>.Inner() { // 'Inner' is unresolved
+        // Also, T1 is not resolved to anything, and not marked as resolved
+        init {
+            val x: Super<T1>.Inner = this // T1 is not resolved to anything
+        }
+
+        override fun getOuter(): Sub<T1> = throw UnsupportedOperationException()
+    }
+}
@@ -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()
+}
@@ -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>().<!UNRESOLVED_REFERENCE!>foo<!>(1.0, true) // type mismatch on 1.0
+}
@@ -0,0 +1,23 @@
+import A.B.D
+import A.B.C
+import A.B.D.Innermost
+
+class A<T> {
+    inner class B<F> {
+        inner class C<E>
+        inner class D {
+            inner class Innermost<X>
+        }
+    }
+
+    class Nested {
+        val x: B<String>? = null
+        val y: B<String>.C<String>? = null
+        val z: B<String>.D? = null
+
+        val c: C<Int>? = null
+        val d: D? = null
+
+        val innerMost: Innermost<String>? = null
+    }
+}
@@ -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 { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+}
@@ -0,0 +1,24 @@
+// !WITH_NEW_INFERENCE
+// !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: Outer.Inner, z: Inner) {
+        var inner = Inner()
+        x.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Inner>() }
+        x.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Outer<String>.Inner>() }
+        z.checkType { _<Inner>() }
+        z.checkType { _<Outer<T>.Inner>() }
+
+        inner = x
+    }
+
+    class Nested
+    fun bar(x: Outer.Nested) {
+        var nested = Nested()
+        nested = x
+
+        x.checkType { _<Nested>() }
+    }
+}
@@ -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(): Q<A>.W<B, C, D>.R.M = null!!
+
+fun error1(): Outer<A>.Inner<B>.Inner3<C, D> = null!!
+fun error2(): Outer<A>.Inner<B, C, D>.Inner2 = null!!
+fun error3(): Outer.Inner<A, B>.Inner3<C> = null!!
+
+fun error4(): Outer<A>.Nested<B>.Inner4<C> = null!!
+fun error5(): Outer<A>.Obj.Nested2<B>.Inner5<C> = null!!
+fun error6(): Outer.Obj<A>.Nested2<B>.Inner5<C> = null!!
+
+fun error7(): test<String>.Outer.Obj.Nested2<A>.Inner5<B> = null!!
@@ -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 inferred = 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)
+}
@@ -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 inferred = 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(x)
+    val y: Outer<CharSequence>.Inner = infer<CharSequence>("")
+    outer.set(y)
+
+    outer.set(infer<Any>(""))
+}
@@ -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 inferred = 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)
+}
@@ -0,0 +1,37 @@
+// !WITH_NEW_INFERENCE
+// !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 inferred = 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())
+
+    outer.set(outer.bar())
+    outer.set(outer.Inner())
+
+    val x: Outer<String>.Inner = factoryString()
+    outer.set(x)
+}
@@ -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())
+
+            <!INAPPLICABLE_CANDIDATE!>bar<!>(topLevel().Inner<E>().baz(), topLevel().Inner<E>().baz())
+            <!INAPPLICABLE_CANDIDATE!>bar<!>(topLevel().Inner<E>().foo(), 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 { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    strInt.baz().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+
+    strInt.instance().<!INAPPLICABLE_CANDIDATE!>setE<!>("")
+    strInt.instance().outerE().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+
+    strInt.instance().Inner<Double>().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Outer<String>.Inner<Double>>() }
+
+    Outer<String>().<!INAPPLICABLE_CANDIDATE!>setInner<!>(strInt)
+    Outer<CharSequence>().<!INAPPLICABLE_CANDIDATE!>setInner<!>(strInt)
+}