Support static class scope in frontend, JVM codegen and IDE

compiler/frontend/src/org/jetbrains/jet/lang/evaluate/ConstantExpressionEvaluator.kt

@@ -47,7 +47,7 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
             if (descriptor.isVar()) {
                 return false
             }
-            if (DescriptorUtils.isClassObject(descriptor.getContainingDeclaration()) || DescriptorUtils.isTopLevelDeclaration(descriptor)) {
+            if (DescriptorUtils.isClassObject(descriptor.getContainingDeclaration()) || DescriptorUtils.isStaticDeclaration(descriptor)) {
                 val returnType = descriptor.getType()
                 return KotlinBuiltIns.getInstance().isPrimitiveType(returnType) || KotlinBuiltIns.getInstance().getStringType() == returnType
             }

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

@@ -86,12 +86,13 @@ public interface Importer {
         }
 
         protected void importAllUnderDeclaration(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) {
-            List<JetScope> scopesToImport = new ArrayList<JetScope>(2);
+            List<JetScope> scopesToImport = new ArrayList<JetScope>(3);
             if (descriptor instanceof PackageViewDescriptor) {
                 scopesToImport.add(((PackageViewDescriptor) descriptor).getMemberScope());
             }
             else if (descriptor instanceof ClassDescriptor && ((ClassDescriptor) descriptor).getKind() != ClassKind.OBJECT) {
                 ClassDescriptor classDescriptor = (ClassDescriptor) descriptor;
+                scopesToImport.add(classDescriptor.getStaticScope());
                 scopesToImport.add(classDescriptor.getUnsubstitutedInnerClassesScope());
                 ClassDescriptor classObjectDescriptor = classDescriptor.getClassObjectDescriptor();
                 if (classObjectDescriptor != null) {

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

@@ -21,6 +21,7 @@ import com.google.common.collect.Collections2;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import kotlin.jvm.KotlinSignature;
+import org.jetbrains.annotations.Mutable;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -232,35 +233,42 @@ public class QualifiedExpressionResolver {
             @NotNull LookupMode lookupMode,
             boolean storeResult
     ) {
-        Set<SuccessfulLookupResult> results = Sets.newHashSet();
+        Set<SuccessfulLookupResult> results = Sets.newLinkedHashSet();
         for (DeclarationDescriptor declarationDescriptor : declarationDescriptors) {
             if (declarationDescriptor instanceof PackageViewDescriptor) {
                 addResult(results, lookupSimpleNameReference(selector, ((PackageViewDescriptor) declarationDescriptor).getMemberScope(),
                                                              lookupMode, true));
             }
             if (declarationDescriptor instanceof ClassDescriptor) {
-                addResult(results, lookupSimpleNameReference(selector, getAppropriateScope((ClassDescriptor) declarationDescriptor,
-                                                                                           lookupMode), lookupMode, false));
-                ClassDescriptor classObjectDescriptor = ((ClassDescriptor) declarationDescriptor).getClassObjectDescriptor();
-                if (classObjectDescriptor != null) {
-                    addResult(results, lookupSimpleNameReference(selector, getAppropriateScope(classObjectDescriptor, lookupMode),
-                                                                 lookupMode, false));
-                }
+                addResultsForClass(results, selector, lookupMode, (ClassDescriptor) declarationDescriptor);
             }
         }
         return filterAndStoreResolutionResult(results, selector, trace, scopeToCheckVisibility, lookupMode, storeResult);
     }
 
-    @NotNull
-    private static JetScope getAppropriateScope(@NotNull ClassDescriptor classDescriptor, @NotNull LookupMode lookupMode) {
-        return lookupMode == LookupMode.ONLY_CLASSES
-               ? classDescriptor.getUnsubstitutedInnerClassesScope()
-               : classDescriptor.getDefaultType().getMemberScope();
+    private static void addResultsForClass(
+            @NotNull @Mutable Set<SuccessfulLookupResult> results,
+            @NotNull JetSimpleNameExpression selector,
+            @NotNull LookupMode lookupMode,
+            @NotNull ClassDescriptor descriptor
+    ) {
+        JetScope scope = lookupMode == LookupMode.ONLY_CLASSES
+                         ? descriptor.getUnsubstitutedInnerClassesScope()
+                         : descriptor.getDefaultType().getMemberScope();
+        addResult(results, lookupSimpleNameReference(selector, scope, lookupMode, false));
+
+        addResult(results, lookupSimpleNameReference(selector, descriptor.getStaticScope(), lookupMode, true));
+
+        ClassDescriptor classObject = descriptor.getClassObjectDescriptor();
+        if (classObject != null) {
+            addResultsForClass(results, selector, lookupMode, classObject);
+        }
     }
 
     private static void addResult(@NotNull Set<SuccessfulLookupResult> results, @NotNull LookupResult result) {
-        if (result == LookupResult.EMPTY) return;
-        results.add((SuccessfulLookupResult) result);
+        if (result != LookupResult.EMPTY) {
+            results.add((SuccessfulLookupResult) result);
+        }
     }
 
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/Qualifier.kt

@@ -16,13 +16,10 @@
 
 package org.jetbrains.jet.lang.resolve.scopes.receivers
 
+import org.jetbrains.jet.lang.descriptors.*
 import org.jetbrains.jet.lang.types.JetType
-import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
-import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor
 import org.jetbrains.jet.lang.psi.JetSimpleNameExpression
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor
-import org.jetbrains.jet.lang.descriptors.ClassKind
 import org.jetbrains.jet.lang.resolve.DescriptorUtils
 import org.jetbrains.jet.lang.resolve.DescriptorUtils.getFqName
 import org.jetbrains.jet.lang.resolve.name.Name
@@ -30,17 +27,13 @@ import org.jetbrains.jet.lang.resolve.scopes.ChainedScope
 import java.util.ArrayList
 import org.jetbrains.jet.utils.addIfNotNull
 import org.jetbrains.jet.lang.resolve.BindingContext.*
-import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor
 import org.jetbrains.jet.lang.diagnostics.Errors.*
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
-import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingContext
 import org.jetbrains.jet.lang.psi.psiUtil.getTopmostParentQualifiedExpressionForSelector
 import org.jetbrains.jet.lang.resolve.descriptorUtil.getClassObjectReferenceTarget
 import org.jetbrains.jet.lang.psi.JetExpression
 import org.jetbrains.jet.lang.resolve.bindingContextUtil.recordScopeAndDataFlowInfo
 import kotlin.properties.Delegates
-import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor
 
 public trait Qualifier {
 
@@ -81,18 +74,22 @@ class QualifierReceiver (
             classifier?.getClassObjectType()?.let { ExpressionReceiver(referenceExpression, it) } ?: ReceiverValue.NO_RECEIVER
 
     fun getNestedClassesAndPackageMembersScope(): JetScope {
-        val scopes = ArrayList<JetScope>(3)
-
-        val classObjectDescriptor = (classifier as? ClassDescriptor)?.getClassObjectDescriptor()
-        if (classObjectDescriptor != null) {
-            // non-static members are resolved through class object receiver
-            scopes.add(DescriptorUtils.getStaticNestedClassesScope(classObjectDescriptor))
-        }
+        val scopes = ArrayList<JetScope>(4)
 
         scopes.addIfNotNull(packageView?.getMemberScope())
 
-        if (classifier is ClassDescriptor && classifier.getKind() != ClassKind.ENUM_ENTRY) {
-            scopes.add(DescriptorUtils.getStaticNestedClassesScope(classifier))
+        if (classifier is ClassDescriptor) {
+            scopes.add(classifier.getStaticScope())
+
+            val classObjectDescriptor = classifier.getClassObjectDescriptor()
+            if (classObjectDescriptor != null) {
+                // non-static members are resolved through class object receiver
+                scopes.add(DescriptorUtils.getStaticNestedClassesScope(classObjectDescriptor))
+            }
+
+            if (classifier.getKind() != ClassKind.ENUM_ENTRY) {
+                scopes.add(DescriptorUtils.getStaticNestedClassesScope(classifier))
+            }
         }
 
         return ChainedScope(descriptor, "Static scope for " + name + " as package or class or object", *scopes.copyToArray())