more asserts that we are not using JavaDescriptorResolver to resolve JetLightClass

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

@@ -32,7 +32,8 @@ import java.util.*;
  * @author abreslav
  */
 public class JavaClassMembersScope extends JavaClassOrPackageScope {
-    private final PsiClassWrapper psiClass;
+    @NotNull
+    protected final PsiClass psiClass;
     private final boolean staticMembers;
     private final Map<String, ClassifierDescriptor> classifiers = Maps.newHashMap();
     private Collection<DeclarationDescriptor> allDescriptors;
@@ -42,16 +43,11 @@ public class JavaClassMembersScope extends JavaClassOrPackageScope {
             @NotNull PsiClass psiClass,
             @NotNull JavaSemanticServices semanticServices,
             boolean staticMembers) {
-        super(classOrNamespaceDescriptor, semanticServices);
-        this.psiClass = new PsiClassWrapper(psiClass);
+        super(classOrNamespaceDescriptor, semanticServices, psiClass);
+        this.psiClass = psiClass;
         this.staticMembers = staticMembers;
     }
 
-    @Override
-    protected PsiClassWrapper psiClass() {
-        return psiClass;
-    }
-
     @Override
     protected boolean staticMembers() {
         return staticMembers;
@@ -90,18 +86,18 @@ public class JavaClassMembersScope extends JavaClassOrPackageScope {
         if (allDescriptors == null) {
             allDescriptors = Sets.newHashSet();
 
-            allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveMethods(psiClass.getPsiClass(), descriptor));
+            allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveMethods(psiClass, descriptor));
 
-            allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveFieldGroup(descriptor, psiClass.getPsiClass(), staticMembers));
+            allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveFieldGroup(descriptor, psiClass, staticMembers));
 
