Allow resolve class declarations in class objects

Use INACCESSIBLE_OUTER_CLASS_EXPRESSION error for marking already resolved elements

 #KT-3261 Fixed

compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java

@@ -28,10 +28,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.impl.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.*;
-import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
-import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
-import org.jetbrains.jet.lang.resolve.scopes.WriteThroughScope;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.SubstitutionUtils;
 import org.jetbrains.jet.lang.types.TypeConstructor;
@@ -147,40 +144,6 @@ public class TypeHierarchyResolver {
         checkTypesInClassHeaders(); // Check bounds in the types used in generic bounds and supertype lists
     }
 
-    /**
-     * Use nearest class object scope or namespace scope
-     *
-     * @param declarationElement
-     * @param owner
-     * @return
-     */
-    @SuppressWarnings("SuspiciousMethodCalls")
-    @NotNull
-    private JetScope getStaticScope(PsiElement declarationElement, @NotNull NamespaceLikeBuilder owner) {
-        DeclarationDescriptor ownerDescriptor = owner.getOwnerForChildren();
-        if (ownerDescriptor instanceof NamespaceDescriptorImpl) {
-            return context.getNamespaceScopes().get(declarationElement.getContainingFile());
-        }
-
-        if (ownerDescriptor instanceof MutableClassDescriptor) {
-            MutableClassDescriptor classDescriptor = (MutableClassDescriptor) ownerDescriptor;
-            if (classDescriptor.getKind() == ClassKind.CLASS_OBJECT) {
-                return classDescriptor.getScopeForMemberResolution();
-            }
-
-            DeclarationDescriptor declaration = classDescriptor.getContainingDeclaration();
-            if (declaration instanceof NamespaceDescriptorImpl) {
-                return getStaticScope(declarationElement, ((NamespaceDescriptorImpl) declaration).getBuilder());
-            }
-
-            if (declaration instanceof MutableClassDescriptorLite) {
-                return getStaticScope(declarationElement, ((MutableClassDescriptorLite) declaration).getBuilder());
-            }
-        }
-
-        return null;
-    }
-
     @Nullable
     private Collection<JetDeclarationContainer> collectNamespacesAndClassifiers(
             @NotNull JetScope outerScope,
@@ -517,7 +480,7 @@ public class TypeHierarchyResolver {
             MutableClassDescriptorLite classObjectDescriptor = ownerClassDescriptor.getClassObjectDescriptor();
 
             assert classObjectDescriptor != null : enumEntry.getParent().getText();
-            createClassDescriptorForEnumEntry(enumEntry, classObjectDescriptor.getBuilder());
+            createClassDescriptorForEnumEntry(enumEntry, classObjectDescriptor);
         }
 
         @Override
@@ -530,9 +493,11 @@ public class TypeHierarchyResolver {
             JetObjectDeclaration objectDeclaration = classObject.getObjectDeclaration();
             if (objectDeclaration != null) {
                 Name classObjectName = getClassObjectName(owner.getOwnerForChildren().getName());
-                MutableClassDescriptor classObjectDescriptor =
+
-                      createClassDescriptorForObject(objectDeclaration, owner, getStaticScope(classObject, owner),
+                MutableClassDescriptor classObjectDescriptor = createClassDescriptorForObject(
-                                                     classObjectName, ClassKind.CLASS_OBJECT);
+                        objectDeclaration, owner, outerScope,
+                        classObjectName, ClassKind.CLASS_OBJECT);
+
                 NamespaceLikeBuilder.ClassObjectStatus status = owner.setClassObjectDescriptor(classObjectDescriptor);
                 switch (status) {
                     case DUPLICATE:
@@ -606,6 +571,7 @@ public class TypeHierarchyResolver {
         ) {
             MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(
                     owner.getOwnerForChildren(), scope, kind, false, name);
+
             context.getObjects().put(declaration, mutableClassDescriptor);
 
             JetScope classScope = mutableClassDescriptor.getScopeForMemberResolution();
@@ -619,10 +585,13 @@ public class TypeHierarchyResolver {
 
         private MutableClassDescriptor createClassDescriptorForEnumEntry(
                 @NotNull JetEnumEntry declaration,
-                @NotNull NamespaceLikeBuilder owner
+                @NotNull MutableClassDescriptorLite classObjectDescriptor
         ) {
+            NamespaceLikeBuilder owner = classObjectDescriptor.getBuilder();
+            MutableClassDescriptor mutableClassObjectDescriptor = (MutableClassDescriptor) classObjectDescriptor;
+
             MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(
-                    owner.getOwnerForChildren(), getStaticScope(declaration, owner), ClassKind.ENUM_ENTRY,
+                    owner.getOwnerForChildren(), mutableClassObjectDescriptor.getScopeForMemberResolution(), ClassKind.ENUM_ENTRY,
                     false, JetPsiUtil.safeName(declaration.getName()));
             context.getClasses().put(declaration, mutableClassDescriptor);
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java

@@ -165,8 +165,7 @@ public class ScopeProvider {
             LazyClassDescriptor classObjectDescriptor =
                     (LazyClassDescriptor) resolveSession.getClassObjectDescriptor(classObject).getContainingDeclaration();
 
-            // During class object header resolve there should be no resolution for parent class generic params
+            return classObjectDescriptor.getScopeForMemberDeclarationResolution();
-            return new InnerClassesScopeWrapper(classObjectDescriptor.getScopeForMemberDeclarationResolution());
         }
 
         throw new IllegalStateException("Don't call this method for local declarations: " + jetDeclaration + " " + jetDeclaration.getText());

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

compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java

@@ -3007,6 +3007,11 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage
                 JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/diagnostics/tests/inner"), Pattern.compile("^(.+)\\.kt$"), true);
             }
             
+            @TestMetadata("classesInClassObjectHeader.kt")
+            public void testClassesInClassObjectHeader() throws Exception {
+                doTest("compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.kt");
+            }
+            
             @TestMetadata("constructorAccess.kt")
             public void testConstructorAccess() throws Exception {
                 doTest("compiler/testData/diagnostics/tests/inner/constructorAccess.kt");
@@ -3027,6 +3032,21 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage
                 doTest("compiler/testData/diagnostics/tests/inner/illegalModifier.kt");
             }
             
+            @TestMetadata("innerClassesInStaticParameters.kt")
+            public void testInnerClassesInStaticParameters() throws Exception {
+                doTest("compiler/testData/diagnostics/tests/inner/innerClassesInStaticParameters.kt");
+            }
+            
+            @TestMetadata("innerErrorForClassObjects.kt")
+            public void testInnerErrorForClassObjects() throws Exception {
+                doTest("compiler/testData/diagnostics/tests/inner/innerErrorForClassObjects.kt");
+            }
+            
+            @TestMetadata("innerErrorForObjects.kt")
+            public void testInnerErrorForObjects() throws Exception {
+                doTest("compiler/testData/diagnostics/tests/inner/innerErrorForObjects.kt");
+            }
+            
             @TestMetadata("innerThisSuper.kt")
             public void testInnerThisSuper() throws Exception {
                 doTest("compiler/testData/diagnostics/tests/inner/innerThisSuper.kt");
@@ -3087,6 +3107,16 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage
                 doTest("compiler/testData/diagnostics/tests/inner/outerSuperClassMember.kt");
             }
             
+            @TestMetadata("resolvePackageClassInObjects.kt")
+            public void testResolvePackageClassInObjects() throws Exception {
+                doTest("compiler/testData/diagnostics/tests/inner/resolvePackageClassInObjects.kt");
+            }
+            
+            @TestMetadata("selfAnnotationForClassObject.kt")
+            public void testSelfAnnotationForClassObject() throws Exception {
+                doTest("compiler/testData/diagnostics/tests/inner/selfAnnotationForClassObject.kt");
+            }
+            
             @TestMetadata("traits.kt")
             public void testTraits() throws Exception {
                 doTest("compiler/testData/diagnostics/tests/inner/traits.kt");

compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java

@@ -680,6 +680,11 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
             doTest("compiler/testData/codegen/box/classes/classObjectNotOfEnum.kt");
         }
         
+        @TestMetadata("classObjectsWithParentClasses.kt")
+        public void testClassObjectsWithParentClasses() throws Exception {
+            doTest("compiler/testData/codegen/box/classes/classObjectsWithParentClasses.kt");
+        }
+        
         @TestMetadata("delegation2.kt")
         public void testDelegation2() throws Exception {
             doTest("compiler/testData/codegen/box/classes/delegation2.kt");

compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java

@@ -259,6 +259,11 @@ public class LoadCompiledKotlinTestGenerated extends AbstractLoadCompiledKotlinT
             doTestWithAccessors("compiler/testData/loadKotlin/classObject/ClassObjectExtendsTraitWithTP.kt");
         }
         
+        @TestMetadata("InnerClassInClassObject.kt")
+        public void testInnerClassInClassObject() throws Exception {
+            doTestWithAccessors("compiler/testData/loadKotlin/classObject/InnerClassInClassObject.kt");
+        }
+        
         @TestMetadata("SimpleClassObject.kt")
         public void testSimpleClassObject() throws Exception {
             doTestWithAccessors("compiler/testData/loadKotlin/classObject/SimpleClassObject.kt");

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java

@@ -261,6 +261,11 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
                 doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadKotlin/classObject/ClassObjectExtendsTraitWithTP.kt");
             }
             
+            @TestMetadata("InnerClassInClassObject.kt")
+            public void testInnerClassInClassObject() throws Exception {
+                doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadKotlin/classObject/InnerClassInClassObject.kt");
+            }
+            
             @TestMetadata("SimpleClassObject.kt")
             public void testSimpleClassObject() throws Exception {
                 doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadKotlin/classObject/SimpleClassObject.kt");
@@ -2137,6 +2142,11 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
             doTestCheckingPrimaryConstructors("compiler/testData/lazyResolve/namespaceComparator/propertyClassFileDependencyRecursion.kt");
         }
         
+        @TestMetadata("resolveFunctionInsideClassObject.kt")
+        public void testResolveFunctionInsideClassObject() throws Exception {
+            doTestCheckingPrimaryConstructors("compiler/testData/lazyResolve/namespaceComparator/resolveFunctionInsideClassObject.kt");
+        }
+        
         @TestMetadata("sameClassNameResolve.kt")
         public void testSameClassNameResolve() throws Exception {
             doTestCheckingPrimaryConstructors("compiler/testData/lazyResolve/namespaceComparator/sameClassNameResolve.kt");

compiler/tests/org/jetbrains/jet/resolve/JetResolveTestGenerated.java

@@ -163,6 +163,11 @@ public class JetResolveTestGenerated extends AbstractResolveTest {
             JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/resolve/candidatesPriority"), Pattern.compile("^(.+)\\.resolve$"), true);
         }
         
+        @TestMetadata("classObjectOuterResolve.resolve")
+        public void testClassObjectOuterResolve() throws Exception {
+            doTest("compiler/testData/resolve/candidatesPriority/classObjectOuterResolve.resolve");
+        }
+        
         @TestMetadata("preferImplicitThisToNoReceiver.resolve")
         public void testPreferImplicitThisToNoReceiver() throws Exception {
             doTest("compiler/testData/resolve/candidatesPriority/preferImplicitThisToNoReceiver.resolve");