From 37cd7eb1ba8f3c2ff0cdb81920be63ac5af255fa Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Tue, 4 Jun 2013 16:18:29 +0400 Subject: [PATCH] Allow resolve class declarations in class objects Use INACCESSIBLE_OUTER_CLASS_EXPRESSION error for marking already resolved elements #KT-3261 Fixed --- .../lang/resolve/TypeHierarchyResolver.java | 57 +++++-------------- .../jet/lang/resolve/lazy/ScopeProvider.java | 3 +- .../classes/classObjectsWithParentClasses.kt | 12 ++++ .../ClassObjectCannotAccessClassFields.kt | 2 +- .../innerConstructorFromClass.kt | 2 +- .../nestedConstructorFromClass.kt | 2 +- .../tests/inner/classesInClassObjectHeader.kt | 11 ++++ .../inner/innerClassesInStaticParameters.kt | 11 ++++ .../tests/inner/innerErrorForClassObjects.kt | 26 +++++++++ .../tests/inner/innerErrorForObjects.kt | 27 +++++++++ .../inner/resolvePackageClassInObjects.kt | 9 +++ .../inner/selfAnnotationForClassObject.kt | 9 +++ .../classObjectAnnotation.txt | 2 +- .../namespaceComparator/classObjectHeader.txt | 2 +- .../resolveFunctionInsideClassObject.kt | 9 +++ .../resolveFunctionInsideClassObject.txt | 11 ++++ .../classObject/InnerClassInClassObject.kt | 11 ++++ .../classObject/InnerClassInClassObject.txt | 19 +++++++ .../classObjectOuterResolve.resolve | 10 ++++ .../checkers/JetDiagnosticsTestGenerated.java | 30 ++++++++++ .../BlackBoxCodegenTestGenerated.java | 5 ++ .../LoadCompiledKotlinTestGenerated.java | 5 ++ ...esolveNamespaceComparingTestGenerated.java | 10 ++++ .../jet/resolve/JetResolveTestGenerated.java | 5 ++ 24 files changed, 239 insertions(+), 51 deletions(-) create mode 100644 compiler/testData/codegen/box/classes/classObjectsWithParentClasses.kt create mode 100644 compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.kt create mode 100644 compiler/testData/diagnostics/tests/inner/innerClassesInStaticParameters.kt create mode 100644 compiler/testData/diagnostics/tests/inner/innerErrorForClassObjects.kt create mode 100644 compiler/testData/diagnostics/tests/inner/innerErrorForObjects.kt create mode 100644 compiler/testData/diagnostics/tests/inner/resolvePackageClassInObjects.kt create mode 100644 compiler/testData/diagnostics/tests/inner/selfAnnotationForClassObject.kt create mode 100644 compiler/testData/lazyResolve/namespaceComparator/resolveFunctionInsideClassObject.kt create mode 100644 compiler/testData/lazyResolve/namespaceComparator/resolveFunctionInsideClassObject.txt create mode 100644 compiler/testData/loadKotlin/classObject/InnerClassInClassObject.kt create mode 100644 compiler/testData/loadKotlin/classObject/InnerClassInClassObject.txt create mode 100644 compiler/testData/resolve/candidatesPriority/classObjectOuterResolve.resolve diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java index 4cf4a074da2..d8bac9bb6c9 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java +++ b/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.RedeclarationHandler; -import org.jetbrains.jet.lang.resolve.scopes.WritableScope; -import org.jetbrains.jet.lang.resolve.scopes.WriteThroughScope; +import org.jetbrains.jet.lang.resolve.scopes.*; 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 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), - classObjectName, ClassKind.CLASS_OBJECT); + + MutableClassDescriptor classObjectDescriptor = createClassDescriptorForObject( + 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); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java index 318a347cc62..245e7c2bb95 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java +++ b/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 new InnerClassesScopeWrapper(classObjectDescriptor.getScopeForMemberDeclarationResolution()); + return classObjectDescriptor.getScopeForMemberDeclarationResolution(); } throw new IllegalStateException("Don't call this method for local declarations: " + jetDeclaration + " " + jetDeclaration.getText()); diff --git a/compiler/testData/codegen/box/classes/classObjectsWithParentClasses.kt b/compiler/testData/codegen/box/classes/classObjectsWithParentClasses.kt new file mode 100644 index 00000000000..c79a6babccf --- /dev/null +++ b/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" \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/ClassObjectCannotAccessClassFields.kt b/compiler/testData/diagnostics/tests/ClassObjectCannotAccessClassFields.kt index dc034c09650..49f50bbd546 100644 --- a/compiler/testData/diagnostics/tests/ClassObjectCannotAccessClassFields.kt +++ b/compiler/testData/diagnostics/tests/ClassObjectCannotAccessClassFields.kt @@ -4,6 +4,6 @@ class A() { val x = 1 class object { - val y = x + val y = x } } diff --git a/compiler/testData/diagnostics/tests/callableReference/innerConstructorFromClass.kt b/compiler/testData/diagnostics/tests/callableReference/innerConstructorFromClass.kt index 680ed70cb43..72a822aefa6 100644 --- a/compiler/testData/diagnostics/tests/callableReference/innerConstructorFromClass.kt +++ b/compiler/testData/diagnostics/tests/callableReference/innerConstructorFromClass.kt @@ -11,7 +11,7 @@ class A { class object { fun main() { - ::Inner + ::Inner val y = A::Inner y : KMemberFunction0 diff --git a/compiler/testData/diagnostics/tests/callableReference/nestedConstructorFromClass.kt b/compiler/testData/diagnostics/tests/callableReference/nestedConstructorFromClass.kt index 325393a0b2b..a51da3e20b5 100644 --- a/compiler/testData/diagnostics/tests/callableReference/nestedConstructorFromClass.kt +++ b/compiler/testData/diagnostics/tests/callableReference/nestedConstructorFromClass.kt @@ -11,7 +11,7 @@ class A { class object { fun main() { - ::Nested // KT-3261 + ::Nested val y = A::Nested y : KFunction0 diff --git a/compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.kt b/compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.kt new file mode 100644 index 00000000000..4426e63b9f8 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.kt @@ -0,0 +1,11 @@ +class Test { + [`InnerAnnotation`InnerAnnotation] + class object : StaticClass(), InnerClass() { + + } + + annotation class InnerAnnotation + open class StaticClass + + open inner class InnerClass +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inner/innerClassesInStaticParameters.kt b/compiler/testData/diagnostics/tests/inner/innerClassesInStaticParameters.kt new file mode 100644 index 00000000000..68798c8f33a --- /dev/null +++ b/compiler/testData/diagnostics/tests/inner/innerClassesInStaticParameters.kt @@ -0,0 +1,11 @@ +class Test { + class object { + fun test(t: TestInner) = 42 + } + + class TestStatic { + fun test(t: TestInner) = 42 + } + + inner class TestInner +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inner/innerErrorForClassObjects.kt b/compiler/testData/diagnostics/tests/inner/innerErrorForClassObjects.kt new file mode 100644 index 00000000000..eac005ac624 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inner/innerErrorForClassObjects.kt @@ -0,0 +1,26 @@ +open class SomeClass +class TestSome

