Fix resolve of inner and nested classes in JavaDescriptorResolver

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

@@ -16,7 +16,6 @@
 
 package org.jetbrains.jet.lang.resolve.java;
 
-import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -172,7 +171,10 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     }
 
     @NotNull
-    public List<ClassDescriptor> resolveInnerClasses(DeclarationDescriptor owner, PsiClass psiClass, boolean staticMembers) {
+    public List<ClassDescriptor> resolveInnerClasses(
-        return innerClassResolver.resolveInnerClasses(owner, psiClass, staticMembers);
+            @NotNull DeclarationDescriptor owner,
+            @NotNull ClassPsiDeclarationProvider declarationProvider)
+    {
+        return innerClassResolver.resolveInnerClasses(owner, declarationProvider);
     }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaInnerClassResolver.java

@@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
+import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import javax.inject.Inject;
@@ -33,6 +34,8 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
+import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.KOTLIN;
+
 public final class JavaInnerClassResolver {
 
     private JavaClassResolver classResolver;
@@ -46,20 +49,21 @@ public final class JavaInnerClassResolver {
     }
 
     @NotNull
-    public List<ClassDescriptor> resolveInnerClasses(@NotNull DeclarationDescriptor owner, @NotNull PsiClass psiClass, boolean staticMembers) {
+    public List<ClassDescriptor> resolveInnerClasses(@NotNull DeclarationDescriptor owner,
-        if (staticMembers) {
+            @NotNull ClassPsiDeclarationProvider declarationProvider) {
-            return resolveInnerClassesOfClassObject(owner, psiClass);
+        if (declarationProvider.isStaticMembers() && declarationProvider.getDeclarationOrigin() == KOTLIN) {
+            return resolveInnerClassesOfClassObject(owner, declarationProvider.getPsiClass());
         }
 
-        return resolveInnerClasses(owner, psiClass);
+        return resolveInnerClasses(owner, declarationProvider.getPsiClass(), declarationProvider.isStaticMembers());
     }
 
     @NotNull
-    private List<ClassDescriptor> resolveInnerClasses(@NotNull DeclarationDescriptor owner, @NotNull PsiClass psiClass) {
+    private List<ClassDescriptor> resolveInnerClasses(@NotNull DeclarationDescriptor owner, @NotNull PsiClass psiClass, boolean isStatic) {
         PsiClass[] innerPsiClasses = psiClass.getInnerClasses();
         List<ClassDescriptor> result = new ArrayList<ClassDescriptor>(innerPsiClasses.length);
         for (PsiClass innerPsiClass : innerPsiClasses) {
-            if (shouldBeIgnored(owner, innerPsiClass)) {
+            if (shouldBeIgnored(owner, innerPsiClass, isStatic)) {
                 continue;
             }
             ClassDescriptor classDescriptor = resolveInnerClass(innerPsiClass);
@@ -68,9 +72,10 @@ public final class JavaInnerClassResolver {
         return result;
     }
 
-    private static boolean shouldBeIgnored(DeclarationDescriptor owner, PsiClass innerPsiClass) {
+    private static boolean shouldBeIgnored(DeclarationDescriptor owner, PsiClass innerPsiClass, boolean isStatic) {
         // TODO: hack against inner classes
         return innerPsiClass.hasModifierProperty(PsiModifier.PRIVATE)
+                || innerPsiClass.hasModifierProperty(PsiModifier.STATIC) != isStatic
                 || innerPsiClass.getName().equals(JvmAbi.CLASS_OBJECT_CLASS_NAME)
                 || DescriptorResolverUtils.isInnerEnum(innerPsiClass, owner);
     }

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

@@ -72,4 +72,10 @@ public abstract class JavaClassMembersScope extends JavaBaseScope {
         }
         return classifiersMap;
     }
+
+    @NotNull
+    @Override
+    protected Collection<ClassDescriptor> computeInnerClasses() {
+        return getResolver().resolveInnerClasses(descriptor, declarationProvider);
+    }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassNonStaticMembersScope.java

@@ -47,10 +47,4 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope
         }
         return constructors;
     }
-
-    @NotNull
-    @Override
-    protected Collection<ClassDescriptor> computeInnerClasses() {
-        return getResolver().resolveInnerClasses(descriptor, declarationProvider.getPsiClass(), declarationProvider.isStaticMembers());
-    }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java

@@ -25,8 +25,6 @@ import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
-import java.util.Collection;
-
 public final class JavaClassStaticMembersScope extends JavaClassMembersScope {
     @NotNull
     private final FqName packageFQN;
@@ -51,10 +49,4 @@ public final class JavaClassStaticMembersScope extends JavaClassMembersScope {
     public NamespaceDescriptor getNamespace(@NotNull Name name) {
         return getResolver().resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN);
     }
-
-    @NotNull
-    @Override
-    protected Collection<ClassDescriptor> computeInnerClasses() {
-        return getResolver().resolveInnerClasses(descriptor, declarationProvider.getPsiClass(), false);
-    }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaScopeForKotlinNamespace.java

@@ -51,6 +51,6 @@ public final class JavaScopeForKotlinNamespace extends JavaPackageScope {
     @NotNull
     @Override
     protected Collection<ClassDescriptor> computeInnerClasses() {
-        return getResolver().resolveInnerClasses(descriptor, declarationProvider.getPsiClass(), false);
+        return getResolver().resolveInnerClasses(descriptor, declarationProvider);
     }
 }

compiler/testData/javaDescriptorResolver/staticMembers/InnerClass.java

@@ -0,0 +1,11 @@
+package test;
+
+public class InnerClass {
+    public class Inner {
+        public void foo() {}
+    }
+
+    public static class Nested {
+        public void bar() {}
+    }
+}

compiler/testData/javaDescriptorResolver/staticMembers/InnerClass_non_static.txt

@@ -0,0 +1,9 @@
+namespace test
+
+public open class test.InnerClass : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.InnerClass
+    public open class test.InnerClass.Inner : java.lang.Object {
+        public final /*constructor*/ fun <init>(): test.InnerClass.Inner
+        public open fun foo(): jet.Tuple0
+    }
+}

compiler/testData/javaDescriptorResolver/staticMembers/InnerClass_static.txt

@@ -0,0 +1,6 @@
+namespace InnerClass
+
+public open class test.InnerClass.Nested : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.InnerClass.Nested
+    public open fun bar(): jet.Tuple0
+}

compiler/tests/org/jetbrains/jet/jvm/compiler/StaticMembersJavaDescriptorResolverTest.java

@@ -42,6 +42,10 @@ public final class StaticMembersJavaDescriptorResolverTest extends AbstractJavaR
         doTest();
     }
 
+    public void testInnerClass() throws Exception {
+        doTest();
+    }
+
     private void doTest() throws IOException {
         String name = getTestName(false);
         compileJavaFile(name + ".java");