kill JavaNamespaceDescriptor

compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java

@@ -218,7 +218,11 @@ public class JetTypeMapper {
      *
      * @see DescriptorUtils#getFQName(DeclarationDescriptor)
      */
-    public String getFQName(DeclarationDescriptor descriptor) {
+    public String getFQName(@NotNull DeclarationDescriptor descriptor) {
+        if (descriptor instanceof ModuleDescriptor) {
+            throw new IllegalStateException("missed something");
+        }
+
         descriptor = descriptor.getOriginal();
 
         if(descriptor instanceof FunctionDescriptor) {
@@ -233,11 +237,8 @@ public class JetTypeMapper {
         if(name.contains("/"))
             return name;
         if (container != null) {
-            if (container.getContainingDeclaration() instanceof ModuleDescriptor) {
-                return name;
-            }
             if (container instanceof ModuleDescriptor) {
-                throw new IllegalStateException("missed something");
+                return "";
             }
             String baseName = getFQName(container);
             if (!baseName.isEmpty()) { 

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

@@ -21,18 +21,16 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.DefaultModuleConfiguration;
 import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.JetImportDirective;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.FqName;
 import org.jetbrains.jet.lang.resolve.ImportPath;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 
 import javax.inject.Inject;
 import java.util.Collection;
-import java.util.Collections;
 
 /**
  * @author abreslav
@@ -72,7 +70,11 @@ public class JavaBridgeConfiguration implements ModuleConfiguration {
 
     @Override
     public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) {
-        namespaceMemberScope.importScope(javaSemanticServices.getDescriptorResolver().createJavaPackageScope(DescriptorUtils.getFQName(namespaceDescriptor).toSafe(), namespaceDescriptor));
+        JetScope scope = javaSemanticServices.getDescriptorResolver().resolveJavaPackageScope(
+                DescriptorUtils.getFQName(namespaceDescriptor).toSafe(), namespaceDescriptor);
+        if (scope != null) {
+            namespaceMemberScope.importScope(scope);
+        }
         delegateConfiguration.extendNamespaceScope(trace, namespaceDescriptor, namespaceMemberScope);
     }
 

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

@@ -42,8 +42,9 @@ public class JavaClassMembersScope extends JavaClassOrPackageScope {
             @NotNull ClassOrNamespaceDescriptor classOrNamespaceDescriptor,
             @NotNull PsiClass psiClass,
             @NotNull JavaSemanticServices semanticServices,
-            boolean staticMembers) {
+            boolean staticMembers,
-        super(classOrNamespaceDescriptor, semanticServices, psiClass);
+            @NotNull JavaDescriptorResolver.ResolverScopeData resolverScopeData) {
+        super(classOrNamespaceDescriptor, semanticServices, psiClass, resolverScopeData);
         this.psiClass = psiClass;
         this.staticMembers = staticMembers;
     }
@@ -89,9 +90,9 @@ public class JavaClassMembersScope extends JavaClassOrPackageScope {
         if (allDescriptors == null) {
             allDescriptors = Sets.newHashSet();
 
-            allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveMethods(psiClass, descriptor));
+            allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveMethods(psiClass, descriptor, getResolverScopeData()));
 
-            allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveFieldGroup(descriptor, psiClass, staticMembers));
+            allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveFieldGroup(descriptor, psiClass, staticMembers, getResolverScopeData()));
 
             allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveInnerClasses(descriptor, psiClass, staticMembers));
         }

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

@@ -39,12 +39,18 @@ public abstract class JavaClassOrPackageScope extends JetScopeImpl {
     protected final JavaSemanticServices semanticServices;
     @Nullable
     protected final PsiClass psiClass;
+    @NotNull
+    private final JavaDescriptorResolver.ResolverScopeData resolverScopeData;
 
-    protected JavaClassOrPackageScope(@NotNull ClassOrNamespaceDescriptor descriptor, @NotNull JavaSemanticServices semanticServices,
+    protected JavaClassOrPackageScope(
-                                      @Nullable PsiClass psiClass) {
+            @NotNull ClassOrNamespaceDescriptor descriptor,
+            @NotNull JavaSemanticServices semanticServices,
+            @Nullable PsiClass psiClass,
+            @NotNull JavaDescriptorResolver.ResolverScopeData resolverScopeData) {
         this.descriptor = descriptor;
         this.semanticServices = semanticServices;
         this.psiClass = psiClass;
+        this.resolverScopeData = resolverScopeData;
 
         JavaDescriptorResolver.checkPsiClassIsNotJet(psiClass);
     }
@@ -66,7 +72,7 @@ public abstract class JavaClassOrPackageScope extends JetScopeImpl {
 
         // TODO: cache
         return semanticServices.getDescriptorResolver().resolveFieldGroupByName(
-                descriptor, psiClass, name, staticMembers());
+                descriptor, psiClass, name, staticMembers(), getResolverScopeData());
     }
 
     @NotNull
@@ -77,7 +83,14 @@ public abstract class JavaClassOrPackageScope extends JetScopeImpl {
             return Collections.emptySet();
         }
 
-        return semanticServices.getDescriptorResolver().resolveFunctionGroup(descriptor, psiClass, name, staticMembers());
+        return semanticServices.getDescriptorResolver().resolveFunctionGroup(
+                descriptor, psiClass, name, staticMembers(), getResolverScopeData());
+    }
+
+    @NotNull
+    protected JavaDescriptorResolver.ResolverScopeData getResolverScopeData() {
+        semanticServices.getDescriptorResolver().initializeResolverScopeData(resolverScopeData, psiClass, staticMembers());
+        return resolverScopeData;
     }
 
 }

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

@@ -34,6 +34,7 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.constants.*;
+import org.jetbrains.jet.lang.resolve.constants.StringValue;
 import org.jetbrains.jet.lang.resolve.java.alt.AltClassFinder;
 import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
 import org.jetbrains.jet.lang.types.*;
@@ -118,7 +119,7 @@ public class JavaDescriptorResolver {
     }
 
 
-    private static abstract class ResolverScopeData {
+    static abstract class ResolverScopeData {
         protected boolean kotlin;
         
         private Map<String, NamedMembers> namedMembersMap;
@@ -173,7 +174,8 @@ public class JavaDescriptorResolver {
 
     /** Either package or class with static members */
     private static class ResolverNamespaceData extends ResolverScopeData {
-        private JavaNamespaceDescriptor namespaceDescriptor;
+        private NamespaceDescriptor namespaceDescriptor;
+        private JavaClassOrPackageScope scope;
 
         @NotNull
         public NamespaceDescriptor getNamespaceDescriptor() {
@@ -365,7 +367,7 @@ public class JavaDescriptorResolver {
         }
         classData.classDescriptor.setModality(modality);
         classData.classDescriptor.createTypeConstructor();
-        classData.classDescriptor.setScopeForMemberLookup(new JavaClassMembersScope(classData.classDescriptor, psiClass, semanticServices, false));
+        classData.classDescriptor.setScopeForMemberLookup(new JavaClassMembersScope(classData.classDescriptor, psiClass, semanticServices, false, classData));
 
         initializeTypeParameters(classData.typeParameters, classData.classDescriptor, "class " + psiClass.getQualifiedName());
 
@@ -513,7 +515,7 @@ public class JavaDescriptorResolver {
         classData.classDescriptor.setModality(Modality.FINAL);
         classData.classDescriptor.setTypeParameterDescriptors(new ArrayList<TypeParameterDescriptor>(0));
         classData.classDescriptor.createTypeConstructor();
-        classData.classDescriptor.setScopeForMemberLookup(new JavaClassMembersScope(classData.classDescriptor, classObjectPsiClass, semanticServices, false));
+        classData.classDescriptor.setScopeForMemberLookup(new JavaClassMembersScope(classData.classDescriptor, classObjectPsiClass, semanticServices, false, classData));
 
         // TODO: wrong: class objects do not need visible constructors
         ConstructorDescriptorImpl constructor = new ConstructorDescriptorImpl(classData.classDescriptor, new ArrayList<AnnotationDescriptor>(0), true);
@@ -839,13 +841,12 @@ public class JavaDescriptorResolver {
             }
         }
 
-        PsiPackage psiPackage = findPackage(qualifiedName);
+        PsiClassOrPsiPackage psiElement = findPsiElementForNamespace(qualifiedName);
-        if (psiPackage == null) {
+        if (psiElement == null) {
-            PsiClass psiClass = findClass(qualifiedName);
+            return null;
-            if (psiClass == null) return null;
-            return resolveNamespace(psiClass);
         }
-        return resolveNamespace(psiPackage);
+
+        return resolveNamespace(psiElement);
     }
 
     @Nullable
@@ -875,79 +876,100 @@ public class JavaDescriptorResolver {
         return javaFacade.findPackage(qualifiedName.getFqName());
     }
 
-    private NamespaceDescriptor resolveNamespace(@NotNull PsiPackage psiPackage) {
+    @Nullable
-        ResolverNamespaceData namespaceData = namespaceDescriptorCache.get(psiPackage);
+    private PsiClassOrPsiPackage findPsiElementForNamespace(@NotNull FqName fqName) {
-        if (namespaceData == null) {
+        PsiPackage psiPackage = findPackage(fqName);
-            namespaceData = createJavaNamespaceDescriptor(psiPackage);
+        if (psiPackage != null) {
-            namespaceDescriptorCache.put(psiPackage, namespaceData);
+            return new PsiClassOrPsiPackage(psiPackage);
-            namespaceDescriptorCacheByFqn.put(new FqName(psiPackage.getQualifiedName()), namespaceData);
         }
-        return namespaceData.namespaceDescriptor;
+        PsiClass psiClass = findClass(fqName);
-    }
+        if (psiClass != null) {
-
+            return new PsiClassOrPsiPackage(psiClass);
-    private NamespaceDescriptor resolveNamespace(@NotNull PsiClass psiClass) {
-        ResolverNamespaceData namespaceData = namespaceDescriptorCache.get(psiClass);
-        if (namespaceData == null) {
-            namespaceData = createJavaNamespaceDescriptor(psiClass);
-            namespaceDescriptorCache.put(psiClass, namespaceData);
-            namespaceDescriptorCacheByFqn.put(new FqName(psiClass.getQualifiedName()), namespaceData);
         }
-        return namespaceData.namespaceDescriptor;
+        return null;
-    }
-
-    private ResolverNamespaceData createJavaNamespaceDescriptor(@NotNull PsiPackage psiPackage) {
-        ResolverNamespaceData namespaceData = new ResolverNamespaceData();
-        String name = psiPackage.getName();
-        namespaceData.namespaceDescriptor = new JavaNamespaceDescriptor(
-                (NamespaceDescriptorParent) resolveParentDescriptor(psiPackage),
-                Collections.<AnnotationDescriptor>emptyList(), // TODO
-                name == null ? JAVA_ROOT : name,
-                name == null ? FqName.ROOT : new FqName(psiPackage.getQualifiedName()),
-                true
-        );
-        trace.record(JavaBindingContext.NAMESPACE_IS_CLASS_STATICS, namespaceData.namespaceDescriptor, false);
-
-        namespaceData.namespaceDescriptor.setMemberScope(createJavaPackageScope(new FqName(psiPackage.getQualifiedName()), namespaceData.namespaceDescriptor));
-        trace.record(BindingContext.NAMESPACE, psiPackage, namespaceData.namespaceDescriptor);
-        // TODO: hack
-        namespaceData.kotlin = true;
-        return namespaceData;
-    }
-
-    public JavaPackageScope createJavaPackageScope(@NotNull FqName fqName, @NotNull NamespaceDescriptor ns) {
-        return new JavaPackageScope(fqName, ns, semanticServices);
     }
 
     @NotNull
-    private DeclarationDescriptor resolveParentDescriptor(@NotNull PsiPackage psiPackage) {
+    private NamespaceDescriptor resolveNamespace(@NotNull PsiClassOrPsiPackage psi) {
-        PsiPackage parentPackage = psiPackage.getParentPackage();
+        return namespaceFactory.createNamespaceDescriptorPathIfNeeded(psi.getFqName(), psi.getPsiElement());
-        if (parentPackage == null) {
-            return FAKE_ROOT_MODULE;
-        }
-        return resolveNamespace(parentPackage);
     }
 
-    /**
+    private static class PsiClassOrPsiPackage {
-     * TODO
+        @NotNull
-     * @see #createClassObjectDescriptor(org.jetbrains.jet.lang.descriptors.ClassDescriptor, com.intellij.psi.PsiClass)
+        private final PsiElement psiElement;
-     */
+        @NotNull
-    private ResolverNamespaceData createJavaNamespaceDescriptor(@NotNull final PsiClass psiClass) {
+        private final FqName fqName;
 
-        checkPsiClassIsNotJet(psiClass);
+        private PsiClassOrPsiPackage(@NotNull PsiClass psiElement) {
+            this.psiElement = psiElement;
+            this.fqName = new FqName(psiElement.getQualifiedName());
+        }
 
-        ResolverNamespaceData namespaceData = new ResolverNamespaceData();
+        private PsiClassOrPsiPackage(@NotNull PsiPackage psiElement) {
-        namespaceData.namespaceDescriptor = new JavaNamespaceDescriptor(
+            this.psiElement = psiElement;
-                (NamespaceDescriptorParent) resolveParentDescriptor(psiClass),
+            this.fqName = new FqName(psiElement.getQualifiedName());
-                Collections.<AnnotationDescriptor>emptyList(), // TODO
+        }
-                psiClass.getName(),
-                new FqName(psiClass.getQualifiedName()),
-                false
-        );
-        trace.record(JavaBindingContext.NAMESPACE_IS_CLASS_STATICS, namespaceData.namespaceDescriptor, true);
 
-        namespaceData.namespaceDescriptor.setMemberScope(new JavaClassMembersScope(namespaceData.namespaceDescriptor, psiClass, semanticServices, true));
+        public boolean isClass() {
-        trace.record(BindingContext.NAMESPACE, psiClass, namespaceData.namespaceDescriptor);
+            return psiElement instanceof PsiClass;
-        return namespaceData;
+        }
+
+        public boolean isPackage() {
+            return psiElement instanceof PsiPackage;
+        }
+
+        @NotNull
+        public PsiClass getPsiClass() {
+            return (PsiClass)psiElement;
+        }
+
+        @NotNull
+        public PsiPackage getPsiPackage() {
+            return (PsiPackage)psiElement;
+        }
+
+        @NotNull
+        public PsiElement getPsiElement() {
+            return psiElement;
+        }
+
+        @NotNull
+        public FqName getFqName() {
+            return fqName;
+        }
+    }
+
+    @Nullable
+    public JavaClassOrPackageScope resolveJavaPackageScope(@NotNull FqName fqName, @NotNull NamespaceDescriptor namespace) {
+        PsiClassOrPsiPackage psi = findPsiElementForNamespace(fqName);
+        if (psi == null) {
+            return null;
+        }
+
+        ResolverNamespaceData namespaceData = namespaceDescriptorCacheByFqn.get(fqName);
+        if (namespaceData != null) {
+            throw new IllegalStateException("cache must be empty for ns " + fqName);
+        }
+
+        namespaceData = new ResolverNamespaceData();
+        namespaceDescriptorCache.put(psi.getPsiElement(), namespaceData);
+        namespaceDescriptorCacheByFqn.put(fqName, namespaceData);
+
+        if (psi.isClass()) {
+            checkPsiClassIsNotJet(psi.getPsiClass());
+        }
+
+        namespaceData.namespaceDescriptor = namespace;
+        namespaceData.kotlin = psi.isPackage();
+        trace.record(JavaBindingContext.NAMESPACE_IS_CLASS_STATICS, namespaceData.namespaceDescriptor, psi.isClass());
+
+        if (psi.isClass()) {
+            namespaceData.scope = new JavaClassMembersScope(namespace, psi.getPsiClass(), semanticServices, true, namespaceData);
+        } else {
+            namespaceData.scope = new JavaPackageScope(fqName, namespace, semanticServices, namespaceData);
+        }
+
+        return namespaceData.scope;
     }
 
     private static class ValueParameterDescriptors {
@@ -1052,8 +1074,12 @@ public class JavaDescriptorResolver {
         }
     }
 
-    public Set<VariableDescriptor> resolveFieldGroupByName(@NotNull ClassOrNamespaceDescriptor owner, @NotNull PsiClass psiClass, String fieldName, boolean staticMembers) {
+    public Set<VariableDescriptor> resolveFieldGroupByName(
-        ResolverScopeData scopeData = getResolverScopeData(owner, new PsiClassWrapper(psiClass));
+            @NotNull ClassOrNamespaceDescriptor owner,
+            @NotNull PsiClass psiClass,
+            String fieldName,
+            boolean staticMembers,
+            @NotNull ResolverScopeData scopeData) {
 
         NamedMembers namedMembers = scopeData.namedMembersMap.get(fieldName);
         if (namedMembers == null) {
@@ -1073,9 +1099,11 @@ public class JavaDescriptorResolver {
     }
     
     @NotNull
-    public Set<VariableDescriptor> resolveFieldGroup(@NotNull ClassOrNamespaceDescriptor owner, @NotNull PsiClass psiClass, boolean staticMembers) {
+    public Set<VariableDescriptor> resolveFieldGroup(
-
+            @NotNull ClassOrNamespaceDescriptor owner,
-        ResolverScopeData scopeData = getResolverScopeData(owner, new PsiClassWrapper(psiClass));
+            @NotNull PsiClass psiClass,
+            boolean staticMembers,
+            @NotNull ResolverScopeData scopeData) {
 
         Set<VariableDescriptor> descriptors = Sets.newHashSet();
         Map<String, NamedMembers> membersForProperties = scopeData.namedMembersMap;
@@ -1330,7 +1358,7 @@ public class JavaDescriptorResolver {
         namedMembers.propertyDescriptors = r;
     }
 
-    private void resolveNamedGroupFunctions(ClassOrNamespaceDescriptor owner, PsiClass psiClass, TypeSubstitutor typeSubstitutorForGenericSuperclasses, NamedMembers namedMembers, String methodName, ResolverScopeData scopeData) {
+    private void resolveNamedGroupFunctions(ClassOrNamespaceDescriptor owner, PsiClass psiClass, NamedMembers namedMembers, String methodName, ResolverScopeData scopeData) {
         if (namedMembers.functionDescriptors != null) {
             return;
         }
@@ -1339,8 +1367,7 @@ public class JavaDescriptorResolver {
 
         Set<SimpleFunctionDescriptor> functionsFromCurrent = Sets.newHashSet();
         for (PsiMethodWrapper method : namedMembers.methods) {
-            FunctionDescriptorImpl function = resolveMethodToFunctionDescriptor(owner, psiClass,
+            FunctionDescriptorImpl function = resolveMethodToFunctionDescriptor(owner, psiClass, method, scopeData);
-                    method);
             if (function != null) {
                 functionsFromCurrent.add((SimpleFunctionDescriptor) function);
             }
@@ -1380,42 +1407,30 @@ public class JavaDescriptorResolver {
         return r;
     }
 
-    private ResolverScopeData getResolverScopeData(@NotNull ClassOrNamespaceDescriptor owner, PsiClassWrapper psiClass) {
+    void initializeResolverScopeData(@NotNull ResolverScopeData scopeData, @Nullable PsiClass psiClass, boolean staticMembers) {
-        // TODO: store scopeData in Java*Scope
-        ResolverScopeData scopeData;
-        boolean staticMembers;
-        if (owner instanceof JavaNamespaceDescriptor) {
-            scopeData = namespaceDescriptorCacheByFqn.get(((JavaNamespaceDescriptor) owner).getQualifiedName());
-            staticMembers = true;
-        } else if (owner instanceof ClassDescriptor) {
-            scopeData = classDescriptorCache.get(new FqName(psiClass.getQualifiedName()));
-            staticMembers = false;
-        } else {
-            throw new IllegalStateException("unknown owner: " + owner.getClass().getName());
-        }
-        if (scopeData == null) {
-            throw new IllegalStateException();
-        }
-        
         if (scopeData.namedMembersMap == null) {
-            scopeData.namedMembersMap = JavaDescriptorResolverHelper.getNamedMembers(psiClass, staticMembers, scopeData.kotlin);
+            if (psiClass != null) {
+                scopeData.namedMembersMap = JavaDescriptorResolverHelper.getNamedMembers(
+                        new PsiClassWrapper(psiClass), staticMembers, scopeData.kotlin);
+            } else {
+                scopeData.namedMembersMap = Maps.newHashMap();
+            }
         }
-        
-        return scopeData;
     }
 
     @NotNull
-    public Set<FunctionDescriptor> resolveFunctionGroup(@NotNull ClassOrNamespaceDescriptor descriptor, @NotNull PsiClass psiClass, @NotNull String methodName, boolean staticMembers) {
+    public Set<FunctionDescriptor> resolveFunctionGroup(
+            @NotNull ClassOrNamespaceDescriptor descriptor,
+            @NotNull PsiClass psiClass,
+            @NotNull String methodName,
+            boolean staticMembers,
+            @NotNull ResolverScopeData scopeData) {
 
-        ResolverScopeData resolverScopeData = getResolverScopeData(descriptor, new PsiClassWrapper(psiClass));
+        Map<String, NamedMembers> namedMembersMap = scopeData.namedMembersMap;
-
-        Map<String, NamedMembers> namedMembersMap = resolverScopeData.namedMembersMap;
 
         NamedMembers namedMembers = namedMembersMap.get(methodName);
         if (namedMembers != null && namedMembers.methods != null) {
-            TypeSubstitutor typeSubstitutor = typeSubstitutorForGenericSupertypes(resolverScopeData);
+            resolveNamedGroupFunctions(descriptor, psiClass, namedMembers, methodName, scopeData);
-
-            resolveNamedGroupFunctions(descriptor, psiClass, typeSubstitutor, namedMembers, methodName, resolverScopeData);
 
             return namedMembers.functionDescriptors;
         } else {
@@ -1459,20 +1474,24 @@ public class JavaDescriptorResolver {
     }
 
     @Nullable
-    private FunctionDescriptorImpl resolveMethodToFunctionDescriptor(ClassOrNamespaceDescriptor owner, final PsiClass psiClass, final PsiMethodWrapper method) {
+    private FunctionDescriptorImpl resolveMethodToFunctionDescriptor(
+            ClassOrNamespaceDescriptor owner,
+            final PsiClass psiClass,
+            final PsiMethodWrapper method,
+            @NotNull ResolverScopeData scopeData) {
 
         PsiType returnType = method.getReturnType();
         if (returnType == null) {
             return null;
         }
-        ResolverScopeData scopeData = getResolverScopeData(owner, new PsiClassWrapper(psiClass));
 
         boolean kotlin;
-        if (owner instanceof JavaNamespaceDescriptor) {
+        if (owner instanceof NamespaceDescriptor) {
-            JavaNamespaceDescriptor javaNamespaceDescriptor = (JavaNamespaceDescriptor) owner;
+            NamespaceDescriptor javaNamespaceDescriptor = (NamespaceDescriptor) owner;
-            ResolverNamespaceData namespaceData = namespaceDescriptorCacheByFqn.get(javaNamespaceDescriptor.getQualifiedName());
+            FqName fqName = DescriptorUtils.getFQName(javaNamespaceDescriptor).toSafe();
+            ResolverNamespaceData namespaceData = namespaceDescriptorCacheByFqn.get(fqName);
             if (namespaceData == null) {
-                throw new IllegalStateException("namespaceData not found by name " + javaNamespaceDescriptor.getQualifiedName());
+                throw new IllegalStateException("namespaceData not found by name " + fqName);
             }
             kotlin = namespaceData.kotlin;
         } else {
@@ -1502,7 +1521,7 @@ public class JavaDescriptorResolver {
             classDescriptor = classClassDescriptor;
         }
         else {
-            classDescriptor = resolveNamespace(method.getPsiMethod().getContainingClass());
+            classDescriptor = resolveNamespace(new PsiClassOrPsiPackage(method.getPsiMethod().getContainingClass()));
         }
         if (classDescriptor == null) {
             return null;
@@ -1601,9 +1620,10 @@ public class JavaDescriptorResolver {
         return annotation;
     }
 
-    public List<FunctionDescriptor> resolveMethods(@NotNull PsiClass psiClass, @NotNull ClassOrNamespaceDescriptor containingDeclaration) {
+    public List<FunctionDescriptor> resolveMethods(
-        ResolverScopeData scopeData = getResolverScopeData(containingDeclaration, new PsiClassWrapper(psiClass));
+            @NotNull PsiClass psiClass,
-
+            @NotNull ClassOrNamespaceDescriptor containingDeclaration,
+            @NotNull ResolverScopeData scopeData) {
         TypeSubstitutor substitutorForGenericSupertypes = typeSubstitutorForGenericSupertypes(scopeData);
 
         List<FunctionDescriptor> functions = new ArrayList<FunctionDescriptor>();
@@ -1611,7 +1631,7 @@ public class JavaDescriptorResolver {
         for (Map.Entry<String, NamedMembers> entry : scopeData.namedMembersMap.entrySet()) {
             String methodName = entry.getKey();
             NamedMembers namedMembers = entry.getValue();
-            resolveNamedGroupFunctions(containingDeclaration, psiClass, substitutorForGenericSupertypes, namedMembers, methodName, scopeData);
+            resolveNamedGroupFunctions(containingDeclaration, psiClass, namedMembers, methodName, scopeData);
             functions.addAll(namedMembers.functionDescriptors);
         }
 

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

@@ -1,62 +0,0 @@
-/*
- * 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;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.AbstractNamespaceDescriptorImpl;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptorParent;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.FqName;
-import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-
-import java.util.List;
-
-/**
- * @author abreslav
- */
-public class JavaNamespaceDescriptor extends AbstractNamespaceDescriptorImpl {
-    private JetScope memberScope;
-    private final FqName qualifiedName;
-    /** Namespace of class with static methods */
-    private final boolean namespace;
-    
-    public JavaNamespaceDescriptor(NamespaceDescriptorParent containingDeclaration, List<AnnotationDescriptor> annotations,
-            @NotNull String name, @NotNull FqName qualifiedName, boolean namespace) {
-        super(containingDeclaration, annotations, name);
-        this.qualifiedName = qualifiedName;
-        this.namespace = namespace;
-    }
-
-    public void setMemberScope(@NotNull JetScope memberScope) {
-        this.memberScope = memberScope;
-    }
-
-    @NotNull
-    @Override
-    public JetScope getMemberScope() {
-        return memberScope;
-    }
-
-    public FqName getQualifiedName() {
-        return qualifiedName;
-    }
-
-    public boolean isNamespace() {
-        return namespace;
-    }
-}

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

@@ -46,21 +46,18 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
     public JavaPackageScope(
             @NotNull FqName packageFQN,
             @NotNull NamespaceDescriptor containingDescriptor,
-            @NotNull JavaSemanticServices semanticServices) {
+            @NotNull JavaSemanticServices semanticServices,
-        super(containingDescriptor, semanticServices, getPiClass(packageFQN, semanticServices));
+            @NotNull JavaDescriptorResolver.ResolverScopeData resolverScopeData) {
+        super(containingDescriptor, semanticServices, getPiClass(packageFQN, semanticServices), resolverScopeData);
         this.packageFQN = packageFQN;
     }
 
     private static PsiClass getPiClass(FqName packageFQN, JavaSemanticServices semanticServices) {
-        // TODO: move this check outside
+        PsiClass psiClass = semanticServices.getDescriptorResolver().findClass(getQualifiedName(packageFQN, JvmAbi.PACKAGE_CLASS));
-        // If this package is actually a Kotlin namespace, then we access it through a namespace descriptor, and
+        if (psiClass instanceof JetJavaMirrorMarker) {
-        // Kotlin functions are already there
-        NamespaceDescriptor kotlinNamespaceDescriptor = semanticServices.getKotlinNamespaceDescriptor(packageFQN);
-        if (kotlinNamespaceDescriptor != null) {
             return null;
         } else {
-            // TODO: what is GlobalSearchScope
+            return psiClass;
-            return semanticServices.getDescriptorResolver().javaFacade.findClass(getQualifiedName(packageFQN, JvmAbi.PACKAGE_CLASS).getFqName());
         }
     }
 
@@ -102,9 +99,9 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
             allDescriptors = Sets.newHashSet();
 
             if (psiClass != null) {
-                allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveMethods(psiClass, descriptor));
+                allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveMethods(psiClass, descriptor, getResolverScopeData()));
 
-                allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveFieldGroup(descriptor, psiClass, staticMembers()));
+                allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveFieldGroup(descriptor, psiClass, staticMembers(), getResolverScopeData()));
             }
 
             final PsiPackage javaPackage = semanticServices.getDescriptorResolver().findPackage(packageFQN);

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamespaceHeader.java

@@ -59,6 +59,10 @@ public class JetNamespaceHeader extends JetReferenceExpression {
         return findChildByType(JetTokens.IDENTIFIER);
     }
 
+    public boolean isRoot() {
+        return getNameIdentifier() == null;
+    }
+
     @Override
     public String getName() {
         PsiElement nameIdentifier = getNameIdentifier();

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

@@ -172,7 +172,7 @@ public interface BindingContext {
     WritableSlice<JetParameter, PropertyDescriptor> VALUE_PARAMETER_AS_PROPERTY = Slices.<JetParameter, PropertyDescriptor>sliceBuilder().build();
 
     WritableSlice<FqName, ClassDescriptor> FQNAME_TO_CLASS_DESCRIPTOR = new BasicWritableSlice<FqName, ClassDescriptor>(DO_NOTHING, true);
-    WritableSlice<FqName, NamespaceDescriptor> FQNAME_TO_NAMESPACE_DESCRIPTOR = new BasicWritableSlice<FqName, NamespaceDescriptor>(DO_NOTHING);
+    WritableSlice<FqName, NamespaceDescriptor> FQNAME_TO_NAMESPACE_DESCRIPTOR = new BasicWritableSlice<FqName, NamespaceDescriptor>(Slices.ONLY_REWRITE_TO_EQUAL);
 
     /**
      * Each namespace found in src must be registered here.

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

@@ -16,7 +16,9 @@
 
 package org.jetbrains.jet.lang.resolve;
 
+import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptorImpl;
 
 /**
@@ -24,5 +26,6 @@ import org.jetbrains.jet.lang.descriptors.NamespaceDescriptorImpl;
  */
 public interface NamespaceFactory {
     @NotNull
-    NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(@NotNull FqName fqName);
+    NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(
+            @NotNull FqName fqName, @Nullable PsiElement declaration);
 }

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.lang.resolve;
 
+import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.ModuleConfiguration;
@@ -68,7 +69,7 @@ public class NamespaceFactoryImpl implements NamespaceFactory {
         JetNamespaceHeader namespaceHeader = file.getNamespaceHeader();
 
         if (moduleDescriptor.getRootNs() == null) {
-            createNamespaceDescriptorIfNeeded(null, moduleDescriptor, "<root>", true);
+            createNamespaceDescriptorIfNeeded(null, null, moduleDescriptor, "<root>", true);
         }
 
         NamespaceDescriptorParent currentOwner = moduleDescriptor.getRootNs();
@@ -79,7 +80,7 @@ public class NamespaceFactoryImpl implements NamespaceFactory {
         for (JetSimpleNameExpression nameExpression : namespaceHeader.getParentNamespaceNames()) {
             String namespaceName = JetPsiUtil.safeName(nameExpression.getReferencedName());
 
-            NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorIfNeeded(null, currentOwner, namespaceName, false);
+            NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorIfNeeded(null, null, currentOwner, namespaceName, false);
             trace.record(BindingContext.NAMESPACE_IS_SRC, namespaceDescriptor, true);
 
             currentOwner = namespaceDescriptor;
@@ -93,7 +94,8 @@ public class NamespaceFactoryImpl implements NamespaceFactory {
         String name = JetPsiUtil.safeName(namespaceHeader.getName());
         trace.record(RESOLUTION_SCOPE, namespaceHeader, outerScope);
 
-        NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorIfNeeded(file, currentOwner, name, false);
+        NamespaceDescriptorImpl namespaceDescriptor =
+                createNamespaceDescriptorIfNeeded(file, file, namespaceHeader.isRoot() ? moduleDescriptor : currentOwner, name, namespaceHeader.isRoot());
         trace.record(BindingContext.NAMESPACE_IS_SRC, namespaceDescriptor, true);
 
         return namespaceDescriptor;
@@ -101,17 +103,21 @@ public class NamespaceFactoryImpl implements NamespaceFactory {
 
     @Override
     @NotNull
-    public NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(@NotNull FqName fqName) {
+    public NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(
+            @NotNull FqName fqName, @Nullable PsiElement declaration) {
         NamespaceDescriptorParent owner = moduleDescriptor;
         for (FqName pathElement : fqName.path()) {
-            owner = createNamespaceDescriptorIfNeeded(null,
+            boolean needDeclaration = pathElement.equals(fqName);
+            owner = createNamespaceDescriptorIfNeeded(null, needDeclaration ? declaration : null,
                     owner, pathElement.isRoot() ? "<root>" : pathElement.shortName(), pathElement.isRoot());
         }
         return (NamespaceDescriptorImpl) owner;
     }
 
     @NotNull
-    public NamespaceDescriptorImpl createNamespaceDescriptorIfNeeded(@Nullable JetFile file, @NotNull NamespaceDescriptorParent owner, @NotNull String name, boolean root) {
+    public NamespaceDescriptorImpl createNamespaceDescriptorIfNeeded(
+            @Nullable JetFile file, @Nullable PsiElement declaration,
+            @NotNull NamespaceDescriptorParent owner, @NotNull String name, boolean root) {
 
         FqName fqName;
         NamespaceDescriptorImpl namespaceDescriptor;
@@ -120,7 +126,7 @@ public class NamespaceFactoryImpl implements NamespaceFactory {
                 throw new IllegalStateException();
             }
             fqName = FqName.ROOT;
-            namespaceDescriptor = ((ModuleDescriptor) owner).getRootNs();
+            namespaceDescriptor = (NamespaceDescriptorImpl) trace.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, FqName.ROOT);
         }
         else {
             FqName ownerFqName = DescriptorUtils.getFQName(owner).toSafe();
@@ -140,8 +146,8 @@ public class NamespaceFactoryImpl implements NamespaceFactory {
             namespaceDescriptor.initialize(scope);
             configuration.extendNamespaceScope(trace, namespaceDescriptor, scope);
             owner.addNamespace(namespaceDescriptor);
-            if (file != null) {
+            if (declaration != null) {
-                trace.record(BindingContext.NAMESPACE, file, namespaceDescriptor);
+                trace.record(BindingContext.NAMESPACE, declaration, namespaceDescriptor);
             }
         }
 

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

@@ -297,11 +297,11 @@ public class TopDownAnalyzer {
                 new TraceBasedRedeclarationHandler(trace)).setDebugName("Root scope in analyzeNamespace");
         scope.changeLockLevel(WritableScope.LockLevel.BOTH);
 
-        NamespaceDescriptorImpl rootNs = namespaceFactory.createNamespaceDescriptorPathIfNeeded(FqName.ROOT);
+        NamespaceDescriptorImpl rootNs = namespaceFactory.createNamespaceDescriptorPathIfNeeded(FqName.ROOT, null);
 
         // map "jet" namespace into JetStandardLibrary/Classes
         // @see DefaultModuleConfiguraiton#extendNamespaceScope
-        namespaceFactory.createNamespaceDescriptorPathIfNeeded(JetStandardClasses.STANDARD_CLASSES_FQNAME);
+        namespaceFactory.createNamespaceDescriptorPathIfNeeded(JetStandardClasses.STANDARD_CLASSES_FQNAME, null);
 
         // Import a scope that contains all top-level namespaces that come from dependencies
         // This makes the namespaces visible at all, does not import themselves

idea/testData/completion/basic/InPackage.kt

@@ -7,4 +7,5 @@ class Test {
 }
 
 // EXIST: concurrent
-// ABSENT: AbstractList, Date, Random, import
+// ABSENT: TodoAbstractList, Date, Random, import
+// TODO: add AbstractList back to ABSENT