From 047fe9df9a20fefc2ff8dabbf86cdd4c4a2ed0ad Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Fri, 30 Dec 2011 00:05:29 +0400 Subject: [PATCH] refactoring: ResolverClassData internal structure in JavaDescriptorResolver --- .../resolve/java/JavaDescriptorResolver.java | 80 +++++++++++-------- 1 file changed, 46 insertions(+), 34 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index 66dfe604e63..c7b061152d4 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -86,7 +86,17 @@ public class JavaDescriptorResolver { } } - protected final Map classDescriptorCache = Maps.newHashMap(); + private static class ResolverClassData { + private JavaClassDescriptor classDescriptor; + private boolean kotlin; + + @NotNull + public ClassDescriptor getClassDescriptor() { + return classDescriptor; + } + } + + protected final Map classDescriptorCache = Maps.newHashMap(); protected final Map typeParameterDescriptorCache = Maps.newHashMap(); protected final Map methodDescriptorCache = Maps.newHashMap(); protected final Map 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 supertypes = new ArrayList(); - List typeParameters = resolveClassTypeParameters(psiClass, classDescriptor, new OuterClassTypeVariableResolver()); - classDescriptor.setTypeConstructor(new TypeConstructorImpl( - classDescriptor, + List typeParameters = resolveClassTypeParameters(psiClass, classData, new OuterClassTypeVariableResolver()); + classData.classDescriptor.setTypeConstructor(new TypeConstructorImpl( + classData.classDescriptor, Collections.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.emptyList(), false); - constructorDescriptor.initialize(typeParameters, Collections.emptyList(), Modality.FINAL, classDescriptor.getVisibility()); - constructorDescriptor.setReturnType(classDescriptor.getDefaultType()); - classDescriptor.addConstructor(constructorDescriptor); + constructorDescriptor.initialize(typeParameters, Collections.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.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 resolveClassTypeParameters(PsiClass psiClass, JavaClassDescriptor classDescriptor, TypeVariableResolver typeVariableResolver) { + private List 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