From 37fd1aebf62934bd45465a0b06853ea2f61502f8 Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Sat, 6 Oct 2012 20:09:45 +0400 Subject: [PATCH] Extract util methods from JavaDescriptorResolver to the new class DescriptorResolverUtils --- .../resolve/java/DescriptorResolverUtils.java | 123 ++++++++++++++++++ .../java/JavaDescriptorResolveData.java | 2 +- .../resolve/java/JavaDescriptorResolver.java | 90 +------------ .../java/resolver/AnnotationResolver.java | 3 +- .../resolve/java/resolver/ClassResolver.java | 8 +- .../resolver/CompileTimeConstResolver.java | 3 +- .../java/resolver/ConstructorResolver.java | 7 +- .../java/resolver/FunctionResolver.java | 12 +- .../java/resolver/InnerClassResolver.java | 5 +- .../java/resolver/PropertiesResolver.java | 17 +-- .../AnnotationJavaDescriptorResolverTest.java | 2 +- 11 files changed, 155 insertions(+), 117 deletions(-) create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java new file mode 100644 index 00000000000..e4ee08ab48f --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java @@ -0,0 +1,123 @@ +/* + * Copyright 2010-2012 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.lang.resolve.java; + +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiModifier; +import com.intellij.psi.PsiModifierListOwner; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.resolve.java.kt.PsiAnnotationWithFlags; +import org.jetbrains.jet.lang.resolve.java.wrapper.PsiClassWrapper; +import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMemberWrapper; +import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; +import org.jetbrains.jet.lang.resolve.name.Name; +import org.jetbrains.jet.lang.types.JetType; + +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +/** + * @author Pavel Talanov + */ +public final class DescriptorResolverUtils { + private DescriptorResolverUtils() { + } + + public static boolean isKotlinClass(@NotNull PsiClass psiClass) { + return new PsiClassWrapper(psiClass).getJetClass().isDefined() || psiClass.getName().equals(JvmAbi.PACKAGE_CLASS); + } + + public static boolean isInnerEnum(@NotNull PsiClass innerClass, DeclarationDescriptor owner) { + if (!innerClass.isEnum()) return false; + if (!(owner instanceof ClassDescriptor)) return false; + + ClassKind kind = ((ClassDescriptor) owner).getKind(); + return kind == ClassKind.CLASS || kind == ClassKind.TRAIT || kind == ClassKind.ENUM_CLASS; + } + + public static Collection getSupertypes(JavaDescriptorResolveData.ResolverScopeData scope) { + if (scope instanceof JavaDescriptorResolveData.ResolverClassData) { + return ((JavaDescriptorResolveData.ResolverClassData) scope).getClassDescriptor().getSupertypes(); + } + else if (scope instanceof JavaDescriptorResolveData.ResolverNamespaceData) { + return Collections.emptyList(); + } + else { + throw new IllegalStateException(); + } + } + + public static Modality resolveModality(PsiMemberWrapper memberWrapper, boolean isFinal) { + if (memberWrapper instanceof PsiMethodWrapper) { + PsiMethodWrapper method = (PsiMethodWrapper) memberWrapper; + if (method.getJetMethod().hasForceOpenFlag()) { + return Modality.OPEN; + } + if (method.getJetMethod().hasForceFinalFlag()) { + return Modality.FINAL; + } + } + + return Modality.convertFromFlags(memberWrapper.isAbstract(), !isFinal); + } + + public static Visibility resolveVisibility( + PsiModifierListOwner modifierListOwner, + @Nullable PsiAnnotationWithFlags annotation + ) { + if (annotation != null) { + if (annotation.hasPrivateFlag()) { + return Visibilities.PRIVATE; + } + else if (annotation.hasInternalFlag()) { + return Visibilities.INTERNAL; + } + } + return modifierListOwner.hasModifierProperty(PsiModifier.PUBLIC) ? Visibilities.PUBLIC : + (modifierListOwner.hasModifierProperty(PsiModifier.PRIVATE) ? Visibilities.PRIVATE : + (modifierListOwner.hasModifierProperty(PsiModifier.PROTECTED) ? Visibilities.PROTECTED : + //Visibilities.PUBLIC)); + JavaDescriptorResolver.PACKAGE_VISIBILITY)); + } + + @Nullable + public static ValueParameterDescriptor getValueParameterDescriptorForAnnotationParameter( + Name argumentName, + ClassDescriptor classDescriptor + ) { + Collection constructors = classDescriptor.getConstructors(); + assert constructors.size() == 1 : "Annotation class descriptor must have only one constructor"; + List valueParameters = constructors.iterator().next().getValueParameters(); + + for (ValueParameterDescriptor parameter : valueParameters) { + Name parameterName = parameter.getName(); + if (parameterName.equals(argumentName)) { + return parameter; + } + } + return null; + } + + public static void getResolverScopeData(@NotNull JavaDescriptorResolveData.ResolverScopeData scopeData) { + if (scopeData.getNamedMembersMap() == null) { + scopeData.setNamedMembersMap(JavaDescriptorResolverHelper.getNamedMembers(scopeData)); + } + } +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolveData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolveData.java index d163553f71c..1d069c94199 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolveData.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolveData.java @@ -87,7 +87,7 @@ public class JavaDescriptorResolveData { } this.staticMembers = staticMembers; - this.kotlin = psiClass != null && JavaDescriptorResolver.isKotlinClass(psiClass); + this.kotlin = psiClass != null && DescriptorResolverUtils.isKotlinClass(psiClass); classOrNamespaceDescriptor = descriptor; if (fqName != null && fqName.lastSegmentIs(Name.identifier(JvmAbi.PACKAGE_CLASS)) && psiClass != null && kotlin) { 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 a0661d118a3..dac78a358e8 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 @@ -21,7 +21,6 @@ import com.google.common.collect.Sets; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiAnnotation; import com.intellij.psi.PsiClass; -import com.intellij.psi.PsiModifier; import com.intellij.psi.PsiModifierListOwner; import gnu.trove.THashMap; import gnu.trove.TObjectHashingStrategy; @@ -34,12 +33,8 @@ import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolveData.ResolverClassData; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolveData.ResolverNamespaceData; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolveData.ResolverScopeData; -import org.jetbrains.jet.lang.resolve.java.kt.PsiAnnotationWithFlags; 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.PsiClassWrapper; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMemberWrapper; -import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; 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; @@ -219,18 +214,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes return null; } - public static boolean isKotlinClass(@NotNull PsiClass psiClass) { - return new PsiClassWrapper(psiClass).getJetClass().isDefined() || psiClass.getName().equals(JvmAbi.PACKAGE_CLASS); - } - - public static boolean isInnerEnum(@NotNull PsiClass innerClass, DeclarationDescriptor owner) { - if (!innerClass.isEnum()) return false; - if (!(owner instanceof ClassDescriptor)) return false; - - ClassKind kind = ((ClassDescriptor) owner).getKind(); - return kind == ClassKind.CLASS || kind == ClassKind.TRAIT || kind == ClassKind.ENUM_CLASS; - } - static boolean isJavaLangObject(JetType type) { ClassifierDescriptor classifierDescriptor = type.getConstructor().getDeclarationDescriptor(); return classifierDescriptor instanceof ClassDescriptor && @@ -276,7 +259,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes public Set resolveFieldGroupByName(@NotNull Name fieldName, @NotNull ResolverScopeData scopeData) { PsiClass psiClass = scopeData.getPsiClass(); - getResolverScopeData(scopeData); + DescriptorResolverUtils.getResolverScopeData(scopeData); NamedMembers namedMembers = scopeData.getNamedMembersMap().get(fieldName); if (namedMembers == null) { @@ -294,7 +277,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes @NotNull public Set resolveFieldGroup(@NotNull ResolverScopeData scopeData) { - getResolverScopeData(scopeData); + DescriptorResolverUtils.getResolverScopeData(scopeData); final PsiClass psiClass = scopeData.getPsiClass(); assert psiClass != null; @@ -313,12 +296,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes return descriptors; } - public static void getResolverScopeData(@NotNull ResolverScopeData scopeData) { - if (scopeData.getNamedMembersMap() == null) { - scopeData.setNamedMembersMap(JavaDescriptorResolverHelper.getNamedMembers(scopeData)); - } - } - @NotNull public Set resolveFunctionGroup(@NotNull Name methodName, @NotNull ResolverScopeData scopeData) { return functionResolver.resolveFunctionGroup(methodName, scopeData); @@ -344,73 +321,10 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes return annotationResolver.resolveAnnotation(psiAnnotation, taskList); } - @Nullable - public static ValueParameterDescriptor getValueParameterDescriptorForAnnotationParameter( - Name argumentName, - ClassDescriptor classDescriptor - ) { - Collection constructors = classDescriptor.getConstructors(); - assert constructors.size() == 1 : "Annotation class descriptor must have only one constructor"; - List valueParameters = constructors.iterator().next().getValueParameters(); - - for (ValueParameterDescriptor parameter : valueParameters) { - Name parameterName = parameter.getName(); - if (parameterName.equals(argumentName)) { - return parameter; - } - } - return null; - } - public List resolveMethods(@NotNull ResolverScopeData scopeData) { return functionResolver.resolveMethods(scopeData); } - public static Collection getSupertypes(ResolverScopeData scope) { - if (scope instanceof ResolverClassData) { - return ((ResolverClassData) scope).getClassDescriptor().getSupertypes(); - } - else if (scope instanceof ResolverNamespaceData) { - return Collections.emptyList(); - } - else { - throw new IllegalStateException(); - } - } - - public static Modality resolveModality(PsiMemberWrapper memberWrapper, boolean isFinal) { - if (memberWrapper instanceof PsiMethodWrapper) { - PsiMethodWrapper method = (PsiMethodWrapper) memberWrapper; - if (method.getJetMethod().hasForceOpenFlag()) { - return Modality.OPEN; - } - if (method.getJetMethod().hasForceFinalFlag()) { - return Modality.FINAL; - } - } - - return Modality.convertFromFlags(memberWrapper.isAbstract(), !isFinal); - } - - public static Visibility resolveVisibility( - PsiModifierListOwner modifierListOwner, - @Nullable PsiAnnotationWithFlags annotation - ) { - if (annotation != null) { - if (annotation.hasPrivateFlag()) { - return Visibilities.PRIVATE; - } - else if (annotation.hasInternalFlag()) { - return Visibilities.INTERNAL; - } - } - return modifierListOwner.hasModifierProperty(PsiModifier.PUBLIC) ? Visibilities.PUBLIC : - (modifierListOwner.hasModifierProperty(PsiModifier.PRIVATE) ? Visibilities.PRIVATE : - (modifierListOwner.hasModifierProperty(PsiModifier.PROTECTED) ? Visibilities.PROTECTED : - //Visibilities.PUBLIC)); - PACKAGE_VISIBILITY)); - } - public List resolveInnerClasses(DeclarationDescriptor owner, PsiClass psiClass, boolean staticMembers) { return innerClassResolver.resolveInnerClasses(owner, psiClass, staticMembers); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationResolver.java index fa8685c0a3b..f36f67e9dde 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationResolver.java @@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; +import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JvmAbi; @@ -103,7 +104,7 @@ public class AnnotationResolver { .getCompileTimeConstFromExpression(annotationFqName, identifier, value, taskList); if (compileTimeConst != null) { ValueParameterDescriptor valueParameterDescriptor = - JavaDescriptorResolver.getValueParameterDescriptorForAnnotationParameter(identifier, clazz); + DescriptorResolverUtils.getValueParameterDescriptorForAnnotationParameter(identifier, clazz); if (valueParameterDescriptor != null) { annotation.setValueArgument(valueParameterDescriptor, compileTimeConst); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ClassResolver.java index 4038b22b7fd..77e2ec1a1be 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ClassResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ClassResolver.java @@ -173,7 +173,7 @@ public class ClassResolver { classData.getClassDescriptor().setTypeParameterDescriptors(typeParameters); classData.getClassDescriptor().setSupertypes(supertypes); - classData.getClassDescriptor().setVisibility(JavaDescriptorResolver.resolveVisibility(psiClass, jetClassAnnotation)); + classData.getClassDescriptor().setVisibility(DescriptorResolverUtils.resolveVisibility(psiClass, jetClassAnnotation)); Modality modality; if (classData.getClassDescriptor().getKind() == ClassKind.ANNOTATION_CLASS) { modality = Modality.FINAL; @@ -218,13 +218,13 @@ public class ClassResolver { return createClassObjectDescriptorForEnum(containing, psiClass); } - if (!JavaDescriptorResolver.isKotlinClass(psiClass)) { + if (!DescriptorResolverUtils.isKotlinClass(psiClass)) { return null; } // If there's at least one inner enum, we need to create a class object (to put this enum into) for (PsiClass innerClass : psiClass.getInnerClasses()) { - if (JavaDescriptorResolver.isInnerEnum(innerClass, containing)) { + if (DescriptorResolverUtils.isInnerEnum(innerClass, containing)) { return createSyntheticClassObject(containing, psiClass); } } @@ -415,7 +415,7 @@ public class ClassResolver { throw new IllegalStateException( "PsiClass not found by name " + containerFqName + ", required to be container declaration of " + fqName); } - if (JavaDescriptorResolver.isInnerEnum(psiClass, clazz) && JavaDescriptorResolver.isKotlinClass(psiClass)) { + if (DescriptorResolverUtils.isInnerEnum(psiClass, clazz) && DescriptorResolverUtils.isKotlinClass(psiClass)) { ClassDescriptor classObjectDescriptor = clazz.getClassObjectDescriptor(); if (classObjectDescriptor == null) { throw new IllegalStateException("Class object for a class with inner enum should've been created earlier: " + clazz); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/CompileTimeConstResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/CompileTimeConstResolver.java index ca20f0f803f..f04cca50a1c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/CompileTimeConstResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/CompileTimeConstResolver.java @@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.constants.*; import org.jetbrains.jet.lang.resolve.constants.StringValue; +import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -91,7 +92,7 @@ public class CompileTimeConstResolver { javaDescriptorResolver.getClassResolver().resolveClass(annotationFqName, DescriptorSearchRule.INCLUDE_KOTLIN, taskList); ValueParameterDescriptor valueParameterDescriptor = - JavaDescriptorResolver.getValueParameterDescriptorForAnnotationParameter(valueName, classDescriptor); + DescriptorResolverUtils.getValueParameterDescriptorForAnnotationParameter(valueName, classDescriptor); if (valueParameterDescriptor == null) { return null; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ConstructorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ConstructorResolver.java index b67e8c2bbeb..b6634e4a0cb 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ConstructorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ConstructorResolver.java @@ -24,10 +24,7 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.DescriptorResolver; -import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolveData; -import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; -import org.jetbrains.jet.lang.resolve.java.TypeVariableResolver; -import org.jetbrains.jet.lang.resolve.java.TypeVariableResolvers; +import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData; import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; @@ -189,7 +186,7 @@ public class ConstructorResolver { constructorDescriptor.initialize(classData.getClassDescriptor().getTypeConstructor().getParameters(), valueParameterDescriptors.getDescriptors(), - JavaDescriptorResolver.resolveVisibility(psiConstructor, constructor.getJetConstructor()), + DescriptorResolverUtils.resolveVisibility(psiConstructor, constructor.getJetConstructor()), aStatic); javaDescriptorResolver.getTrace().record(BindingContext.CONSTRUCTOR, psiConstructor, constructorDescriptor); return constructorDescriptor; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/FunctionResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/FunctionResolver.java index 2a23e1b938a..ce9cb900576 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/FunctionResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/FunctionResolver.java @@ -53,7 +53,7 @@ public class FunctionResolver { @NotNull JavaDescriptorResolveData.ResolverScopeData scopeData ) { - JavaDescriptorResolver.getResolverScopeData(scopeData); + DescriptorResolverUtils.getResolverScopeData(scopeData); PsiType returnPsiType = method.getReturnType(); if (returnPsiType == null) { @@ -121,8 +121,8 @@ public class FunctionResolver { methodTypeParameters, valueParameterDescriptors.getDescriptors(), returnType, - JavaDescriptorResolver.resolveModality(method, method.isFinal()), - JavaDescriptorResolver.resolveVisibility(psiMethod, method.getJetMethod()), + DescriptorResolverUtils.resolveModality(method, method.isFinal()), + DescriptorResolverUtils.resolveVisibility(psiMethod, method.getJetMethod()), /*isInline = */ false ); @@ -191,7 +191,7 @@ public class FunctionResolver { } public Set resolveFunctionGroup(Name methodName, JavaDescriptorResolveData.ResolverScopeData scopeData) { - JavaDescriptorResolver.getResolverScopeData(scopeData); + DescriptorResolverUtils.getResolverScopeData(scopeData); Map namedMembersMap = scopeData.getNamedMembersMap(); @@ -239,7 +239,7 @@ public class FunctionResolver { Name methodName ) { Set r = Sets.newLinkedHashSet(); - for (JetType supertype : JavaDescriptorResolver.getSupertypes(scopeData)) { + for (JetType supertype : DescriptorResolverUtils.getSupertypes(scopeData)) { for (FunctionDescriptor function : supertype.getMemberScope().getFunctions(methodName)) { r.add((SimpleFunctionDescriptor) function); } @@ -249,7 +249,7 @@ public class FunctionResolver { public List resolveMethods(@NotNull JavaDescriptorResolveData.ResolverScopeData scopeData) { - JavaDescriptorResolver.getResolverScopeData(scopeData); + DescriptorResolverUtils.getResolverScopeData(scopeData); List functions = new ArrayList(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/InnerClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/InnerClassResolver.java index 28894ed2c8b..d84da9064e6 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/InnerClassResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/InnerClassResolver.java @@ -22,6 +22,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JvmAbi; @@ -52,7 +53,7 @@ public class InnerClassResolver { if (innerPsiClass.getName().equals(JvmAbi.CLASS_OBJECT_CLASS_NAME)) { continue; } - if (JavaDescriptorResolver.isInnerEnum(innerPsiClass, owner)) { + if (DescriptorResolverUtils.isInnerEnum(innerPsiClass, owner)) { // Inner enums will be put later into our class object continue; } @@ -71,7 +72,7 @@ public class InnerClassResolver { // If we're a class object, inner enums of our parent need to be put into us DeclarationDescriptor containingDeclaration = owner.getContainingDeclaration(); for (PsiClass innerPsiClass : psiClass.getInnerClasses()) { - if (JavaDescriptorResolver.isInnerEnum(innerPsiClass, containingDeclaration)) { + if (DescriptorResolverUtils.isInnerEnum(innerPsiClass, containingDeclaration)) { ClassDescriptor classDescriptor = resolveInnerClass(innerPsiClass); r.add(classDescriptor); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PropertiesResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PropertiesResolver.java index 5ba73a4e9f0..6c0ec9824e8 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PropertiesResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PropertiesResolver.java @@ -26,8 +26,8 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.OverrideResolver; -import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolveData.ResolverScopeData; import org.jetbrains.jet.lang.resolve.java.*; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolveData.ResolverScopeData; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeFieldSignatureData; import org.jetbrains.jet.lang.resolve.java.kt.DescriptorKindUtils; import org.jetbrains.jet.lang.resolve.java.kt.JetMethodAnnotation; @@ -82,7 +82,7 @@ public final class PropertiesResolver { @NotNull Name propertyName, @NotNull String context ) { - JavaDescriptorResolver.getResolverScopeData(scopeData); + DescriptorResolverUtils.getResolverScopeData(scopeData); if (namedMembers.getPropertyDescriptors() != null) { return; @@ -107,12 +107,12 @@ public final class PropertiesResolver { PropertyAccessorData characteristicMember = getCharacteristicMember(members); - Visibility visibility = JavaDescriptorResolver.resolveVisibility(characteristicMember.getMember().getPsiMember(), null); + Visibility visibility = DescriptorResolverUtils.resolveVisibility(characteristicMember.getMember().getPsiMember(), null); CallableMemberDescriptor.Kind kind = CallableMemberDescriptor.Kind.DECLARATION; if (members.getter != null && members.getter.getMember() instanceof PsiMethodWrapper) { JetMethodAnnotation jetMethod = ((PsiMethodWrapper) members.getter.getMember()).getJetMethod(); - visibility = JavaDescriptorResolver.resolveVisibility(characteristicMember.getMember().getPsiMember(), jetMethod); + visibility = DescriptorResolverUtils.resolveVisibility(characteristicMember.getMember().getPsiMember(), jetMethod); kind = DescriptorKindUtils.flagsToKind(jetMethod.kind()); } @@ -122,7 +122,8 @@ public final class PropertiesResolver { PropertyDescriptor propertyDescriptor = new PropertyDescriptor( realOwner, javaDescriptorResolver.resolveAnnotations(characteristicMember.getMember().getPsiMember()), - JavaDescriptorResolver.resolveModality(characteristicMember.getMember(), isFinal || isEnumEntry || isPropertyForNamedObject), + DescriptorResolverUtils + .resolveModality(characteristicMember.getMember(), isFinal || isEnumEntry || isPropertyForNamedObject), visibility, isVar, propertyName, @@ -157,9 +158,9 @@ public final class PropertiesResolver { } if (members.setter != null) { - Visibility setterVisibility = JavaDescriptorResolver.resolveVisibility(members.setter.getMember().getPsiMember(), null); + Visibility setterVisibility = DescriptorResolverUtils.resolveVisibility(members.setter.getMember().getPsiMember(), null); if (members.setter.getMember() instanceof PsiMethodWrapper) { - setterVisibility = JavaDescriptorResolver.resolveVisibility( + setterVisibility = DescriptorResolverUtils.resolveVisibility( members.setter.getMember().getPsiMember(), ((PsiMethodWrapper) members.setter.getMember()) .getJetMethod()); @@ -372,7 +373,7 @@ public final class PropertiesResolver { private static Set getPropertiesFromSupertypes(ResolverScopeData scopeData, Name propertyName) { Set r = new HashSet(); - for (JetType supertype : JavaDescriptorResolver.getSupertypes(scopeData)) { + for (JetType supertype : DescriptorResolverUtils.getSupertypes(scopeData)) { for (VariableDescriptor property : supertype.getMemberScope().getProperties(propertyName)) { r.add((PropertyDescriptor) property); } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AnnotationJavaDescriptorResolverTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AnnotationJavaDescriptorResolverTest.java index 527c4742efb..17493852db0 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AnnotationJavaDescriptorResolverTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AnnotationJavaDescriptorResolverTest.java @@ -46,7 +46,7 @@ import java.util.ArrayList; import java.util.Collections; import java.util.List; -import static org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver.getValueParameterDescriptorForAnnotationParameter; +import static org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils.getValueParameterDescriptorForAnnotationParameter; /** * @author Natalia Ukhorskaya