From c4f2740074cffa350ea589cf95938d880cee1a12 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Wed, 3 Apr 2013 15:04:32 +0400 Subject: [PATCH] KT-3469 AssertionError: Couldn't find super type for super function Class descriptor for Java class was recreated in KotlinSignatureInJavaMarkerProvider. #KT-3469 fixed --- .../java/resolver/JavaClassResolver.java | 8 ++- .../KotlinSignatureInJavaMarkerProvider.java | 2 +- .../SignatureMarkerProviderTest.java | 56 +++++++++++++++++++ 3 files changed, 64 insertions(+), 2 deletions(-) create mode 100644 idea/tests/org/jetbrains/jet/plugin/codeInsight/ktSignature/SignatureMarkerProviderTest.java diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java index 2e9e3f4820f..d7a928f5ac5 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java @@ -166,13 +166,19 @@ public final class JavaClassResolver { return doResolveClass(qualifiedName, tasks); } - @Nullable private ClassDescriptor doResolveClass(@NotNull FqName qualifiedName, @NotNull PostponedTasks tasks) { PsiClass psiClass = psiClassFinder.findPsiClass(qualifiedName, PsiClassFinder.RuntimeClassesHandleMode.THROW); if (psiClass == null) { cacheNegativeValue(javaClassToKotlinFqName(qualifiedName)); return null; } + + // Class may have been resolved previously by different Java resolver instance, and we are reusing its trace + ClassDescriptor alreadyResolved = trace.get(BindingContext.CLASS, psiClass); + if (alreadyResolved != null) { + return alreadyResolved; + } + return createJavaClassDescriptor(qualifiedName, psiClass, tasks); } diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/ktSignature/KotlinSignatureInJavaMarkerProvider.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/ktSignature/KotlinSignatureInJavaMarkerProvider.java index 4dc37f727a2..3b73b1a4a6a 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/ktSignature/KotlinSignatureInJavaMarkerProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/ktSignature/KotlinSignatureInJavaMarkerProvider.java @@ -114,7 +114,7 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider { } } - private static InjectorForJavaDescriptorResolver createInjector(Project project) { + static InjectorForJavaDescriptorResolver createInjector(Project project) { KotlinDeclarationsCache declarationsCache = KotlinCacheManager.getInstance(project).getDeclarationsFromProject(TargetPlatform.JVM); BindingContext bindingContext = declarationsCache.getBindingContext(); DelegatingBindingTrace delegatingTrace = new DelegatingBindingTrace(bindingContext, "wrapped context of declarations cache"); diff --git a/idea/tests/org/jetbrains/jet/plugin/codeInsight/ktSignature/SignatureMarkerProviderTest.java b/idea/tests/org/jetbrains/jet/plugin/codeInsight/ktSignature/SignatureMarkerProviderTest.java new file mode 100644 index 00000000000..526c55f55cc --- /dev/null +++ b/idea/tests/org/jetbrains/jet/plugin/codeInsight/ktSignature/SignatureMarkerProviderTest.java @@ -0,0 +1,56 @@ +/* + * 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.plugin.codeInsight.ktSignature; + +import com.intellij.openapi.project.Project; +import com.intellij.psi.JavaPsiFacade; +import com.intellij.psi.PsiClass; +import com.intellij.psi.search.GlobalSearchScope; +import com.intellij.testFramework.LightProjectDescriptor; +import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.plugin.JetFileType; +import org.jetbrains.jet.plugin.JetLightProjectDescriptor; +import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManager; + +public class SignatureMarkerProviderTest extends LightCodeInsightFixtureTestCase { + + @NotNull + @Override + protected LightProjectDescriptor getProjectDescriptor() { + return JetLightProjectDescriptor.INSTANCE; + } + + public void testReResolveJavaClass() { + Project project = myFixture.getProject(); + + myFixture.configureByText(JetFileType.INSTANCE, "val t: Thread? = null"); + + PsiClass psiClass = JavaPsiFacade.getInstance(project).findClass("java.lang.Thread", GlobalSearchScope.allScope(project)); + BindingContext context = KotlinCacheManager.getInstance(project).getDeclarationsFromProject().getBindingContext(); + ClassDescriptor preResolvedClass = context.get(BindingContext.CLASS, psiClass); + + InjectorForJavaDescriptorResolver injector = KotlinSignatureInJavaMarkerProvider.createInjector(project); + ClassDescriptor reResolvedClass = injector.getJavaDescriptorResolver().resolveClass(new FqName("java.lang.Thread")); + + assertSame(preResolvedClass, reResolvedClass); + } +}