refactoring: ResolverClassData internal structure in JavaDescriptorResolver

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

@@ -86,7 +86,17 @@ public class JavaDescriptorResolver {
         }
     }
 
-    protected final Map<String, ClassDescriptor> classDescriptorCache = Maps.newHashMap();
+    private static class ResolverClassData {
+        private JavaClassDescriptor classDescriptor;
+        private boolean kotlin;
+
+        @NotNull
+        public ClassDescriptor getClassDescriptor() {
+            return classDescriptor;
+        }
+    }
+
+    protected final Map<String, ResolverClassData> classDescriptorCache = Maps.newHashMap();
     protected final Map<PsiTypeParameter, TypeParameterDescriptorInitialization> typeParameterDescriptorCache = Maps.newHashMap();
     protected final Map<PsiMethod, FunctionDescriptor> methodDescriptorCache = Maps.newHashMap();
     protected final Map<PsiField, VariableDescriptor> fieldDescriptorCache = Maps.newHashMap();
@@ -122,12 +132,12 @@ public class JavaDescriptorResolver {
         }
 
         // Not let's take a descriptor of a Java class
-        ClassDescriptor classDescriptor = classDescriptorCache.get(qualifiedName);
-        if (classDescriptor == null) {
-            classDescriptor = createJavaClassDescriptor(psiClass);
-            classDescriptorCache.put(qualifiedName, classDescriptor);
+        ResolverClassData classData = classDescriptorCache.get(qualifiedName);
+        if (classData == null) {
+            classData = createJavaClassDescriptor(psiClass);
+            classDescriptorCache.put(qualifiedName, classData);
         }
-        return classDescriptor;
+        return classData.getClassDescriptor();
     }
 
     @Nullable
@@ -145,26 +155,27 @@ public class JavaDescriptorResolver {
         }
 
         // Not let's take a descriptor of a Java class
-        ClassDescriptor classDescriptor = classDescriptorCache.get(qualifiedName);
-        if (classDescriptor == null) {
+        ResolverClassData classData = classDescriptorCache.get(qualifiedName);
+        if (classData == null) {
             PsiClass psiClass = findClass(qualifiedName);
             if (psiClass == null) {
                 return null;
             }
-            classDescriptor = createJavaClassDescriptor(psiClass);
+            classData = createJavaClassDescriptor(psiClass);
         }
-        return classDescriptor;
+        return classData.getClassDescriptor();
     }
 
