From e73b3621e76f8ab8078037d53ce465dd90176dcb Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Wed, 28 Mar 2012 22:12:25 +0400 Subject: [PATCH] fix resolution of ArrayList.add in some environments --- .../resolve/java/JavaClassMembersScope.java | 4 +- .../resolve/java/JavaDescriptorResolver.java | 65 ++----------------- .../lang/resolve/java/JavaPackageScope.java | 3 +- .../resolve/java/JavaTypeTransformer.java | 12 ++-- .../libraries/DecompiledDataFactory.java | 2 +- 5 files changed, 17 insertions(+), 69 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java index 40338891a1e..7be7ee1305f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java +++ b/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; } 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 e64deda84ee..dda711b4239 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,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; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java index 89910298097..ec3f1c6b09b 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java +++ b/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); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java index c1aa87085a1..ce5c0fee2d2 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java +++ b/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 arguments = Lists.newArrayList(); if (classType.isRaw()) { - List parameters = classData.getClassDescriptor().getTypeConstructor().getParameters(); + List parameters = classData.getTypeConstructor().getParameters(); for (TypeParameterDescriptor parameter : parameters) { arguments.add(TypeUtils.makeStarProjection(parameter)); } } else { - List parameters = classData.getClassDescriptor().getTypeConstructor().getParameters(); + List parameters = classData.getTypeConstructor().getParameters(); PsiType[] psiArguments = classType.getParameters(); if (parameters.size() != psiArguments.length) { @@ -171,10 +173,10 @@ public class JavaTypeTransformer { } return new JetTypeImpl( Collections.emptyList(), - classData.getClassDescriptor().getTypeConstructor(), + classData.getTypeConstructor(), true, arguments, - classData.getClassDescriptor().getMemberScope(arguments)); + classData.getMemberScope(arguments)); } } diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java b/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java index 62f13699ce8..1b45b4b1b02 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java +++ b/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, ""); }