fix resolution of ArrayList.add in some environments

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

@@ -22,6 +22,7 @@ import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiModifier;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.resolve.FqName;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.*;
@@ -103,7 +104,8 @@ public class JavaClassMembersScope extends JavaClassOrPackageScope {
         for (PsiClass innerClass : psiClass.getAllInnerClasses()) {
             if (name.equals(innerClass.getName())) {
                 if (innerClass.hasModifierProperty(PsiModifier.STATIC) != staticMembers) return null;
-                ClassDescriptor classDescriptor = semanticServices.getDescriptorResolver().resolveClass(innerClass, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
+                ClassDescriptor classDescriptor = semanticServices.getDescriptorResolver()
+                        .resolveClass(new FqName(innerClass.getQualifiedName()), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
                 if (classDescriptor != null) {
                     return classDescriptor;
                 }

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

@@ -21,11 +21,7 @@ import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Pair;
-import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.*;
-import com.intellij.psi.impl.compiled.ClsClassImpl;
-import com.intellij.psi.search.DelegatingGlobalSearchScope;
-import com.intellij.psi.search.GlobalSearchScope;
 import jet.typeinfo.TypeInfoVariance;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -34,12 +30,10 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.constants.*;
-import org.jetbrains.jet.lang.resolve.java.alt.AltClassFinder;
 import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
-import org.jetbrains.jet.plugin.JetFileType;
 import org.jetbrains.jet.rt.signature.JetSignatureAdapter;
 import org.jetbrains.jet.rt.signature.JetSignatureExceptionsAdapter;
 import org.jetbrains.jet.rt.signature.JetSignatureReader;
@@ -222,59 +216,7 @@ public class JavaDescriptorResolver {
         this.psiClassFinder = psiClassFinder;
     }
 
-    @Nullable
-    ResolverClassData resolveClassData(@NotNull PsiClass psiClass, @NotNull DescriptorSearchRule searchRule) {
-        FqName qualifiedName = new FqName(psiClass.getQualifiedName());
 
-        if (qualifiedName.getFqName().endsWith(JvmAbi.TRAIT_IMPL_SUFFIX)) {
-            // TODO: only if -$$TImpl class is created by Kotlin
-            return null;
-        }
-
-        ClassDescriptor builtinClassDescriptor = semanticServices.getKotlinBuiltinClassDescriptor(qualifiedName);
-        if (builtinClassDescriptor != null) {
-            return new ResolverSrcClassData(builtinClassDescriptor);
-        }
-
-        // First, let's check that this is a real Java class, not a Java's view on a Kotlin class:
-        ClassDescriptor kotlinClassDescriptor = semanticServices.getKotlinClassDescriptor(qualifiedName);
-        if (kotlinClassDescriptor != null) {
-            if (searchRule == DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN) {
-                throw new IllegalStateException("class must not be found in kotlin: " + qualifiedName);
-            } else if (searchRule == DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN) {
-                return null;
-            } else if (searchRule == DescriptorSearchRule.INCLUDE_KOTLIN) {
-                // TODO: probably this is evil
-                return new ResolverSrcClassData(kotlinClassDescriptor);
-            } else {
-                throw new IllegalStateException("unknown searchRule: " + searchRule);
-            }
-        }
-
-        PsiClass containingClass = psiClass.getContainingClass();
-        if (containingClass != null) {
-            // must resolve containing class first, because inner class must have a reference to it
-            resolveClass(containingClass, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
-        }
-
-        // Not let's take a descriptor of a Java class
-        ResolverBinaryClassData classData = classDescriptorCache.get(qualifiedName);
-        if (classData == null) {
-            classData = createJavaClassDescriptor(psiClass);
-            classDescriptorCache.put(qualifiedName, classData);
-        }
-        return classData;
-    }
-
-    @Nullable
-    public ClassDescriptor resolveClass(@NotNull PsiClass psiClass, @NotNull DescriptorSearchRule searchRule) {
-        ResolverClassData classData = resolveClassData(psiClass, searchRule);
-        if (classData != null) {
-            return classData.getClassDescriptor();
-        } else {
-            return null;
-        }
-    }
 
     @Nullable
     public ClassDescriptor resolveClass(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
@@ -683,7 +625,7 @@ public class JavaDescriptorResolver {
     private ClassOrNamespaceDescriptor resolveParentDescriptor(PsiClass psiClass) {
         PsiClass containingClass = psiClass.getContainingClass();
         if (containingClass != null) {
-            return resolveClass(containingClass, DescriptorSearchRule.INCLUDE_KOTLIN);
+            return resolveClass(new FqName(containingClass.getQualifiedName()), DescriptorSearchRule.INCLUDE_KOTLIN);
         }
 
         return resolveNamespace(new FqName(psiClass.getQualifiedName()).parent(), DescriptorSearchRule.INCLUDE_KOTLIN);
@@ -1484,7 +1426,8 @@ public class JavaDescriptorResolver {
 
         ClassOrNamespaceDescriptor classDescriptor;
         if (scopeData instanceof ResolverBinaryClassData) {
-            ClassDescriptor classClassDescriptor = resolveClass(method.getPsiMethod().getContainingClass(), DescriptorSearchRule.INCLUDE_KOTLIN);
+            ClassDescriptor classClassDescriptor = resolveClass(new FqName(method.getPsiMethod().getContainingClass().getQualifiedName()),
+                    DescriptorSearchRule.INCLUDE_KOTLIN);
             classDescriptor = classClassDescriptor;
         }
         else {
@@ -1702,7 +1645,7 @@ public class JavaDescriptorResolver {
             if (innerPsiClass.getName().equals(JvmAbi.CLASS_OBJECT_CLASS_NAME)) {
                 continue;
             }
-            r.add(resolveClass(innerPsiClass, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN));
+            r.add(resolveClass(new FqName(innerPsiClass.getQualifiedName()), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN));
         }
         return r;
     }

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

@@ -135,7 +135,8 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
                     }
 
                     if (psiClass.hasModifierProperty(PsiModifier.PUBLIC)) {
-                        ClassDescriptor classDescriptor = descriptorResolver.resolveClass(psiClass, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
+                        ClassDescriptor classDescriptor = descriptorResolver
+                                .resolveClass(new FqName(psiClass.getQualifiedName()), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
                         if (classDescriptor != null) {
                             allDescriptors.add(classDescriptor);
                         }

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

@@ -22,6 +22,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.FqName;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
@@ -142,20 +143,21 @@ public class JavaTypeTransformer {
                         return jetAnalog;
                     }
 
-                    final JavaDescriptorResolver.ResolverClassData classData = resolver.resolveClassData(psiClass, DescriptorSearchRule.INCLUDE_KOTLIN);
+                    final ClassDescriptor classData =
+                            resolver.resolveClass(new FqName(psiClass.getQualifiedName()), DescriptorSearchRule.INCLUDE_KOTLIN);
                     if (classData == null) {
                         return ErrorUtils.createErrorType("Unresolve java class: " + classType.getPresentableText());
                     }
 
                     List<TypeProjection> arguments = Lists.newArrayList();
                     if (classType.isRaw()) {
-                        List<TypeParameterDescriptor> parameters = classData.getClassDescriptor().getTypeConstructor().getParameters();
+                        List<TypeParameterDescriptor> parameters = classData.getTypeConstructor().getParameters();
                         for (TypeParameterDescriptor parameter : parameters) {
                             arguments.add(TypeUtils.makeStarProjection(parameter));
                         }
                     }
                     else {
-                        List<TypeParameterDescriptor> parameters = classData.getClassDescriptor().getTypeConstructor().getParameters();
+                        List<TypeParameterDescriptor> parameters = classData.getTypeConstructor().getParameters();
                         PsiType[] psiArguments = classType.getParameters();
                         
                         if (parameters.size() != psiArguments.length) {
@@ -171,10 +173,10 @@ public class JavaTypeTransformer {
                     }
                     return new JetTypeImpl(
                             Collections.<AnnotationDescriptor>emptyList(),
-                            classData.getClassDescriptor().getTypeConstructor(),
+                            classData.getTypeConstructor(),
                             true,
                             arguments,
-                            classData.getClassDescriptor().getMemberScope(arguments));
+                            classData.getMemberScope(arguments));
                 }
             }
 

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

@@ -95,7 +95,7 @@ class DecompiledDataFactory {
                 }
             }
         } else {
-            ClassDescriptor cd = myJavaDescriptorResolver.resolveClass(psiClass, DescriptorSearchRule.INCLUDE_KOTLIN);
+            ClassDescriptor cd = myJavaDescriptorResolver.resolveClass(new FqName(psiClass.getQualifiedName()), DescriptorSearchRule.INCLUDE_KOTLIN);
             if (cd != null) {
                 appendDescriptor(cd, "");
             }