-    private ClassDescriptor createJavaClassDescriptor(@NotNull final PsiClass psiClass) {
+    private ResolverClassData createJavaClassDescriptor(@NotNull final PsiClass psiClass) {
         assert !classDescriptorCache.containsKey(psiClass.getQualifiedName()) : psiClass.getQualifiedName();
         classDescriptorCache.put(psiClass.getQualifiedName(), null); // TODO
 
         String name = psiClass.getName();
-        JavaClassDescriptor classDescriptor = new JavaClassDescriptor(
+        ResolverClassData classData = new ResolverClassData();
+        classData.classDescriptor = new JavaClassDescriptor(
                 resolveParentDescriptor(psiClass), psiClass.isInterface() ? ClassKind.TRAIT : ClassKind.CLASS
         );
-        classDescriptor.setName(name);
+        classData.classDescriptor.setName(name);
         
         class OuterClassTypeVariableResolver implements TypeVariableResolver {
 
@@ -176,9 +187,9 @@ public class JavaDescriptorResolver {
         }
 
         List<JetType> supertypes = new ArrayList<JetType>();
-        List<TypeParameterDescriptor> typeParameters = resolveClassTypeParameters(psiClass, classDescriptor, new OuterClassTypeVariableResolver());
-        classDescriptor.setTypeConstructor(new TypeConstructorImpl(
-                classDescriptor,
+        List<TypeParameterDescriptor> typeParameters = resolveClassTypeParameters(psiClass, classData, new OuterClassTypeVariableResolver());
+        classData.classDescriptor.setTypeConstructor(new TypeConstructorImpl(
+                classData.classDescriptor,
                 Collections.<AnnotationDescriptor>emptyList(), // TODO
                 // TODO
                 psiClass.hasModifierProperty(PsiModifier.FINAL),
@@ -186,20 +197,20 @@ public class JavaDescriptorResolver {
                 typeParameters,
                 supertypes
         ));
-        classDescriptor.setModality(Modality.convertFromFlags(
+        classData.classDescriptor.setModality(Modality.convertFromFlags(
                 psiClass.hasModifierProperty(PsiModifier.ABSTRACT) || psiClass.isInterface(),
                 !psiClass.hasModifierProperty(PsiModifier.FINAL))
         );
-        classDescriptor.setVisibility(resolveVisibilityFromPsiModifiers(psiClass));
-        classDescriptorCache.put(psiClass.getQualifiedName(), classDescriptor);
-        classDescriptor.setUnsubstitutedMemberScope(new JavaClassMembersScope(classDescriptor, psiClass, semanticServices, false));
+        classData.classDescriptor.setVisibility(resolveVisibilityFromPsiModifiers(psiClass));
+        classDescriptorCache.put(psiClass.getQualifiedName(), classData);
+        classData.classDescriptor.setUnsubstitutedMemberScope(new JavaClassMembersScope(classData.classDescriptor, psiClass, semanticServices, false));
 
         // UGLY HACK (Andrey Breslav is not sure what did he mean)
         initializeTypeParameters(psiClass);
 
         supertypes.addAll(getSupertypes(psiClass));
         if (psiClass.isInterface()) {
-            classDescriptor.setSuperclassType(JetStandardClasses.getAnyType()); // TODO : Make it java.lang.Object
+            classData.classDescriptor.setSuperclassType(JetStandardClasses.getAnyType()); // TODO : Make it java.lang.Object
         }
         else {
             PsiClassType[] extendsListTypes = psiClass.getExtendsListTypes();
@@ -207,7 +218,7 @@ public class JavaDescriptorResolver {
             JetType superclassType = extendsListTypes.length == 0
                                             ? JetStandardClasses.getAnyType()
                                             : semanticServices.getTypeTransformer().transformToType(extendsListTypes[0]);
-            classDescriptor.setSuperclassType(superclassType);
+            classData.classDescriptor.setSuperclassType(superclassType);
         }
 
         PsiMethod[] psiConstructors = psiClass.getConstructors();
@@ -219,19 +230,19 @@ public class JavaDescriptorResolver {
             // abstract public class Java {}
             if (!psiClass.isInterface()) {
                 ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl(
-                        classDescriptor,
+                        classData.classDescriptor,
                         Collections.<AnnotationDescriptor>emptyList(),
                         false);
-                constructorDescriptor.initialize(typeParameters, Collections.<ValueParameterDescriptor>emptyList(), Modality.FINAL, classDescriptor.getVisibility());
-                constructorDescriptor.setReturnType(classDescriptor.getDefaultType());
-                classDescriptor.addConstructor(constructorDescriptor);
+                constructorDescriptor.initialize(typeParameters, Collections.<ValueParameterDescriptor>emptyList(), Modality.FINAL, classData.classDescriptor.getVisibility());
+                constructorDescriptor.setReturnType(classData.classDescriptor.getDefaultType());
+                classData.classDescriptor.addConstructor(constructorDescriptor);
                 semanticServices.getTrace().record(BindingContext.CONSTRUCTOR, psiClass, constructorDescriptor);
             }
         }
         else {
             for (PsiMethod constructor : psiConstructors) {
                 ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl(
-                        classDescriptor,
+                        classData.classDescriptor,
                         Collections.<AnnotationDescriptor>emptyList(), // TODO
                         false);
                 ValueParameterDescriptors valueParameterDescriptors = resolveParameterDescriptors(constructorDescriptor,
@@ -243,30 +254,31 @@ public class JavaDescriptorResolver {
                 }
                 constructorDescriptor.initialize(typeParameters, valueParameterDescriptors.descriptors, Modality.FINAL,
                                                  resolveVisibilityFromPsiModifiers(constructor));
-                constructorDescriptor.setReturnType(classDescriptor.getDefaultType());
-                classDescriptor.addConstructor(constructorDescriptor);
+                constructorDescriptor.setReturnType(classData.classDescriptor.getDefaultType());
+                classData.classDescriptor.addConstructor(constructorDescriptor);
                 semanticServices.getTrace().record(BindingContext.CONSTRUCTOR, constructor, constructorDescriptor);
             }
         }
 
-        semanticServices.getTrace().record(BindingContext.CLASS, psiClass, classDescriptor);
+        semanticServices.getTrace().record(BindingContext.CLASS, psiClass, classData.classDescriptor);
 
-        return classDescriptor;
+        return classData;
     }
 
-    private List<TypeParameterDescriptor> resolveClassTypeParameters(PsiClass psiClass, JavaClassDescriptor classDescriptor, TypeVariableResolver typeVariableResolver) {
+    private List<TypeParameterDescriptor> resolveClassTypeParameters(PsiClass psiClass, ResolverClassData classData, TypeVariableResolver typeVariableResolver) {
         for (PsiAnnotation annotation : psiClass.getModifierList().getAnnotations()) {
             if (annotation.getQualifiedName().equals(JvmStdlibNames.JET_CLASS.getFqName())) {
+                classData.kotlin = true;
                 PsiLiteralExpression attributeValue = (PsiLiteralExpression) annotation.findAttributeValue(JvmStdlibNames.JET_CLASS_SIGNATURE);
                 if (attributeValue != null) {
                     String typeParametersString = (String) attributeValue.getValue();
                     if (typeParametersString != null) {
-                        return resolveClassTypeParametersFromJetSignature(typeParametersString, psiClass, classDescriptor, typeVariableResolver);
+                        return resolveClassTypeParametersFromJetSignature(typeParametersString, psiClass, classData.classDescriptor, typeVariableResolver);
                     }
                 }
             }
         }
-        return makeUninitializedTypeParameters(classDescriptor, psiClass.getTypeParameters());
+        return makeUninitializedTypeParameters(classData.classDescriptor, psiClass.getTypeParameters());
     }
 
     @NotNull