KT-3469 AssertionError: Couldn't find super type for super function

Class descriptor for Java class was recreated in KotlinSignatureInJavaMarkerProvider.

 #KT-3469 fixed

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);
     }
 

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");

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