create JavaPackageScope for class statics

... and compute "kotlin" flag in ResolverScopeData

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

@@ -49,6 +49,9 @@ public class JavaClassMembersScope extends JavaClassOrPackageScope {
         if (resolverScopeData.psiClass == null) {
             throw new IllegalArgumentException("must pass PsiClass here");
         }
+        if (resolverScopeData.staticMembers) {
+            throw new IllegalArgumentException("static members should be resolved using " + JavaPackageScope.class);
+        }
     }
 
     @NotNull

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

@@ -200,8 +200,6 @@ public class JavaDescriptorResolver {
 
 
     static abstract class ResolverScopeData {
-        protected boolean kotlin;
-
         @Nullable
         final PsiClass psiClass;
         @Nullable
@@ -209,6 +207,7 @@ public class JavaDescriptorResolver {
         @NotNull
         final FqName fqName;
         final boolean staticMembers;
+        final boolean kotlin;
         @NotNull
         final ClassOrNamespaceDescriptor classOrNamespaceDescriptor;
 
@@ -228,6 +227,8 @@ public class JavaDescriptorResolver {
             }
 
             this.staticMembers = staticMembers;
+            this.kotlin = psiClass != null &&
+                    (new PsiClassWrapper(psiClass).getJetClass().isDefined() || psiClass.getName().equals(JvmAbi.PACKAGE_CLASS));
             classOrNamespaceDescriptor = descriptor;
         }
 
@@ -539,7 +540,6 @@ public class JavaDescriptorResolver {
 
         classDescriptorCache.put(fqName, classData);
 
-        classData.kotlin = true;
         classData.classDescriptor.setSupertypes(getSupertypes(new PsiClassWrapper(classObjectPsiClass), classData.classDescriptor, new ArrayList<TypeParameterDescriptor>(0)));
         classData.classDescriptor.setName(JetPsiUtil.NO_NAME_PROVIDED); // TODO
         classData.classDescriptor.setModality(Modality.FINAL);
@@ -559,7 +559,6 @@ public class JavaDescriptorResolver {
 
     private List<TypeParameterDescriptorInitialization> createUninitializedClassTypeParameters(PsiClass psiClass, ResolverBinaryClassData classData, TypeVariableResolver typeVariableResolver) {
         JetClassAnnotation jetClassAnnotation = JetClassAnnotation.get(psiClass);
-        classData.kotlin = jetClassAnnotation.isDefined();
 
         if (jetClassAnnotation.signature().length() > 0) {
             return resolveClassTypeParametersFromJetSignature(
@@ -920,10 +919,21 @@ public class JavaDescriptorResolver {
 
     @Nullable
     private ResolverNamespaceData createNamespaceResolverScopeData(@NotNull FqName fqName, @NotNull NamespaceDescriptor ns) {
-        PsiPackage psiPackage = semanticServices.getPsiClassFinder().findPsiPackage(fqName);
+        PsiPackage psiPackage;
-        PsiClass psiClass = getPsiClassForJavaPackageScope(fqName);
+        psiPackage = semanticServices.getPsiClassFinder().findPsiPackage(fqName);
-        if (psiClass == null && psiPackage == null) {
+        PsiClass psiClass;
-            return null;
+
+        lookingForPsi:
+        {
+            psiClass = getPsiClassForJavaPackageScope(fqName);
+            if (psiClass != null || psiPackage != null) {
+                break lookingForPsi;
+            }
+
+            psiClass = psiClassFinder.findPsiClass(fqName);
+            if (psiClass == null) {
+                return null;
+            }
         }
 
         if (psiPackage != null) {
@@ -934,9 +944,6 @@ public class JavaDescriptorResolver {
 
         JavaPackageScope scope = new JavaPackageScope(fqName, semanticServices, namespaceData);
 
-        // TODO: hack
-        namespaceData.kotlin = true;
-
         namespaceData.memberScope = scope;
 
         ResolverNamespaceData oldValue = namespaceDescriptorCacheByFqn.put(fqName, namespaceData);
@@ -987,18 +994,23 @@ public class JavaDescriptorResolver {
 
         FqName fqName = new FqName(psiClass.getQualifiedName());
         JavaNamespaceDescriptor ns = new JavaNamespaceDescriptor(
-                (NamespaceDescriptorParent) resolveParentDescriptor(psiClass),
+                resolveNamespace(fqName.parent(), DescriptorSearchRule.INCLUDE_KOTLIN),
                 Collections.<AnnotationDescriptor>emptyList(), // TODO
                 psiClass.getName(),
                 fqName,
                 false
         );
-        ResolverNamespaceData namespaceData = new ResolverNamespaceData(psiClass, null, fqName, ns);
-        trace.record(JavaBindingContext.NAMESPACE_IS_CLASS_STATICS, namespaceData.namespaceDescriptor, true);
 
-        ns.setMemberScope(new JavaClassMembersScope(semanticServices, namespaceData));
+        ResolverNamespaceData scopeData = createNamespaceResolverScopeData(fqName, ns);
-        trace.record(BindingContext.NAMESPACE, psiClass, namespaceData.namespaceDescriptor);
+        if (scopeData == null) {
-        return namespaceData;
+            throw new IllegalStateException("we have class: " + fqName);
+        }
+
+        ns.setMemberScope(scopeData.memberScope);
+        trace.record(BindingContext.NAMESPACE, psiClass, ns);
+        trace.record(JavaBindingContext.NAMESPACE_IS_CLASS_STATICS, ns, true);
+
+        return scopeData;
     }
     
     private static class ValueParameterDescriptors {

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

@@ -16,18 +16,14 @@
 
 package org.jetbrains.jet.lang.resolve.java;
 
-import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiField;
-import com.intellij.psi.PsiMember;
 import com.intellij.psi.PsiMethod;
 import com.intellij.psi.PsiParameter;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.resolve.java.prop.PropertyNameUtils;
 import org.jetbrains.jet.lang.resolve.java.prop.PropertyParseResult;
 
-import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 
 /**

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

@@ -45,6 +45,10 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
             @NotNull JavaDescriptorResolver.ResolverScopeData resolverNamespaceData) {
         super(semanticServices, resolverNamespaceData);
         this.packageFQN = packageFQN;
+
+        if (!resolverNamespaceData.staticMembers) {
+            throw new IllegalArgumentException("instance members should be resolved using " + JavaClassMembersScope.class);
+        }
     }
 
     @Override