Move classDescriptorCache field to ClassResolver from JavaDescriptorResolver

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

@@ -22,8 +22,6 @@ import com.intellij.psi.PsiAnnotation;
 import com.intellij.psi.PsiAnnotationMemberValue;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiModifierListOwner;
-import gnu.trove.THashMap;
-import gnu.trove.TObjectHashingStrategy;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -38,8 +36,6 @@ import org.jetbrains.jet.lang.resolve.java.resolver.*;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiParameterWrapper;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.FqNameBase;
-import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
 import org.jetbrains.jet.lang.types.JetType;
@@ -78,23 +74,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         }
     };
 
-    // NOTE: this complexity is introduced because class descriptors do not always have valid fqnames (class objects) 
-    protected final Map<FqNameBase, ResolverClassData> classDescriptorCache =
-            new THashMap<FqNameBase, ResolverClassData>(new TObjectHashingStrategy<FqNameBase>() {
-                @Override
-                public int computeHashCode(FqNameBase o) {
-                    if (o instanceof FqName) {
-                        return ((FqName) o).toUnsafe().hashCode();
-                    }
-                    assert o instanceof FqNameUnsafe;
-                    return o.hashCode();
-                }
-
-                @Override
-                public boolean equals(FqNameBase n1, FqNameBase n2) {
-                    return n1.equalsTo(n2.toString()) && n2.equalsTo(n1.toString());
-                }
-            });
     protected final Map<FqName, ResolverNamespaceData> namespaceDescriptorCacheByFqn = Maps.newHashMap();
 
     protected Project project;
@@ -154,10 +133,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         return psiClassFinder;
     }
 
-    public Map<FqNameBase, ResolverClassData> getClassDescriptorCache() {
-        return classDescriptorCache;
-    }
-
     public JavaDescriptorSignatureResolver getJavaDescriptorSignatureResolver() {
         return javaDescriptorSignatureResolver;
     }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ClassResolver.java

@@ -20,6 +20,8 @@ import com.google.common.collect.Lists;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiClassType;
 import com.intellij.psi.PsiModifier;
+import gnu.trove.THashMap;
+import gnu.trove.TObjectHashingStrategy;
 import jet.typeinfo.TypeInfoVariance;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -47,18 +49,34 @@ import org.jetbrains.jet.rt.signature.JetSignatureExceptionsAdapter;
 import org.jetbrains.jet.rt.signature.JetSignatureReader;
 import org.jetbrains.jet.rt.signature.JetSignatureVisitor;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
 
 import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValueOfMethod;
 import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValuesMethod;
 import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName;
 
 public final class ClassResolver {
+
     private final JavaDescriptorResolver javaDescriptorResolver;
 
+    // NOTE: this complexity is introduced because class descriptors do not always have valid fqnames (class objects)
+    private final Map<FqNameBase, JavaDescriptorResolveData.ResolverClassData> classDescriptorCache =
+            new THashMap<FqNameBase, JavaDescriptorResolveData.ResolverClassData>(new TObjectHashingStrategy<FqNameBase>() {
+                @Override
+                public int computeHashCode(FqNameBase o) {
+                    if (o instanceof FqName) {
+                        return ((FqName) o).toUnsafe().hashCode();
+                    }
+                    assert o instanceof FqNameUnsafe;
+                    return o.hashCode();
+                }
+
+                @Override
+                public boolean equals(FqNameBase n1, FqNameBase n2) {
+                    return n1.equalsTo(n2.toString()) && n2.equalsTo(n1.toString());
+                }
+            });
+
     public ClassResolver(JavaDescriptorResolver javaDescriptorResolver) {
         this.javaDescriptorResolver = javaDescriptorResolver;
     }
@@ -107,13 +125,13 @@ public final class ClassResolver {
         }
 
         // Not let's take a descriptor of a Java class
-        JavaDescriptorResolveData.ResolverClassData classData = javaDescriptorResolver.getClassDescriptorCache().get(qualifiedName);
+        JavaDescriptorResolveData.ResolverClassData classData = classDescriptorCache.get(qualifiedName);
         if (classData == null) {
             PsiClass psiClass =
                     javaDescriptorResolver.getPsiClassFinder().findPsiClass(qualifiedName, PsiClassFinder.RuntimeClassesHandleMode.THROW);
             if (psiClass == null) {
                 JavaDescriptorResolveData.ResolverClassData oldValue =
-                        javaDescriptorResolver.getClassDescriptorCache()
+                        classDescriptorCache
                                 .put(qualifiedName, JavaDescriptorResolveData.ResolverBinaryClassData.NEGATIVE);
                 if (oldValue != null) {
                     throw new IllegalStateException("rewrite at " + qualifiedName);
@@ -134,7 +152,7 @@ public final class ClassResolver {
         assert qualifiedName != null;
 
         FqName fqName = new FqName(qualifiedName);
-        if (javaDescriptorResolver.getClassDescriptorCache().containsKey(fqName)) {
+        if (classDescriptorCache.containsKey(fqName)) {
             throw new IllegalStateException(qualifiedName);
         }
 
@@ -146,7 +164,7 @@ public final class ClassResolver {
         ClassOrNamespaceDescriptor containingDeclaration = resolveParentDescriptor(psiClass);
 
         // class may be resolved during resolution of parent
-        JavaDescriptorResolveData.ResolverClassData classData = javaDescriptorResolver.getClassDescriptorCache().get(fqName);
+        JavaDescriptorResolveData.ResolverClassData classData = classDescriptorCache.get(fqName);
         if (classData != null) {
             return classData;
         }
@@ -154,7 +172,7 @@ public final class ClassResolver {
         classData = new ClassDescriptorFromJvmBytecode(
                 containingDeclaration, kind, psiClass, fqName, javaDescriptorResolver)
                 .getResolverBinaryClassData();
-        javaDescriptorResolver.getClassDescriptorCache().put(fqName, classData);
+        classDescriptorCache.put(fqName, classData);
         classData.getClassDescriptor().setName(name);
 
         List<JetType> supertypes = new ArrayList<JetType>();
@@ -251,7 +269,7 @@ public final class ClassResolver {
             @NotNull Name classObjectName
     ) {
         ClassDescriptorFromJvmBytecode classDescriptor = data.getClassDescriptor();
-        javaDescriptorResolver.getClassDescriptorCache().put(fqName, data);
+        classDescriptorCache.put(fqName, data);
         classDescriptor.setName(classObjectName);
         classDescriptor.setModality(Modality.FINAL);
         classDescriptor.setVisibility(containing.getVisibility());