[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,10 @@
+package test
+
+class B {
+    class B {
+      fun foo(b: B.C) {
+      }
+      class C {
+      }
+    }
+}
@@ -0,0 +1,64 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+// FILE: A.java
+
+public class A {
+    static class NC {}
+    class IC {}
+    static interface NI {}
+}
+
+// FILE: I.java
+
+public interface I {
+    class NC {}
+    interface NI {}
+}
+
+// FILE: B.java
+
+public class B extends A {
+
+}
+
+// FILE: C.java
+
+public class C implements I {
+
+}
+
+// FILE: D.java
+
+public class D extends A implements I {
+
+}
+
+// FILE: K.kt
+
+class K : D()
+
+// FILE: test.kt
+
+fun test() {
+    val ac: A.NC = A.NC()
+    val aic: A.IC = A().IC()
+    val ai: A.NI? = null
+
+    val ic: I.NC = I.NC()
+    val ii: I.NI? = null
+
+    val bc: B.NC = B.NC()
+    val bic: B.IC = B().IC()
+    val bi: B.NI? = null
+
+    val cc: C.NC = C.NC()
+    val ci: C.NI? = null
+
+    val dc: D.NC = D.NC()
+    val dic: D.IC = D().IC()
+    val di: D.NI? = null
+
+    val kc: K.NC = K.NC()
+    val kic: K.IC = K().IC()
+    val ki: K.NI? = null
+}
@@ -0,0 +1,44 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+open class A {
+    class NC {}
+    inner class IC {}
+    interface NI {}
+}
+
+interface I {
+    class NC {}
+    interface NI {}
+}
+
+class B : A() {
+
+}
+
+class C : I {
+
+}
+
+class D : A(), I {
+
+}
+
+fun test() {
+    val ac: A.NC = A.NC()
+    val aic: A.IC = A().IC()
+    val ai: A.NI? = null
+
+    val ic: I.NC = I.NC()
+    val ii: I.NI? = null
+
+    val bc: B.NC = B.NC()
+    val bic: B.IC = B().IC()
+    val bi: B.NI? = null
+
+    val cc: C.NC = C.NC()
+    val ci: C.NI? = null
+
+    val dc: D.NC = D.NC()
+    val dic: D.IC = D().IC()
+    val di: D.NI? = null
+}
@@ -0,0 +1,5 @@
+class Outer {
+    inner class Inner {
+        annotation class TestNestedAnnotation
+    }
+}
@@ -0,0 +1,11 @@
+class Test {
+    @`InnerAnnotation` @InnerAnnotation
+    companion object : StaticClass(), InnerClass() {
+
+    }
+
+    annotation class InnerAnnotation
+    open class StaticClass
+
+    open inner class InnerClass
+}
@@ -0,0 +1,32 @@
+class Outer1 {
+    class Nested
+
+    class C1 { val b = Nested() }
+    class C2(val b: Any = Nested())
+    inner class C3 { val b = Nested() }
+    inner class C4(val b: Any = Nested())
+
+    inner class Inner
+
+    class C5 { val b = Inner() }
+    class C6(val b: Any = Inner())
+    inner class C7 { val b = Inner() }
+    inner class C8(val b: Any = Inner())
+}
+
+
+class Outer2 {
+    class Nested {
+        fun foo() = Outer2()
+        fun bar() = Inner()
+    }
+    inner class Inner {
+        fun foo() = Outer2()
+        fun bar() = Nested()
+    }
+
+    fun foo() {
+        Nested()
+        Inner()
+    }
+}
@@ -0,0 +1,14 @@
+interface P<U, Y>
+
+class A<T> {
+    class B {
+        fun test() {
+            class C<W>() : P<W, T> {
+                companion object : P<W, T> {
+                }
+
+                inner class D : P<W, T>
+            }
+        }
+    }
+}
@@ -0,0 +1,12 @@
+enum class E {
+    E1 {
+        override fun foo() = <!UNRESOLVED_REFERENCE!>outerFun<!>() + super.<!UNRESOLVED_REFERENCE!>outerFun<!>()
+    },
+    E2 {
+        override fun foo() = E1.foo()
+    };
+    
+    abstract fun foo(): Int
+    
+    fun outerFun() = 42
+}
@@ -0,0 +1,5 @@
+class Outer {
+    inner class Inner {
+        enum class TestNestedEnum
+    }
+}
@@ -0,0 +1,28 @@
+class Outer {
+    class Nested
+    inner class Inner
+    
+    fun Inner.foo() {
+        Outer()
+        Nested()
+        Inner()
+    }
+    
+    fun Nested.bar() {
+        Outer()
+        Nested()
+        Inner()
+    }
+    
+    fun Outer.baz() {
+        Outer()
+        Nested()
+        Inner()
+    }
+}
+
+fun Outer.foo() {
+    Outer()
+    Nested()
+    Inner()
+}
@@ -0,0 +1,27 @@
+package f
+
+object A {
+    class LoginFormPage() : Request({
+        val failed = <!UNRESOLVED_REFERENCE!>session<!>.<!UNRESOLVED_REFERENCE!>get<!>("LOGIN_FAILED")
+    })
+}
+
+class B {
+    companion object {
+        class LoginFormPage() : Request({
+            val failed = <!UNRESOLVED_REFERENCE!>session<!>.<!UNRESOLVED_REFERENCE!>get<!>("LOGIN_FAILED")
+        })
+    }
+
+    class C {
+        class LoginFormPage() : Request({
+            val failed = <!UNRESOLVED_REFERENCE!>session<!>.<!UNRESOLVED_REFERENCE!>get<!>("LOGIN_FAILED")
+        })
+    }
+}
+
+open class Request(private val handler: ActionContext.() -> Unit) {}
+
+interface ActionContext {
+    val session : Map<String, String>
+}
@@ -0,0 +1,45 @@
+// !LANGUAGE: -InnerClassInEnumEntryClass
+inner fun foo() {}
+inner val prop = 42
+
+inner class A
+inner interface B
+inner object C
+
+class D {
+    inner class E
+    inner interface F
+    inner object G
+    inner enum class R
+    inner annotation class S
+    inner companion object
+}
+
+enum class H {
+    I0 {
+        inner class II0
+    },
+    inner I {
+        inner class II
+    };
+    
+    inner class J
+}
+
+interface K {
+    inner class L
+}
+
+object N {
+    inner class O
+}
+
+class P {
+    companion object {
+        inner class Q
+    }
+}
+
+val R = object {
+    inner class S
+}
@@ -0,0 +1,45 @@
+// !LANGUAGE: +InnerClassInEnumEntryClass
+inner fun foo() {}
+inner val prop = 42
+
+inner class A
+inner interface B
+inner object C
+
+class D {
+    inner class E
+    inner interface F
+    inner object G
+    inner enum class R
+    inner annotation class S
+    inner companion object
+}
+
+enum class H {
+    I0 {
+        inner class II0
+    },
+    inner I {
+        inner class II
+    };
+    
+    inner class J
+}
+
+interface K {
+    inner class L
+}
+
+object N {
+    inner class O
+}
+
+class P {
+    companion object {
+        inner class Q
+    }
+}
+
+val R = object {
+    inner class S
+}
@@ -0,0 +1,13 @@
+// !LANGUAGE: +InnerClassInEnumEntryClass
+
+enum class A {
+    X {
+        val x = 1
+        fun foo() {}
+
+        inner class Inner {
+            val y = x
+            fun bar() = foo()
+        }
+    }
+}
@@ -0,0 +1,19 @@
+// !LANGUAGE: -InnerClassInEnumEntryClass -NestedClassesInEnumEntryShouldBeInner
+
+enum class Enum {
+    ENTRY_WITH_CLASS {
+        inner class TestInner
+
+        class TestNested
+
+        interface TestInterface
+
+        object TestObject
+
+        enum class TestEnumClass {
+            OTHER_ENTRY
+        }
+
+        companion object {}
+    }
+}
@@ -0,0 +1,19 @@
+// !LANGUAGE: +InnerClassInEnumEntryClass -NestedClassesInEnumEntryShouldBeInner
+
+enum class Enum {
+    ENTRY_WITH_CLASS {
+        inner class TestInner
+
+        class TestNested
+
+        interface TestInterface
+
+        object TestObject
+
+        enum class TestEnumClass {
+            OTHER_ENTRY
+        }
+
+        companion object {}
+    }
+}
@@ -0,0 +1,19 @@
+// !LANGUAGE: +InnerClassInEnumEntryClass +NestedClassesInEnumEntryShouldBeInner
+
+enum class Enum {
+    ENTRY_WITH_CLASS {
+        inner class TestInner
+
+        class TestNested
+
+        interface TestInterface
+
+        object TestObject
+
+        enum class TestEnumClass {
+            OTHER_ENTRY
+        }
+
+        companion object {}
+    }
+}
@@ -0,0 +1,11 @@
+class Test {
+    companion object {
+        fun test(t: TestInner) = 42
+    }
+
+    class TestStatic {
+        fun test(t: TestInner) = 42
+    }
+
+    inner class TestInner
+}
@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// SKIP_TXT
+// FILE: Outer.kt
+package abc
+class Outer {
+    inner class Inner() {
+        constructor(x: Int) : this() {}
+    }
+
+    companion object {
+
+        fun baz() {
+            Inner()
+            Inner(1)
+        }
+    }
+}
+
+fun foo() {
+    Outer.<!UNRESOLVED_REFERENCE!>Inner<!>()
+    Outer.<!UNRESOLVED_REFERENCE!>Inner<!>(1)
+}
+
+// FILE: imported.kt
+import abc.Outer
+import abc.Outer.Inner
+
+fun bar() {
+    Inner()
+    Inner(1)
+
+    with(Outer()) {
+        Inner()
+        Inner(1)
+    }
+}
@@ -0,0 +1,43 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// SKIP_TXT
+// FILE: Outer.kt
+package abc
+class Outer {
+    inner class Inner() {
+        constructor(x: Int) : this() {}
+    }
+
+    companion object {
+        fun Inner(x: String) {}
+
+        fun baz() {
+            // Diagnostic here could be better (why can't I call the constructor above?)
+            Inner()
+            Inner(1)
+            Inner("")
+        }
+    }
+}
+
+fun foo() {
+    Outer.<!INAPPLICABLE_CANDIDATE!>Inner<!>()
+    Outer.<!INAPPLICABLE_CANDIDATE!>Inner<!>(1)
+    Outer.Inner("")
+}
+
+// FILE: imported.kt
+import abc.Outer
+import abc.Outer.Inner
+import abc.Outer.Companion.Inner
+
+fun bar() {
+    Inner()
+    Inner(1)
+    Inner("")
+
+    with(Outer()) {
+        Inner()
+        Inner(1)
+        Inner("")
+    }
+}
@@ -0,0 +1,26 @@
+open class SomeClass<T>
+class TestSome<P> {
+    companion object : SomeClass<P>() {
+    }
+}
+
+class Test {
+    companion object : InnerClass() {
+        val a = object: InnerClass() {
+        }
+
+        fun more(): InnerClass {
+            val b = InnerClass()
+
+            val testVal = <!UNRESOLVED_REFERENCE!>inClass<!>
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+
+            return b
+        }
+    }
+
+    val inClass = 12
+    fun foo() {}
+
+    open inner class InnerClass
+}
@@ -0,0 +1,27 @@
+open class SomeClass<T>
+class TestSome<P> {
+    object Some : SomeClass<P>() {
+    }
+}
+
+class Test {
+    object Some : InnerClass() {
+        val a = object: InnerClass() {
+        }
+
+        fun more(): InnerClass {
+            val b = InnerClass()
+
+            val testVal = <!UNRESOLVED_REFERENCE!>inClass<!>
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+
+            return b
+        }
+    }
+
+    val inClass = 12
+    fun foo() {
+    }
+
+    open inner class InnerClass
+}
@@ -0,0 +1,22 @@
+// NI_EXPECTED_FILE
+
+interface Trait {
+    fun bar() = 42
+}
+
+class Outer : Trait {
+    class Nested {
+        val t = this@Outer.bar()
+        val s = super@Outer.<!UNRESOLVED_REFERENCE!>bar<!>()
+        
+        inner class NestedInner {
+            val t = this@Outer.bar()
+            val s = super@Outer.<!UNRESOLVED_REFERENCE!>bar<!>()
+        }
+    }
+    
+    inner class Inner {
+        val t = this@Outer.bar()
+        val s = super@Outer.<!UNRESOLVED_REFERENCE!>bar<!>()
+    }
+}
@@ -0,0 +1,5 @@
+class Outer {
+    inner class Inner {
+        interface TestNestedInterface
+    }
+}
@@ -0,0 +1,11 @@
+//KT-5854 Incorrect 'Nested class should be qualified'
+
+class A {
+    class Nested {
+
+    }
+
+    fun foo() {
+        <!INAPPLICABLE_CANDIDATE!>Nested<!>(1) //two errors here, the first one is wrong
+    }
+}
@@ -0,0 +1,8 @@
+// KT-6026 Exception on instantiating a nested class in an anonymous object
+
+val oo = object {
+    // Forbidden in KT-13510
+    class Nested
+
+    fun f1() = <!UNRESOLVED_REFERENCE!>Nested<!>(11)
+}
@@ -0,0 +1,18 @@
+class Outer {
+    fun foo(): Int {
+        if (outerState > 0) return outerState
+        
+        class Local {
+            val localState = <!UNRESOLVED_REFERENCE!>outerState<!>
+            
+            inner class LocalInner {
+                val o = <!UNRESOLVED_REFERENCE!>outerState<!>
+                val l = localState
+            }
+        }
+        
+        return Local().localState
+    }
+    
+    val outerState = 42
+}
@@ -0,0 +1,11 @@
+class Outer {
+    class Nested {
+        fun foo() {
+            class Local {
+                val state = <!UNRESOLVED_REFERENCE!>outerState<!>
+            }
+        }
+    }
+    
+    val outerState = 42
+}
@@ -0,0 +1,23 @@
+interface Trait {
+    fun bar() = 42
+}
+
+class Outer : Trait {
+    fun foo() {
+        val t = this@Outer
+        val s = super@Outer.bar()
+        
+        class Local : Trait {
+            val t = this@Outer
+            val s = super@Outer.bar()
+            
+            inner class Inner {
+                val t = this@Local
+                val s = super@Local.<!UNRESOLVED_REFERENCE!>bar<!>()
+                
+                val tt = this@Outer
+                val ss = super@Outer.<!UNRESOLVED_REFERENCE!>bar<!>()
+            }
+        }
+    }
+}
@@ -0,0 +1,17 @@
+class Outer {
+    open class OpenNested
+    class FinalNested
+    
+    open inner class OpenInner
+    class FinalInner
+
+    class Nested1 : OpenNested()
+    class Nested2 : FinalNested()
+    class Nested3 : OpenInner()
+    class Nested4 : FinalInner()
+
+    inner class Inner1 : OpenNested()
+    inner class Inner2 : FinalNested()
+    inner class Inner3 : OpenInner()
+    inner class Inner4 : FinalInner()
+}
@@ -0,0 +1,53 @@
+interface N { fun foo() = 1 }
+
+class WithClassObject {
+    companion object {}
+
+    class Nested()
+    class NestedWithClassObject { companion object : N }
+    enum class NestedEnum { A }
+    object NestedObj : N { operator fun invoke() = 1 }
+}
+
+class WithoutClassObject {
+    class Nested()
+    class NestedWithClassObject { companion object : N }
+    enum class NestedEnum { A }
+    object NestedObj : N { operator fun invoke() = 1 }
+}
+
+object Obj {
+    class Nested()
+    class NestedWithClassObject { companion object : N }
+    enum class NestedEnum { A }
+    object NestedObj : N { operator fun invoke() = 1 }
+}
+
+fun test(with: WithClassObject, without: WithoutClassObject, obj: Obj) {
+    with.Nested()
+    with.NestedWithClassObject
+    with.NestedWithClassObject()
+    with.NestedWithClassObject.foo()
+    with.NestedEnum.A
+    with.NestedObj
+    with.<!INAPPLICABLE_CANDIDATE!>NestedObj<!>()
+    with.NestedObj.foo()
+
+    without.Nested()
+    without.NestedWithClassObject
+    without.NestedWithClassObject()
+    without.NestedWithClassObject.foo()
+    without.NestedEnum.A
+    without.NestedObj
+    without.<!INAPPLICABLE_CANDIDATE!>NestedObj<!>()
+    without.NestedObj.foo()
+
+    obj.Nested()
+    obj.NestedWithClassObject
+    obj.NestedWithClassObject()
+    obj.NestedWithClassObject.foo()
+    obj.NestedEnum.A
+    obj.NestedObj
+    obj.<!INAPPLICABLE_CANDIDATE!>NestedObj<!>()
+    obj.NestedObj.foo()
+}
@@ -0,0 +1,8 @@
+open class Outer {
+    class Nested : Outer() {
+        fun bar() = foo()
+        fun baz() = super.foo()
+    }
+    
+    fun foo() = 42
+}
@@ -0,0 +1,12 @@
+open class Outer<T> {
+    class Nested<U> : Outer<U>() {
+        fun bar(): U = foo()
+        fun baz(): U = super.foo()
+    }
+    class Nested2 : Outer<String>() {
+        fun bar(): String = foo()
+        fun baz(): String = super.foo()
+    }
+    
+    fun foo(): T = null!!
+}
@@ -0,0 +1,16 @@
+object Object {
+    class NestedClass {
+        fun test() {
+            outerFun()
+            outerVal
+            OuterObject
+            OuterClass()
+        }
+    }
+
+    fun outerFun() {}
+    val outerVal = 4
+
+    object OuterObject
+    class OuterClass
+}
@@ -0,0 +1,26 @@
+// !LANGUAGE: +NestedClassesInEnumEntryShouldBeInner
+
+class A {
+    inner class B {
+        class C
+    }
+    
+    fun foo() {
+        class B {
+            class C
+        }
+    }
+}
+
+fun foo() {
+    class B {
+        class C
+    }
+}
+
+
+enum class E {
+    E1 {
+        class D
+    }
+}
@@ -0,0 +1,26 @@
+// !LANGUAGE: -NestedClassesInEnumEntryShouldBeInner
+
+class A {
+    inner class B {
+        class C
+    }
+    
+    fun foo() {
+        class B {
+            class C
+        }
+    }
+}
+
+fun foo() {
+    class B {
+        class C
+    }
+}
+
+
+enum class E {
+    E1 {
+        class D
+    }
+}
@@ -0,0 +1,12 @@
+// SKIP_TXT
+class Outer {
+    inner class Inner1 {
+        object Obj1
+
+        companion object Obj2
+
+        inner class Inner2 {
+            object Obj3
+        }
+    }
+}
@@ -0,0 +1,27 @@
+// NI_EXPECTED_FILE
+
+class Outer {
+    fun function() = 42
+    val property = ""
+    
+    class Nested {
+        fun f() = <!UNRESOLVED_REFERENCE!>function<!>()
+        fun g() = <!UNRESOLVED_REFERENCE!>property<!>
+        fun h() = this@Outer.function()
+        fun i() = this@Outer.property
+    }
+    
+    inner class Inner {
+        fun innerFun() = function()
+        val innerProp = property
+        fun innerThisFun() = this@Outer.function()
+        val innerThisProp = this@Outer.property
+        
+        inner class InnerInner {
+            fun f() = innerFun()
+            fun g() = innerProp
+            fun h() = this@Inner.innerFun()
+            fun i() = this@Inner.innerProp
+        }
+    }
+}
@@ -0,0 +1,13 @@
+class Outer<T> {
+    class Nested {
+        fun foo(t: T) = t
+    }
+    
+    class Nested2<T> {
+        fun foo(t: T) = t
+    }
+    
+    inner class Inner {
+        fun foo(t: T) = t
+    }
+}
@@ -0,0 +1,13 @@
+// KT-2100
+
+interface I {
+    val x : String
+}
+
+class Foo {
+    protected val x : String = ""
+
+    inner class Inner : I {
+        override val x : String = this@Foo.x
+    }
+}
@@ -0,0 +1,9 @@
+open class Base {
+    fun foo() {}
+}
+
+class Derived : Base() {
+    class Nested {
+        fun bar() = <!UNRESOLVED_REFERENCE!>foo<!>()
+    }
+}
@@ -0,0 +1,14 @@
+class Outer {
+    class Nested {
+        companion object {
+            fun foo() = 42
+        }
+    }
+    
+    companion object {
+        fun bar() = 239
+    }
+}
+
+fun foo() = Outer.Nested.foo()
+fun bar() = Outer.bar()
@@ -0,0 +1,17 @@
+class Outer {
+    class Nested {
+        class NestedNested
+    }
+
+    inner class Inner {
+        inner class InnerInner
+    }
+}
+
+fun f1() = Outer()
+fun f2() = Outer.Nested()
+fun f3() = Outer.Nested.NestedNested()
+fun f4() = Outer.<!UNRESOLVED_REFERENCE!>Inner<!>()
+fun f5() = Outer.Inner.<!UNRESOLVED_REFERENCE!>InnerInner<!>()
+fun f6() = Outer().Inner()
+fun f7() = Outer().Inner().InnerInner()
@@ -0,0 +1,5 @@
+fun bar(b: Boolean) = b
+
+fun foo(data: List<String>) {
+    bar(data.contains(""))
+}
@@ -0,0 +1,7 @@
+enum class E {
+    E1,
+    E2 { };
+}
+
+fun foo() = E.E1
+fun bar() = E.E2
@@ -0,0 +1,10 @@
+// !WITH_NEW_INFERENCE
+// NI_EXPECTED_FILE
+class Outer {
+    class Nested<T>
+}
+
+fun nested() = Outer.Nested<Int>()
+fun noArguments() = Outer.Nested()
+fun noArgumentsExpectedType(): Outer.Nested<String> = Outer.Nested()
+fun manyArguments() = Outer.Nested<String, Int>()
@@ -0,0 +1,17 @@
+// FILE: a.kt
+class A {
+    class B {
+        class C
+    }
+}
+
+// FILE: b.kt
+import A.B
+import A.B.C
+
+val a = A()
+val b = B()
+val ab = A.B()
+val c = C()
+val bc = B.C()
+val abc = A.B.C()
@@ -0,0 +1,8 @@
+package A
+
+class B {
+    class C {
+    }
+}
+
+val a = A.B.C()
@@ -0,0 +1,9 @@
+class A {
+    enum class E {
+        E1,
+        E2 { };
+    }
+}
+
+fun foo() = A.E.E1
+fun bar() = A.E.E2
@@ -0,0 +1,7 @@
+object A {
+    object B {
+        object C
+    }
+}
+
+val a = A.B.C
@@ -0,0 +1,11 @@
+abstract class Outer {
+    class Nested {
+        class NestedNested
+    }
+    
+    abstract val prop1: Nested
+    abstract val prop2: Nested.NestedNested
+}
+
+fun foo(): Outer.Nested = null!!
+val bar: Outer.Nested.NestedNested = null!!
@@ -0,0 +1,30 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// KT-4351 Cannot resolve reference to self in init of class local to function
+
+fun f() {
+    class MyClass() {
+        init {
+            val x: MyClass = MyClass()
+        }
+
+        fun member() {
+            val x: MyClass = MyClass()
+        }
+    }
+
+    object MyObject {
+        init {
+            val obj: MyObject = MyObject
+        }
+    }
+
+    val x: MyClass = MyClass()
+}
+
+val closure = {
+    class MyClass {
+        init {
+            val x: MyClass = MyClass()
+        }
+    }
+}
@@ -0,0 +1,9 @@
+open class PackageTest
+
+class MoreTest() {
+    companion object: PackageTest() {
+
+    }
+
+    object Some: PackageTest()
+}
@@ -0,0 +1,9 @@
+class Test {
+    @ClassObjectAnnotation
+    @NestedAnnotation
+    companion object {
+        annotation class ClassObjectAnnotation
+    }
+
+    annotation class NestedAnnotation
+}
@@ -0,0 +1,11 @@
+// KT-1188
+
+interface Foo {
+    val b : Bar
+    val b1 : Foo.Bar
+    interface Bar {}
+}
+
+interface Foo2 : Foo {
+    val bb1 : Foo.Bar
+}
@@ -0,0 +1,34 @@
+open class Outer {
+    private class PrivateNested
+    private inner class PrivateInner
+
+    protected class ProtectedNested
+    protected inner class ProtectedInner
+
+    public class PublicNested
+    public inner class PublicInner
+}
+
+class Derived : Outer() {
+    fun foo() {
+        Outer.<!INAPPLICABLE_CANDIDATE!>PrivateNested<!>()
+        super.<!INAPPLICABLE_CANDIDATE!>PrivateInner<!>()
+
+        Outer.ProtectedNested()
+        super.ProtectedInner()
+
+        Outer.PublicNested()
+        super.PublicInner()
+    }
+}
+
+fun foo() {
+    Outer.<!INAPPLICABLE_CANDIDATE!>PrivateNested<!>()
+    Outer().<!INAPPLICABLE_CANDIDATE!>PrivateInner<!>()
+
+    Outer.<!INAPPLICABLE_CANDIDATE!>ProtectedNested<!>()
+    Outer().<!INAPPLICABLE_CANDIDATE!>ProtectedInner<!>()
+
+    Outer.PublicNested()
+    Outer().PublicInner()
+}