Allow resolve class declarations in class objects

Use INACCESSIBLE_OUTER_CLASS_EXPRESSION error for marking already resolved elements

 #KT-3261 Fixed

compiler/testData/codegen/box/classes/classObjectsWithParentClasses.kt

@@ -0,0 +1,12 @@
+open class Test {
+    class object {
+        fun testStatic(ic: InnerClass): NotInnerClass = NotInnerClass(ic.value)
+    }
+
+    fun test(): InnerClass = InnerClass(150)
+
+    inner open class InnerClass(val value: Int)
+    open class NotInnerClass(val value: Int)
+}
+
+fun box() = if (Test.testStatic(Test().test()).value == 150) "OK" else "FAIL"

compiler/testData/diagnostics/tests/ClassObjectCannotAccessClassFields.kt

@@ -4,6 +4,6 @@ class A() {
     val x = 1
 
     class object {
-        val y = <!UNRESOLVED_REFERENCE!>x<!>
+        val y = <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>x<!>
     }
 }

compiler/testData/diagnostics/tests/callableReference/innerConstructorFromClass.kt

@@ -11,7 +11,7 @@ class A {
     
     class object {
         fun main() {
-            ::<!UNRESOLVED_REFERENCE!>Inner<!>
+            ::<!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>Inner<!>
             val y = A::Inner
 
             y : KMemberFunction0<A, A.Inner>

compiler/testData/diagnostics/tests/callableReference/nestedConstructorFromClass.kt

@@ -11,7 +11,7 @@ class A {
     
     class object {
         fun main() {
-            ::<!UNRESOLVED_REFERENCE!>Nested<!>  // KT-3261
+            ::Nested
             val y = A::Nested
 
             y : KFunction0<A.Nested>

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

@@ -0,0 +1,11 @@
+class Test {
+    [`InnerAnnotation`InnerAnnotation]
+    class object : StaticClass(), <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!><!MANY_CLASSES_IN_SUPERTYPE_LIST!>InnerClass<!>()<!> {
+
+    }
+
+    annotation class InnerAnnotation
+    open class StaticClass
+
+    open inner class InnerClass
+}

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

@@ -0,0 +1,11 @@
+class Test {
+    class object {
+        fun test(<!UNUSED_PARAMETER!>t<!>: TestInner) = 42
+    }
+
+    class TestStatic {
+        fun test(<!UNUSED_PARAMETER!>t<!>: TestInner) = 42
+    }
+
+    inner class TestInner
+}

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

@@ -0,0 +1,26 @@
+open class SomeClass<T>
+class TestSome<P> {
+    class object : SomeClass<<!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>P<!>>() {
+    }
+}
+
+class Test {
+    class object : <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>InnerClass()<!> {
+        val a = object: <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>InnerClass()<!> {
+        }
+
+        fun more(): InnerClass {
+            val b = <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>InnerClass()<!>
+
+            val <!UNUSED_VARIABLE!>testVal<!> = <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>inClass<!>
+            <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>foo()<!>
+
+            return b
+        }
+    }
+
+    val inClass = 12
+    fun foo() {}
+
+    open inner class InnerClass
+}

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

@@ -0,0 +1,27 @@
+open class SomeClass<T>
+class TestSome<P> {
+    object Some : SomeClass<<!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>P<!>>() {
+    }
+}
+
+class Test {
+    object Some : <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>InnerClass()<!> {
+        val a = object: <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>InnerClass()<!> {
+        }
+
+        fun more(): InnerClass {
+            val b = <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>InnerClass()<!>
+
+            val <!UNUSED_VARIABLE!>testVal<!> = <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>inClass<!>
+            <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>foo()<!>
+
+            return b
+        }
+    }
+
+    val inClass = 12
+    fun foo() {
+    }
+
+    open inner class InnerClass
+}

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

@@ -0,0 +1,9 @@
+open class PackageTest
+
+class MoreTest() {
+    class object: PackageTest() {
+
+    }
+
+    object Some: PackageTest()
+}

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

@@ -0,0 +1,9 @@
+class Test {
+    [ClassObjectAnnotation]
+    [NestedAnnotation]
+    class object {
+        annotation class ClassObjectAnnotation
+    }
+
+    annotation class NestedAnnotation
+}

compiler/testData/lazyResolve/namespaceComparator/classObjectAnnotation.txt

@@ -3,7 +3,7 @@ package test
 internal final class Some {
     /*primary*/ public constructor Some()
     
-    [ERROR : Unresolved annotation type]() internal class object <class-object-for-Some> {
+    test.Some.TestAnnotation() internal class object <class-object-for-Some> {
         /*primary*/ private constructor <class-object-for-Some>()
         
         internal final annotation class TestAnnotation : jet.Annotation {

compiler/testData/lazyResolve/namespaceComparator/classObjectHeader.txt

@@ -5,7 +5,7 @@ internal fun testFun(/*0*/ a: jet.Int): jet.Int
 internal final class TestSome</*0*/ P> {
     /*primary*/ public constructor TestSome</*0*/ P>()
     
-    internal class object <class-object-for-TestSome> : test.ToResolve<[ERROR : P]> {
+    internal class object <class-object-for-TestSome> : test.ToResolve<P> {
         /*primary*/ private constructor <class-object-for-TestSome>()
     }
 }

compiler/testData/lazyResolve/namespaceComparator/resolveFunctionInsideClassObject.kt

@@ -0,0 +1,9 @@
+package test
+
+class Test {
+  fun test(): Int = 12
+
+  class object {
+    val a = test() // Check if resolver will be able to infer type of a variable
+  }
+}

compiler/testData/lazyResolve/namespaceComparator/resolveFunctionInsideClassObject.txt

@@ -0,0 +1,11 @@
+package test
+
+internal final class Test {
+    /*primary*/ public constructor Test()
+    internal final fun test(): jet.Int
+    
+    internal class object <class-object-for-Test> {
+        /*primary*/ private constructor <class-object-for-Test>()
+        internal final val a: jet.Int
+    }
+}

compiler/testData/loadKotlin/classObject/InnerClassInClassObject.kt

@@ -0,0 +1,11 @@
+package test
+
+class TestFirst {
+  class object {
+    fun testing(a: InnerClass) = 45
+    fun testing(a: NotInnerClass) = 45
+  }
+
+  inner class InnerClass
+  inner class NotInnerClass
+}

compiler/testData/loadKotlin/classObject/InnerClassInClassObject.txt

@@ -0,0 +1,19 @@
+package test
+
+internal final class TestFirst {
+    /*primary*/ public constructor TestFirst()
+    
+    internal class object <class-object-for-TestFirst> {
+        /*primary*/ private constructor <class-object-for-TestFirst>()
+        internal final fun testing(/*0*/ a: test.TestFirst.InnerClass): jet.Int
+        internal final fun testing(/*0*/ a: test.TestFirst.NotInnerClass): jet.Int
+    }
+    
+    internal final inner class InnerClass {
+        /*primary*/ public constructor InnerClass()
+    }
+    
+    internal final inner class NotInnerClass {
+        /*primary*/ public constructor NotInnerClass()
+    }
+}

compiler/testData/resolve/candidatesPriority/classObjectOuterResolve.resolve

@@ -0,0 +1,10 @@
+fun ~test~test() = 1
+
+class Test {
+    class object {
+        fun call() = `test`test()
+    }
+
+    fun test() = 2
+}
+