diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java index cbd18f10ed3..6ce6b4dfb36 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java @@ -1009,7 +1009,7 @@ public class JetPsiUtil { } @Nullable - public static JetElement getEnclosingElementForLocalDeclaration(@Nullable JetNamedDeclaration declaration) { + public static JetElement getEnclosingElementForLocalDeclaration(@Nullable JetDeclaration declaration) { if (declaration instanceof JetTypeParameter) { declaration = PsiTreeUtil.getParentOfType(declaration, JetNamedDeclaration.class); } @@ -1030,7 +1030,7 @@ public class JetPsiUtil { return (container instanceof JetClassInitializer) ? ((JetClassInitializer) container).getBody() : container; } - public static boolean isLocal(@NotNull JetNamedDeclaration declaration) { + public static boolean isLocal(@NotNull JetDeclaration declaration) { return getEnclosingElementForLocalDeclaration(declaration) != null; } diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java index c7ab38140a9..128a8c7335c 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java @@ -41,14 +41,19 @@ import java.util.Collection; import java.util.List; public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTestWithEnvironment { - @Override protected JetCoreEnvironment createEnvironment() { return createEnvironmentWithMockJdk(ConfigurationKind.ALL); } + protected DeclarationDescriptor getDescriptor(JetDeclaration declaration, ResolveSession resolveSession) { + return resolveSession.resolveToDescriptor(declaration); + } + protected void doTest(@NotNull String testFile) throws IOException { - JetFile psiFile = JetPsiFactory.createFile(getProject(), FileUtil.loadFile(new File(testFile), true)); + String fileText = FileUtil.loadFile(new File(testFile), true); + + JetFile psiFile = JetPsiFactory.createFile(getProject(), fileText); Collection files = Lists.newArrayList(psiFile); final ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule(""); @@ -82,13 +87,13 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe } if (declaringElement instanceof JetNamedFunction) { JetNamedFunction jetNamedFunction = (JetNamedFunction) declaringElement; - FunctionDescriptor functionDescriptor = (FunctionDescriptor) resolveSession.resolveToDescriptor(jetNamedFunction); + FunctionDescriptor functionDescriptor = (FunctionDescriptor) getDescriptor(jetNamedFunction, resolveSession); addCorrespondingParameterDescriptor(functionDescriptor, parameter); } else if (declaringElement instanceof JetClass) { // Primary constructor parameter JetClass jetClass = (JetClass) declaringElement; - ClassDescriptor classDescriptor = resolveSession.getClassDescriptor(jetClass); + ClassDescriptor classDescriptor = (ClassDescriptor) getDescriptor(jetClass, resolveSession); addCorrespondingParameterDescriptor(classDescriptor.getConstructors().iterator().next(), parameter); } else { @@ -102,23 +107,30 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe descriptors.add(valueParameterDescriptor); } } + parameter.acceptChildren(this); } @Override public void visitPropertyAccessor(@NotNull JetPropertyAccessor accessor) { JetProperty parent = (JetProperty) accessor.getParent(); - PropertyDescriptor propertyDescriptor = (PropertyDescriptor) resolveSession.resolveToDescriptor(parent); + PropertyDescriptor propertyDescriptor = (PropertyDescriptor) getDescriptor(parent, resolveSession); if (accessor.isGetter()) { descriptors.add(propertyDescriptor.getGetter()); } else { descriptors.add(propertyDescriptor.getSetter()); } + accessor.acceptChildren(this); + } + + @Override + public void visitAnonymousInitializer(@NotNull JetClassInitializer initializer) { + initializer.acceptChildren(this); } @Override public void visitDeclaration(@NotNull JetDeclaration element) { - DeclarationDescriptor descriptor = resolveSession.resolveToDescriptor(element); + DeclarationDescriptor descriptor = getDescriptor(element, resolveSession); descriptors.add(descriptor); if (descriptor instanceof ClassDescriptor) { descriptors.addAll(((ClassDescriptor) descriptor).getConstructors()); diff --git a/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt b/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt index 324462e5e4c..dfb7d2f6778 100644 --- a/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt +++ b/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt @@ -83,6 +83,7 @@ import org.jetbrains.jet.j2k.test.AbstractJavaToKotlinConverterBasicTest import org.jetbrains.jet.plugin.conversion.copy.AbstractJavaToKotlinCopyPasteConversionTest import org.jetbrains.jet.shortenRefs.AbstractShortenRefsTest import org.jetbrains.jet.completion.handlers.AbstractSmartCompletionHandlerTest +import org.jetbrains.jet.resolve.AbstractAdditionalLazyResolveDescriptorRendererTest fun main(args: Array) { System.setProperty("java.awt.headless", "true") @@ -227,6 +228,10 @@ fun main(args: Array) { testGroup("idea/tests", "idea/testData") { + testClass(javaClass()) { + model("resolve/additionalLazyResolve", testMethod = "doTest") + } + testClass(javaClass()) { model("jetPsiMatcher/expressions", testMethod = "doTestExpressions") model("jetPsiMatcher/types", testMethod = "doTestTypes") diff --git a/idea/testData/resolve/additionalLazyResolve/anonymousObjectInClassInitializer.kt b/idea/testData/resolve/additionalLazyResolve/anonymousObjectInClassInitializer.kt new file mode 100644 index 00000000000..e8e5c1d8be5 --- /dev/null +++ b/idea/testData/resolve/additionalLazyResolve/anonymousObjectInClassInitializer.kt @@ -0,0 +1,20 @@ +package test + +open class A + +class MyClass() { + { + val a = object: A() { + + } + } +} + +//package test +//internal open class A defined in test +//public constructor A() defined in test.A +//internal final class MyClass defined in test +//public constructor MyClass() defined in test.MyClass +//val a: test.MyClass.. defined in test.MyClass. +//internal final class : test.A defined in test.MyClass. +//private constructor () defined in test.MyClass.. \ No newline at end of file diff --git a/idea/testData/resolve/additionalLazyResolve/anonymousObjectInClassParameterInitializer.kt b/idea/testData/resolve/additionalLazyResolve/anonymousObjectInClassParameterInitializer.kt new file mode 100644 index 00000000000..f69afc12c3e --- /dev/null +++ b/idea/testData/resolve/additionalLazyResolve/anonymousObjectInClassParameterInitializer.kt @@ -0,0 +1,18 @@ +package test + +open class A + +class MyClass( + a: A = object: A() { + + } +) + +//package test +//internal open class A defined in test +//public constructor A() defined in test.A +//internal final class MyClass defined in test +//public constructor MyClass(a: test.A = ...) defined in test.MyClass +//value-parameter val a: test.A = ... defined in test.MyClass. +//internal final class : test.A defined in test.MyClass. +//private constructor () defined in test.MyClass.. \ No newline at end of file diff --git a/idea/testData/resolve/additionalLazyResolve/localClassInClassInitializer.kt b/idea/testData/resolve/additionalLazyResolve/localClassInClassInitializer.kt new file mode 100644 index 00000000000..2df6de8818b --- /dev/null +++ b/idea/testData/resolve/additionalLazyResolve/localClassInClassInitializer.kt @@ -0,0 +1,19 @@ +package test + +open class A + +class MyClass() { + { + class B: A() { + + } + } +} + +//package test +//internal open class A defined in test +//public constructor A() defined in test.A +//internal final class MyClass defined in test +//public constructor MyClass() defined in test.MyClass +//internal final class B : test.A defined in test.MyClass. +//public constructor B() defined in test.MyClass..B \ No newline at end of file diff --git a/idea/testData/resolve/additionalLazyResolve/localClassInClosureInClassParameterInitializer.kt b/idea/testData/resolve/additionalLazyResolve/localClassInClosureInClassParameterInitializer.kt new file mode 100644 index 00000000000..e1f57ac02fa --- /dev/null +++ b/idea/testData/resolve/additionalLazyResolve/localClassInClosureInClassParameterInitializer.kt @@ -0,0 +1,22 @@ +package test + +open class A + +class MyClass( + a: A = run { + class B: A() { + + } + + B() + } +) + +//package test +//internal open class A defined in test +//public constructor A() defined in test.A +//internal final class MyClass defined in test +//public constructor MyClass(a: test.A = ...) defined in test.MyClass +//value-parameter val a: test.A = ... defined in test.MyClass. +//internal final class B : test.A defined in test.MyClass.. +//public constructor B() defined in test.MyClass...B \ No newline at end of file diff --git a/idea/testData/resolve/additionalLazyResolve/localObjectInClassInitializer.kt b/idea/testData/resolve/additionalLazyResolve/localObjectInClassInitializer.kt new file mode 100644 index 00000000000..65a7cc80224 --- /dev/null +++ b/idea/testData/resolve/additionalLazyResolve/localObjectInClassInitializer.kt @@ -0,0 +1,19 @@ +package test + +open class A + +class MyClass() { + { + object O: A() { + + } + } +} + +//package test +//internal open class A defined in test +//public constructor A() defined in test.A +//internal final class MyClass defined in test +//public constructor MyClass() defined in test.MyClass +//internal object O : test.A defined in test.MyClass. +//private constructor O() defined in test.MyClass..O \ No newline at end of file diff --git a/idea/testData/resolve/additionalLazyResolve/localObjectInClosureInClassParameterInitializer.kt b/idea/testData/resolve/additionalLazyResolve/localObjectInClosureInClassParameterInitializer.kt new file mode 100644 index 00000000000..2d3f2a59160 --- /dev/null +++ b/idea/testData/resolve/additionalLazyResolve/localObjectInClosureInClassParameterInitializer.kt @@ -0,0 +1,22 @@ +package test + +open class A + +class MyClass( + a: A = run { + object O: A() { + + } + + O + } +) + +//package test +//internal open class A defined in test +//public constructor A() defined in test.A +//internal final class MyClass defined in test +//public constructor MyClass(a: test.A = ...) defined in test.MyClass +//value-parameter val a: test.A = ... defined in test.MyClass. +//internal object O : test.A defined in test.MyClass.. +//private constructor O() defined in test.MyClass...O \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/resolve/AbstractAdditionalLazyResolveDescriptorRendererTest.java b/idea/tests/org/jetbrains/jet/resolve/AbstractAdditionalLazyResolveDescriptorRendererTest.java new file mode 100644 index 00000000000..189c66bc978 --- /dev/null +++ b/idea/tests/org/jetbrains/jet/resolve/AbstractAdditionalLazyResolveDescriptorRendererTest.java @@ -0,0 +1,37 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.resolve; + +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.psi.JetClassInitializer; +import org.jetbrains.jet.lang.psi.JetDeclaration; +import org.jetbrains.jet.lang.psi.JetPsiUtil; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.lazy.AbstractLazyResolveDescriptorRendererTest; +import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; +import org.jetbrains.jet.plugin.project.ResolveElementCache; + +public abstract class AbstractAdditionalLazyResolveDescriptorRendererTest extends AbstractLazyResolveDescriptorRendererTest { + @Override + protected DeclarationDescriptor getDescriptor(JetDeclaration declaration, ResolveSession resolveSession) { + if (declaration instanceof JetClassInitializer || JetPsiUtil.isLocal(declaration)) { + ResolveElementCache resolveElementCache = new ResolveElementCache(resolveSession, getProject()); + return resolveElementCache.resolveToElement(declaration).get(BindingContext.DECLARATION_TO_DESCRIPTOR, declaration); + } + return resolveSession.resolveToDescriptor(declaration); + } +} diff --git a/idea/tests/org/jetbrains/jet/resolve/AdditionalLazyResolveDescriptorRendererTestGenerated.java b/idea/tests/org/jetbrains/jet/resolve/AdditionalLazyResolveDescriptorRendererTestGenerated.java new file mode 100644 index 00000000000..f5472b6504d --- /dev/null +++ b/idea/tests/org/jetbrains/jet/resolve/AdditionalLazyResolveDescriptorRendererTestGenerated.java @@ -0,0 +1,69 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.resolve; + +import junit.framework.Assert; +import junit.framework.Test; +import junit.framework.TestSuite; + +import java.io.File; +import java.util.regex.Pattern; +import org.jetbrains.jet.JetTestUtils; +import org.jetbrains.jet.test.InnerTestClasses; +import org.jetbrains.jet.test.TestMetadata; + +import org.jetbrains.jet.resolve.AbstractAdditionalLazyResolveDescriptorRendererTest; + +/** This class is generated by {@link org.jetbrains.jet.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("idea/testData/resolve/additionalLazyResolve") +public class AdditionalLazyResolveDescriptorRendererTestGenerated extends AbstractAdditionalLazyResolveDescriptorRendererTest { + public void testAllFilesPresentInAdditionalLazyResolve() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("idea/testData/resolve/additionalLazyResolve"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("anonymousObjectInClassInitializer.kt") + public void testAnonymousObjectInClassInitializer() throws Exception { + doTest("idea/testData/resolve/additionalLazyResolve/anonymousObjectInClassInitializer.kt"); + } + + @TestMetadata("anonymousObjectInClassParameterInitializer.kt") + public void testAnonymousObjectInClassParameterInitializer() throws Exception { + doTest("idea/testData/resolve/additionalLazyResolve/anonymousObjectInClassParameterInitializer.kt"); + } + + @TestMetadata("localClassInClassInitializer.kt") + public void testLocalClassInClassInitializer() throws Exception { + doTest("idea/testData/resolve/additionalLazyResolve/localClassInClassInitializer.kt"); + } + + @TestMetadata("localClassInClosureInClassParameterInitializer.kt") + public void testLocalClassInClosureInClassParameterInitializer() throws Exception { + doTest("idea/testData/resolve/additionalLazyResolve/localClassInClosureInClassParameterInitializer.kt"); + } + + @TestMetadata("localObjectInClassInitializer.kt") + public void testLocalObjectInClassInitializer() throws Exception { + doTest("idea/testData/resolve/additionalLazyResolve/localObjectInClassInitializer.kt"); + } + + @TestMetadata("localObjectInClosureInClassParameterInitializer.kt") + public void testLocalObjectInClosureInClassParameterInitializer() throws Exception { + doTest("idea/testData/resolve/additionalLazyResolve/localObjectInClosureInClassParameterInitializer.kt"); + } + +}