Got rid of method duplication.

idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java

@@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
 import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -40,7 +41,6 @@ import org.jetbrains.jet.plugin.JetDescriptorIconProvider;
 import org.jetbrains.jet.plugin.completion.handlers.JetClassInsertHandler;
 import org.jetbrains.jet.plugin.completion.handlers.JetFunctionInsertHandler;
 import org.jetbrains.jet.plugin.completion.handlers.JetJavaClassInsertHandler;
-import org.jetbrains.jet.plugin.libraries.DecompiledDataFactory;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
 
 import java.util.List;
@@ -145,14 +145,14 @@ public final class DescriptorLookupConverter {
     private static MutableLookupElement createJavaLookupElementIfPossible(@NotNull PsiElement declaration) {
         if (declaration instanceof PsiClass) {
             PsiClass psiClass = (PsiClass) declaration;
-            if (!DecompiledDataFactory.isCompiledFromKotlin(psiClass)) {
+            if (!DescriptorResolverUtils.isKotlinClass(psiClass)) {
                 return new JavaPsiClassReferenceElement(psiClass);
             }
         }
 
         if (declaration instanceof PsiMember) {
             PsiClass containingClass = ((PsiMember) declaration).getContainingClass();
-            if (containingClass != null && !DecompiledDataFactory.isCompiledFromKotlin(containingClass)) {
+            if (containingClass != null && !DescriptorResolverUtils.isKotlinClass(containingClass)) {
                 if (declaration instanceof PsiMethod) {
                     return new JavaMethodCallElementWithCustomHandler(declaration);
                 }

idea/src/org/jetbrains/jet/plugin/completion/JetTypesCompletionHelper.java

@@ -24,6 +24,7 @@ import com.intellij.util.Consumer;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.asJava.KotlinLightClass;
 import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -87,7 +88,7 @@ public class JetTypesCompletionHelper {
             return true;
         }
 
-        if (DecompiledDataFactory.isCompiledFromKotlin(aClass)) {
+        if (DescriptorResolverUtils.isKotlinClass(aClass)) {
             if (!DecompiledDataFactory.isKotlinObject(aClass)) {
                 String qualifiedName = aClass.getQualifiedName();
                 if (qualifiedName != null) {

idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java

@@ -18,14 +18,12 @@ package org.jetbrains.jet.plugin.libraries;
 
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.TextRange;
-import com.intellij.psi.*;
+import com.intellij.psi.PsiClass;
-import com.intellij.psi.impl.compiled.ClsAnnotationImpl;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiField;
 import com.intellij.psi.impl.compiled.ClsElementImpl;
 import com.intellij.psi.impl.compiled.ClsFileImpl;
 import com.intellij.psi.util.PsiTreeUtil;
-import jet.runtime.typeinfo.JetClass;
-import jet.runtime.typeinfo.JetMethod;
-import jet.runtime.typeinfo.JetPackageClass;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -43,9 +41,6 @@ import org.jetbrains.jet.renderer.DescriptorRendererBuilder;
 import java.util.*;
 
 public class DecompiledDataFactory {
-    private static final String JET_CLASS = JetClass.class.getName();
-    private static final String JET_PACKAGE_CLASS = JetPackageClass.class.getName();
-    private static final String JET_METHOD = JetMethod.class.getName();
     private static final String DECOMPILED_COMMENT = "/* compiled code */";
     private static final DescriptorRenderer DESCRIPTOR_RENDERER =
             new DescriptorRendererBuilder().setWithDefinedIn(false).setClassWithPrimaryConstructor(true).build();
@@ -83,7 +78,7 @@ public class DecompiledDataFactory {
 
         PsiClass psiClass = clsFile.getClasses()[0];
 
-        if (isKotlinNamespaceClass(psiClass)) {
+        if (PackageClassUtils.isPackageClass(psiClass)) {
             NamespaceDescriptor nd = javaDescriptorResolver.resolveNamespace(new FqName(packageName), DescriptorSearchRule.INCLUDE_KOTLIN);
 
             if (nd != null) {
@@ -206,20 +201,6 @@ public class DecompiledDataFactory {
         }
     }
 
-    private static boolean hasAnnotation(PsiModifierListOwner modifierListOwner, String qualifiedName) {
-        PsiModifierList modifierList = modifierListOwner.getModifierList();
-        if (modifierList != null) {
-            for (PsiAnnotation annotation : modifierList.getAnnotations()) {
-                if (annotation instanceof ClsAnnotationImpl) {
-                    if (qualifiedName.equals(annotation.getQualifiedName())) {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    }
-
     private static boolean isNamedObjectProperty(@NotNull DeclarationDescriptor descriptor, BindingContext bindingContext) {
         if (descriptor instanceof PropertyDescriptor) {
             ClassDescriptor objectDeclaration = bindingContext.get(BindingContext.OBJECT_DECLARATION_CLASS, (PropertyDescriptor) descriptor);
@@ -230,18 +211,6 @@ public class DecompiledDataFactory {
         return false;
     }
 
-    public static boolean isKotlinClass(@NotNull PsiClass psiClass) {
-        return hasAnnotation(psiClass, JET_CLASS);
-    }
-
-    public static boolean isKotlinNamespaceClass(@NotNull PsiClass psiClass) {
-        return hasAnnotation(psiClass, JET_PACKAGE_CLASS);
-    }
-
-    public static boolean isCompiledFromKotlin(@NotNull PsiClass psiClass) {
-        return isKotlinClass(psiClass) || isKotlinNamespaceClass(psiClass);
-    }
-
     public static boolean isKotlinObject(PsiClass aClass) {
         return JetClassAnnotation.get(aClass).kind() == JvmStdlibNames.FLAG_CLASS_KIND_OBJECT;
     }

idea/src/org/jetbrains/jet/plugin/libraries/JetDecompiledData.java

@@ -21,7 +21,6 @@ import com.intellij.openapi.fileTypes.FileTypeManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiManager;
 import com.intellij.psi.impl.compiled.ClsElementImpl;
@@ -31,6 +30,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
 
 import java.util.Map;
 
@@ -78,8 +78,7 @@ public class JetDecompiledData {
     }
 
     public static boolean isKotlinFile(@NotNull ClsFileImpl clsFile) {
-        PsiClass psiClass = clsFile.getClasses()[0];
+        return DescriptorResolverUtils.isKotlinClass(clsFile.getClasses()[0]);
-        return DecompiledDataFactory.isKotlinNamespaceClass(psiClass) || DecompiledDataFactory.isKotlinClass(psiClass);
     }
 
     @NotNull