From 2a3126e71eb551b226974418ff04093e8ce05eb1 Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Tue, 20 Mar 2012 00:16:15 +0400 Subject: [PATCH] DescriptorSearchRule should help detecting loops --- .../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 | 17 ++--- .../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, 108 insertions(+), 48 deletions(-) create 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 new file mode 100644 index 00000000000..494635e7206 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorSearchRule.java @@ -0,0 +1,26 @@ +/* + * 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 46cb4da7a53..40338891a1e 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); + ClassDescriptor classDescriptor = semanticServices.getDescriptorResolver().resolveClass(innerClass, 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 72a110875e3..526235fe374 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) { + ResolverClassData resolveClassData(@NotNull PsiClass psiClass, @NotNull DescriptorSearchRule searchRule) { FqName qualifiedName = new FqName(psiClass.getQualifiedName()); if (qualifiedName.getFqName().endsWith(JvmAbi.TRAIT_IMPL_SUFFIX)) { @@ -219,17 +219,30 @@ 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) { - // TODO: return null, no loops here - return new ResolverSrcClassData(kotlinClassDescriptor); + 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); + resolveClass(containingClass, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); } // Not let's take a descriptor of a Java class @@ -242,8 +255,8 @@ public class JavaDescriptorResolver { } @Nullable - public ClassDescriptor resolveClass(@NotNull PsiClass psiClass) { - ResolverClassData classData = resolveClassData(psiClass); + public ClassDescriptor resolveClass(@NotNull PsiClass psiClass, @NotNull DescriptorSearchRule searchRule) { + ResolverClassData classData = resolveClassData(psiClass, searchRule); if (classData != null) { return classData.getClassDescriptor(); } else { @@ -252,18 +265,30 @@ public class JavaDescriptorResolver { } @Nullable - public ClassDescriptor resolveClass(@NotNull FqName qualifiedName) { + public ClassDescriptor resolveClass(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) { 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) { - // TODO: return null, no loops here - return kotlinClassDescriptor; + 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); + } } // Not let's take a descriptor of a Java class @@ -509,7 +534,7 @@ public class JavaDescriptorResolver { @NotNull private ClassDescriptor getJavaLangObject() { if (javaLangObject == null) { - javaLangObject = resolveClass(new FqName("java.lang.Object")); + javaLangObject = resolveClass(new FqName("java.lang.Object"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); } return javaLangObject; } @@ -653,10 +678,10 @@ public class JavaDescriptorResolver { private ClassOrNamespaceDescriptor resolveParentDescriptor(PsiClass psiClass) { PsiClass containingClass = psiClass.getContainingClass(); if (containingClass != null) { - return resolveClass(containingClass); + return resolveClass(containingClass, DescriptorSearchRule.INCLUDE_KOTLIN); } - return resolveNamespace(new FqName(psiClass.getQualifiedName()).parent()); + return resolveNamespace(new FqName(psiClass.getQualifiedName()).parent(), DescriptorSearchRule.INCLUDE_KOTLIN); } private List makeUninitializedTypeParameters(@NotNull DeclarationDescriptor containingDeclaration, @NotNull PsiTypeParameter[] typeParameters) { @@ -786,11 +811,20 @@ public class JavaDescriptorResolver { } @Nullable - public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName) { + public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) { // First, let's check that there is no Kotlin package: NamespaceDescriptor kotlinNamespaceDescriptor = semanticServices.getKotlinNamespaceDescriptor(qualifiedName); if (kotlinNamespaceDescriptor != null) { - return kotlinNamespaceDescriptor; + 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); + } } PsiPackage psiPackage = findPackage(qualifiedName); @@ -1445,7 +1479,7 @@ public class JavaDescriptorResolver { ClassOrNamespaceDescriptor classDescriptor; if (scopeData instanceof ResolverBinaryClassData) { - ClassDescriptor classClassDescriptor = resolveClass(method.getPsiMethod().getContainingClass()); + ClassDescriptor classClassDescriptor = resolveClass(method.getPsiMethod().getContainingClass(), DescriptorSearchRule.INCLUDE_KOTLIN); classDescriptor = classClassDescriptor; } else { @@ -1511,7 +1545,7 @@ public class JavaDescriptorResolver { return null; } - ClassDescriptor clazz = resolveClass(new FqName(psiAnnotation.getQualifiedName())); + ClassDescriptor clazz = resolveClass(new FqName(psiAnnotation.getQualifiedName()), DescriptorSearchRule.INCLUDE_KOTLIN); if (clazz == null) { return null; } @@ -1662,7 +1696,7 @@ public class JavaDescriptorResolver { if (innerPsiClass.getName().equals(JvmAbi.CLASS_OBJECT_CLASS_NAME)) { continue; } - r.add(resolveClass(innerPsiClass)); + r.add(resolveClass(innerPsiClass, 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 198b4aa3ef9..84bfb74654e 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)); + ClassDescriptor classDescriptor = semanticServices.getDescriptorResolver().resolveClass(getQualifiedName(packageFQN, name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); 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)); + return semanticServices.getDescriptorResolver().resolveNamespace(getQualifiedName(packageFQN, name), DescriptorSearchRule.INCLUDE_KOTLIN); } @Override @@ -114,8 +114,9 @@ public class JavaPackageScope extends JavaClassOrPackageScope { final JavaDescriptorResolver descriptorResolver = semanticServices.getDescriptorResolver(); for (PsiPackage psiSubPackage : javaPackage.getSubPackages()) { - if (semanticServices.getKotlinNamespaceDescriptor(new FqName(psiSubPackage.getQualifiedName())) == null) { - allDescriptors.add(descriptorResolver.resolveNamespace(new FqName(psiSubPackage.getQualifiedName()))); + NamespaceDescriptor childNs = descriptorResolver.resolveNamespace(new FqName(psiSubPackage.getQualifiedName()), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); + if (childNs != null) { + allDescriptors.add(childNs); } } @@ -123,10 +124,8 @@ public class JavaPackageScope extends JavaClassOrPackageScope { if (isKotlinNamespace && JvmAbi.PACKAGE_CLASS.equals(psiClass.getName())) { continue; } - - // 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) { + + if (psiClass instanceof JetJavaMirrorMarker) { continue; } @@ -136,7 +135,7 @@ public class JavaPackageScope extends JavaClassOrPackageScope { } if (psiClass.hasModifierProperty(PsiModifier.PUBLIC)) { - ClassDescriptor classDescriptor = descriptorResolver.resolveClass(psiClass); + ClassDescriptor classDescriptor = descriptorResolver.resolveClass(psiClass, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); 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 b7296338f1f..c05652899b2 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,17 +57,18 @@ public class JavaSemanticServices { @Nullable public ClassDescriptor getKotlinClassDescriptor(@NotNull FqName qualifiedName) { - if (qualifiedName.getFqName().startsWith("jet.")) { - 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 + 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; + } + } + @Nullable public NamespaceDescriptor getKotlinNamespaceDescriptor(@NotNull FqName qualifiedName) { return getTrace().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, qualifiedName); 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 4e555446b08..fac8d4e0868 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); + final JavaDescriptorResolver.ResolverClassData classData = resolver.resolveClassData(psiClass, DescriptorSearchRule.INCLUDE_KOTLIN); 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 a74c29a558c..089d4c83324 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); + this.classDescriptor = javaDescriptorResolver.resolveClass(ourName, DescriptorSearchRule.INCLUDE_KOTLIN); } 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 5b1a8ab6b23..02c9ea23c2e 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java +++ b/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java @@ -33,6 +33,7 @@ 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; @@ -115,7 +116,7 @@ public class ReadJavaBinaryClassTest extends TestCaseWithTmpdir { JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), new BindingTraceContext()); JavaDescriptorResolver javaDescriptorResolver = semanticServices.getDescriptorResolver(); - return javaDescriptorResolver.resolveNamespace(FqName.topLevel("test")); + return javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); } 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 d3ae41cea21..d0af3c24d4e 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java +++ b/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java @@ -35,6 +35,7 @@ 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; @@ -93,7 +94,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")); + NamespaceDescriptor namespaceFromClass = javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); 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 b1e8975ade9..322b0bcc8f5 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -28,10 +28,7 @@ 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.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.java.*; 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; @@ -588,8 +585,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).getMemberScope()); - writableScope.importScope(javaSemanticServices.getDescriptorResolver().resolveNamespace(new FqName("java.lang")).getMemberScope()); + 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.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 a673389f08f..385e252eb94 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java @@ -32,6 +32,7 @@ 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; @@ -81,7 +82,7 @@ class DecompiledDataFactory { PsiClass psiClass = myClsFile.getClasses()[0]; if (isKotlinNamespaceClass(psiClass)) { - NamespaceDescriptor nd = myJavaDescriptorResolver.resolveNamespace(new FqName(packageName)); + NamespaceDescriptor nd = myJavaDescriptorResolver.resolveNamespace(new FqName(packageName), DescriptorSearchRule.INCLUDE_KOTLIN); if (nd != null) { for (DeclarationDescriptor member : sortDeclarations(nd.getMemberScope().getAllDescriptors())) { @@ -93,7 +94,7 @@ class DecompiledDataFactory { } } } else { - ClassDescriptor cd = myJavaDescriptorResolver.resolveClass(psiClass); + ClassDescriptor cd = myJavaDescriptorResolver.resolveClass(psiClass, DescriptorSearchRule.INCLUDE_KOTLIN); if (cd != null) { appendDescriptor(cd, ""); }