Inaccessible outer class member is now an error

#KT-1174 In Progress

compiler/testData/diagnostics/tests/inner/constructorAccess.kt

@@ -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 = <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>Inner()<!> }
+    class C6(val b: Any = <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>Inner()<!>)
+    inner class C7 { val b = Inner() }
+    inner class C8(val b: Any = Inner())
+}
+
+
+class Outer2 {
+    class Nested {
+        fun foo() = Outer2()
+        fun bar() = <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>Inner()<!>
+    }
+    inner class Inner {
+        fun foo() = Outer2()
+        fun bar() = Nested()
+    }
+    
+    fun foo() {
+        Nested()
+        Inner()
+    }
+}

compiler/testData/diagnostics/tests/inner/enumEntries.kt

@@ -0,0 +1,12 @@
+enum class E {
+    E1 {
+        override fun foo() = outerFun() + super.outerFun()
+    }
+    E2 {
+        override fun foo() = E1.foo()
+    }
+    
+    abstract fun foo(): Int
+    
+    fun outerFun() = 42
+}

compiler/testData/diagnostics/tests/inner/extensionFun.kt

@@ -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()
+    <!UNRESOLVED_REFERENCE!>Nested<!>()
+    Inner()
+}

compiler/testData/diagnostics/tests/inner/localClass.kt

@@ -0,0 +1,18 @@
+class Outer {
+    fun foo(): Int {
+        if (outerState > 0) return outerState
+        
+        class Local {
+            val localState = outerState
+            
+            inner class LocalInner {
+                val o = outerState
+                val l = localState
+            }
+        }
+        
+        return Local().localState
+    }
+    
+    val outerState = 42
+}

compiler/testData/diagnostics/tests/inner/localClassInsideNested.kt

@@ -0,0 +1,11 @@
+class Outer {
+    class Nested {
+        fun foo() {
+            class Local {
+                val state = <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>outerState<!>
+            }
+        }
+    }
+    
+    val outerState = 42
+}

compiler/testData/diagnostics/tests/inner/modality.kt

@@ -0,0 +1,17 @@
+class Outer {
+    open class OpenNested
+    class FinalNested
+    
+    open inner class OpenInner
+    class FinalInner
+
+    class Nested1 : OpenNested()
+    class Nested2 : <!FINAL_SUPERTYPE!>FinalNested<!>()
+    class Nested3 : <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>OpenInner()<!>
+    class Nested4 : <!FINAL_SUPERTYPE!>FinalInner<!>()
+
+    inner class Inner1 : OpenNested()
+    inner class Inner2 : <!FINAL_SUPERTYPE!>FinalNested<!>()
+    inner class Inner3 : OpenInner()
+    inner class Inner4 : <!FINAL_SUPERTYPE!>FinalInner<!>()
+}

compiler/testData/diagnostics/tests/inner/nestedClassExtendsOuter.kt

@@ -0,0 +1,8 @@
+open class Outer {
+    class Nested : Outer() {
+        fun bar() = foo()
+        fun baz() = super.foo()
+    }
+    
+    fun foo() = 42
+}

compiler/testData/diagnostics/tests/inner/nestedClassExtendsOuterGeneric.kt

@@ -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!!
+}

compiler/testData/diagnostics/tests/inner/nestedVsInnerAccessOuterMember.kt

@@ -0,0 +1,19 @@
+class Outer {
+    fun function() = 42
+    val property = ""
+    
+    class Nested {
+        fun f() = <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>function()<!>
+        fun g() = <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>property<!>
+    }
+    
+    inner class Inner {
+        fun innerFun() = function()
+        val innerProp = property
+        
+        inner class InnerInner {
+            fun f() = innerFun()
+            fun g() = innerProp
+        }
+    }
+}

compiler/testData/diagnostics/tests/inner/visibility.kt

@@ -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.<!INVISIBLE_MEMBER!>PrivateNested<!>()
+        super.<!INVISIBLE_MEMBER!>PrivateInner<!>()
+
+        Outer.ProtectedNested()
+        super.ProtectedInner()
+
+        Outer.PublicNested()
+        super.PublicInner()
+    }
+}
+
+fun foo() {
+    Outer.<!INVISIBLE_MEMBER!>PrivateNested<!>()
+    Outer().<!INVISIBLE_MEMBER!>PrivateInner<!>()
+
+    Outer.<!INVISIBLE_MEMBER!>ProtectedNested<!>()
+    Outer().<!INVISIBLE_MEMBER!>ProtectedInner<!>()
+
+    Outer.PublicNested()
+    Outer().PublicInner()
+}