Big refactoring. Migrating to package views and fragments.

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java

@@ -42,19 +42,7 @@ public class JavaBridgeConfiguration implements ModuleConfiguration {
         ALL_JAVA_IMPORTS = Collections.unmodifiableList(allJavaImports);
     }
 
-    private JavaDescriptorResolver javaDescriptorResolver;
-
-    @Inject
-    public void setJavaDescriptorResolver(@NotNull JavaDescriptorResolver javaDescriptorResolver) {
-        this.javaDescriptorResolver = javaDescriptorResolver;
-    }
-
     @Override
     public void extendNamespaceScope(@NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) {
-        JetScope javaPackageScope = javaDescriptorResolver.getJavaPackageScope(namespaceDescriptor);
-        if (javaPackageScope != null) {
-            namespaceMemberScope.importScope(javaPackageScope);
-        }
-        DefaultModuleConfiguration.INSTANCE.extendNamespaceScope(namespaceDescriptor, namespaceMemberScope);
     }
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java

@@ -21,10 +21,9 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
 
 import javax.inject.Inject;
@@ -35,7 +34,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     public static final Name JAVA_ROOT = Name.special("<java_root>");
 
     private JavaClassResolver classResolver;
-    private JavaNamespaceResolver namespaceResolver;
+    private JavaPackageFragmentProvider packageFragmentProvider;
 
     @Inject
     public void setClassResolver(JavaClassResolver classResolver) {
@@ -43,8 +42,8 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     }
 
     @Inject
-    public void setNamespaceResolver(JavaNamespaceResolver namespaceResolver) {
-        this.namespaceResolver = namespaceResolver;
+    public void setPackageFragmentProvider(JavaPackageFragmentProvider packageFragmentProvider) {
+        this.packageFragmentProvider = packageFragmentProvider;
     }
 
     @Nullable
@@ -57,13 +56,15 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         return classResolver.resolveClass(qualifiedName, IGNORE_KOTLIN_SOURCES);
     }
 
+    @Deprecated
     @Nullable
     public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
-        return namespaceResolver.resolveNamespace(qualifiedName, searchRule);
+        // TODO 1 remove this method
+        return null;
     }
 