{ + class object : SomeClass<P>() { + } +} + +class Test { + class object : InnerClass() { + val a = object: InnerClass() { + } + + fun more(): InnerClass { + val b = InnerClass() + + val testVal = inClass + foo() + + return b + } + } + + val inClass = 12 + fun foo() {} + + open inner class InnerClass +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inner/innerErrorForObjects.kt b/compiler/testData/diagnostics/tests/inner/innerErrorForObjects.kt new file mode 100644 index 00000000000..95567aaf347 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inner/innerErrorForObjects.kt @@ -0,0 +1,27 @@ +open class SomeClass +class TestSome

{ + object Some : SomeClass<P>() { + } +} + +class Test { + object Some : InnerClass() { + val a = object: InnerClass() { + } + + fun more(): InnerClass { + val b = InnerClass() + + val testVal = inClass + foo() + + return b + } + } + + val inClass = 12 + fun foo() { + } + + open inner class InnerClass +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inner/resolvePackageClassInObjects.kt b/compiler/testData/diagnostics/tests/inner/resolvePackageClassInObjects.kt new file mode 100644 index 00000000000..d168e77b3dd --- /dev/null +++ b/compiler/testData/diagnostics/tests/inner/resolvePackageClassInObjects.kt @@ -0,0 +1,9 @@ +open class PackageTest + +class MoreTest() { + class object: PackageTest() { + + } + + object Some: PackageTest() +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inner/selfAnnotationForClassObject.kt b/compiler/testData/diagnostics/tests/inner/selfAnnotationForClassObject.kt new file mode 100644 index 00000000000..668bf4eb8c8 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inner/selfAnnotationForClassObject.kt @@ -0,0 +1,9 @@ +class Test { + [ClassObjectAnnotation] + [NestedAnnotation] + class object { + annotation class ClassObjectAnnotation + } + + annotation class NestedAnnotation +} \ No newline at end of file diff --git a/compiler/testData/lazyResolve/namespaceComparator/classObjectAnnotation.txt b/compiler/testData/lazyResolve/namespaceComparator/classObjectAnnotation.txt index 3d4931ae33e..ab574b211b5 100644 --- a/compiler/testData/lazyResolve/namespaceComparator/classObjectAnnotation.txt +++ b/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 { + test.Some.TestAnnotation() internal class object { /*primary*/ private constructor () internal final annotation class TestAnnotation : jet.Annotation { diff --git a/compiler/testData/lazyResolve/namespaceComparator/classObjectHeader.txt b/compiler/testData/lazyResolve/namespaceComparator/classObjectHeader.txt index f65b6da44a1..2ca691d634e 100644 --- a/compiler/testData/lazyResolve/namespaceComparator/classObjectHeader.txt +++ b/compiler/testData/lazyResolve/namespaceComparator/classObjectHeader.txt @@ -5,7 +5,7 @@ internal fun testFun(/*0*/ a: jet.Int): jet.Int internal final class TestSome { /*primary*/ public constructor TestSome() - internal class object : test.ToResolve<[ERROR : P]> { + internal class object : test.ToResolve

{ /*primary*/ private constructor () } } diff --git a/compiler/testData/lazyResolve/namespaceComparator/resolveFunctionInsideClassObject.kt b/compiler/testData/lazyResolve/namespaceComparator/resolveFunctionInsideClassObject.kt new file mode 100644 index 00000000000..5040cae40d1 --- /dev/null +++ b/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 + } +} \ No newline at end of file diff --git a/compiler/testData/lazyResolve/namespaceComparator/resolveFunctionInsideClassObject.txt b/compiler/testData/lazyResolve/namespaceComparator/resolveFunctionInsideClassObject.txt new file mode 100644 index 00000000000..84a88ca64f9 --- /dev/null +++ b/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 { + /*primary*/ private constructor () + internal final val a: jet.Int + } +} diff --git a/compiler/testData/loadKotlin/classObject/InnerClassInClassObject.kt b/compiler/testData/loadKotlin/classObject/InnerClassInClassObject.kt new file mode 100644 index 00000000000..d98b171f835 --- /dev/null +++ b/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 +} diff --git a/compiler/testData/loadKotlin/classObject/InnerClassInClassObject.txt b/compiler/testData/loadKotlin/classObject/InnerClassInClassObject.txt new file mode 100644 index 00000000000..ba01845e53e --- /dev/null +++ b/compiler/testData/loadKotlin/classObject/InnerClassInClassObject.txt @@ -0,0 +1,19 @@ +package test + +internal final class TestFirst { + /*primary*/ public constructor TestFirst() + + internal class object { + /*primary*/ private constructor () + 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() + } +} diff --git a/compiler/testData/resolve/candidatesPriority/classObjectOuterResolve.resolve b/compiler/testData/resolve/candidatesPriority/classObjectOuterResolve.resolve new file mode 100644 index 00000000000..7715cedc1e2 --- /dev/null +++ b/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 +} + diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java index 0d258ad49d2..c32e00daae0 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java +++ b/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"); diff --git a/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java index bd7388a1c49..0996939a371 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java +++ b/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"); diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java index 595eeab747e..a7eb520a901 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java +++ b/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"); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java index e26cdf37436..f7e249dfbe0 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java +++ b/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"); diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTestGenerated.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTestGenerated.java index 07c283377e1..677f28521d0 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTestGenerated.java +++ b/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");