Extract util methods from JavaDescriptorResolver to the new class DescriptorResolverUtils

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<JetType> 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<ConstructorDescriptor> constructors = classDescriptor.getConstructors();
+        assert constructors.size() == 1 : "Annotation class descriptor must have only one constructor";
+        List<ValueParameterDescriptor> 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));
+        }
+    }
+}

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) {

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<VariableDescriptor> 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<VariableDescriptor> 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<FunctionDescriptor> 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<ConstructorDescriptor> constructors = classDescriptor.getConstructors();
-        assert constructors.size() == 1 : "Annotation class descriptor must have only one constructor";
-        List<ValueParameterDescriptor> valueParameters = constructors.iterator().next().getValueParameters();
-
-        for (ValueParameterDescriptor parameter : valueParameters) {
-            Name parameterName = parameter.getName();
-            if (parameterName.equals(argumentName)) {
-                return parameter;
-            }
-        }
-        return null;
-    }
-
     public List<FunctionDescriptor> resolveMethods(@NotNull ResolverScopeData scopeData) {
         return functionResolver.resolveMethods(scopeData);
     }
 
-    public static Collection<JetType> 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<ClassDescriptor> resolveInnerClasses(DeclarationDescriptor owner, PsiClass psiClass, boolean staticMembers) {
         return innerClassResolver.resolveInnerClasses(owner, psiClass, staticMembers);
     }

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

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

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

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.*;
-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.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;

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()),
+                DescriptorResolverUtils.resolveModality(method, method.isFinal()),
-                JavaDescriptorResolver.resolveVisibility(psiMethod, method.getJetMethod()),
+                DescriptorResolverUtils.resolveVisibility(psiMethod, method.getJetMethod()),
                 /*isInline = */ false
         );
 
@@ -191,7 +191,7 @@ public class FunctionResolver {
     }
 
     public Set<FunctionDescriptor> resolveFunctionGroup(Name methodName, JavaDescriptorResolveData.ResolverScopeData scopeData) {
-        JavaDescriptorResolver.getResolverScopeData(scopeData);
+        DescriptorResolverUtils.getResolverScopeData(scopeData);
 
         Map<Name, NamedMembers> namedMembersMap = scopeData.getNamedMembersMap();
 
@@ -239,7 +239,7 @@ public class FunctionResolver {
             Name methodName
     ) {
         Set<SimpleFunctionDescriptor> 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<FunctionDescriptor> resolveMethods(@NotNull JavaDescriptorResolveData.ResolverScopeData scopeData) {
 
-        JavaDescriptorResolver.getResolverScopeData(scopeData);
+        DescriptorResolverUtils.getResolverScopeData(scopeData);
 
         List<FunctionDescriptor> functions = new ArrayList<FunctionDescriptor>();
 

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

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<PropertyDescriptor> getPropertiesFromSupertypes(ResolverScopeData scopeData, Name propertyName) {
         Set<PropertyDescriptor> r = new HashSet<PropertyDescriptor>();
-        for (JetType supertype : JavaDescriptorResolver.getSupertypes(scopeData)) {
+        for (JetType supertype : DescriptorResolverUtils.getSupertypes(scopeData)) {
             for (VariableDescriptor property : supertype.getMemberScope().getProperties(propertyName)) {
                 r.add((PropertyDescriptor) property);
             }

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