From 881a633ba056fd7def0d050e5212ff767443f4de Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Mon, 26 Aug 2013 22:07:36 +0400 Subject: [PATCH] Get rid of DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN Rename other constants in DescriptorSearchRule Inline methods with default values for DescriptorSearchRule --- .../resolve/java/DescriptorSearchRule.java | 11 ++-------- .../resolve/java/JavaDescriptorResolver.java | 6 +++-- .../resolve/java/JavaTypeTransformer.java | 3 ++- .../AnnotationDescriptorDeserializer.java | 4 ++-- .../DeserializedDescriptorResolver.java | 13 ++++++----- .../java/resolver/JavaAnnotationResolver.java | 6 ++--- .../java/resolver/JavaClassResolver.java | 11 +++------- .../JavaCompileTimeConstResolver.java | 8 +++---- .../java/resolver/JavaNamespaceResolver.java | 9 +++----- .../java/resolver/JavaSupertypeResolver.java | 9 ++++++-- .../scope/JavaClassNonStaticMembersScope.java | 6 ++--- .../scope/JavaClassStaticMembersScope.java | 5 +++-- .../resolve/java/scope/JavaPackageScope.java | 22 +++++++++++-------- .../AbstractDescriptorSerializationTest.java | 3 ++- .../jvm/compiler/AbstractLoadJavaTest.java | 5 ++--- .../compiler/JdkAnnotationsValidityTest.java | 8 ++++--- .../jet/jvm/compiler/LoadDescriptorUtil.java | 4 ++-- ...solveDescriptorsFromExternalLibraries.java | 5 +++-- .../jet/types/JetTypeCheckerTest.java | 11 +++++----- .../KotlinSignatureAnnotationIntention.java | 9 ++++---- .../KotlinSignatureInJavaMarkerProvider.java | 6 +++-- .../libraries/DecompiledDataFactory.java | 6 ++--- .../SignatureMarkerProviderTest.java | 5 ++++- 23 files changed, 92 insertions(+), 83 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorSearchRule.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorSearchRule.java index 61aff16d8de..3611d9b86ec 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorSearchRule.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorSearchRule.java @@ -17,26 +17,19 @@ package org.jetbrains.jet.lang.resolve.java; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; public enum DescriptorSearchRule { - INCLUDE_KOTLIN { + INCLUDE_KOTLIN_SOURCES { @Override public T processFoundInKotlin(T foundDescriptor) { return foundDescriptor; } }, - IGNORE_IF_FOUND_IN_KOTLIN { + IGNORE_KOTLIN_SOURCES { @Override public T processFoundInKotlin(T foundDescriptor) { return null; } - }, - ERROR_IF_FOUND_IN_KOTLIN { - @Override - public T processFoundInKotlin(T foundDescriptor) { - throw new IllegalStateException(DescriptorUtils.getFQName(foundDescriptor) + " should not be found in Kotlin."); - } }; public abstract T processFoundInKotlin(T foundDescriptor); 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 3271088632a..9ebb4b5c172 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 @@ -33,6 +33,8 @@ import java.util.Collection; import java.util.List; import java.util.Set; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; + public class JavaDescriptorResolver implements DependencyClassByQualifiedNameResolver { public static final Name JAVA_ROOT = Name.special(""); @@ -75,7 +77,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes @Override public ClassDescriptor resolveClass(@NotNull FqName qualifiedName) { - return classResolver.resolveClass(qualifiedName); + return classResolver.resolveClass(qualifiedName, IGNORE_KOTLIN_SOURCES); } @NotNull @@ -90,7 +92,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes @Override public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName) { - return namespaceResolver.resolveNamespace(qualifiedName); + return resolveNamespace(qualifiedName, IGNORE_KOTLIN_SOURCES); } @Nullable 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 32584c91c5f..361ca88a87b 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 @@ -37,6 +37,7 @@ import java.util.EnumSet; import java.util.List; import java.util.Set; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; import static org.jetbrains.jet.lang.resolve.java.TypeUsage.*; import static org.jetbrains.jet.lang.types.Variance.*; @@ -138,7 +139,7 @@ public class JavaTypeTransformer { howThisTypeIsUsed); if (classData == null) { - classData = resolver.resolveClass(new FqName(psiClass.getQualifiedName()), DescriptorSearchRule.INCLUDE_KOTLIN); + classData = resolver.resolveClass(new FqName(psiClass.getQualifiedName()), INCLUDE_KOTLIN_SOURCES); } if (classData == null) { return ErrorUtils.createErrorType("Unresolved java class: " + classType.getPresentableText()); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationDescriptorDeserializer.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationDescriptorDeserializer.java index cdd8db88ec1..43482ce8d8d 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationDescriptorDeserializer.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationDescriptorDeserializer.java @@ -45,7 +45,7 @@ import java.io.IOException; import java.util.*; import static org.jetbrains.asm4.ClassReader.*; -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; import static org.jetbrains.jet.lang.resolve.java.resolver.DeserializedResolverUtils.*; public class AnnotationDescriptorDeserializer implements AnnotationDeserializer { @@ -180,7 +180,7 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer if (ignoreAnnotation(desc)) return null; FqName annotationFqName = convertJvmDescriptorToFqName(desc); - final ClassDescriptor annotationClass = javaClassResolver.resolveClass(annotationFqName, ERROR_IF_FOUND_IN_KOTLIN); + final ClassDescriptor annotationClass = javaClassResolver.resolveClass(annotationFqName, IGNORE_KOTLIN_SOURCES); assert annotationClass != null : "Annotation class is not found: " + desc; final AnnotationDescriptor annotation = new AnnotationDescriptor(); annotation.setAnnotationType(annotationClass.getDefaultType()); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DeserializedDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DeserializedDescriptorResolver.java index e7ba7fe071f..94fd9bbcbb7 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DeserializedDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DeserializedDescriptorResolver.java @@ -34,7 +34,8 @@ import javax.inject.Inject; import java.util.Collection; import static org.jetbrains.jet.lang.resolve.java.AbiVersionUtil.isAbiVersionCompatible; -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; import static org.jetbrains.jet.lang.resolve.java.resolver.DeserializedResolverUtils.kotlinFqNameToJavaFqName; public final class DeserializedDescriptorResolver { @@ -52,13 +53,13 @@ public final class DeserializedDescriptorResolver { @Nullable @Override public ClassDescriptor findClass(@NotNull ClassId classId) { - return javaClassResolver.resolveClass(kotlinFqNameToJavaFqName(classId.asSingleFqName())); + return javaClassResolver.resolveClass(kotlinFqNameToJavaFqName(classId.asSingleFqName()), IGNORE_KOTLIN_SOURCES); } @Nullable @Override public NamespaceDescriptor findPackage(@NotNull FqName name) { - return javaNamespaceResolver.resolveNamespace(name); + return javaNamespaceResolver.resolveNamespace(name, IGNORE_KOTLIN_SOURCES); } @NotNull @@ -108,9 +109,9 @@ public final class DeserializedDescriptorResolver { @Nullable private ClassDescriptor createDeserializedClass(@NotNull ClassData classData, @NotNull ClassId classId) { DeclarationDescriptor owner = classId.isTopLevelClass() - ? javaNamespaceResolver.resolveNamespace(classId.getPackageFqName(), INCLUDE_KOTLIN) - : javaClassResolver - .resolveClass(kotlinFqNameToJavaFqName(classId.getOuterClassId().asSingleFqName())); + ? javaNamespaceResolver.resolveNamespace(classId.getPackageFqName(), INCLUDE_KOTLIN_SOURCES) + : javaClassResolver.resolveClass(kotlinFqNameToJavaFqName(classId.getOuterClassId().asSingleFqName()), + IGNORE_KOTLIN_SOURCES); assert owner != null : "No owner found for " + classId; return new DeserializedClassDescriptor(classId, storageManager, owner, classData.getNameResolver(), diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java index d1792f5262f..aa27fb45ff1 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java @@ -26,7 +26,6 @@ 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.JvmAnnotationNames; import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -37,6 +36,8 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.List; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; + public final class JavaAnnotationResolver { private JavaClassResolver classResolver; private JavaCompileTimeConstResolver compileTimeConstResolver; @@ -99,8 +100,7 @@ public final class JavaAnnotationResolver { return mappedClassDescriptor; } - final ClassDescriptor annotationClass = - classResolver.resolveClass(annotationFqName, DescriptorSearchRule.INCLUDE_KOTLIN, postponedTasks); + final ClassDescriptor annotationClass = classResolver.resolveClass(annotationFqName, INCLUDE_KOTLIN_SOURCES, postponedTasks); if (annotationClass == null) { return null; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java index 8640b2593d8..e7bab6a1c6c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java @@ -57,6 +57,7 @@ import java.util.*; import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValueOfMethod; import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValuesMethod; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; public final class JavaClassResolver { @@ -428,15 +429,14 @@ public final class JavaClassResolver { private ClassOrNamespaceDescriptor resolveParentDescriptor(@NotNull FqName childClassFQName, boolean isInnerClass) { FqName parentFqName = childClassFQName.parent(); if (isInnerClass) { - ClassDescriptor parentClass = resolveClass(parentFqName, DescriptorSearchRule.INCLUDE_KOTLIN); + ClassDescriptor parentClass = resolveClass(parentFqName, INCLUDE_KOTLIN_SOURCES); if (parentClass == null) { throw new IllegalStateException("Could not resolve " + parentFqName + " required to be parent for " + childClassFQName); } return parentClass; } else { - //TODO: why do we include kotlin here? what this flags means anyway? - NamespaceDescriptor parentNamespace = namespaceResolver.resolveNamespace(parentFqName, DescriptorSearchRule.INCLUDE_KOTLIN); + NamespaceDescriptor parentNamespace = namespaceResolver.resolveNamespace(parentFqName, INCLUDE_KOTLIN_SOURCES); if (parentNamespace == null) { throw new IllegalStateException("Could not resolve " + parentFqName + " required to be parent for " + childClassFQName); } @@ -480,11 +480,6 @@ public final class JavaClassResolver { return ClassKind.CLASS; } - @Nullable - public ClassDescriptor resolveClass(FqName name) { - return resolveClass(name, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); - } - @NotNull private ClassDescriptorFromJvmBytecode createClassObjectDescriptorForEnum( @NotNull ClassDescriptor containing, diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaCompileTimeConstResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaCompileTimeConstResolver.java index 7b1f272ed91..da0994ff5d9 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaCompileTimeConstResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaCompileTimeConstResolver.java @@ -27,7 +27,6 @@ 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.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -40,6 +39,8 @@ import java.util.ArrayList; import java.util.Collection; import java.util.List; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; + public final class JavaCompileTimeConstResolver { private JavaAnnotationResolver annotationResolver; private JavaClassResolver classResolver; @@ -99,8 +100,7 @@ public final class JavaCompileTimeConstResolver { PsiAnnotationMemberValue[] initializers = value.getInitializers(); List> values = getCompileTimeConstantForArrayValues(annotationFqName, valueName, taskList, initializers); - ClassDescriptor classDescriptor = - classResolver.resolveClass(annotationFqName, DescriptorSearchRule.INCLUDE_KOTLIN, taskList); + ClassDescriptor classDescriptor = classResolver.resolveClass(annotationFqName, INCLUDE_KOTLIN_SOURCES, taskList); //TODO: nullability issues ValueParameterDescriptor valueParameterDescriptor = @@ -143,7 +143,7 @@ public final class JavaCompileTimeConstResolver { } JetScope scope; - ClassDescriptor classDescriptor = classResolver.resolveClass(new FqName(fqName), DescriptorSearchRule.INCLUDE_KOTLIN, taskList); + ClassDescriptor classDescriptor = classResolver.resolveClass(new FqName(fqName), INCLUDE_KOTLIN_SOURCES, taskList); if (classDescriptor == null) { return null; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java index 4cabe6e4fd1..10870cfe3fb 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java @@ -49,6 +49,8 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope; import javax.inject.Inject; import java.util.*; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; + public final class JavaNamespaceResolver { @NotNull @@ -137,18 +139,13 @@ public final class JavaNamespaceResolver { return javaNamespaceDescriptor; } - @Nullable - public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName) { - return resolveNamespace(qualifiedName, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); - } - @Nullable private NamespaceDescriptorParent resolveParentNamespace(@NotNull FqName fqName) { if (fqName.isRoot()) { return FAKE_ROOT_MODULE; } else { - return resolveNamespace(fqName.parent(), DescriptorSearchRule.INCLUDE_KOTLIN); + return resolveNamespace(fqName.parent(), INCLUDE_KOTLIN_SOURCES); } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java index 0a055c3d390..6ac3b46c5ea 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java @@ -24,7 +24,10 @@ 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.java.JavaTypeTransformer; +import org.jetbrains.jet.lang.resolve.java.JvmAbi; +import org.jetbrains.jet.lang.resolve.java.TypeUsage; +import org.jetbrains.jet.lang.resolve.java.TypeVariableResolver; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; @@ -36,6 +39,8 @@ import java.util.ArrayList; import java.util.Collection; import java.util.List; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; + public final class JavaSupertypeResolver { private static final FqName OBJECT_FQ_NAME = new FqName("java.lang.Object"); @@ -85,7 +90,7 @@ public final class JavaSupertypeResolver { result.add(KotlinBuiltIns.getInstance().getAnyType()); } else { - ClassDescriptor object = classResolver.resolveClass(OBJECT_FQ_NAME, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); + ClassDescriptor object = classResolver.resolveClass(OBJECT_FQ_NAME, IGNORE_KOTLIN_SOURCES); if (object != null) { result.add(object.getDefaultType()); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassNonStaticMembersScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassNonStaticMembersScope.java index 0ac3d378de9..1acc2c98be9 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassNonStaticMembersScope.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassNonStaticMembersScope.java @@ -21,7 +21,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor; -import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.PsiClassFinder; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -31,6 +30,8 @@ import java.util.Collection; import java.util.Collections; import java.util.List; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; + public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope { private Collection constructors = null; @@ -102,8 +103,7 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope private ClassDescriptor resolveInnerClass(@NotNull PsiClass innerPsiClass) { String name = innerPsiClass.getQualifiedName(); assert name != null : "Inner class has no qualified name: " + innerPsiClass; - ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(new FqName(name), - DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); + ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(new FqName(name), IGNORE_KOTLIN_SOURCES); assert classDescriptor != null : "Couldn't resolve inner class " + name; return classDescriptor; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java index f2222ae9966..f630c405d20 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java @@ -22,7 +22,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.PsiClassFinder; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -31,6 +30,8 @@ import org.jetbrains.jet.lang.resolve.name.Name; import java.util.Collection; import java.util.Collections; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; + public final class JavaClassStaticMembersScope extends JavaClassMembersScope { @NotNull private final FqName packageFQN; @@ -51,7 +52,7 @@ public final class JavaClassStaticMembersScope extends JavaClassMembersScope { @Override public NamespaceDescriptor getNamespace(@NotNull Name name) { - return javaDescriptorResolver.resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN); + return javaDescriptorResolver.resolveNamespace(packageFQN.child(name), INCLUDE_KOTLIN_SOURCES); } @NotNull diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScope.java index 959de9e4033..b3ebc51c35a 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScope.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScope.java @@ -23,7 +23,10 @@ import com.intellij.psi.PsiModifier; import com.intellij.psi.PsiPackage; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.resolve.java.*; +import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; +import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker; +import org.jetbrains.jet.lang.resolve.java.PsiClassFinder; import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; @@ -32,6 +35,9 @@ import java.util.Collection; import java.util.Collections; import java.util.Set; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; + public final class JavaPackageScope extends JavaBaseScope { @NotNull private final PsiPackage psiPackage; @@ -61,8 +67,7 @@ public final class JavaPackageScope extends JavaBaseScope { @Override public ClassifierDescriptor getClassifier(@NotNull Name name) { - ClassDescriptor classDescriptor = - javaDescriptorResolver.resolveClass(packageFQN.child(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); + ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(packageFQN.child(name), IGNORE_KOTLIN_SOURCES); if (classDescriptor == null || classDescriptor.getKind().isObject()) { return null; } @@ -71,8 +76,7 @@ public final class JavaPackageScope extends JavaBaseScope { @Override public ClassDescriptor getObjectDescriptor(@NotNull Name name) { - ClassDescriptor classDescriptor = - javaDescriptorResolver.resolveClass(packageFQN.child(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); + ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(packageFQN.child(name), IGNORE_KOTLIN_SOURCES); if (classDescriptor != null && classDescriptor.getKind().isObject()) { return classDescriptor; } @@ -81,7 +85,7 @@ public final class JavaPackageScope extends JavaBaseScope { @Override public NamespaceDescriptor getNamespace(@NotNull Name name) { - return javaDescriptorResolver.resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN); + return javaDescriptorResolver.resolveNamespace(packageFQN.child(name), INCLUDE_KOTLIN_SOURCES); } @NotNull @@ -98,7 +102,7 @@ public final class JavaPackageScope extends JavaBaseScope { for (PsiPackage psiSubPackage : psiPackage.getSubPackages()) { FqName fqName = new FqName(psiSubPackage.getQualifiedName()); - NamespaceDescriptor childNs = javaDescriptorResolver.resolveNamespace(fqName, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); + NamespaceDescriptor childNs = javaDescriptorResolver.resolveNamespace(fqName, IGNORE_KOTLIN_SOURCES); if (childNs != null) { result.add(childNs); } @@ -117,12 +121,12 @@ public final class JavaPackageScope extends JavaBaseScope { if (qualifiedName == null) continue; FqName fqName = new FqName(qualifiedName); - ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(fqName, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); + ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(fqName, IGNORE_KOTLIN_SOURCES); if (classDescriptor != null) { result.add(classDescriptor); } - NamespaceDescriptor namespace = javaDescriptorResolver.resolveNamespace(fqName, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); + NamespaceDescriptor namespace = javaDescriptorResolver.resolveNamespace(fqName, IGNORE_KOTLIN_SOURCES); if (namespace != null) { result.add(namespace); } diff --git a/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java b/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java index 751521a2923..187f41cc8b0 100644 --- a/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java +++ b/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java @@ -44,6 +44,7 @@ import java.util.*; import static org.jetbrains.jet.descriptors.serialization.ClassSerializationUtil.getClassId; import static org.jetbrains.jet.descriptors.serialization.NameSerializationUtil.createNameResolver; import static org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer.UNSUPPORTED; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; import static org.jetbrains.jet.lang.resolve.java.resolver.DeserializedResolverUtils.naiveKotlinFqName; public abstract class AbstractDescriptorSerializationTest extends KotlinTestWithEnvironment { @@ -184,7 +185,7 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith @Override public ClassDescriptor findClass(@NotNull ClassId classId) { ClassDescriptor found = super.findClass(classId); - return found != null ? found : javaDescriptorResolver.resolveClass(classId.asSingleFqName().toSafe()); + return found != null ? found : javaDescriptorResolver.resolveClass(classId.asSingleFqName().toSafe(), IGNORE_KOTLIN_SOURCES); } @Nullable diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java index d2e4b026ba7..8ea189ffa4b 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java @@ -39,7 +39,6 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; -import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.test.TestCaseWithTmpdir; import org.junit.Assert; @@ -52,6 +51,7 @@ import java.util.Collections; import java.util.List; import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.*; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; import static org.jetbrains.jet.test.util.DescriptorValidator.ValidationVisitor.ALLOW_ERROR_TYPES; import static org.jetbrains.jet.test.util.NamespaceComparator.*; @@ -159,8 +159,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles(environment.getSourceFiles(), Collections.emptyList()); JavaDescriptorResolver javaDescriptorResolver = injectorForJava.getJavaDescriptorResolver(); - NamespaceDescriptor namespaceDescriptor = javaDescriptorResolver.resolveNamespace( - LoadDescriptorUtil.TEST_PACKAGE_FQNAME, DescriptorSearchRule.INCLUDE_KOTLIN); + NamespaceDescriptor namespaceDescriptor = javaDescriptorResolver.resolveNamespace(TEST_PACKAGE_FQNAME, INCLUDE_KOTLIN_SOURCES); assert namespaceDescriptor != null : "Test namespace not found"; checkJavaNamespace(expectedFile, namespaceDescriptor, trace.getBindingContext(), DONT_INCLUDE_METHODS_OF_OBJECT); diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/JdkAnnotationsValidityTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/JdkAnnotationsValidityTest.java index 172f32adbbf..f302b75a092 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/JdkAnnotationsValidityTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/JdkAnnotationsValidityTest.java @@ -45,8 +45,8 @@ import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.JavaBindingContext; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; -import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.TypeTransformingVisitor; +import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.renderer.DescriptorRenderer; @@ -59,6 +59,8 @@ import java.util.Set; import java.util.regex.Matcher; import java.util.regex.Pattern; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; + public class JdkAnnotationsValidityTest extends UsefulTestCase { private static final int CLASSES_IN_CHUNK = 500; @@ -103,8 +105,8 @@ public class JdkAnnotationsValidityTest extends UsefulTestCase { int chunkStart = chunkIndex * CLASSES_IN_CHUNK; for (FqName javaClass : affectedClasses.subList(chunkStart, Math.min(chunkStart + CLASSES_IN_CHUNK, affectedClasses.size()))) { - ClassDescriptor topLevelClass = javaDescriptorResolver.resolveClass(javaClass); - NamespaceDescriptor topLevelNamespace = javaDescriptorResolver.resolveNamespace(javaClass); + ClassDescriptor topLevelClass = javaDescriptorResolver.resolveClass(javaClass, IGNORE_KOTLIN_SOURCES); + NamespaceDescriptor topLevelNamespace = javaDescriptorResolver.resolveNamespace(javaClass, IGNORE_KOTLIN_SOURCES); if (topLevelClass == null) { continue; } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java index 6ca2fe16487..7f7cd55bcdd 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java @@ -37,7 +37,6 @@ import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; -import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; @@ -48,6 +47,7 @@ import java.util.Collection; import java.util.Collections; import static org.jetbrains.jet.JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; public final class LoadDescriptorUtil { @@ -99,7 +99,7 @@ public final class LoadDescriptorUtil { BindingTraceContext trace = new BindingTraceContext(); InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(jetCoreEnvironment.getProject(), trace); NamespaceDescriptor namespaceDescriptor = - injector.getJavaDescriptorResolver().resolveNamespace(TEST_PACKAGE_FQNAME, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); + injector.getJavaDescriptorResolver().resolveNamespace(TEST_PACKAGE_FQNAME, IGNORE_KOTLIN_SOURCES); assert namespaceDescriptor != null; return Pair.create(namespaceDescriptor, trace.getBindingContext()); diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java index 4740c6b00c4..c364670e51e 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java @@ -35,7 +35,6 @@ import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.resolve.BindingTraceContext; -import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.utils.PathUtil; @@ -46,6 +45,8 @@ import java.util.List; import java.util.zip.ZipEntry; import java.util.zip.ZipInputStream; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; + public class ResolveDescriptorsFromExternalLibraries { @@ -190,7 +191,7 @@ public class ResolveDescriptorsFromExternalLibraries { String className = entryName.substring(0, entryName.length() - ".class".length()).replace("/", "."); try { - ClassDescriptor clazz = javaDescriptorResolver.resolveClass(new FqName(className), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); + ClassDescriptor clazz = javaDescriptorResolver.resolveClass(new FqName(className), IGNORE_KOTLIN_SOURCES); if (clazz == null) { throw new IllegalStateException("class not found by name " + className + " in " + libDescription); } diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index 86650c299da..36f3f92d233 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -36,7 +36,6 @@ import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; -import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.lazy.LazyResolveTestUtil; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -54,6 +53,9 @@ import java.io.File; import java.io.IOException; import java.util.*; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; + public class JetTypeCheckerTest extends JetLiteFixture { private KotlinBuiltIns builtIns; @@ -580,15 +582,14 @@ public class JetTypeCheckerTest extends JetLiteFixture { return addImports(testData.getMemberScope()); } + @SuppressWarnings("ConstantConditions") private WritableScopeImpl addImports(JetScope scope) { WritableScopeImpl writableScope = new WritableScopeImpl( scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "JetTypeCheckerTest.addImports"); InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(getProject(), new BindingTraceContext()); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); - writableScope.importScope(javaDescriptorResolver.resolveNamespace(FqName.ROOT, - DescriptorSearchRule.INCLUDE_KOTLIN).getMemberScope()); - writableScope.importScope(javaDescriptorResolver.resolveNamespace(new FqName("java.lang"), - DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN).getMemberScope()); + writableScope.importScope(javaDescriptorResolver.resolveNamespace(FqName.ROOT, INCLUDE_KOTLIN_SOURCES).getMemberScope()); + writableScope.importScope(javaDescriptorResolver.resolveNamespace(new FqName("java.lang"), IGNORE_KOTLIN_SOURCES).getMemberScope()); writableScope.changeLockLevel(WritableScope.LockLevel.BOTH); writableScope.importScope(builtIns.getBuiltInsScope()); return writableScope; diff --git a/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureAnnotationIntention.java b/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureAnnotationIntention.java index 8b402047000..86e47869e4b 100644 --- a/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureAnnotationIntention.java +++ b/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureAnnotationIntention.java @@ -37,7 +37,6 @@ import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTraceContext; -import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; @@ -49,6 +48,8 @@ import org.jetbrains.jet.renderer.DescriptorRendererBuilder; import javax.swing.*; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; + public class KotlinSignatureAnnotationIntention extends BaseIntentionAction implements Iconable { private static final DescriptorRenderer RENDERER = new DescriptorRendererBuilder() .setShortNames(true) @@ -134,7 +135,7 @@ public class KotlinSignatureAnnotationIntention extends BaseIntentionAction impl private static String getDefaultSignature(@NotNull PsiMethod method, FqName classFqName, JavaDescriptorResolver javaDescriptorResolver, BindingContext context) { if (method.getReturnType() == null) { // For constructor - ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(classFqName); + ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(classFqName, IGNORE_KOTLIN_SOURCES); assert classDescriptor != null: "Couldn't resolve class descriptor for " + classFqName; classDescriptor.getConstructors(); @@ -185,12 +186,12 @@ public class KotlinSignatureAnnotationIntention extends BaseIntentionAction impl @NotNull private static JetScope getMemberScope(PsiModifierListOwner psiModifierListOwner, FqName classFqName, JavaDescriptorResolver javaDescriptorResolver) { if (psiModifierListOwner.hasModifierProperty(PsiModifier.STATIC)) { - NamespaceDescriptor namespaceDescriptor = javaDescriptorResolver.resolveNamespace(classFqName); + NamespaceDescriptor namespaceDescriptor = javaDescriptorResolver.resolveNamespace(classFqName, IGNORE_KOTLIN_SOURCES); assert namespaceDescriptor != null: "Couldn't resolve namespace descriptor for " + classFqName; return namespaceDescriptor.getMemberScope(); } - ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(classFqName); + ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(classFqName, IGNORE_KOTLIN_SOURCES); assert classDescriptor != null: "Couldn't resolve class descriptor for " + classFqName; return classDescriptor.getDefaultType().getMemberScope(); } diff --git a/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureInJavaMarkerProvider.java b/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureInJavaMarkerProvider.java index be6873a9f8b..7141d372f09 100644 --- a/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureInJavaMarkerProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureInJavaMarkerProvider.java @@ -55,6 +55,8 @@ import java.awt.event.MouseEvent; import java.util.Collection; import java.util.List; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; + public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider { private static final String SHOW_MARKERS_PROPERTY = "kotlin.signature.markers.enabled"; @@ -152,7 +154,7 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider { @NotNull PsiMember member ) { if (member.hasModifierProperty(PsiModifier.STATIC)) { - NamespaceDescriptor packageDescriptor = javaDescriptorResolver.resolveNamespace(classFqName); + NamespaceDescriptor packageDescriptor = javaDescriptorResolver.resolveNamespace(classFqName, IGNORE_KOTLIN_SOURCES); if (packageDescriptor == null) { return null; } @@ -160,7 +162,7 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider { return packageDescriptor.getMemberScope(); } else { - ClassDescriptor klass = javaDescriptorResolver.resolveClass(classFqName); + ClassDescriptor klass = javaDescriptorResolver.resolveClass(classFqName, IGNORE_KOTLIN_SOURCES); if (klass == null) { return null; } diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java b/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java index 35b55154ccc..27730518ec1 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java @@ -26,7 +26,6 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.MemberComparator; -import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.KotlinClassFileHeader; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -35,6 +34,7 @@ import org.jetbrains.jet.renderer.DescriptorRendererBuilder; import java.util.*; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; import static org.jetbrains.jet.plugin.libraries.JetDecompiledData.descriptorToKey; public final class DecompiledDataFactory { @@ -73,7 +73,7 @@ public final class DecompiledDataFactory { appendDecompiledTextAndPackageName(packageFqName); KotlinClassFileHeader.HeaderType type = kotlinClassFileHeader.getType(); if (type == KotlinClassFileHeader.HeaderType.PACKAGE) { - NamespaceDescriptor nd = javaDescriptorResolver.resolveNamespace(packageFqName, DescriptorSearchRule.INCLUDE_KOTLIN); + NamespaceDescriptor nd = javaDescriptorResolver.resolveNamespace(packageFqName, INCLUDE_KOTLIN_SOURCES); if (nd != null) { for (DeclarationDescriptor member : sortDeclarations(nd.getMemberScope().getAllDescriptors())) { if (member instanceof ClassDescriptor || member instanceof NamespaceDescriptor @@ -88,7 +88,7 @@ public final class DecompiledDataFactory { else { assert type == KotlinClassFileHeader.HeaderType.CLASS; ClassDescriptor cd = javaDescriptorResolver.resolveClass(kotlinClassFileHeader.getJvmClassName().getFqName(), - DescriptorSearchRule.INCLUDE_KOTLIN); + INCLUDE_KOTLIN_SOURCES); if (cd != null) { appendDescriptor(cd, ""); } diff --git a/idea/tests/org/jetbrains/jet/plugin/ktSignature/SignatureMarkerProviderTest.java b/idea/tests/org/jetbrains/jet/plugin/ktSignature/SignatureMarkerProviderTest.java index f284a1c0828..7ed132d4e2a 100644 --- a/idea/tests/org/jetbrains/jet/plugin/ktSignature/SignatureMarkerProviderTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/ktSignature/SignatureMarkerProviderTest.java @@ -32,6 +32,8 @@ import org.jetbrains.jet.plugin.JetLightProjectDescriptor; import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManager; import org.jetbrains.jet.plugin.project.TargetPlatform; +import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; + public class SignatureMarkerProviderTest extends LightCodeInsightFixtureTestCase { @NotNull @@ -53,7 +55,8 @@ public class SignatureMarkerProviderTest extends LightCodeInsightFixtureTestCase InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, KotlinSignatureInJavaMarkerProvider.createDelegatingTrace(project)); - ClassDescriptor reResolvedClass = injector.getJavaDescriptorResolver().resolveClass(new FqName("java.lang.Thread")); + ClassDescriptor reResolvedClass = injector.getJavaDescriptorResolver() + .resolveClass(new FqName("java.lang.Thread"), IGNORE_KOTLIN_SOURCES); assertSame(preResolvedClass, reResolvedClass); }