Minor, move utilities to where they are used

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

@@ -22,12 +22,9 @@ import com.intellij.psi.util.PsiFormatUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.constants.StringValue;
 import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.JetType;
 
@@ -36,31 +33,27 @@ import java.util.Collections;
 import java.util.List;
 
 import static com.intellij.psi.util.PsiFormatUtilBase.*;
-import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName;
 import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isEnumClassObject;
 
 public final class DescriptorResolverUtils {
-
-    public static final FqName OBJECT_FQ_NAME = new FqName("java.lang.Object");
-
     private DescriptorResolverUtils() {
     }
 
     public static boolean isCompiledKotlinPackageClass(@NotNull PsiClass psiClass) {
-        if (!(psiClass instanceof ClsClassImpl)) {
+        if (psiClass instanceof ClsClassImpl) {
-            return false;
+            String qualifiedName = psiClass.getQualifiedName();
+            if (qualifiedName != null && PackageClassUtils.isPackageClassFqName(new FqName(qualifiedName))) {
+                return hasAnnotation(psiClass, JvmAnnotationNames.KOTLIN_PACKAGE.getFqName());
+            }
         }
-        if (!PackageClassUtils.isPackageClassFqName(new FqName(psiClass.getQualifiedName()))) {
+        return false;
-            return false;
-        }
-        return hasAnnotation(psiClass, JvmAnnotationNames.KOTLIN_PACKAGE.getFqName());
     }
 
     public static boolean isCompiledKotlinClass(@NotNull PsiClass psiClass) {
-        if (!(psiClass instanceof ClsClassImpl)) {
+        if (psiClass instanceof ClsClassImpl) {
-            return false;
+            return hasAnnotation(psiClass, JvmAnnotationNames.KOTLIN_CLASS.getFqName());
         }
-        return hasAnnotation(psiClass, JvmAnnotationNames.KOTLIN_CLASS.getFqName());
+        return false;
     }
 
     public static boolean hasAnnotation(@NotNull PsiClass psiClass, @NotNull FqName annotationFqName) {
@@ -83,9 +76,7 @@ public final class DescriptorResolverUtils {
         return Collections.emptyList();
     }
 
-    public static Visibility resolveVisibility(
+    public static Visibility resolveVisibility(@NotNull PsiModifierListOwner modifierListOwner) {
-            @NotNull PsiModifierListOwner modifierListOwner
-    ) {
         if (modifierListOwner.hasModifierProperty(PsiModifier.PUBLIC)) {
             return Visibilities.PUBLIC;
         }
@@ -119,29 +110,6 @@ public final class DescriptorResolverUtils {
         return null;
     }
 
-    public static void checkPsiClassIsNotJet(@Nullable PsiClass psiClass) {
-        if (psiClass instanceof JetJavaMirrorMarker) {
-            throw new IllegalStateException("trying to resolve fake jet PsiClass as regular PsiClass: " + psiClass.getQualifiedName());
-        }
-    }
-
-    @NotNull
-    public static FqNameUnsafe getFqNameForClassObject(@NotNull PsiClass psiClass) {
-        String psiClassQualifiedName = psiClass.getQualifiedName();
-        assert psiClassQualifiedName != null : "Reading java class with no qualified name";
-        return new FqNameUnsafe(psiClassQualifiedName + "." + getClassObjectName(psiClass.getName()).asString());
-    }
-
-    @NotNull
-    public static AnnotationDescriptor getAnnotationDescriptorForJavaLangDeprecated(ClassDescriptor classDescriptor) {
-        AnnotationDescriptor annotationDescriptor = new AnnotationDescriptor();
-        annotationDescriptor.setAnnotationType(classDescriptor.getDefaultType());
-        ValueParameterDescriptor value = getValueParameterDescriptorForAnnotationParameter(Name.identifier("value"), classDescriptor);
-        assert value != null : "jet.deprecated must have one parameter called value";
-        annotationDescriptor.setValueArgument(value, new StringValue("Deprecated in Java"));
-        return annotationDescriptor;
-    }
-
     /**
      * @return true if {@code member} is a static member of enum class, which is to be put into its class object (and not into the
      *         corresponding package). This applies to enum entries, values() and valueOf(String) methods

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

@@ -16,22 +16,31 @@
 
 package org.jetbrains.jet.lang.resolve.java;
 
-import com.google.common.collect.*;
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
 import com.intellij.psi.CommonClassNames;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.constants.StringValue;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
+import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lang.types.lang.PrimitiveType;
 
-import java.util.*;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
 
 public class JavaToKotlinClassMap extends JavaToKotlinClassMapBuilder implements PlatformToKotlinClassMap {
     private static JavaToKotlinClassMap instance = null;
@@ -92,11 +101,22 @@ public class JavaToKotlinClassMap extends JavaToKotlinClassMapBuilder implements
     public AnnotationDescriptor mapToAnnotationClass(@NotNull FqName fqName) {
         ClassDescriptor classDescriptor = classDescriptorMap.get(fqName);
         if (classDescriptor != null && fqName.asString().equals(CommonClassNames.JAVA_LANG_DEPRECATED)) {
-            return DescriptorResolverUtils.getAnnotationDescriptorForJavaLangDeprecated(classDescriptor);
+            return getAnnotationDescriptorForJavaLangDeprecated(classDescriptor);
         }
         return null;
     }
 
+    @NotNull
+    private static AnnotationDescriptor getAnnotationDescriptorForJavaLangDeprecated(@NotNull ClassDescriptor classDescriptor) {
+        AnnotationDescriptor annotation = new AnnotationDescriptor();
+        annotation.setAnnotationType(classDescriptor.getDefaultType());
+        ValueParameterDescriptor value =
+                DescriptorResolverUtils.getValueParameterDescriptorForAnnotationParameter(Name.identifier("value"), classDescriptor);
+        assert value != null : "jet.deprecated must have one parameter called value";
+        annotation.setValueArgument(value, new StringValue("Deprecated in Java"));
+        return annotation;
+    }
+
     private static FqName getJavaClassFqName(@NotNull Class<?> javaClass) {
         return new FqName(javaClass.getName().replace('$', '.'));
     }

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

@@ -236,7 +236,7 @@ public final class JavaClassResolver {
             @NotNull PostponedTasks taskList
     ) {
         checkFqNamesAreConsistent(psiClass, fqName);
-        DescriptorResolverUtils.checkPsiClassIsNotJet(psiClass);
+        checkPsiClassIsNotJet(psiClass);
 
         ClassOrNamespaceDescriptor containingDeclaration = resolveParentDescriptor(psiClass);
         // class may be resolved during resolution of parent
@@ -304,7 +304,7 @@ public final class JavaClassResolver {
 
         if (psiClass.isEnum()) {
             ClassDescriptorFromJvmBytecode classObjectDescriptor = createClassObjectDescriptorForEnum(classDescriptor, psiClass);
-            cache(DescriptorResolverUtils.getFqNameForClassObject(psiClass), classObjectDescriptor);
+            cache(getFqNameForClassObject(psiClass), classObjectDescriptor);
             classDescriptor.getBuilder().setClassObjectDescriptor(classObjectDescriptor);
         }
 
@@ -321,6 +321,13 @@ public final class JavaClassResolver {
         return classDescriptor;
     }
 
+    @NotNull
+    private static FqNameUnsafe getFqNameForClassObject(@NotNull PsiClass psiClass) {
+        String qualifiedName = psiClass.getQualifiedName();
+        assert qualifiedName != null : "Reading java class with no qualified name";
+        return new FqNameUnsafe(qualifiedName + "." + getClassObjectName(psiClass.getName()).asString());
+    }
+
     @NotNull
     private SimpleFunctionDescriptor resolveFunctionOfSamInterface(
             @NotNull PsiMethod samInterfaceMethod,
@@ -393,7 +400,7 @@ public final class JavaClassResolver {
                 !psiClass.hasModifierProperty(PsiModifier.FINAL));
     }
 
-    void checkFqNamesAreConsistent(@NotNull PsiClass psiClass, @NotNull FqName desiredFqName) {
+    private void checkFqNamesAreConsistent(@NotNull PsiClass psiClass, @NotNull FqName desiredFqName) {
         String qualifiedName = psiClass.getQualifiedName();
         assert qualifiedName != null;
 
@@ -405,6 +412,12 @@ public final class JavaClassResolver {
         }
     }
 
+    private static void checkPsiClassIsNotJet(@NotNull PsiClass psiClass) {
+        if (psiClass instanceof JetJavaMirrorMarker) {
+            throw new IllegalStateException("trying to resolve fake jet PsiClass as regular PsiClass: " + psiClass.getQualifiedName());
+        }
+    }
+
     @NotNull
     private ClassOrNamespaceDescriptor resolveParentDescriptor(@NotNull PsiClass psiClass) {
         if (isContainedInClass(psiClass)) {

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

@@ -19,13 +19,13 @@ package org.jetbrains.jet.lang.resolve.java.resolver;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiClassType;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassKind;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.java.*;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeUtils;
@@ -37,6 +37,7 @@ import java.util.Collection;
 import java.util.List;
 
 public final class JavaSupertypeResolver {
+    private static final FqName OBJECT_FQ_NAME = new FqName("java.lang.Object");
 
     private BindingTrace trace;
     private JavaTypeTransformer typeTransformer;
@@ -79,17 +80,12 @@ public final class JavaSupertypeResolver {
         return result;
     }
 
-    private void addBaseClass(
+    private void addBaseClass(@NotNull PsiClass psiClass, @NotNull ClassDescriptor classDescriptor, @NotNull List<JetType> result) {
-            @NotNull PsiClass psiClass,
+        if (OBJECT_FQ_NAME.asString().equals(psiClass.getQualifiedName()) || classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS) {
-            @NotNull ClassDescriptor classDescriptor,
-            @NotNull List<JetType> result
-    ) {
-        if (DescriptorResolverUtils.OBJECT_FQ_NAME.equalsTo(psiClass.getQualifiedName())
-            || classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS) {
             result.add(KotlinBuiltIns.getInstance().getAnyType());
         }
         else {
-            ClassDescriptor object = resolveJavaLangObject();
+            ClassDescriptor object = classResolver.resolveClass(OBJECT_FQ_NAME, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
             if (object != null) {
                 result.add(object.getDefaultType());
             }
@@ -133,15 +129,4 @@ public final class JavaSupertypeResolver {
             result.add(TypeUtils.makeNotNullable(transform));
         }
     }
-
-
-    @Nullable
-    private ClassDescriptor resolveJavaLangObject() {
-        ClassDescriptor clazz = classResolver.resolveClass(DescriptorResolverUtils.OBJECT_FQ_NAME,
-                                                           DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
-        if (clazz == null) {
-            // TODO: warning
-        }
-        return clazz;
-    }
 }