From 1a34a9976e990f84b7048e20aceeb9b4248fc735 Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Tue, 20 Mar 2012 00:42:44 +0400 Subject: [PATCH] Revert "DescriptorSearchRule should help detecting loops" This reverts commit 2a3126e71eb551b226974418ff04093e8ce05eb1. Commit breaks alt-headers compilation --- .../resolve/java/DescriptorSearchRule.java | 26 ------- .../resolve/java/JavaClassMembersScope.java | 2 +- .../resolve/java/JavaDescriptorResolver.java | 70 +++++-------------- .../lang/resolve/java/JavaPackageScope.java | 17 ++--- .../resolve/java/JavaSemanticServices.java | 15 ++-- .../resolve/java/JavaTypeTransformer.java | 2 +- .../java/JetTypeJetSignatureReader.java | 2 +- .../jet/compiler/ReadJavaBinaryClassTest.java | 3 +- .../compiler/ReadKotlinBinaryClassTest.java | 3 +- .../jet/types/JetTypeCheckerTest.java | 9 ++- .../libraries/DecompiledDataFactory.java | 5 +- 11 files changed, 47 insertions(+), 107 deletions(-) delete mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorSearchRule.java 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 deleted file mode 100644 index 494635e7206..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorSearchRule.java +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright 2010-2012 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.jet.lang.resolve.java; - -/** - * @author Stepan Koltsov - */ -public enum DescriptorSearchRule { - INCLUDE_KOTLIN, - IGNORE_IF_FOUND_IN_KOTLIN, - ERROR_IF_FOUND_IN_KOTLIN, -} 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..46cb4da7a53 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 @@ -103,7 +103,7 @@ 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(innerClass); 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 526235fe374..72a110875e3 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 @@ -211,7 +211,7 @@ public class JavaDescriptorResolver { } @Nullable - ResolverClassData resolveClassData(@NotNull PsiClass psiClass, @NotNull DescriptorSearchRule searchRule) { + ResolverClassData resolveClassData(@NotNull PsiClass psiClass) { FqName qualifiedName = new FqName(psiClass.getQualifiedName()); if (qualifiedName.getFqName().endsWith(JvmAbi.TRAIT_IMPL_SUFFIX)) { @@ -219,30 +219,17 @@ public class JavaDescriptorResolver { 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); - } + // TODO: return null, no loops here + return new ResolverSrcClassData(kotlinClassDescriptor); } 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); + resolveClass(containingClass); } // Not let's take a descriptor of a Java class @@ -255,8 +242,8 @@ public class JavaDescriptorResolver { } @Nullable - public ClassDescriptor resolveClass(@NotNull PsiClass psiClass, @NotNull DescriptorSearchRule searchRule) { - ResolverClassData classData = resolveClassData(psiClass, searchRule); + public ClassDescriptor resolveClass(@NotNull PsiClass psiClass) { + ResolverClassData classData = resolveClassData(psiClass); if (classData != null) { return classData.getClassDescriptor(); } else { @@ -265,30 +252,18 @@ public class JavaDescriptorResolver { } @Nullable - public ClassDescriptor resolveClass(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) { + public ClassDescriptor resolveClass(@NotNull FqName qualifiedName) { 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 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) { - return kotlinClassDescriptor; - } else { - throw new IllegalStateException("unknown searchRule: " + searchRule); - } + // TODO: return null, no loops here + return kotlinClassDescriptor; } // Not let's take a descriptor of a Java class @@ -534,7 +509,7 @@ public class JavaDescriptorResolver { @NotNull private ClassDescriptor getJavaLangObject() { if (javaLangObject == null) { - javaLangObject = resolveClass(new FqName("java.lang.Object"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); + javaLangObject = resolveClass(new FqName("java.lang.Object")); } return javaLangObject; } @@ -678,10 +653,10 @@ public class JavaDescriptorResolver { private ClassOrNamespaceDescriptor resolveParentDescriptor(PsiClass psiClass) { PsiClass containingClass = psiClass.getContainingClass(); if (containingClass != null) { - return resolveClass(containingClass, DescriptorSearchRule.INCLUDE_KOTLIN); + return resolveClass(containingClass); } - return resolveNamespace(new FqName(psiClass.getQualifiedName()).parent(), DescriptorSearchRule.INCLUDE_KOTLIN); + return resolveNamespace(new FqName(psiClass.getQualifiedName()).parent()); } private List makeUninitializedTypeParameters(@NotNull DeclarationDescriptor containingDeclaration, @NotNull PsiTypeParameter[] typeParameters) { @@ -811,20 +786,11 @@ public class JavaDescriptorResolver { } @Nullable - public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) { + public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName) { // First, let's check that there is no Kotlin package: NamespaceDescriptor kotlinNamespaceDescriptor = semanticServices.getKotlinNamespaceDescriptor(qualifiedName); if (kotlinNamespaceDescriptor != 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 kotlinNamespaceDescriptor; - } else { - throw new IllegalStateException("unknown searchRule: " + searchRule); - } + return kotlinNamespaceDescriptor; } PsiPackage psiPackage = findPackage(qualifiedName); @@ -1479,7 +1445,7 @@ public class JavaDescriptorResolver { ClassOrNamespaceDescriptor classDescriptor; if (scopeData instanceof ResolverBinaryClassData) { - ClassDescriptor classClassDescriptor = resolveClass(method.getPsiMethod().getContainingClass(), DescriptorSearchRule.INCLUDE_KOTLIN); + ClassDescriptor classClassDescriptor = resolveClass(method.getPsiMethod().getContainingClass()); classDescriptor = classClassDescriptor; } else { @@ -1545,7 +1511,7 @@ public class JavaDescriptorResolver { return null; } - ClassDescriptor clazz = resolveClass(new FqName(psiAnnotation.getQualifiedName()), DescriptorSearchRule.INCLUDE_KOTLIN); + ClassDescriptor clazz = resolveClass(new FqName(psiAnnotation.getQualifiedName())); if (clazz == null) { return null; } @@ -1696,7 +1662,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(innerPsiClass)); } 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 84bfb74654e..198b4aa3ef9 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 @@ -66,7 +66,7 @@ public class JavaPackageScope extends JavaClassOrPackageScope { @Override public ClassifierDescriptor getClassifier(@NotNull String name) { - ClassDescriptor classDescriptor = semanticServices.getDescriptorResolver().resolveClass(getQualifiedName(packageFQN, name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); + ClassDescriptor classDescriptor = semanticServices.getDescriptorResolver().resolveClass(getQualifiedName(packageFQN, name)); if (classDescriptor == null || DescriptorUtils.isObject(classDescriptor)) { // TODO: this is a big hack against several things that I barely understand myself and cannot explain // 1. We should not return objects from this method, and maybe JDR.resolveClass should not return too @@ -84,7 +84,7 @@ public class JavaPackageScope extends JavaClassOrPackageScope { @Override public NamespaceDescriptor getNamespace(@NotNull String name) { - return semanticServices.getDescriptorResolver().resolveNamespace(getQualifiedName(packageFQN, name), DescriptorSearchRule.INCLUDE_KOTLIN); + return semanticServices.getDescriptorResolver().resolveNamespace(getQualifiedName(packageFQN, name)); } @Override @@ -114,9 +114,8 @@ public class JavaPackageScope extends JavaClassOrPackageScope { final JavaDescriptorResolver descriptorResolver = semanticServices.getDescriptorResolver(); for (PsiPackage psiSubPackage : javaPackage.getSubPackages()) { - NamespaceDescriptor childNs = descriptorResolver.resolveNamespace(new FqName(psiSubPackage.getQualifiedName()), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); - if (childNs != null) { - allDescriptors.add(childNs); + if (semanticServices.getKotlinNamespaceDescriptor(new FqName(psiSubPackage.getQualifiedName())) == null) { + allDescriptors.add(descriptorResolver.resolveNamespace(new FqName(psiSubPackage.getQualifiedName()))); } } @@ -124,8 +123,10 @@ public class JavaPackageScope extends JavaClassOrPackageScope { if (isKotlinNamespace && JvmAbi.PACKAGE_CLASS.equals(psiClass.getName())) { continue; } - - if (psiClass instanceof JetJavaMirrorMarker) { + + // If this is a Kotlin class, we have already taken it through a containing namespace descriptor + ClassDescriptor kotlinClassDescriptor = semanticServices.getKotlinClassDescriptor(new FqName(psiClass.getQualifiedName())); + if (kotlinClassDescriptor != null) { continue; } @@ -135,7 +136,7 @@ public class JavaPackageScope extends JavaClassOrPackageScope { } if (psiClass.hasModifierProperty(PsiModifier.PUBLIC)) { - ClassDescriptor classDescriptor = descriptorResolver.resolveClass(psiClass, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); + ClassDescriptor classDescriptor = descriptorResolver.resolveClass(psiClass); if (classDescriptor != null) { allDescriptors.add(classDescriptor); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java index c05652899b2..b7296338f1f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java @@ -57,16 +57,15 @@ public class JavaSemanticServices { @Nullable public ClassDescriptor getKotlinClassDescriptor(@NotNull FqName qualifiedName) { - return getTrace().get(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, qualifiedName); - } - - @Nullable - public ClassDescriptor getKotlinBuiltinClassDescriptor(@NotNull FqName qualifiedName) { if (qualifiedName.getFqName().startsWith("jet.")) { - return (ClassDescriptor) JetStandardLibrary.getInstance().getLibraryScope().getClassifier(qualifiedName.getFqName().substring("jet.".length())); - } else { - return null; + ClassDescriptor r = (ClassDescriptor) JetStandardLibrary.getInstance().getLibraryScope().getClassifier(qualifiedName.getFqName().substring("jet.".length())); + if (r == null) { + // TODO: better error + //throw new IllegalStateException(); + } + return r; } + return getTrace().get(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, qualifiedName); } @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 fac8d4e0868..4e555446b08 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 @@ -119,7 +119,7 @@ public class JavaTypeTransformer { return jetAnalog; } - final JavaDescriptorResolver.ResolverClassData classData = resolver.resolveClassData(psiClass, DescriptorSearchRule.INCLUDE_KOTLIN); + final JavaDescriptorResolver.ResolverClassData classData = resolver.resolveClassData(psiClass); if (classData == null) { return ErrorUtils.createErrorType("Unresolve java class: " + classType.getPresentableText()); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java index 089d4c83324..a74c29a558c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java @@ -117,7 +117,7 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd if (this.classDescriptor == null) { - this.classDescriptor = javaDescriptorResolver.resolveClass(ourName, DescriptorSearchRule.INCLUDE_KOTLIN); + this.classDescriptor = javaDescriptorResolver.resolveClass(ourName); } if (this.classDescriptor == null) { diff --git a/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java b/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java index 02c9ea23c2e..5b1a8ab6b23 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java +++ b/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java @@ -33,7 +33,6 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.FqName; 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.lang.resolve.java.JavaSemanticServices; import org.jetbrains.jet.plugin.JetLanguage; @@ -116,7 +115,7 @@ public class ReadJavaBinaryClassTest extends TestCaseWithTmpdir { JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), new BindingTraceContext()); JavaDescriptorResolver javaDescriptorResolver = semanticServices.getDescriptorResolver(); - return javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); + return javaDescriptorResolver.resolveNamespace(FqName.topLevel("test")); } public static Test suite() { diff --git a/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java b/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java index d0af3c24d4e..d3ae41cea21 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java +++ b/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java @@ -35,7 +35,6 @@ import org.jetbrains.jet.lang.resolve.AnalyzingUtils; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.FqName; -import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; import org.jetbrains.jet.plugin.JetLanguage; @@ -94,7 +93,7 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir { JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), new BindingTraceContext()); JavaDescriptorResolver javaDescriptorResolver = semanticServices.getDescriptorResolver(); - NamespaceDescriptor namespaceFromClass = javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); + NamespaceDescriptor namespaceFromClass = javaDescriptorResolver.resolveNamespace(FqName.topLevel("test")); NamespaceComparator.compareNamespaces(namespaceFromSource, namespaceFromClass, false, txtFile); } diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index 322b0bcc8f5..b1e8975ade9 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -28,7 +28,10 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.*; -import org.jetbrains.jet.lang.resolve.java.*; +import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; +import org.jetbrains.jet.lang.resolve.java.JavaPackageScope; +import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; import org.jetbrains.jet.lang.resolve.scopes.*; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; @@ -585,8 +588,8 @@ public class JetTypeCheckerTest extends JetLiteFixture { WritableScopeImpl writableScope = new WritableScopeImpl(scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING); writableScope.importScope(library.getLibraryScope()); JavaSemanticServices javaSemanticServices = new JavaSemanticServices(getProject(), JetTestUtils.DUMMY_TRACE); - writableScope.importScope(javaSemanticServices.getDescriptorResolver().resolveNamespace(FqName.ROOT, DescriptorSearchRule.INCLUDE_KOTLIN).getMemberScope()); - writableScope.importScope(javaSemanticServices.getDescriptorResolver().resolveNamespace(new FqName("java.lang"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN).getMemberScope()); + writableScope.importScope(javaSemanticServices.getDescriptorResolver().resolveNamespace(FqName.ROOT).getMemberScope()); + writableScope.importScope(javaSemanticServices.getDescriptorResolver().resolveNamespace(new FqName("java.lang")).getMemberScope()); writableScope.changeLockLevel(WritableScope.LockLevel.BOTH); return writableScope; } diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java b/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java index 385e252eb94..a673389f08f 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java @@ -32,7 +32,6 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.FqName; -import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; import org.jetbrains.jet.lang.resolve.java.JvmAbi; @@ -82,7 +81,7 @@ class DecompiledDataFactory { PsiClass psiClass = myClsFile.getClasses()[0]; if (isKotlinNamespaceClass(psiClass)) { - NamespaceDescriptor nd = myJavaDescriptorResolver.resolveNamespace(new FqName(packageName), DescriptorSearchRule.INCLUDE_KOTLIN); + NamespaceDescriptor nd = myJavaDescriptorResolver.resolveNamespace(new FqName(packageName)); if (nd != null) { for (DeclarationDescriptor member : sortDeclarations(nd.getMemberScope().getAllDescriptors())) { @@ -94,7 +93,7 @@ class DecompiledDataFactory { } } } else { - ClassDescriptor cd = myJavaDescriptorResolver.resolveClass(psiClass, DescriptorSearchRule.INCLUDE_KOTLIN); + ClassDescriptor cd = myJavaDescriptorResolver.resolveClass(psiClass); if (cd != null) { appendDescriptor(cd, ""); }