-            allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveInnerClasses(descriptor, psiClass.getPsiClass(), staticMembers));
+            allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveInnerClasses(descriptor, psiClass, staticMembers));
         }
         return allDescriptors;
     }
 
     private ClassifierDescriptor doGetClassifierDescriptor(String name) {
         // TODO : suboptimal, walk the list only once
-        for (PsiClass innerClass : psiClass.getPsiClass().getAllInnerClasses()) {
+        for (PsiClass innerClass : psiClass.getAllInnerClasses()) {
             if (name.equals(innerClass.getName())) {
                 if (innerClass.hasModifierProperty(PsiModifier.STATIC) != staticMembers) return null;
                 ClassDescriptor classDescriptor = semanticServices.getDescriptorResolver().resolveClass(innerClass);

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

@@ -16,7 +16,7 @@
 
 package org.jetbrains.jet.lang.resolve.java;
 
-import com.intellij.openapi.util.Ref;
+import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor;
@@ -35,12 +35,17 @@ public abstract class JavaClassOrPackageScope extends JetScopeImpl {
 
     @NotNull
     protected final ClassOrNamespaceDescriptor descriptor;
+    @NotNull
     protected final JavaSemanticServices semanticServices;
-    private Ref<PsiClassWrapper> myPsiClassMemo;
+    @Nullable
+    protected final PsiClass psiClass;
 
-    protected JavaClassOrPackageScope(@NotNull ClassOrNamespaceDescriptor descriptor, @NotNull JavaSemanticServices semanticServices) {
+    protected JavaClassOrPackageScope(@NotNull ClassOrNamespaceDescriptor descriptor, @NotNull JavaSemanticServices semanticServices, @Nullable PsiClass psiClass) {
         this.descriptor = descriptor;
         this.semanticServices = semanticServices;
+        this.psiClass = psiClass;
+
+        JavaDescriptorResolver.checkPsiClassIsNotJet(psiClass);
     }
 
     @NotNull
@@ -49,42 +54,29 @@ public abstract class JavaClassOrPackageScope extends JetScopeImpl {
         return descriptor;
     }
 
-    @Nullable
-    protected abstract PsiClassWrapper psiClass();
-
     protected abstract boolean staticMembers();
 
     @NotNull
     @Override
     public Set<VariableDescriptor> getProperties(@NotNull String name) {
-        PsiClassWrapper psiClass = memoPsiClass();
-
         if (psiClass == null) {
             return Collections.emptySet();
         }
 
         // TODO: cache
         return semanticServices.getDescriptorResolver().resolveFieldGroupByName(
-                descriptor, psiClass.getPsiClass(), name, staticMembers());
-    }
-
-    private PsiClassWrapper memoPsiClass() {
-        if (myPsiClassMemo != null) return myPsiClassMemo.get();
-        PsiClassWrapper answer = psiClass();
-        myPsiClassMemo = new Ref<PsiClassWrapper>(answer);
-        return answer;
+                descriptor, psiClass, name, staticMembers());
     }
 
     @NotNull
     @Override
     public Set<FunctionDescriptor> getFunctions(@NotNull String name) {
-        PsiClassWrapper psiClassForPackage = memoPsiClass();
 
-        if (psiClassForPackage == null) {
+        if (psiClass == null) {
             return Collections.emptySet();
         }
 
-        return semanticServices.getDescriptorResolver().resolveFunctionGroup(descriptor, psiClassForPackage.getPsiClass(), name, staticMembers());
+        return semanticServices.getDescriptorResolver().resolveFunctionGroup(descriptor, psiClass, name, staticMembers());
     }
 
 }

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

@@ -417,7 +417,7 @@ public class JavaDescriptorResolver {
         return classData;
     }
 
-    private void checkPsiClassIsNotJet(PsiClass psiClass) {
+    static void checkPsiClassIsNotJet(PsiClass psiClass) {
         if (psiClass instanceof JetJavaMirrorMarker) {
             throw new IllegalStateException("trying to resolve fake jet PsiClass as regular PsiClass");
         }
@@ -444,6 +444,8 @@ public class JavaDescriptorResolver {
             return null;
         }
 
+        checkPsiClassIsNotJet(psiClass);
+
         ResolverBinaryClassData classData = new ResolverBinaryClassData();
         classData.kotlin = true;
         classData.classDescriptor = new MutableClassDescriptorLite(containing, ClassKind.OBJECT);

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

@@ -24,6 +24,7 @@ import com.intellij.psi.PsiMethod;
 import com.intellij.psi.PsiModifier;
 import com.intellij.psi.PsiPackage;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
@@ -39,6 +40,7 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
 
     private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.migration.PsiMigrationImpl");
 
+    @NotNull
     private final String packageFQN;
 
     private Collection<DeclarationDescriptor> allDescriptors;
@@ -47,13 +49,26 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
             @NotNull String packageFQN,
             @NotNull NamespaceDescriptor containingDescriptor,
             @NotNull JavaSemanticServices semanticServices) {
-        super(containingDescriptor, semanticServices);
+        super(containingDescriptor, semanticServices, getPiClass(packageFQN, semanticServices));
         this.packageFQN = packageFQN;
     }
 
+    private static PsiClass getPiClass(String packageFQN, JavaSemanticServices semanticServices) {
+        // TODO: move this check outside
+        // If this package is actually a Kotlin namespace, then we access it through a namespace descriptor, and
+        // Kotlin functions are already there
+        NamespaceDescriptor kotlinNamespaceDescriptor = semanticServices.getKotlinNamespaceDescriptor(packageFQN);
+        if (kotlinNamespaceDescriptor != null) {
+            return null;
+        } else {
+            // TODO: what is GlobalSearchScope
+            return semanticServices.getDescriptorResolver().javaFacade.findClass(getQualifiedName(packageFQN, JvmAbi.PACKAGE_CLASS));
+        }
+    }
+
     @Override
     public ClassifierDescriptor getClassifier(@NotNull String name) {
-        return semanticServices.getDescriptorResolver().resolveClass(getQualifiedName(name));
+        return semanticServices.getDescriptorResolver().resolveClass(getQualifiedName(packageFQN, name));
     }
 
     @Override
@@ -64,25 +79,7 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
 
     @Override
     public NamespaceDescriptor getNamespace(@NotNull String name) {
-        return semanticServices.getDescriptorResolver().resolveNamespace(getQualifiedName(name));
-    }
-
-    @Override
-    protected PsiClassWrapper psiClass() {
-        // If this package is actually a Kotlin namespace, then we access it through a namespace descriptor, and
-        // Kotlin functions are already there
-        NamespaceDescriptor kotlinNamespaceDescriptor = semanticServices.getKotlinNamespaceDescriptor(packageFQN);
-        if (kotlinNamespaceDescriptor != null) {
-            return null;
-        }
-
-        // TODO: what is GlobalSearchScope
-        PsiClass psiClass = semanticServices.getDescriptorResolver().javaFacade.findClass(getQualifiedName(JvmAbi.PACKAGE_CLASS));
-        if (psiClass == null) {
-            return null;
-        }
-
-        return new PsiClassWrapper(psiClass);
+        return semanticServices.getDescriptorResolver().resolveNamespace(getQualifiedName(packageFQN, name));
     }
 
     @Override
@@ -150,7 +147,7 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
         return allDescriptors;
     }
 
-    private String getQualifiedName(String name) {
+    private static String getQualifiedName(@NotNull String packageFQN, @NotNull String name) {
         return (packageFQN.isEmpty() ? "" : packageFQN + ".") + name;
     }
 }