-    @Nullable
-    public JetScope getJavaPackageScope(@NotNull NamespaceDescriptor namespaceDescriptor) {
-        return namespaceResolver.getJavaPackageScopeForExistingNamespaceDescriptor(namespaceDescriptor);
+    @NotNull
+    public JavaPackageFragmentProvider getPackageFragmentProvider() {
+        return packageFragmentProvider;
     }
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaVisibilities.java

@@ -17,10 +17,10 @@
 package org.jetbrains.jet.lang.resolve.java;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
 
 public class JavaVisibilities {
     private JavaVisibilities() {
@@ -29,7 +29,7 @@ public class JavaVisibilities {
     public static final Visibility PACKAGE_VISIBILITY = new Visibility("package", false) {
         @Override
         protected boolean isVisible(@NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) {
-            return isInSameNamespace(what, from);
+            return areInSamePackage(what, from);
         }
 
         @Override
@@ -67,8 +67,8 @@ public class JavaVisibilities {
             // protected static function or property
             else {
                 DeclarationDescriptor whatDeclarationDescriptor = what.getContainingDeclaration();
-                assert whatDeclarationDescriptor instanceof NamespaceDescriptor : "Only static declarations can have protected_static visibility";
-                whatClass = getClassForCorrespondingJavaNamespace((NamespaceDescriptor) whatDeclarationDescriptor);
+                assert whatDeclarationDescriptor instanceof JavaPackageFragmentDescriptor : "Only static declarations can have protected_static visibility";
+                whatClass = JavaFunctionResolver.getClassForCorrespondingJavaPackage((JavaPackageFragmentDescriptor) whatDeclarationDescriptor);
             }
 
             assert whatClass != null : "Couldn't find ClassDescriptor for protected static member " + what;
@@ -94,7 +94,7 @@ public class JavaVisibilities {
     public static final Visibility PROTECTED_AND_PACKAGE = new Visibility("protected_and_package", false) {
         @Override
         protected boolean isVisible(@NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) {
-            if (isInSameNamespace(what, from)) {
+            if (areInSamePackage(what, from)) {
                 return true;
             }
 
@@ -130,40 +130,9 @@ public class JavaVisibilities {
         }
     };
 
-    private static boolean isInSameNamespace(@NotNull DeclarationDescriptor first, @NotNull DeclarationDescriptor second) {
-        NamespaceDescriptor whatPackage = DescriptorUtils.getParentOfType(first, NamespaceDescriptor.class, false);
-        NamespaceDescriptor fromPackage = DescriptorUtils.getParentOfType(second, NamespaceDescriptor.class, false);
-        return fromPackage != null && whatPackage != null && fqNamesEqual(whatPackage, fromPackage);
-    }
-
-    private static boolean fqNamesEqual(@NotNull NamespaceDescriptor a, @NotNull NamespaceDescriptor b) {
-        return DescriptorUtils.getFQName(a).equals(DescriptorUtils.getFQName(b));
-    }
-
-    @Nullable
-    private static ClassDescriptor getClassForCorrespondingJavaNamespace(@NotNull NamespaceDescriptor correspondingNamespace) {
-        NamespaceDescriptorParent containingDeclaration = correspondingNamespace.getContainingDeclaration();
-        if (!(containingDeclaration instanceof NamespaceDescriptor)) {
-            return null;
-        }
-
-        NamespaceDescriptor namespaceDescriptor = (NamespaceDescriptor) containingDeclaration;
-
-        ClassifierDescriptor classDescriptor = namespaceDescriptor.getMemberScope().getClassifier(correspondingNamespace.getName());
-        if (classDescriptor != null && classDescriptor instanceof ClassDescriptor) {
-            return (ClassDescriptor) classDescriptor;
-        }
-
-        ClassDescriptor classDescriptorForOuterClass = getClassForCorrespondingJavaNamespace(namespaceDescriptor);
-        if (classDescriptorForOuterClass == null) {
-            return null;
-        }
-
-        ClassifierDescriptor innerClassDescriptor =
-                classDescriptorForOuterClass.getUnsubstitutedInnerClassesScope().getClassifier(correspondingNamespace.getName());
-        if (innerClassDescriptor instanceof ClassDescriptor) {
-            return (ClassDescriptor) innerClassDescriptor;
-        }
-        return null;
+    private static boolean areInSamePackage(@NotNull DeclarationDescriptor first, @NotNull DeclarationDescriptor second) {
+        PackageFragmentDescriptor whatPackage = DescriptorUtils.getParentOfType(first, PackageFragmentDescriptor.class, false);
+        PackageFragmentDescriptor fromPackage = DescriptorUtils.getParentOfType(second, PackageFragmentDescriptor.class, false);
+        return fromPackage != null && whatPackage != null && whatPackage.getFqName().equals(fromPackage.getFqName());
     }
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaNamespaceDescriptor.java

@@ -1,53 +0,0 @@
-/*
- * Copyright 2010-2013 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.descriptor;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.impl.AbstractNamespaceDescriptorImpl;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-
-import java.util.List;
-
-public class JavaNamespaceDescriptor extends AbstractNamespaceDescriptorImpl {
-    private JetScope memberScope;
-    private final FqName qualifiedName;
-
-    public JavaNamespaceDescriptor(NamespaceDescriptorParent containingDeclaration, List<AnnotationDescriptor> annotations,
-            @NotNull FqName qualifiedName) {
-        super(containingDeclaration, annotations, qualifiedName.shortNameOrSpecial());
-        this.qualifiedName = qualifiedName;
-    }
-
-    public void setMemberScope(@NotNull JetScope memberScope) {
-        this.memberScope = memberScope;
-    }
-
-    @NotNull
-    @Override
-    public JetScope getMemberScope() {
-        return memberScope;
-    }
-
-    @NotNull
-    @Override
-    public FqName getFqName() {
-        return qualifiedName;
-    }
-}

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaPackageFragmentDescriptor.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2010-2013 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.descriptor;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitor;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.types.TypeSubstitutor;
+
+import java.util.Collections;
+import java.util.List;
+
+public class JavaPackageFragmentDescriptor extends DeclarationDescriptorImpl implements PackageFragmentDescriptor {
+    private final JavaPackageFragmentProvider provider;
+    private final FqName fqName;
+    private JetScope memberScope;
+
+    public JavaPackageFragmentDescriptor(
+            @NotNull JavaPackageFragmentProvider provider,
+            @NotNull FqName fqName
+    ) {
+        super(Collections.<AnnotationDescriptor>emptyList(), fqName.shortNameOrSpecial());
+        this.provider = provider;
+        this.fqName = fqName;
+    }
+
+    @NotNull
+    @Override
+    public ModuleDescriptor getContainingDeclaration() {
+        return provider.getModule();
+    }
+
+    @Nullable
+    @Override
+    public DeclarationDescriptor substitute(@NotNull TypeSubstitutor substitutor) {
+        return this;
+    }
+
+    @Override
+    public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
+        return visitor.visitPackageFragmentDescriptor(this, data);
+    }
+
+    public void setMemberScope(@NotNull JetScope memberScope) {
+        this.memberScope = memberScope;
+    }
+
+    @NotNull
+    @Override
+    public JetScope getMemberScope() {
+        return memberScope;
+    }
+
+    @NotNull
+    @Override
+    public FqName getFqName() {
+        return fqName;
+    }
+
+    @NotNull
+    public JavaPackageFragmentProvider getProvider() {
+        return provider;
+    }
+}

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java

@@ -65,7 +65,7 @@ public final class JavaClassResolver {
     private JavaMemberResolver memberResolver;
     private JavaAnnotationResolver annotationResolver;
     private JavaClassFinder javaClassFinder;
-    private JavaNamespaceResolver namespaceResolver;
+    private JavaPackageFragmentProvider packageFragmentProvider;
     private JavaSupertypeResolver supertypesResolver;
     private JavaFunctionResolver functionResolver;
     private DeserializedDescriptorResolver deserializedDescriptorResolver;
@@ -105,8 +105,8 @@ public final class JavaClassResolver {
     }
 
     @Inject
-    public void setNamespaceResolver(JavaNamespaceResolver namespaceResolver) {
-        this.namespaceResolver = namespaceResolver;
+    public void setPackageFragmentProvider(JavaPackageFragmentProvider packageFragmentProvider) {
+        this.packageFragmentProvider = packageFragmentProvider;
     }
 
     @Inject
@@ -385,11 +385,11 @@ public final class JavaClassResolver {
         }
         else {
             FqName parentFqName = childClassFQName.parent();
-            NamespaceDescriptor parentNamespace = namespaceResolver.resolveNamespace(parentFqName, INCLUDE_KOTLIN_SOURCES);
-            if (parentNamespace == null) {
+            PackageFragmentDescriptor parentPackage = packageFragmentProvider.getOrCreatePackage(parentFqName);
+            if (parentPackage == null) {
                 throw new IllegalStateException("Could not resolve " + parentFqName + " required to be parent for " + childClassFQName);
             }
-            return parentNamespace;
+            return parentPackage;
         }
     }
 

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java

@@ -19,15 +19,16 @@ package org.jetbrains.jet.lang.resolve.java.resolver;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent;
 import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaMethodDescriptor;
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor;
 import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptor;
 import org.jetbrains.jet.lang.resolve.java.scope.NamedMembers;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaType;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetType;
@@ -137,7 +138,7 @@ public final class JavaFunctionResolver {
         List<FunctionDescriptor> superFunctions;
         ExternalSignatureResolver.AlternativeMethodSignature effectiveSignature;
 
-        if (ownerDescriptor instanceof NamespaceDescriptor) {
+        if (ownerDescriptor instanceof PackageFragmentDescriptor) {
             superFunctions = Collections.emptyList();
             effectiveSignature = externalSignatureResolver
                     .resolveAlternativeMethodSignature(method, false, returnType, null, valueParameters, methodTypeParameters);
@@ -198,8 +199,8 @@ public final class JavaFunctionResolver {
             }
         }
 
-        if (owner instanceof NamespaceDescriptor) {
-            SamConstructorDescriptor samConstructor = resolveSamConstructor((NamespaceDescriptor) owner, members);
+        if (owner instanceof JavaPackageFragmentDescriptor) {
+            SamConstructorDescriptor samConstructor = resolveSamConstructor((JavaPackageFragmentDescriptor) owner, members);
             if (samConstructor != null) {
                 functionsFromCurrent.add(samConstructor);
             }
@@ -237,39 +238,63 @@ public final class JavaFunctionResolver {
         return null;
     }
 
+    // TODO 2 move to proper place
     // E.g. we have foo.Bar.Baz class declared in Java. It will produce the following descriptors structure:
-    // namespace foo
+    // package fragment foo
     // +-- class Bar
     // |    +-- class Baz
-    // +-- namespace Bar
-    // We need to find class 'Baz' in namespace 'foo.Bar'.
+    // +-- package fragment Bar
+    // We need to find class 'Baz' in fragment 'foo.Bar'.
     @Nullable
-    private static JavaClassDescriptor findClassInNamespace(@NotNull NamespaceDescriptor namespace, @NotNull Name name) {
-        // First, try to find in namespace directly
-        JavaClassDescriptor found = findClassInScope(namespace.getMemberScope(), name);
+    private static JavaClassDescriptor findClassInPackage(@NotNull JavaPackageFragmentDescriptor fragment, @NotNull Name name) {
+        // First, try to find in fragment directly
+        JavaClassDescriptor found = findClassInScope(fragment.getMemberScope(), name);
         if (found != null) {
             return found;
         }
 
         // If unsuccessful, try to find class of the same name as current (class 'foo.Bar')
-        NamespaceDescriptorParent parent = namespace.getContainingDeclaration();
-        if (parent instanceof NamespaceDescriptor) {
-            // Calling recursively, looking for 'Bar' in 'foo'
-            ClassDescriptor classForCurrentNamespace = findClassInNamespace((NamespaceDescriptor) parent, namespace.getName());
-            if (classForCurrentNamespace == null) {
-                return null;
-            }
-
-            // Try to find nested class 'Baz' in class 'foo.Bar'
-            return findClassInScope(DescriptorUtils.getStaticNestedClassesScope(classForCurrentNamespace), name);
+        JavaPackageFragmentDescriptor parentPackage = getParentPackage(fragment);
+        if (parentPackage == null) {
+            return null;
         }
+
+        // Calling recursively, looking for 'Bar' in 'foo'
+        ClassDescriptor classForCurrentPackage = findClassInPackage(parentPackage, fragment.getName());
+        if (classForCurrentPackage != null) {
+            // Try to find nested class 'Baz' in class 'foo.Bar'
+            return findClassInScope(DescriptorUtils.getStaticNestedClassesScope(classForCurrentPackage), name);
+        }
+
         return null;
     }
 
     @Nullable
-    public static SamConstructorDescriptor resolveSamConstructor(@NotNull NamespaceDescriptor owner, @NotNull NamedMembers namedMembers) {
+    private static JavaPackageFragmentDescriptor getParentPackage(JavaPackageFragmentDescriptor fragment) {
+        FqName fqName = fragment.getFqName();
+        if (fqName.isRoot()) {
+            return null;
+        }
+
+        JavaPackageFragmentDescriptor parentPackage = fragment.getProvider().getOrCreatePackage(fqName.parent());
+        assert parentPackage != null : " couldn't find parent package for " + fragment;
+        return parentPackage;
+    }
+
+    @Nullable
+    public static JavaClassDescriptor getClassForCorrespondingJavaPackage(@NotNull JavaPackageFragmentDescriptor fragment) {
+        JavaPackageFragmentDescriptor parentPackage = getParentPackage(fragment);
+        if (parentPackage == null) {
+            return null;
+        }
+
+        return findClassInPackage(parentPackage, fragment.getFqName().shortName());
+    }
+
+    @Nullable
+    public static SamConstructorDescriptor resolveSamConstructor(@NotNull JavaPackageFragmentDescriptor owner, @NotNull NamedMembers namedMembers) {
         if (namedMembers.getSamInterface() != null) {
-            JavaClassDescriptor klass = findClassInNamespace(owner, namedMembers.getName());
+            JavaClassDescriptor klass = findClassInPackage(owner, namedMembers.getName());
             if (klass != null) {
                 return createSamConstructorFunction(owner, klass);
             }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaMemberResolver.java

@@ -30,7 +30,6 @@ import java.util.Set;
 
 public class JavaMemberResolver {
     private JavaClassResolver classResolver;
-    private JavaNamespaceResolver namespaceResolver;
     private JavaFunctionResolver functionResolver;
     private JavaPropertyResolver propertyResolver;
     private JavaConstructorResolver constructorResolver;
@@ -40,11 +39,6 @@ public class JavaMemberResolver {
         this.classResolver = classResolver;
     }
 
-    @Inject
-    public void setNamespaceResolver(JavaNamespaceResolver namespaceResolver) {
-        this.namespaceResolver = namespaceResolver;
-    }
-
     @Inject
     public void setFunctionResolver(JavaFunctionResolver functionResolver) {
         this.functionResolver = functionResolver;
@@ -65,11 +59,6 @@ public class JavaMemberResolver {
         return classResolver.resolveClass(qualifiedName, searchRule);
     }
 
-    @Nullable
-    public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
-        return namespaceResolver.resolveNamespace(qualifiedName, searchRule);
-    }
-
     @NotNull
     public Set<FunctionDescriptor> resolveFunctionGroupForClass(@NotNull NamedMembers members, @NotNull ClassOrNamespaceDescriptor owner) {
         return functionResolver.resolveFunctionGroupForClass(members, owner);

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPackageFragmentProvider.java

@@ -16,17 +16,16 @@
 
 package org.jetbrains.jet.lang.resolve.java.resolver;
 
+import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.java.*;
-import org.jetbrains.jet.lang.resolve.java.descriptor.JavaNamespaceDescriptor;
-import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider;
+import org.jetbrains.jet.lang.resolve.java.JavaClassFinder;
+import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor;
 import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaClassStaticMembersScope;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
@@ -44,16 +43,9 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import javax.inject.Inject;
 import java.util.*;
 
-import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES;
-
-public final class JavaNamespaceResolver {
-
+public final class JavaPackageFragmentProvider implements PackageFragmentProvider {
     @NotNull
-    public static final ModuleDescriptor FAKE_ROOT_MODULE = new ModuleDescriptorImpl(JavaDescriptorResolver.JAVA_ROOT,
-                                                                                     JavaBridgeConfiguration.ALL_JAVA_IMPORTS,
-                                                                                     JavaToKotlinClassMap.getInstance());
-    @NotNull
-    private final Map<FqName, JetScope> resolvedNamespaceCache = new HashMap<FqName, JetScope>();
+    private final Map<FqName, JetScope> packageFragments = new HashMap<FqName, JetScope>();
     @NotNull
     private final Set<FqName> unresolvedCache = new HashSet<FqName>();
 
@@ -64,6 +56,8 @@ public final class JavaNamespaceResolver {
     private DeserializedDescriptorResolver deserializedDescriptorResolver;
     private KotlinClassFinder kotlinClassFinder;
 
+    private ModuleDescriptor module;
+
     @Inject
     public void setKotlinClassFinder(KotlinClassFinder kotlinClassFinder) {
         this.kotlinClassFinder = kotlinClassFinder;
@@ -89,65 +83,66 @@ public final class JavaNamespaceResolver {
         this.deserializedDescriptorResolver = deserializedDescriptorResolver;
     }
 
-    @Nullable
-    public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
-        if (searchRule == INCLUDE_KOTLIN_SOURCES) {
-            NamespaceDescriptor kotlinNamespaceDescriptor = cache.getPackageResolvedFromSource(qualifiedName);
-            if (kotlinNamespaceDescriptor != null) {
-                return kotlinNamespaceDescriptor;
-            }
+    @Inject
+    public void setModule(ModuleDescriptor module) {
+        this.module = module;
+        // TODO 1 hacky
+        ((ModuleDescriptorImpl) module).addFragmentProvider(this);
+    }
+
+    @NotNull
+    @Override
+    public List<PackageFragmentDescriptor> getPackageFragments(@NotNull FqName fqName) {
+        return ContainerUtil.<PackageFragmentDescriptor>createMaybeSingletonList(getOrCreatePackage(fqName));
+    }
+
+    @NotNull
+    @Override
+    public Collection<FqName> getSubPackagesOf(@NotNull FqName fqName) {
+        PackageFragmentDescriptor packageFragment = getOrCreatePackage(fqName);
+        if (packageFragment == null) {
+            return Collections.emptyList();
         }
 
+        JetScope scope = packageFragment.getMemberScope();
+        // TODO 2 replace instanceof with interface
+        if (scope instanceof JavaPackageScope) {
+            return ((JavaPackageScope) scope).getSubPackages();
+        }
+        if (scope instanceof JavaClassStaticMembersScope) {
+            return ((JavaClassStaticMembersScope) scope).getSubPackages();
+        }
+        return Collections.emptyList();
+    }
+
+    @Nullable
+    public JavaPackageFragmentDescriptor getOrCreatePackage(@NotNull FqName qualifiedName) {
+        // TODO 1 use one cache
         if (unresolvedCache.contains(qualifiedName)) {
             return null;
         }
-        JetScope scope = resolvedNamespaceCache.get(qualifiedName);
+        JetScope scope = packageFragments.get(qualifiedName);
         if (scope != null) {
-            return (NamespaceDescriptor) scope.getContainingDeclaration();
+            return (JavaPackageFragmentDescriptor) scope.getContainingDeclaration();
         }
 
-        NamespaceDescriptorParent parentNs = resolveParentNamespace(qualifiedName);
-        if (parentNs == null) {
+        JavaPackageFragmentDescriptor packageFragment = new JavaPackageFragmentDescriptor(this, qualifiedName);
+
+        JetScope namespaceScope = createPackageScope(qualifiedName, packageFragment, true);
+        cache(qualifiedName, namespaceScope);
+        if (namespaceScope == null) {
             return null;
         }
 
-        JavaNamespaceDescriptor javaNamespaceDescriptor = new JavaNamespaceDescriptor(
-                parentNs,
-                Collections.<AnnotationDescriptor>emptyList(), // TODO
-                qualifiedName
-        );
+        packageFragment.setMemberScope(namespaceScope);
 
-        JetScope newScope = createNamespaceScope(qualifiedName, javaNamespaceDescriptor, true);
-        if (newScope == null) {
-            return null;
-        }
-
-        javaNamespaceDescriptor.setMemberScope(newScope);
-
-        return javaNamespaceDescriptor;
+        return packageFragment;
     }
 
     @Nullable
-    private NamespaceDescriptorParent resolveParentNamespace(@NotNull FqName fqName) {
-        if (fqName.isRoot()) {
-            return FAKE_ROOT_MODULE;
-        }
-        else {
-            return resolveNamespace(fqName.parent(), INCLUDE_KOTLIN_SOURCES);
-        }
-    }
-
-    @Nullable
-    private JetScope createNamespaceScope(@NotNull FqName fqName, @NotNull NamespaceDescriptor namespaceDescriptor, boolean record) {
-        JetScope namespaceScope = doCreateNamespaceScope(fqName, namespaceDescriptor, record);
-        cache(fqName, namespaceScope);
-        return namespaceScope;
-    }
-
-    @Nullable
-    private JetScope doCreateNamespaceScope(
+    private JetScope createPackageScope(
             @NotNull FqName fqName,
-            @NotNull NamespaceDescriptor namespaceDescriptor,
+            @NotNull PackageFragmentDescriptor packageFragment,
             boolean record
     ) {
         JavaPackage javaPackage = javaClassFinder.findPackage(fqName);
@@ -155,43 +150,29 @@ public final class JavaNamespaceResolver {
             FqName packageClassFqName = PackageClassUtils.getPackageClassFqName(fqName);
             KotlinJvmBinaryClass kotlinClass = kotlinClassFinder.find(packageClassFqName);
 
-            cache.recordProperNamespace(namespaceDescriptor);
+            cache.recordProperPackage(packageFragment);
 
             if (kotlinClass != null) {
-                JetScope kotlinPackageScope = deserializedDescriptorResolver.createKotlinPackageScope(namespaceDescriptor, kotlinClass);
+                JetScope kotlinPackageScope = deserializedDescriptorResolver.createKotlinPackageScope(packageFragment, kotlinClass);
                 if (kotlinPackageScope != null) {
                     return kotlinPackageScope;
                 }
             }
 
-
-            // Otherwise (if psiClass is null or doesn't have a supported Kotlin annotation), it's a Java class and the package is empty
-            if (record) {
-                cache.recordPackage(javaPackage, namespaceDescriptor);
-            }
-
-            return new JavaPackageScope(namespaceDescriptor, javaPackage, fqName, memberResolver);
+            return new JavaPackageScope(packageFragment, javaPackage, fqName, memberResolver);
         }
 
         JavaClass javaClass = javaClassFinder.findClass(fqName);
-        if (javaClass == null) {
-            return null;
+        if (javaClass != null && shouldCreateStaticMembersPackage(javaClass)) {
+            cache.recordClassStaticMembersNamespace(packageFragment);
+            return new JavaClassStaticMembersScope(packageFragment, javaClass, memberResolver);
         }
+        return null;
+    }
 
-        if (DescriptorResolverUtils.isCompiledKotlinClassOrPackageClass(javaClass)) {
-            return null;
-        }
-        if (!hasStaticMembers(javaClass)) {
-            return null;
-        }
-
-        cache.recordClassStaticMembersNamespace(namespaceDescriptor);
-
-        if (record) {
-            cache.recordPackage(javaClass, namespaceDescriptor);
-        }
-
-        return new JavaClassStaticMembersScope(namespaceDescriptor, fqName, javaClass, memberResolver);
+    // TODO 2 move to more decent place
+    public static boolean shouldCreateStaticMembersPackage(@NotNull JavaClass javaClass) {
+        return !DescriptorResolverUtils.isCompiledKotlinClassOrPackageClass(javaClass) && hasStaticMembers(javaClass);
     }
 
     private void cache(@NotNull FqName fqName, @Nullable JetScope packageScope) {
@@ -199,27 +180,12 @@ public final class JavaNamespaceResolver {
             unresolvedCache.add(fqName);
             return;
         }
-        JetScope oldValue = resolvedNamespaceCache.put(fqName, packageScope);
+        JetScope oldValue = packageFragments.put(fqName, packageScope);
         if (oldValue != null) {
             throw new IllegalStateException("rewrite at " + fqName);
         }
     }
 
-    @Nullable
-    public JetScope getJavaPackageScopeForExistingNamespaceDescriptor(@NotNull NamespaceDescriptor namespaceDescriptor) {
-        FqName fqName = DescriptorUtils.getFQName(namespaceDescriptor).toSafe();
-        if (unresolvedCache.contains(fqName)) {
-            throw new IllegalStateException(
-                    "This means that we are trying to create a Java package, but have a package with the same FQN defined in Kotlin: " +
-                    fqName);
-        }
-        JetScope alreadyResolvedScope = resolvedNamespaceCache.get(fqName);
-        if (alreadyResolvedScope != null) {
-            return alreadyResolvedScope;
-        }
-        return createNamespaceScope(fqName, namespaceDescriptor, false);
-    }
-
     private static boolean hasStaticMembers(@NotNull JavaClass javaClass) {
         for (JavaMethod method : javaClass.getMethods()) {
             if (method.isStatic() && !DescriptorResolverUtils.shouldBeInEnumClassObject(method)) {
@@ -260,4 +226,9 @@ public final class JavaNamespaceResolver {
 
         return result;
     }
+
+    @NotNull
+    public ModuleDescriptor getModule() {
+        return module;
+    }
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaResolverCache.java

@@ -29,9 +29,6 @@ public interface JavaResolverCache {
     @Nullable
     ClassDescriptor getClassResolvedFromSource(@NotNull FqName fqName);
 
-    @Nullable
-    NamespaceDescriptor getPackageResolvedFromSource(@NotNull FqName fqName);
-
     @Nullable
     SimpleFunctionDescriptor getMethod(@NotNull JavaMethod method);
 
@@ -49,9 +46,7 @@ public interface JavaResolverCache {
 
     void recordClass(@NotNull JavaClass javaClass, @NotNull ClassDescriptor descriptor);
 
-    void recordProperNamespace(@NotNull NamespaceDescriptor descriptor);
+    void recordProperPackage(@NotNull PackageFragmentDescriptor descriptor);
 
-    void recordClassStaticMembersNamespace(@NotNull NamespaceDescriptor descriptor);
-
-    void recordPackage(@NotNull JavaElement element, @NotNull NamespaceDescriptor descriptor);
+    void recordClassStaticMembersNamespace(@NotNull PackageFragmentDescriptor descriptor);
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java

@@ -16,58 +16,47 @@
 
 package org.jetbrains.jet.lang.resolve.java.scope;
 
+import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;
 
 import java.util.Collection;
 import java.util.Collections;
-
-import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES;
+import java.util.List;
 
 public final class JavaClassStaticMembersScope extends JavaClassMembersScope {
-    @NotNull
-    private final FqName packageFQN;
     @NotNull
     private final JavaClass javaClass;
 
     public JavaClassStaticMembersScope(
-            @NotNull NamespaceDescriptor descriptor,
-            @NotNull FqName packageFQN,
+            @NotNull PackageFragmentDescriptor descriptor,
             @NotNull JavaClass javaClass,
             @NotNull JavaMemberResolver memberResolver
     ) {
         super(descriptor, MembersProvider.forClass(javaClass, true), memberResolver);
-        this.packageFQN = packageFQN;
         this.javaClass = javaClass;
     }
 
-    @Override
-    public NamespaceDescriptor getNamespace(@NotNull Name name) {
-        return memberResolver.resolveNamespace(packageFQN.child(name), INCLUDE_KOTLIN_SOURCES);
-    }
-
-    @NotNull
-    @Override
-    protected Collection<DeclarationDescriptor> computeAllDescriptors() {
-        Collection<DeclarationDescriptor> result = super.computeAllDescriptors();
-        for (JavaClass nested : javaClass.getInnerClasses()) {
-            NamespaceDescriptor namespace = getNamespace(nested.getName());
-            if (namespace != null) {
-                result.add(namespace);
-            }
-        }
-        return result;
-    }
-
     @NotNull
     @Override
     protected Collection<ClassDescriptor> computeInnerClasses() {
         return Collections.emptyList();
     }
+
+    @NotNull
+    public Collection<FqName> getSubPackages() {
+        List<FqName> result = Lists.newArrayList();
+        for (JavaClass nested : javaClass.getInnerClasses()) {
+            if (JavaPackageFragmentProvider.shouldCreateStaticMembersPackage(nested)) {
+                result.add(nested.getFqName());
+            }
+        }
+        return result;
+    }
+
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScope.java

@@ -16,25 +16,20 @@
 
 package org.jetbrains.jet.lang.resolve.java.scope;
 
+import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor;
 import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptor;
-import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.ProgressChecker;
+import org.jetbrains.jet.lang.resolve.java.resolver.*;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.*;
 
 import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES;
-import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES;
 
 public final class JavaPackageScope extends JavaBaseScope {
     @NotNull
@@ -43,7 +38,7 @@ public final class JavaPackageScope extends JavaBaseScope {
     private final FqName packageFQN;
 
     public JavaPackageScope(
-            @NotNull NamespaceDescriptor descriptor,
+            @NotNull PackageFragmentDescriptor descriptor,
             @NotNull JavaPackage javaPackage,
             @NotNull FqName packageFQN,
             @NotNull JavaMemberResolver memberResolver
@@ -58,11 +53,6 @@ public final class JavaPackageScope extends JavaBaseScope {
         return memberResolver.resolveClass(packageFQN.child(name), IGNORE_KOTLIN_SOURCES);
     }
 
-    @Override
-    public NamespaceDescriptor getNamespace(@NotNull Name name) {
-        return memberResolver.resolveNamespace(packageFQN.child(name), INCLUDE_KOTLIN_SOURCES);
-    }
-
     @NotNull
     @Override
     protected Collection<DeclarationDescriptor> computeAllDescriptors() {
@@ -75,13 +65,6 @@ public final class JavaPackageScope extends JavaBaseScope {
     private Collection<DeclarationDescriptor> computeAllPackageDeclarations() {
         Collection<DeclarationDescriptor> result = new HashSet<DeclarationDescriptor>();
 
-        for (JavaPackage subPackage : javaPackage.getSubPackages()) {
-            NamespaceDescriptor childNs = memberResolver.resolveNamespace(subPackage.getFqName(), IGNORE_KOTLIN_SOURCES);
-            if (childNs != null) {
-                result.add(childNs);
-            }
-        }
-
         for (JavaClass javaClass : DescriptorResolverUtils.getClassesInPackage(javaPackage)) {
             if (DescriptorResolverUtils.isCompiledKotlinPackageClass(javaClass)) continue;
 
@@ -98,11 +81,6 @@ public final class JavaPackageScope extends JavaBaseScope {
             if (classDescriptor != null) {
                 result.add(classDescriptor);
             }
-
-            NamespaceDescriptor namespace = memberResolver.resolveNamespace(fqName, IGNORE_KOTLIN_SOURCES);
-            if (namespace != null) {
-                result.add(namespace);
-            }
         }
 
         return result;
@@ -115,7 +93,7 @@ public final class JavaPackageScope extends JavaBaseScope {
         if (members == null) {
             return Collections.emptySet();
         }
-        SamConstructorDescriptor samConstructor = JavaFunctionResolver.resolveSamConstructor((NamespaceDescriptor) descriptor, members);
+        SamConstructorDescriptor samConstructor = JavaFunctionResolver.resolveSamConstructor((JavaPackageFragmentDescriptor) descriptor, members);
         if (samConstructor == null) {
             return Collections.emptySet();
         }
@@ -127,4 +105,18 @@ public final class JavaPackageScope extends JavaBaseScope {
     protected Collection<ClassDescriptor> computeInnerClasses() {
         return Collections.emptyList();
     }
+
+    @NotNull
+    public Collection<FqName> getSubPackages() {
+        List<FqName> result = Lists.newArrayList();
+        for (JavaPackage subPackage : javaPackage.getSubPackages()) {
+            result.add(subPackage.getFqName());
+        }
+        for (JavaClass javaClass : DescriptorResolverUtils.getClassesInPackage(javaPackage)) {
+            if (JavaPackageFragmentProvider.shouldCreateStaticMembersPackage(javaClass)) {
+                result.add(javaClass.getFqName());
+            }
+        }
+        return result;
+    }
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java

@@ -114,8 +114,8 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer
         if (descriptor instanceof ClassDescriptor) {
             return kotlinClassFinder.find(kotlinFqNameToJavaFqName(naiveKotlinFqName((ClassDescriptor) descriptor)));
         }
-        else if (descriptor instanceof NamespaceDescriptor) {
-            return kotlinClassFinder.find(PackageClassUtils.getPackageClassFqName(DescriptorUtils.getFQName(descriptor).toSafe()));
+        else if (descriptor instanceof PackageFragmentDescriptor) {
+            return kotlinClassFinder.find(PackageClassUtils.getPackageClassFqName(((PackageFragmentDescriptor) descriptor).getFqName()));
         }
         else {
             throw new IllegalStateException("Unrecognized descriptor: " + descriptor);
@@ -253,15 +253,15 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer
             @NotNull NameResolver nameResolver,
             @NotNull AnnotatedCallableKind kind
     ) {
-        if (container instanceof NamespaceDescriptor) {
-            return loadPackageFragmentClassFqName((NamespaceDescriptor) container, proto, nameResolver);
+        if (container instanceof PackageFragmentDescriptor) {
+            return loadPackageFragmentClassFqName((PackageFragmentDescriptor) container, proto, nameResolver);
         }
         else if (isClassObject(container) && isStaticFieldInOuter(proto)) {
             // Backing fields of properties of a class object are generated in the outer class
             return findKotlinClassByDescriptor((ClassOrNamespaceDescriptor) container.getContainingDeclaration());
         }
         else if (isTrait(container) && kind == AnnotatedCallableKind.PROPERTY) {
-            NamespaceDescriptor containingPackage = DescriptorUtils.getParentOfType(container, NamespaceDescriptor.class);
+            PackageFragmentDescriptor containingPackage = DescriptorUtils.getParentOfType(container, PackageFragmentDescriptor.class);
             assert containingPackage != null : "Trait must have a namespace among his parents: " + container;
 
             if (proto.hasExtension(JavaProtoBuf.implClassName)) {
@@ -276,7 +276,7 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer
 
     @Nullable
     private KotlinJvmBinaryClass loadPackageFragmentClassFqName(
-            @NotNull NamespaceDescriptor container,
+            @NotNull PackageFragmentDescriptor container,
             @NotNull ProtoBuf.Callable proto,
             @NotNull NameResolver nameResolver
     ) {

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedDescriptorResolver.java

@@ -25,10 +25,10 @@ import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader;
 import org.jetbrains.jet.lang.resolve.kotlin.header.SerializedDataHeader;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -39,7 +39,6 @@ import org.jetbrains.jet.storage.LockBasedStorageManager;
 import javax.inject.Inject;
 import java.util.Collection;
 
-import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES;
 import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES;
 import static org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.kotlinFqNameToJavaFqName;
 
@@ -48,7 +47,7 @@ public final class DeserializedDescriptorResolver {
 
     private final LockBasedStorageManager storageManager = new LockBasedStorageManager();
 
-    private JavaNamespaceResolver javaNamespaceResolver;
+    private JavaPackageFragmentProvider javaPackageFragmentProvider;
 
     private JavaClassResolver javaClassResolver;
 
@@ -64,14 +63,14 @@ public final class DeserializedDescriptorResolver {
 
         @Nullable
         @Override
-        public NamespaceDescriptor findPackage(@NotNull FqName name) {
-            return javaNamespaceResolver.resolveNamespace(name, IGNORE_KOTLIN_SOURCES);
+        public PackageFragmentDescriptor findPackage(@NotNull FqName name) {
+            return javaPackageFragmentProvider.getOrCreatePackage(name);
         }
 
         @NotNull
         @Override
         public Collection<Name> getClassNames(@NotNull FqName packageName) {
-            return javaNamespaceResolver.getClassNamesInPackage(packageName);
+            return javaPackageFragmentProvider.getClassNamesInPackage(packageName);
         }
     };
 
@@ -81,8 +80,8 @@ public final class DeserializedDescriptorResolver {
     }
 
     @Inject
-    public void setJavaNamespaceResolver(JavaNamespaceResolver javaNamespaceResolver) {
-        this.javaNamespaceResolver = javaNamespaceResolver;
+    public void setJavaPackageFragmentProvider(JavaPackageFragmentProvider javaPackageFragmentProvider) {
+        this.javaPackageFragmentProvider = javaPackageFragmentProvider;
     }
 
     @Inject
@@ -107,7 +106,7 @@ public final class DeserializedDescriptorResolver {
     }
 
     @Nullable
-    public JetScope createKotlinPackageScope(@NotNull NamespaceDescriptor descriptor, @NotNull KotlinJvmBinaryClass kotlinClass) {
+    public JetScope createKotlinPackageScope(@NotNull PackageFragmentDescriptor descriptor, @NotNull KotlinJvmBinaryClass kotlinClass) {
         String[] data = readData(kotlinClass);
         if (data != null) {
             return new DeserializedPackageMemberScope(storageManager, descriptor, annotationDeserializer, javaDescriptorFinder,

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedResolverUtils.java

@@ -19,8 +19,7 @@ package org.jetbrains.jet.lang.resolve.kotlin;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
@@ -51,8 +50,8 @@ public class DeserializedResolverUtils {
         if (containing instanceof ClassDescriptor) {
             return naiveKotlinFqName((ClassDescriptor) containing).child(descriptor.getName());
         }
-        else if (containing instanceof NamespaceDescriptor) {
-            return DescriptorUtils.getFQName(containing).child(descriptor.getName());
+        else if (containing instanceof PackageFragmentDescriptor) {
+            return ((PackageFragmentDescriptor) containing).getFqName().child(descriptor.getName()).toUnsafe();
         }
         else {
             throw new IllegalArgumentException("Class doesn't have a FQ name: " + descriptor);