Big refactoring. Migrating to package views and fragments.

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

@@ -269,7 +269,7 @@ public class AsmUtil {
                 return ACC_PROTECTED;
             }
         }
-        if (containingDeclaration instanceof NamespaceDescriptor) {
+        if (containingDeclaration instanceof PackageFragmentDescriptor) {
             return ACC_PUBLIC;
         }
         return null;

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

@@ -25,7 +25,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.codegen.binding.CalculatedClosure;
 import org.jetbrains.jet.codegen.context.CodegenContext;
-import org.jetbrains.jet.codegen.context.NamespaceContext;
+import org.jetbrains.jet.codegen.context.PackageContext;
 import org.jetbrains.jet.codegen.signature.BothSignatureWriter;
 import org.jetbrains.jet.codegen.signature.JvmMethodParameterKind;
 import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
@@ -194,7 +194,7 @@ public class CodegenUtil {
 
         return !isFakeOverride && !isDelegate &&
                (((context.hasThisDescriptor() && containingDeclaration == context.getThisDescriptor()) ||
-                 (context.getParentContext() instanceof NamespaceContext && context.getParentContext().getContextDescriptor() == containingDeclaration))
+                 (context.getParentContext() instanceof PackageContext && context.getParentContext().getContextDescriptor() == containingDeclaration))
                 && context.getContextKind() != OwnerKind.TRAIT_IMPL);
     }
 

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

@@ -1782,7 +1782,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         DeclarationDescriptor containingDeclaration = propertyDescriptor.getContainingDeclaration();
 
         boolean isBackingFieldInAnotherClass = AsmUtil.isPropertyWithBackingFieldInOuterClass(propertyDescriptor);
-        boolean isStatic = containingDeclaration instanceof NamespaceDescriptor;
+        boolean isStatic = containingDeclaration instanceof PackageFragmentDescriptor;
         boolean isSuper = superExpression != null;
         boolean isInsideClass = isCallInsideSameClassAsDeclared(propertyDescriptor, context);
         boolean isInsideModule = isCallInsideSameModuleAsDeclared(propertyDescriptor, context);

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

@@ -32,7 +32,7 @@ import org.jetbrains.asm4.util.TraceMethodVisitor;
 import org.jetbrains.jet.codegen.binding.CodegenBinding;
 import org.jetbrains.jet.codegen.context.CodegenContext;
 import org.jetbrains.jet.codegen.context.MethodContext;
-import org.jetbrains.jet.codegen.context.NamespaceFacadeContext;
+import org.jetbrains.jet.codegen.context.PackageFacadeContext;
 import org.jetbrains.jet.codegen.signature.JvmMethodParameterKind;
 import org.jetbrains.jet.codegen.signature.JvmMethodParameterSignature;
 import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
@@ -113,8 +113,8 @@ public class FunctionCodegen extends ParentCodegenAwareImpl {
                                        jvmSignature.getGenericsSignature(),
                                        null);
 
-        if (owner instanceof NamespaceFacadeContext) {
-            Type ownerType = ((NamespaceFacadeContext) owner).getDelegateToClassType();
+        if (owner instanceof PackageFacadeContext) {
+            Type ownerType = ((PackageFacadeContext) owner).getDelegateToClassType();
             v.getSerializationBindings().put(IMPL_CLASS_NAME_FOR_CALLABLE, functionDescriptor, shortNameByAsmType(ownerType));
         }
         else {
@@ -274,8 +274,8 @@ public class FunctionCodegen extends ParentCodegenAwareImpl {
         Label methodBegin = new Label();
         mv.visitLabel(methodBegin);
 
-        if (context.getParentContext() instanceof NamespaceFacadeContext) {
-            generateStaticDelegateMethodBody(mv, signature.getAsmMethod(), (NamespaceFacadeContext) context.getParentContext());
+        if (context.getParentContext() instanceof PackageFacadeContext) {
+            generateStaticDelegateMethodBody(mv, signature.getAsmMethod(), (PackageFacadeContext) context.getParentContext());
         }
         else {
             FrameMap frameMap = strategy.getFrameMap(typeMapper, context);
@@ -411,7 +411,7 @@ public class FunctionCodegen extends ParentCodegenAwareImpl {
     private static void generateStaticDelegateMethodBody(
             @NotNull MethodVisitor mv,
             @NotNull Method asmMethod,
-            @NotNull NamespaceFacadeContext context
+            @NotNull PackageFacadeContext context
     ) {
         InstructionAdapter iv = new InstructionAdapter(mv);
         Type[] argTypes = asmMethod.getArgumentTypes();
@@ -585,7 +585,7 @@ public class FunctionCodegen extends ParentCodegenAwareImpl {
         int flags = ACC_PUBLIC | ACC_SYNTHETIC; // TODO.
 
         Type ownerType;
-        if (contextClass instanceof NamespaceDescriptor) {
+        if (contextClass instanceof PackageFragmentDescriptor) {
             ownerType = state.getTypeMapper().getOwner(functionDescriptor, kind, true);
         }
         else if (contextClass instanceof ClassDescriptor) {

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

@@ -143,7 +143,7 @@ public class FunctionTypesUtil {
         JetScope builtInsScope = KotlinBuiltIns.getInstance().getBuiltInsScope();
 
         MutableClassDescriptor functionImpl = new MutableClassDescriptor(
-                builtInsScope.getContainingDeclaration(),
+                KotlinBuiltIns.getInstance().getBuiltInsPackageFragment(),
                 builtInsScope,
                 ClassKind.CLASS,
                 false,

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

@@ -234,7 +234,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         boolean isObjectLiteral = DescriptorUtils.isAnonymousObject(descriptor);
 
         boolean isLocalOrAnonymousClass = isObjectLiteral ||
-                                          !(parentDescriptor instanceof NamespaceDescriptor || parentDescriptor instanceof ClassDescriptor);
+                                          !(parentDescriptor instanceof PackageFragmentDescriptor || parentDescriptor instanceof ClassDescriptor);
         // Do not emit enclosing method in "light-classes mode" since currently we genenerate local light classes as if they're top level
         if (isLocalOrAnonymousClass && getState().getClassBuilderMode() != ClassBuilderMode.LIGHT_CLASSES) {
             String outerClassName = getOuterClassName(descriptor, typeMapper);

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

@@ -16,11 +16,13 @@
 
 package org.jetbrains.jet.codegen;
 
+import com.google.common.collect.Sets;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.progress.ProcessCanceledException;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiFile;
+import com.intellij.util.ArrayUtil;
 import com.intellij.util.PathUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -33,7 +35,7 @@ import org.jetbrains.jet.descriptors.serialization.BitEncoding;
 import org.jetbrains.jet.descriptors.serialization.DescriptorSerializer;
 import org.jetbrains.jet.descriptors.serialization.PackageData;
 import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -43,9 +45,7 @@ import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
+import java.util.*;
 
 import static org.jetbrains.asm4.Opcodes.*;
 import static org.jetbrains.jet.codegen.AsmUtil.asmDescByFqNameWithoutInnerClasses;
@@ -54,7 +54,6 @@ import static org.jetbrains.jet.descriptors.serialization.NameSerializationUtil.
 import static org.jetbrains.jet.lang.resolve.java.PackageClassUtils.getPackageClassFqName;
 
 public class NamespaceCodegen extends MemberCodegen {
-    @NotNull
     private final ClassBuilderOnDemand v;
 
     @NotNull
@@ -62,7 +61,7 @@ public class NamespaceCodegen extends MemberCodegen {
 
     @NotNull
     private final Collection<JetFile> files;
-    private final NamespaceDescriptor descriptor;
+    private final Set<PackageFragmentDescriptor> packageFragments;
 
     public NamespaceCodegen(
             @NotNull ClassBuilderOnDemand v,
@@ -77,8 +76,10 @@ public class NamespaceCodegen extends MemberCodegen {
         name = fqName;
         this.files = namespaceFiles;
 
-        descriptor = state.getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, name);
-        assert descriptor != null : "No namespace found for FQ name " + name;
+        packageFragments = Sets.newHashSet();
+        for (JetFile file : namespaceFiles) {
+            packageFragments.add(getPackageFragment(file));
+        }
 
         final PsiFile sourceFile = namespaceFiles.size() == 1 ? namespaceFiles.iterator().next().getContainingFile() : null;
 
@@ -89,9 +90,8 @@ public class NamespaceCodegen extends MemberCodegen {
                               ACC_PUBLIC | ACC_FINAL,
                               JvmClassName.byFqNameWithoutInnerClasses(getPackageClassFqName(fqName)).getInternalName(),
                               null,
-                              //"jet/lang/Namespace",
                               "java/lang/Object",
-                              new String[0]
+                              ArrayUtil.EMPTY_STRING_ARRAY
                 );
                 //We don't generate any source information for namespace with multiple files
                 if (sourceFile != null) {
@@ -147,7 +147,7 @@ public class NamespaceCodegen extends MemberCodegen {
         }
 
         DescriptorSerializer serializer = new DescriptorSerializer(new JavaSerializerExtension(bindings));
-        ProtoBuf.Package packageProto = serializer.packageProto(descriptor).build();
+        ProtoBuf.Package packageProto = serializer.packageProto(packageFragments).build();
 
         if (packageProto.getMemberCount() == 0) return;
 
@@ -167,7 +167,7 @@ public class NamespaceCodegen extends MemberCodegen {
     @Nullable
     private ClassBuilder generate(@NotNull JetFile file) {
         boolean generateSrcClass = false;
-        FieldOwnerContext packageFragmentContext = CodegenContext.STATIC.intoNamespace(descriptor);
+        FieldOwnerContext packagePartContext = CodegenContext.STATIC.intoPackagePart(getPackageFragment(file));
 
         for (JetDeclaration declaration : file.getDeclarations()) {
             if (declaration instanceof JetProperty || declaration instanceof JetNamedFunction) {
@@ -179,18 +179,18 @@ public class NamespaceCodegen extends MemberCodegen {
                 }
             }
             else if (declaration instanceof JetScript) {
-               ScriptCodegen.createScriptCodegen((JetScript) declaration, state, packageFragmentContext).generate();
+               ScriptCodegen.createScriptCodegen((JetScript) declaration, state, packagePartContext).generate();
             }
         }
 
         if (!generateSrcClass) return null;
 
-        Type packageFragmentType = getNamespacePartType(getPackageClassFqName(name), file.getVirtualFile());
-        ClassBuilder builder = state.getFactory().forPackageFragment(packageFragmentType, file);
+        Type packagePartType = getNamespacePartType(getPackageClassFqName(name), file.getVirtualFile());
+        ClassBuilder builder = state.getFactory().forPackageFragment(packagePartType, file);
 
-        new NamespacePartCodegen(builder, file, packageFragmentType, packageFragmentContext, state).generate();
+        new NamespacePartCodegen(builder, file, packagePartType, packagePartContext, state).generate();
 
-        FieldOwnerContext namespaceFacade = CodegenContext.STATIC.intoNamespaceFacade(packageFragmentType, descriptor);
+        FieldOwnerContext namespaceFacade = CodegenContext.STATIC.intoPackageFacade(packagePartType, getPackageFragment(file));
 
         for (JetDeclaration declaration : file.getDeclarations()) {
             if (declaration instanceof JetNamedFunction || declaration instanceof JetProperty) {
@@ -201,8 +201,15 @@ public class NamespaceCodegen extends MemberCodegen {
         return builder;
     }
 
+    @NotNull
+    private PackageFragmentDescriptor getPackageFragment(@NotNull JetFile file) {
+        PackageFragmentDescriptor packageFragment = bindingContext.get(BindingContext.FILE_TO_PACKAGE_FRAGMENT, file);
+        assert packageFragment != null : "package fragment is null for " + file;
+        return packageFragment;
+    }
+
     public void generateClassOrObject(@NotNull JetClassOrObject classOrObject) {
-        CodegenContext context = CodegenContext.STATIC.intoNamespace(descriptor);
+        CodegenContext context = CodegenContext.STATIC.intoPackagePart(getPackageFragment((JetFile) classOrObject.getContainingFile()));
         genClassOrObject(context, classOrObject);
     }
 

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

@@ -17,6 +17,7 @@
 package org.jetbrains.jet.codegen;
 
 import com.google.common.collect.Lists;
+import com.intellij.util.ArrayUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.AnnotationVisitor;
 import org.jetbrains.asm4.MethodVisitor;
@@ -42,7 +43,7 @@ public class NamespacePartCodegen extends MemberCodegen {
 
     private final ClassBuilder v;
 
-    private final NamespaceDescriptor descriptor;
+    private final PackageFragmentDescriptor descriptor;
 
     private final JetFile jetFile;
 
@@ -62,7 +63,7 @@ public class NamespacePartCodegen extends MemberCodegen {
         this.jetFile = jetFile;
         this.namespacePartName = namespacePartName;
         this.context = context;
-        descriptor = state.getBindingContext().get(BindingContext.FILE_TO_NAMESPACE, jetFile);
+        descriptor = state.getBindingContext().get(BindingContext.FILE_TO_PACKAGE_FRAGMENT, jetFile);
         assert descriptor != null : "No namespace found for jetFile " + jetFile + " declared package: " + jetFile.getPackageName();
     }
 
@@ -71,9 +72,8 @@ public class NamespacePartCodegen extends MemberCodegen {
                       ACC_PUBLIC | ACC_FINAL,
                       namespacePartName.getInternalName(),
                       null,
-                      //"jet/lang/Namespace",
                       "java/lang/Object",
-                      new String[0]
+                      ArrayUtil.EMPTY_STRING_ARRAY
         );
         v.visitSource(jetFile.getName(), null);
 

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

@@ -28,7 +28,7 @@ import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.asm4.commons.Method;
 import org.jetbrains.jet.codegen.context.CodegenContext;
 import org.jetbrains.jet.codegen.context.FieldOwnerContext;
-import org.jetbrains.jet.codegen.context.NamespaceFacadeContext;
+import org.jetbrains.jet.codegen.context.PackageFacadeContext;
 import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.state.GenerationStateAware;
@@ -92,8 +92,8 @@ public class PropertyCodegen extends GenerationStateAware {
                 : "Generating property with a wrong kind (" + kind + "): " + propertyDescriptor;
 
 
-        if (context instanceof NamespaceFacadeContext) {
-            Type ownerType = ((NamespaceFacadeContext) context).getDelegateToClassType();
+        if (context instanceof PackageFacadeContext) {
+            Type ownerType = ((PackageFacadeContext) context).getDelegateToClassType();
             v.getSerializationBindings().put(IMPL_CLASS_NAME_FOR_CALLABLE, propertyDescriptor, shortNameByAsmType(ownerType));
         }
         else if (!generateBackingField(p, propertyDescriptor)) {

compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java

@@ -379,8 +379,8 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
         if (containingDeclaration instanceof ClassDescriptor) {
             return peek + '$' + name;
         }
-        else if (containingDeclaration instanceof NamespaceDescriptor) {
-            FqName qualifiedName = ((NamespaceDescriptor) containingDeclaration).getFqName();
+        else if (containingDeclaration instanceof PackageFragmentDescriptor) {
+            FqName qualifiedName = ((PackageFragmentDescriptor) containingDeclaration).getFqName();
             String packageClassShortName = PackageClassUtils.getPackageClassName(qualifiedName);
             String packageClassName = peek.isEmpty() ? packageClassShortName : peek + "/" + packageClassShortName;
             return packageClassName + '$' + name;

compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java

@@ -240,8 +240,7 @@ public class CodegenBinding {
         answer.addAll(files);
 
         for (FqName name : names) {
-            NamespaceDescriptor namespaceDescriptor = bindingContext.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, name);
-            Collection<JetFile> jetFiles = bindingContext.get(NAMESPACE_TO_FILES, namespaceDescriptor);
+            Collection<JetFile> jetFiles = bindingContext.get(PACKAGE_TO_FILES, name);
             if (jetFiles != null) {
                 answer.addAll(jetFiles);
             }
@@ -289,6 +288,7 @@ public class CodegenBinding {
         return false;
     }
 
+    // TODO 2 accept ClassDescriptor and simplify
     @NotNull
     public static Type getAsmType(@NotNull BindingTrace bindingTrace, @NotNull DeclarationDescriptor descriptor) {
         descriptor = descriptor.getOriginal();
@@ -304,14 +304,19 @@ public class CodegenBinding {
         return asmType;
     }
 
+    // TODO 2 accept ClassDescriptor and simplify
     @NotNull
     private static String getAsmTypeImpl(@NotNull BindingTrace bindingTrace, @NotNull DeclarationDescriptor descriptor) {
+        if (descriptor instanceof PackageFragmentDescriptor) {
+            throw new IllegalStateException("package is unexpected: " + descriptor);
+        }
+
         if (descriptor instanceof FunctionDescriptor) {
             throw new IllegalStateException("requested fq name for function: " + descriptor);
         }
 
         if (descriptor instanceof ModuleDescriptor) {
-            throw new IllegalStateException("missed something");
+            throw new IllegalStateException("module is unexpected: " + descriptor);
         }
 
         DeclarationDescriptor container = descriptor.getContainingDeclaration();
@@ -319,13 +324,21 @@ public class CodegenBinding {
             throw new IllegalStateException("descriptor has no container: " + descriptor);
         }
 
-        if (container.getContainingDeclaration() instanceof ModuleDescriptor || container instanceof ScriptDescriptor) {
+        if (container instanceof ScriptDescriptor) {
             return descriptor.getName().getIdentifier();
         }
 
-        String containerInternalName = getAsmType(bindingTrace, container).getInternalName();
 
-        if (descriptor instanceof ClassDescriptor && container instanceof ClassDescriptor) {
+        if (container instanceof PackageFragmentDescriptor) {
+            String shortName = descriptor.getName().getIdentifier();
+            FqName fqName = ((PackageFragmentDescriptor) container).getFqName();
+            return fqName.isRoot() ? shortName : fqName.asString().replace('.', '/') + '/' + shortName;
+        }
+
+        if (descriptor instanceof ClassDescriptor) {
+            assert container instanceof ClassDescriptor : "Unexpected container: " + container + " for " + descriptor;
+
+            String containerInternalName = getAsmType(bindingTrace, container).getInternalName();
             ClassDescriptor klass = (ClassDescriptor) descriptor;
             if (klass.getKind() == ClassKind.OBJECT || klass.getKind() == ClassKind.CLASS_OBJECT) {
                 if (isEnumClass(container)) {
@@ -338,9 +351,10 @@ public class CodegenBinding {
                     return containerInternalName + JvmAbi.CLASS_OBJECT_SUFFIX;
                 }
             }
+            return containerInternalName + "$" + descriptor.getName().getIdentifier();
         }
 
-        return containerInternalName + (container instanceof NamespaceDescriptor ? "/" : "$") + descriptor.getName().getIdentifier();
+        throw new IllegalStateException("neither top-level nor nested class: " + descriptor);
     }
 
     public static boolean isVarCapturedInClosure(BindingContext bindingContext, DeclarationDescriptor descriptor) {

compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java

@@ -106,7 +106,7 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
         while (true) {
             assert c != null;
             DeclarationDescriptor contextDescriptor = c.getContextDescriptor();
-            if (!(contextDescriptor instanceof ClassDescriptor) && !(contextDescriptor instanceof NamespaceDescriptor)) {
+            if (!(contextDescriptor instanceof ClassDescriptor) && !(contextDescriptor instanceof PackageFragmentDescriptor)) {
                 c = c.getParentContext();
             }
             else {
@@ -157,13 +157,13 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
     }
 
     @NotNull
-    public FieldOwnerContext intoNamespace(@NotNull NamespaceDescriptor descriptor) {
-        return new NamespaceContext(descriptor, this);
+    public FieldOwnerContext intoPackagePart(@NotNull PackageFragmentDescriptor descriptor) {
+        return new PackageContext(descriptor, this);
     }
 
     @NotNull
-    public FieldOwnerContext intoNamespaceFacade(@NotNull Type delegateTo, @NotNull NamespaceDescriptor descriptor) {
-        return new NamespaceFacadeContext(descriptor, this, delegateTo);
+    public FieldOwnerContext intoPackageFacade(@NotNull Type delegateTo, @NotNull PackageFragmentDescriptor descriptor) {
+        return new PackageFacadeContext(descriptor, this, delegateTo);
     }
 
     @NotNull

compiler/backend/src/org/jetbrains/jet/codegen/context/PackageContext.java

@@ -18,13 +18,12 @@ package org.jetbrains.jet.codegen.context;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.codegen.OwnerKind;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
 
-public class NamespaceContext extends FieldOwnerContext<NamespaceDescriptor> {
-
-    public NamespaceContext(@NotNull NamespaceDescriptor contextDescriptor, @Nullable CodegenContext parent) {
+public class PackageContext extends FieldOwnerContext<PackageFragmentDescriptor> {
+    
+    public PackageContext(@NotNull PackageFragmentDescriptor contextDescriptor, @Nullable CodegenContext parent) {
         super(contextDescriptor, OwnerKind.NAMESPACE, parent, null, null, null);
     }
 

compiler/backend/src/org/jetbrains/jet/codegen/context/PackageFacadeContext.java

@@ -19,14 +19,14 @@ package org.jetbrains.jet.codegen.context;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
 
-public class NamespaceFacadeContext extends NamespaceContext {
+public class PackageFacadeContext extends PackageContext {
 
     private final Type delegateTo;
 
-    public NamespaceFacadeContext(
-            @NotNull NamespaceDescriptor contextDescriptor,
+    public PackageFacadeContext(
+            @NotNull PackageFragmentDescriptor contextDescriptor,
             @Nullable CodegenContext parent,
             @NotNull Type delegateTo
     ) {

compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java

@@ -75,7 +75,13 @@ public class GenerationState {
     @Nullable
     private List<ScriptDescriptor> earlierScriptsForReplInterpreter;
 
-    public GenerationState(Project project, ClassBuilderFactory builderFactory, BindingContext bindingContext, List<JetFile> files, boolean inlineEnabled) {
+    public GenerationState(
+            @NotNull Project project,
+            @NotNull ClassBuilderFactory builderFactory,
+            @NotNull BindingContext bindingContext,
+            @NotNull List<JetFile> files,
+            boolean inlineEnabled
+    ) {
         this(project, builderFactory, Progress.DEAF, bindingContext, files, true, false, true, inlineEnabled);
     }
 

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

@@ -16,7 +16,6 @@
 
 package org.jetbrains.jet.codegen.state;
 
-import com.google.common.collect.Lists;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -30,6 +29,7 @@ import org.jetbrains.jet.codegen.signature.BothSignatureWriter;
 import org.jetbrains.jet.codegen.signature.JvmMethodParameterKind;
 import org.jetbrains.jet.codegen.signature.JvmMethodParameterSignature;
 import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
+import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -37,10 +37,18 @@ import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.calls.util.ExpressionAsFunctionDescriptor;
-import org.jetbrains.jet.lang.resolve.java.*;
+import org.jetbrains.jet.lang.resolve.java.AsmTypeConstants;
+import org.jetbrains.jet.lang.resolve.java.JvmAbi;
+import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor;
 import org.jetbrains.jet.lang.resolve.java.mapping.KotlinToJavaTypesMap;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider;
+import org.jetbrains.jet.lang.resolve.java.scope.JavaClassStaticMembersScope;
+import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
@@ -88,8 +96,8 @@ public class JetTypeMapper extends BindingTraceAware {
     @NotNull
     public Type getOwner(@NotNull DeclarationDescriptor descriptor, @NotNull OwnerKind kind, boolean isInsideModule) {
         DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration();
-        if (containingDeclaration instanceof NamespaceDescriptor) {
-            return asmTypeForNamespace((NamespaceDescriptor) containingDeclaration, descriptor, isInsideModule);
+        if (containingDeclaration instanceof PackageFragmentDescriptor) {
+            return asmTypeForPackage((PackageFragmentDescriptor) containingDeclaration, descriptor, isInsideModule);
         }
         else if (containingDeclaration instanceof ClassDescriptor) {
             ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration;
@@ -104,84 +112,57 @@ public class JetTypeMapper extends BindingTraceAware {
     }
 
     @NotNull
-    private JavaNamespaceKind getNsKind(@NotNull NamespaceDescriptor ns) {
-        JavaNamespaceKind javaNamespaceKind = bindingContext.get(JavaBindingContext.JAVA_NAMESPACE_KIND, ns);
-        Boolean src = bindingContext.get(BindingContext.NAMESPACE_IS_SRC, ns);
-
-        if (javaNamespaceKind == null && src == null) {
-            throw new IllegalStateException("unknown namespace origin: " + ns);
-        }
-
-        if (javaNamespaceKind != null) {
-            if (javaNamespaceKind == JavaNamespaceKind.CLASS_STATICS && src != null) {
-                throw new IllegalStateException(
-                        "conflicting namespace " + ns + ": it is both java statics and from src");
-            }
-            return javaNamespaceKind;
-        }
-        else {
-            return JavaNamespaceKind.PROPER;
-        }
-    }
-
-    @NotNull
-    private Type asmTypeForNamespace(
-            @NotNull NamespaceDescriptor namespace,
+    private Type asmTypeForPackage(
+            @NotNull PackageFragmentDescriptor packageFragment,
             @NotNull DeclarationDescriptor descriptor,
             boolean insideModule
     ) {
-        StringBuilder r = new StringBuilder();
-
-        List<DeclarationDescriptor> path = getPathWithoutRootNsAndModule(namespace);
-
-        for (DeclarationDescriptor pathElement : path) {
-            NamespaceDescriptor ns = (NamespaceDescriptor) pathElement;
-            if (r.length() > 0) {
-                JavaNamespaceKind nsKind = getNsKind((NamespaceDescriptor) ns.getContainingDeclaration());
-                if (nsKind == JavaNamespaceKind.PROPER) {
-                    r.append("/");
-                }
-                else if (nsKind == JavaNamespaceKind.CLASS_STATICS) {
-                    r.append("$");
-                }
-            }
-            r.append(ns.getName());
-        }
-
-        if (getNsKind(namespace) == JavaNamespaceKind.PROPER) {
-            if (r.length() > 0) {
-                r.append("/");
-            }
-
-            JetFile file = BindingContextUtils.getContainingFile(bindingContext, descriptor);
-            if (insideModule && file != null) {
-                String internalName = NamespaceCodegen.getNamespacePartInternalName(file);
-                r.append(internalName.substring(r.length()));
-            }
-            else {
-                r.append(PackageClassUtils.getPackageClassName(namespace.getFqName()));
-            }
-        }
-
-        if (r.length() == 0) {
-            throw new IllegalStateException("internal error: failed to generate classname for " + namespace);
-        }
-
-        return Type.getObjectType(r.toString());
+        return Type.getObjectType(internalNameForPackage(packageFragment, descriptor, insideModule));
     }
 
     @NotNull
-    public static List<DeclarationDescriptor> getPathWithoutRootNsAndModule(@NotNull NamespaceDescriptor descriptor) {
-        List<DeclarationDescriptor> path = new ArrayList<DeclarationDescriptor>();
-        DeclarationDescriptor current = descriptor;
-        while (true) {
-            if (current instanceof NamespaceDescriptor && DescriptorUtils.isRootNamespace((NamespaceDescriptor) current)) {
-                return Lists.reverse(path);
+    private String internalNameForPackage(
+            @NotNull PackageFragmentDescriptor packageFragment,
+            @NotNull DeclarationDescriptor descriptor,
+            boolean insideModule
+    ) {
+        if (!(packageFragment instanceof JavaPackageFragmentDescriptor) || packageFragment.getMemberScope() instanceof DeserializedPackageMemberScope) {
+            JetFile file = BindingContextUtils.getContainingFile(bindingContext, descriptor);
+            if (insideModule && file != null) {
+                return NamespaceCodegen.getNamespacePartInternalName(file);
+            }
+            else {
+                return PackageClassUtils.getPackageClassFqName(packageFragment.getFqName()).asString().replace('.', '/');
             }
-            path.add(current);
-            assert current != null : "Namespace must have a parent: " + descriptor;
-            current = current.getContainingDeclaration();
         }
+
+        if (!(packageFragment.getMemberScope() instanceof JavaClassStaticMembersScope)) {
+            throw new IllegalStateException("Unexpected scope: " + packageFragment.getMemberScope().getClass());
+        }
+
+        JavaPackageFragmentProvider javaFragmentProvider = ((JavaPackageFragmentDescriptor) packageFragment).getProvider();
+
+        StringBuilder r = new StringBuilder();
+        for (FqName pathItem : packageFragment.getFqName().parent().path()) {
+            if (pathItem.isRoot()) {
+                continue;
+            }
+            r.append(pathItem.shortName().asString());
+
+            JetScope memberScope = javaFragmentProvider.getOrCreatePackage(pathItem).getMemberScope();
+            if (memberScope instanceof JavaClassStaticMembersScope) {
+                r.append("$");
+            }
+            else if (memberScope instanceof JavaPackageScope) {
+                r.append("/");
+            }
+            else {
+                throw new IllegalStateException("Unexpected scope: " + memberScope.getClass());
+            }
+        }
+
+        r.append(packageFragment.getName().asString());
+        return r.toString();
     }
 
     @NotNull
@@ -473,9 +454,9 @@ public class JetTypeMapper extends BindingTraceAware {
             descriptor = mapSignature("invoke", functionDescriptor, true, kind);
             calleeType = owner;
         }
-        else if (functionParent instanceof NamespaceDescriptor) {
+        else if (functionParent instanceof PackageFragmentDescriptor) {
             assert !superCall;
-            owner = asmTypeForNamespace((NamespaceDescriptor) functionParent, functionDescriptor, isInsideModule);
+            owner = asmTypeForPackage((PackageFragmentDescriptor) functionParent, functionDescriptor, isInsideModule);
             ownerForDefaultImpl = ownerForDefaultParam = owner;
             invokeOpcode = INVOKESTATIC;
             thisClass = null;

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java

@@ -133,17 +133,14 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport
     @NotNull
     @Override
     public Collection<JetFile> findFilesForPackage(@NotNull FqName fqName, @NotNull final GlobalSearchScope searchScope) {
-        NamespaceDescriptor namespaceDescriptor = getTrace().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, fqName);
-        if (namespaceDescriptor != null) {
-            Collection<JetFile> files = getTrace().get(BindingContext.NAMESPACE_TO_FILES, namespaceDescriptor);
-            if (files != null) {
-                return Collections2.filter(files, new Predicate<JetFile>() {
-                    @Override
-                    public boolean apply(JetFile input) {
-                        return PsiSearchScopeUtil.isInScope(searchScope, input);
-                    }
-                });
-            }
+        Collection<JetFile> files = getTrace().get(BindingContext.PACKAGE_TO_FILES, fqName);
+        if (files != null) {
+            return Collections2.filter(files, new Predicate<JetFile>() {
+                @Override
+                public boolean apply(JetFile input) {
+                    return PsiSearchScopeUtil.isInScope(searchScope, input);
+                }
+            });
         }
         return Collections.emptyList();
     }

compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java

@@ -45,7 +45,6 @@ import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.NamespaceLikeBuilderDummy;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
@@ -287,15 +286,12 @@ public class ReplInterpreter {
 
         scope.changeLockLevel(WritableScope.LockLevel.BOTH);
 
-        NamespaceDescriptorImpl rootNs = injector.getNamespaceFactory().createNamespaceDescriptorPathIfNeeded(FqName.ROOT);
-
-        // map "jet" namespace into KotlinBuiltIns
-        // @see DefaultModuleConfiguraiton#extendNamespaceScope
-        injector.getNamespaceFactory().createNamespaceDescriptorPathIfNeeded(KotlinBuiltIns.getInstance().getBuiltInsPackageFqName());
+        module.addFragmentProvider(injector.getTopDownAnalyzer().getPackageFragmentProvider());
+        module.addFragmentProvider(KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
 
         // Import a scope that contains all top-level namespaces that come from dependencies
         // This makes the namespaces visible at all, does not import themselves
-        scope.importScope(rootNs.getMemberScope());
+        scope.importScope(module.getPackage(FqName.ROOT).getMemberScope());
 
         if (lastLineScope != null) {
             scope.importScope(lastLineScope);

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java

@@ -17,6 +17,7 @@
 package org.jetbrains.jet.di;
 
 import com.intellij.openapi.project.Project;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver;
@@ -27,12 +28,13 @@ import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationRe
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileKotlinClassFinder;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationArgumentResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaTypeTransformer;
@@ -58,12 +60,13 @@ public class InjectorForJavaDescriptorResolver {
     private final JavaDescriptorResolver javaDescriptorResolver;
     private final VirtualFileKotlinClassFinder virtualFileKotlinClassFinder;
     private final VirtualFileFinder virtualFileFinder;
+    private final ModuleDescriptorImpl module;
     private final JavaAnnotationResolver javaAnnotationResolver;
     private final JavaAnnotationArgumentResolver javaAnnotationArgumentResolver;
     private final JavaClassResolver javaClassResolver;
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
     private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
-    private final JavaNamespaceResolver javaNamespaceResolver;
+    private final JavaPackageFragmentProvider javaPackageFragmentProvider;
     private final JavaMemberResolver javaMemberResolver;
     private final JavaConstructorResolver javaConstructorResolver;
     private final JavaTypeTransformer javaTypeTransformer;
@@ -88,12 +91,13 @@ public class InjectorForJavaDescriptorResolver {
         this.javaDescriptorResolver = new JavaDescriptorResolver();
         this.virtualFileKotlinClassFinder = new VirtualFileKotlinClassFinder();
         this.virtualFileFinder = com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class);
+        this.module = org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM.createJavaModule("<fake-jdr-module>");
         this.javaAnnotationResolver = new JavaAnnotationResolver();
         this.javaAnnotationArgumentResolver = new JavaAnnotationArgumentResolver();
         this.javaClassResolver = new JavaClassResolver();
         this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
-        this.javaNamespaceResolver = new JavaNamespaceResolver();
+        this.javaPackageFragmentProvider = new JavaPackageFragmentProvider();
         this.javaMemberResolver = new JavaMemberResolver();
         this.javaConstructorResolver = new JavaConstructorResolver();
         this.javaTypeTransformer = new JavaTypeTransformer();
@@ -116,7 +120,7 @@ public class InjectorForJavaDescriptorResolver {
         psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
 
         this.javaDescriptorResolver.setClassResolver(javaClassResolver);
-        this.javaDescriptorResolver.setNamespaceResolver(javaNamespaceResolver);
+        this.javaDescriptorResolver.setPackageFragmentProvider(javaPackageFragmentProvider);
 
         virtualFileKotlinClassFinder.setVirtualFileFinder(virtualFileFinder);
 
@@ -135,29 +139,29 @@ public class InjectorForJavaDescriptorResolver {
         javaClassResolver.setJavaClassFinder(javaClassFinder);
         javaClassResolver.setKotlinClassFinder(virtualFileKotlinClassFinder);
         javaClassResolver.setMemberResolver(javaMemberResolver);
-        javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
+        javaClassResolver.setPackageFragmentProvider(javaPackageFragmentProvider);
         javaClassResolver.setSupertypesResolver(javaSupertypeResolver);
         javaClassResolver.setTypeParameterResolver(javaTypeParameterResolver);
 
         deserializedDescriptorResolver.setAnnotationDeserializer(annotationDescriptorDeserializer);
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
         deserializedDescriptorResolver.setJavaClassResolver(javaClassResolver);
-        deserializedDescriptorResolver.setJavaNamespaceResolver(javaNamespaceResolver);
+        deserializedDescriptorResolver.setJavaPackageFragmentProvider(javaPackageFragmentProvider);
 
         annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
         annotationDescriptorDeserializer.setJavaClassResolver(javaClassResolver);
         annotationDescriptorDeserializer.setKotlinClassFinder(virtualFileKotlinClassFinder);
 
-        javaNamespaceResolver.setCache(traceBasedJavaResolverCache);
-        javaNamespaceResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver);
-        javaNamespaceResolver.setJavaClassFinder(javaClassFinder);
-        javaNamespaceResolver.setKotlinClassFinder(virtualFileKotlinClassFinder);
-        javaNamespaceResolver.setMemberResolver(javaMemberResolver);
+        javaPackageFragmentProvider.setCache(traceBasedJavaResolverCache);
+        javaPackageFragmentProvider.setDeserializedDescriptorResolver(deserializedDescriptorResolver);
+        javaPackageFragmentProvider.setJavaClassFinder(javaClassFinder);
+        javaPackageFragmentProvider.setKotlinClassFinder(virtualFileKotlinClassFinder);
+        javaPackageFragmentProvider.setMemberResolver(javaMemberResolver);
+        javaPackageFragmentProvider.setModule(module);
 
         javaMemberResolver.setClassResolver(javaClassResolver);
         javaMemberResolver.setConstructorResolver(javaConstructorResolver);
         javaMemberResolver.setFunctionResolver(javaFunctionResolver);
-        javaMemberResolver.setNamespaceResolver(javaNamespaceResolver);
         javaMemberResolver.setPropertyResolver(javaPropertyResolver);
 
         javaConstructorResolver.setCache(traceBasedJavaResolverCache);
@@ -206,4 +210,8 @@ public class InjectorForJavaDescriptorResolver {
         return this.javaDescriptorResolver;
     }
     
+    public ModuleDescriptorImpl getModule() {
+        return this.module;
+    }
+    
 }

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java

@@ -37,6 +37,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedErrorReporter;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileKotlinClassFinder;
+import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
 import org.jetbrains.jet.lang.resolve.DeclarationResolver;
@@ -63,7 +64,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationArgumentResolv
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaTypeTransformer;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
@@ -98,6 +99,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker;
     private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
     private final VirtualFileKotlinClassFinder virtualFileKotlinClassFinder;
+    private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
     private final NamespaceFactoryImpl namespaceFactory;
     private final VirtualFileFinder virtualFileFinder;
     private final DeclarationResolver declarationResolver;
@@ -124,7 +126,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final JavaTypeTransformer javaTypeTransformer;
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
     private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
-    private final JavaNamespaceResolver javaNamespaceResolver;
+    private final JavaPackageFragmentProvider javaPackageFragmentProvider;
     private final JavaMemberResolver javaMemberResolver;
     private final JavaConstructorResolver javaConstructorResolver;
     private final JavaValueParameterResolver javaValueParameterResolver;
@@ -160,6 +162,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker();
         this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver();
         this.virtualFileKotlinClassFinder = new VirtualFileKotlinClassFinder();
+        this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor());
         this.namespaceFactory = new NamespaceFactoryImpl();
         this.virtualFileFinder = com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class);
         this.declarationResolver = new DeclarationResolver();
@@ -186,7 +189,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.javaTypeTransformer = new JavaTypeTransformer();
         this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
-        this.javaNamespaceResolver = new JavaNamespaceResolver();
+        this.javaPackageFragmentProvider = new JavaPackageFragmentProvider();
         this.javaMemberResolver = new JavaMemberResolver();
         this.javaConstructorResolver = new JavaConstructorResolver();
         this.javaValueParameterResolver = new JavaValueParameterResolver();
@@ -199,9 +202,9 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.topDownAnalyzer.setContext(topDownAnalysisContext);
         this.topDownAnalyzer.setDeclarationResolver(declarationResolver);
         this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor);
-        this.topDownAnalyzer.setNamespaceFactory(namespaceFactory);
         this.topDownAnalyzer.setOverloadResolver(overloadResolver);
         this.topDownAnalyzer.setOverrideResolver(overrideResolver);
+        this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
         this.topDownAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters);
         this.topDownAnalyzer.setTrace(bindingTrace);
         this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
@@ -230,10 +233,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
         this.descriptorResolver.setTypeResolver(typeResolver);
 
-        this.javaBridgeConfiguration.setJavaDescriptorResolver(javaDescriptorResolver);
-
         javaDescriptorResolver.setClassResolver(javaClassResolver);
-        javaDescriptorResolver.setNamespaceResolver(javaNamespaceResolver);
+        javaDescriptorResolver.setPackageFragmentProvider(javaPackageFragmentProvider);
 
         javaClassFinder.setProject(project);
 
@@ -249,8 +250,9 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
 
         virtualFileKotlinClassFinder.setVirtualFileFinder(virtualFileFinder);
 
-        this.namespaceFactory.setModuleDescriptor(moduleDescriptor);
-        this.namespaceFactory.setTrace(bindingTrace);
+        namespaceFactory.setModule(moduleDescriptor);
+        namespaceFactory.setPackageFragmentProvider(mutablePackageFragmentProvider);
+        namespaceFactory.setTrace(bindingTrace);
 
         declarationResolver.setAnnotationResolver(annotationResolver);
         declarationResolver.setContext(topDownAnalysisContext);
@@ -330,7 +332,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         javaClassResolver.setJavaClassFinder(javaClassFinder);
         javaClassResolver.setKotlinClassFinder(virtualFileKotlinClassFinder);
         javaClassResolver.setMemberResolver(javaMemberResolver);
-        javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
+        javaClassResolver.setPackageFragmentProvider(javaPackageFragmentProvider);
         javaClassResolver.setSupertypesResolver(javaSupertypeResolver);
         javaClassResolver.setTypeParameterResolver(javaTypeParameterResolver);
 
@@ -347,22 +349,22 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         deserializedDescriptorResolver.setAnnotationDeserializer(annotationDescriptorDeserializer);
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
         deserializedDescriptorResolver.setJavaClassResolver(javaClassResolver);
-        deserializedDescriptorResolver.setJavaNamespaceResolver(javaNamespaceResolver);
+        deserializedDescriptorResolver.setJavaPackageFragmentProvider(javaPackageFragmentProvider);
 
         annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
         annotationDescriptorDeserializer.setJavaClassResolver(javaClassResolver);
         annotationDescriptorDeserializer.setKotlinClassFinder(virtualFileKotlinClassFinder);
 
-        javaNamespaceResolver.setCache(traceBasedJavaResolverCache);
-        javaNamespaceResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver);
-        javaNamespaceResolver.setJavaClassFinder(javaClassFinder);
-        javaNamespaceResolver.setKotlinClassFinder(virtualFileKotlinClassFinder);
-        javaNamespaceResolver.setMemberResolver(javaMemberResolver);
+        javaPackageFragmentProvider.setCache(traceBasedJavaResolverCache);
+        javaPackageFragmentProvider.setDeserializedDescriptorResolver(deserializedDescriptorResolver);
+        javaPackageFragmentProvider.setJavaClassFinder(javaClassFinder);
+        javaPackageFragmentProvider.setKotlinClassFinder(virtualFileKotlinClassFinder);
+        javaPackageFragmentProvider.setMemberResolver(javaMemberResolver);
+        javaPackageFragmentProvider.setModule(moduleDescriptor);
 
         javaMemberResolver.setClassResolver(javaClassResolver);
         javaMemberResolver.setConstructorResolver(javaConstructorResolver);
         javaMemberResolver.setFunctionResolver(javaFunctionResolver);
-        javaMemberResolver.setNamespaceResolver(javaNamespaceResolver);
         javaMemberResolver.setPropertyResolver(javaPropertyResolver);
 
         javaConstructorResolver.setCache(traceBasedJavaResolverCache);
@@ -445,8 +447,4 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         return this.javaBridgeConfiguration;
     }
     
-    public NamespaceFactoryImpl getNamespaceFactory() {
-        return this.namespaceFactory;
-    }
-    
 }

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

@@ -26,10 +26,9 @@ import org.jetbrains.jet.analyzer.AnalyzerFacade;
 import org.jetbrains.jet.analyzer.AnalyzerFacadeForEverything;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
-import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.DefaultModuleConfiguration;
 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.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap;
@@ -38,8 +37,6 @@ import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProv
 import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedLazyResolveStorageManager;
 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.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
 import java.util.Collection;
@@ -90,7 +87,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             @NotNull Collection<JetFile> files,
             @NotNull BindingTrace trace,
             @NotNull InjectorForJavaDescriptorResolver injector,
-            final boolean addBuiltIns
+            boolean addBuiltIns
     ) {
         final JavaClassFinderImpl classFinder = injector.getJavaClassFinder();
 
@@ -103,30 +100,17 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             }
         });
 
-        final JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
+        JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
 
-        ModuleConfiguration moduleConfiguration = new ModuleConfiguration() {
-            @Override
-            public void extendNamespaceScope(
-                    @NotNull NamespaceDescriptor namespaceDescriptor,
-                    @NotNull WritableScope namespaceMemberScope
-            ) {
-                FqName fqName = DescriptorUtils.getFQName(namespaceDescriptor).toSafe();
-                if (KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(fqName) && addBuiltIns) {
-                    namespaceMemberScope.importScope(KotlinBuiltIns.getInstance().getBuiltInsScope());
-                }
-                if (classFinder.findPackage(fqName) != null) {
-                    JetScope javaPackageScope = javaDescriptorResolver.getJavaPackageScope(namespaceDescriptor);
-                    assert javaPackageScope != null;
-                    namespaceMemberScope.importScope(javaPackageScope);
-                }
-            }
-        };
+        ModuleDescriptorImpl module = injector.getModule();
 
-        ModuleDescriptorImpl lazyModule = createJavaModule("<lazy module>");
-        lazyModule.setModuleConfiguration(moduleConfiguration);
+        module.setModuleConfiguration(DefaultModuleConfiguration.INSTANCE);
+        module.addFragmentProvider(javaDescriptorResolver.getPackageFragmentProvider());
+        if (addBuiltIns) {
+            module.addFragmentProvider(KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
+        }
 
-        return new ResolveSession(project, storageManager, lazyModule, declarationProviderFactory, trace);
+        return new ResolveSession(project, storageManager, module, declarationProviderFactory, trace);
     }
 
     public static AnalyzeExhaust analyzeOneFileWithJavaIntegrationAndCheckForErrors(
@@ -192,7 +176,6 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             boolean storeContextForBodiesResolve
     ) {
         ModuleDescriptorImpl owner = createJavaModule("<module>");
-
         TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
                 filesToAnalyzeCompletely, false, false, scriptParameters);
 
@@ -206,7 +189,8 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
                                                         new CachedBodiesResolveContext(injector.getTopDownAnalysisContext()) :
                                                         null;
             return AnalyzeExhaust.success(trace.getBindingContext(), bodiesResolveContext, owner);
-        } finally {
+        }
+        finally {
             injector.destroy();
         }
     }

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

@@ -17,7 +17,7 @@
 package org.jetbrains.jet.lang.resolve.java;
 
 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.BindingContext;
 import org.jetbrains.jet.util.slicedmap.Slices;
 import org.jetbrains.jet.util.slicedmap.WritableSlice;
@@ -32,7 +32,7 @@ public class JavaBindingContext {
     /**
      * @see BindingContext#NAMESPACE_IS_SRC
      */
-    public static final WritableSlice<NamespaceDescriptor, JavaNamespaceKind> JAVA_NAMESPACE_KIND = Slices.createSimpleSlice();
+    public static final WritableSlice<PackageFragmentDescriptor, JavaNamespaceKind> JAVA_NAMESPACE_KIND = Slices.createSimpleSlice();
 
     public static final WritableSlice<DeclarationDescriptor, List<String>> LOAD_FROM_JAVA_SIGNATURE_ERRORS = Slices.createCollectiveSlice();
 

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedJavaResolverCache.java

@@ -64,12 +64,6 @@ public class TraceBasedJavaResolverCache implements JavaResolverCache {
         return trace.get(FQNAME_TO_CLASS_DESCRIPTOR, fqName);
     }
 
-    @Nullable
-    @Override
-    public NamespaceDescriptor getPackageResolvedFromSource(@NotNull FqName fqName) {
-        return trace.get(FQNAME_TO_NAMESPACE_DESCRIPTOR, fqName);
-    }
-
     @Nullable
     @Override
     public SimpleFunctionDescriptor getMethod(@NotNull JavaMethod method) {
@@ -132,17 +126,12 @@ public class TraceBasedJavaResolverCache implements JavaResolverCache {
     }
 
     @Override
-    public void recordProperNamespace(@NotNull NamespaceDescriptor descriptor) {
+    public void recordProperPackage(@NotNull PackageFragmentDescriptor descriptor) {
         trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, descriptor, JavaNamespaceKind.PROPER);
     }
 
     @Override
-    public void recordClassStaticMembersNamespace(@NotNull NamespaceDescriptor descriptor) {
+    public void recordClassStaticMembersNamespace(@NotNull PackageFragmentDescriptor descriptor) {
         trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, descriptor, JavaNamespaceKind.CLASS_STATICS);
     }
-
-    @Override
-    public void recordPackage(@NotNull JavaElement element, @NotNull NamespaceDescriptor descriptor) {
-        trace.record(NAMESPACE, ((JavaElementImpl) element).getPsi(), descriptor);
-    }
 }

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorFinder.java

@@ -19,7 +19,7 @@ package org.jetbrains.jet.descriptors.serialization;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 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.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
@@ -34,9 +34,10 @@ public interface DescriptorFinder {
             return null;
         }
 
+        // TODO 1 remove it, make owner not lazy
         @Nullable
         @Override
-        public NamespaceDescriptor findPackage(@NotNull FqName name) {
+        public PackageFragmentDescriptor findPackage(@NotNull FqName name) {
             return null;
         }
 
@@ -51,7 +52,7 @@ public interface DescriptorFinder {
     ClassDescriptor findClass(@NotNull ClassId classId);
 
     @Nullable
-    NamespaceDescriptor findPackage(@NotNull FqName name);
+    PackageFragmentDescriptor findPackage(@NotNull FqName name);
 
     @NotNull
     Collection<Name> getClassNames(@NotNull FqName packageName);

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorSerializer.java

@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.descriptors.serialization;
 
+import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
@@ -391,10 +392,15 @@ public class DescriptorSerializer {
     }
 
     @NotNull
-    public ProtoBuf.Package.Builder packageProto(@NotNull NamespaceDescriptor descriptor) {
+    public ProtoBuf.Package.Builder packageProto(@NotNull Collection<PackageFragmentDescriptor> fragments) {
         ProtoBuf.Package.Builder builder = ProtoBuf.Package.newBuilder();
 
-        for (DeclarationDescriptor declaration : sort(descriptor.getMemberScope().getAllDescriptors())) {
+        Collection<DeclarationDescriptor> members = Lists.newArrayList();
+        for (PackageFragmentDescriptor fragment : fragments) {
+            members.addAll(fragment.getMemberScope().getAllDescriptors());
+        }
+
+        for (DeclarationDescriptor declaration : sort(members)) {
             if (declaration instanceof PropertyDescriptor || declaration instanceof FunctionDescriptor) {
                 builder.addMember(callableProto((CallableMemberDescriptor) declaration));
             }

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/NameTable.java

@@ -18,10 +18,7 @@ package org.jetbrains.jet.descriptors.serialization;
 
 import gnu.trove.TObjectHashingStrategy;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -78,10 +75,10 @@ public class NameTable {
         builder.setShortName(getSimpleNameIndex(descriptor.getName()));
 
         DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration();
-        if (containingDeclaration instanceof NamespaceDescriptor) {
-            NamespaceDescriptor namespaceDescriptor = (NamespaceDescriptor) containingDeclaration;
-            if (!DescriptorUtils.isRootNamespace(namespaceDescriptor)) {
-                builder.setParentQualifiedName(getFqNameIndex(namespaceDescriptor));
+        if (containingDeclaration instanceof PackageFragmentDescriptor) {
+            PackageFragmentDescriptor fragment = (PackageFragmentDescriptor) containingDeclaration;
+            if (!fragment.getFqName().isRoot()) {
+                builder.setParentQualifiedName(getFqNameIndex(fragment.getFqName()));
             }
         }
         else if (containingDeclaration instanceof ClassDescriptor) {

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java

@@ -167,7 +167,7 @@ public abstract class DeserializedMemberScope implements JetScope {
 
     @Nullable
     @Override
-    public NamespaceDescriptor getNamespace(@NotNull Name name) {
+    public PackageViewDescriptor getPackage(@NotNull Name name) {
         return null;
     }
 

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java

@@ -19,11 +19,7 @@ package org.jetbrains.jet.descriptors.serialization.descriptors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.*;
-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.ReceiverParameterDescriptor;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -38,7 +34,7 @@ public class DeserializedPackageMemberScope extends DeserializedMemberScope {
 
     public DeserializedPackageMemberScope(
             @NotNull StorageManager storageManager,
-            @NotNull NamespaceDescriptor packageDescriptor,
+            @NotNull PackageFragmentDescriptor packageDescriptor,
             @NotNull AnnotationDeserializer annotationDeserializer,
             @NotNull DescriptorFinder descriptorFinder,
             @NotNull ProtoBuf.Package proto,
@@ -48,12 +44,12 @@ public class DeserializedPackageMemberScope extends DeserializedMemberScope {
               DescriptorDeserializer.create(storageManager, packageDescriptor, nameResolver, descriptorFinder, annotationDeserializer),
               proto.getMemberList());
         this.descriptorFinder = descriptorFinder;
-        this.packageFqName = DescriptorUtils.getFQName(packageDescriptor).toSafe();
+        this.packageFqName = packageDescriptor.getFqName();
     }
 
     public DeserializedPackageMemberScope(
             @NotNull StorageManager storageManager,
-            @NotNull NamespaceDescriptor packageDescriptor,
+            @NotNull PackageFragmentDescriptor packageDescriptor,
             @NotNull AnnotationDeserializer annotationDeserializer,
             @NotNull DescriptorFinder descriptorFinder,
             @NotNull PackageData packageData
@@ -84,12 +80,6 @@ public class DeserializedPackageMemberScope extends DeserializedMemberScope {
         // Do nothing
     }
 
-    @Nullable
-    @Override
-    public NamespaceDescriptor getNamespace(@NotNull Name name) {
-        return descriptorFinder.findPackage(packageFqName.child(name));
-    }
-
     @Nullable
     @Override
     protected ReceiverParameterDescriptor getImplicitReceiver() {

compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java

@@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl;
+import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.DeclarationResolver;
@@ -66,6 +67,7 @@ public class InjectorForTopDownAnalyzerBasic {
     private final BindingTrace bindingTrace;
     private final ModuleDescriptorImpl moduleDescriptor;
     private final DependencyClassByQualifiedNameResolverDummyImpl dependencyClassByQualifiedNameResolverDummy;
+    private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
     private final NamespaceFactoryImpl namespaceFactory;
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final DeclarationResolver declarationResolver;
@@ -106,6 +108,7 @@ public class InjectorForTopDownAnalyzerBasic {
         this.bindingTrace = bindingTrace;
         this.moduleDescriptor = moduleDescriptor;
         this.dependencyClassByQualifiedNameResolverDummy = new DependencyClassByQualifiedNameResolverDummyImpl();
+        this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor());
         this.namespaceFactory = new NamespaceFactoryImpl();
         this.platformToKotlinClassMap = platformToKotlinClassMap;
         this.declarationResolver = new DeclarationResolver();
@@ -131,9 +134,9 @@ public class InjectorForTopDownAnalyzerBasic {
         this.topDownAnalyzer.setContext(topDownAnalysisContext);
         this.topDownAnalyzer.setDeclarationResolver(declarationResolver);
         this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor);
-        this.topDownAnalyzer.setNamespaceFactory(namespaceFactory);
         this.topDownAnalyzer.setOverloadResolver(overloadResolver);
         this.topDownAnalyzer.setOverrideResolver(overrideResolver);
+        this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
         this.topDownAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters);
         this.topDownAnalyzer.setTrace(bindingTrace);
         this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
@@ -162,7 +165,8 @@ public class InjectorForTopDownAnalyzerBasic {
         this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
         this.descriptorResolver.setTypeResolver(typeResolver);
 
-        namespaceFactory.setModuleDescriptor(moduleDescriptor);
+        namespaceFactory.setModule(moduleDescriptor);
+        namespaceFactory.setPackageFragmentProvider(mutablePackageFragmentProvider);
         namespaceFactory.setTrace(bindingTrace);
 
         declarationResolver.setAnnotationResolver(annotationResolver);

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

@@ -81,7 +81,7 @@ public class JetNamespaceHeader extends JetReferenceExpression {
     }
 
     @NotNull
-    public FqName getParentFqName(JetReferenceExpression nameExpression) {
+    public FqName getParentFqName(JetSimpleNameExpression nameExpression) {
         String parentQualifiedName = getQualifiedNameParentOf(nameExpression);
         return parentQualifiedName.isEmpty() ? FqName.ROOT : new FqName(parentQualifiedName);
     }
@@ -96,7 +96,7 @@ public class JetNamespaceHeader extends JetReferenceExpression {
     }
 
     @NotNull
-    private String getQualifiedNameParentOf(@Nullable JetReferenceExpression nameExpression) {
+    private String getQualifiedNameParentOf(@Nullable JetSimpleNameExpression nameExpression) {
         StringBuilder builder = new StringBuilder();
         for (JetSimpleNameExpression e : findChildrenByClass(JetSimpleNameExpression.class)) {
             if (e == nameExpression) {

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

@@ -196,8 +196,6 @@ public interface BindingContext {
         }
     };
 
-    WritableSlice<PsiElement, NamespaceDescriptor> NAMESPACE = Slices.<PsiElement, NamespaceDescriptor>sliceBuilder()
-            .setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build();
     WritableSlice<PsiElement, ClassDescriptor> CLASS =
             Slices.<PsiElement, ClassDescriptor>sliceBuilder().setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION)
                     .build();
@@ -229,7 +227,7 @@ public interface BindingContext {
                     .build();
 
     WritableSlice[] DECLARATIONS_TO_DESCRIPTORS = new WritableSlice[] {
-            NAMESPACE, CLASS, TYPE_PARAMETER, FUNCTION, CONSTRUCTOR, VARIABLE, VALUE_PARAMETER, PROPERTY_ACCESSOR,
+            CLASS, TYPE_PARAMETER, FUNCTION, CONSTRUCTOR, VARIABLE, VALUE_PARAMETER, PROPERTY_ACCESSOR,
             PRIMARY_CONSTRUCTOR_PARAMETER
     };
 
@@ -248,15 +246,11 @@ public interface BindingContext {
             Slices.<ClassDescriptor, FunctionDescriptor>sliceBuilder().build();
 
     WritableSlice<FqName, ClassDescriptor> FQNAME_TO_CLASS_DESCRIPTOR = new BasicWritableSlice<FqName, ClassDescriptor>(DO_NOTHING, true);
+    @Deprecated
     WritableSlice<FqName, NamespaceDescriptor> FQNAME_TO_NAMESPACE_DESCRIPTOR =
             new BasicWritableSlice<FqName, NamespaceDescriptor>(DO_NOTHING);
-    WritableSlice<JetFile, NamespaceDescriptor> FILE_TO_NAMESPACE = Slices.createSimpleSlice();
-    WritableSlice<NamespaceDescriptor, Collection<JetFile>> NAMESPACE_TO_FILES = Slices.createSimpleSlice();
-
-    /**
-     * Each namespace found in src must be registered here.
-     */
-    WritableSlice<NamespaceDescriptor, Boolean> NAMESPACE_IS_SRC = Slices.createSimpleSlice();
+    WritableSlice<JetFile, PackageFragmentDescriptor> FILE_TO_PACKAGE_FRAGMENT = Slices.createSimpleSlice();
+    WritableSlice<FqName, Collection<JetFile>> PACKAGE_TO_FILES = Slices.createSimpleSlice();
 
     WritableSlice<ClassDescriptor, Boolean> INCOMPLETE_HIERARCHY = Slices.createCollectiveSetSlice();
 

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

@@ -22,13 +22,11 @@ import com.google.common.collect.*;
 import com.intellij.lang.ASTNode;
 import com.intellij.openapi.util.Pair;
 import com.intellij.psi.PsiElement;
+import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptorLite;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceLikeBuilder;
+import org.jetbrains.jet.lang.descriptors.impl.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -96,13 +94,13 @@ public class DeclarationResolver {
         resolveAnnotationStubsOnClassesAndConstructors();
         resolveFunctionAndPropertyHeaders();
         createFunctionsForDataClasses();
-        importsResolver.processMembersImports(rootScope);
+        importsResolver.processMembersImports();
         checkRedeclarationsInNamespaces();
         checkRedeclarationsInInnerClassNames();
     }
 
     private void checkModifiersAndAnnotationsInNamespaceHeaders() {
-        for (JetFile file : context.getNamespaceDescriptors().keySet()) {
+        for (JetFile file : context.getPackageFragments().keySet()) {
             JetNamespaceHeader namespaceHeader = file.getNamespaceHeader();
             if (namespaceHeader == null) continue;
 
@@ -163,7 +161,7 @@ public class DeclarationResolver {
         for (Map.Entry<JetFile, WritableScope> entry : context.getNamespaceScopes().entrySet()) {
             JetFile namespace = entry.getKey();
             WritableScope namespaceScope = entry.getValue();
-            NamespaceLikeBuilder namespaceDescriptor = context.getNamespaceDescriptors().get(namespace).getBuilder();
+            NamespaceLikeBuilder namespaceDescriptor = context.getPackageFragments().get(namespace).getBuilder();
 
             resolveFunctionAndPropertyHeaders(namespace.getDeclarations(), namespaceScope, namespaceScope, namespaceScope, namespaceDescriptor);
         }
@@ -312,8 +310,10 @@ public class DeclarationResolver {
     }
 
     private void checkRedeclarationsInNamespaces() {
-        for (NamespaceDescriptorImpl descriptor : Sets.newHashSet(context.getNamespaceDescriptors().values())) {
-            Multimap<Name, DeclarationDescriptor> simpleNameDescriptors = descriptor.getMemberScope().getDeclaredDescriptorsAccessibleBySimpleName();
+        for (MutablePackageFragmentDescriptor packageFragment : Sets.newHashSet(context.getPackageFragments().values())) {
+            PackageViewDescriptor packageView = packageFragment.getContainingDeclaration().getPackage(packageFragment.getFqName());
+            JetScope packageViewScope = packageView.getMemberScope();
+            Multimap<Name, DeclarationDescriptor> simpleNameDescriptors = packageFragment.getMemberScope().getDeclaredDescriptorsAccessibleBySimpleName();
             for (Name name : simpleNameDescriptors.keySet()) {
                 // Keep only properties with no receiver
                 Collection<DeclarationDescriptor> descriptors = Collections2.filter(simpleNameDescriptors.get(name), new Predicate<DeclarationDescriptor>() {
@@ -326,6 +326,8 @@ public class DeclarationResolver {
                         return true;
                     }
                 });
+                ContainerUtil.addIfNotNull(descriptors, packageViewScope.getPackage(name));
+
                 if (descriptors.size() > 1) {
                     for (DeclarationDescriptor declarationDescriptor : descriptors) {
                         for (PsiElement declaration : getDeclarationsByDescriptor(declarationDescriptor)) {
@@ -341,18 +343,18 @@ public class DeclarationResolver {
 
     private Collection<PsiElement> getDeclarationsByDescriptor(DeclarationDescriptor declarationDescriptor) {
         Collection<PsiElement> declarations;
-        if (declarationDescriptor instanceof NamespaceDescriptor) {
-            final NamespaceDescriptor namespace = (NamespaceDescriptor)declarationDescriptor;
-            Collection<JetFile> files = trace.get(BindingContext.NAMESPACE_TO_FILES, namespace);
+        if (declarationDescriptor instanceof PackageViewDescriptor) {
+            final PackageViewDescriptor aPackage = (PackageViewDescriptor)declarationDescriptor;
+            Collection<JetFile> files = trace.get(BindingContext.PACKAGE_TO_FILES, aPackage.getFqName());
 
             if (files == null) {
-                throw new IllegalStateException("declarations corresponding to " + namespace + " are not found");
+                throw new IllegalStateException("declarations corresponding to " + aPackage + " are not found");
             }
 
             declarations = Collections2.transform(files, new Function<JetFile, PsiElement>() {
                 @Override
                 public PsiElement apply(@Nullable JetFile file) {
-                    assert file != null : "File is null for namespace " + namespace;
+                    assert file != null : "File is null for aPackage " + aPackage;
                     return file.getNamespaceHeader().getNameIdentifier();
                 }
             });

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

@@ -88,8 +88,8 @@ public interface Importer {
 
         protected void importAllUnderDeclaration(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) {
             List<JetScope> scopesToImport = new ArrayList<JetScope>(2);
-            if (descriptor instanceof NamespaceDescriptor) {
-                scopesToImport.add(((NamespaceDescriptor) descriptor).getMemberScope());
+            if (descriptor instanceof PackageViewDescriptor) {
+                scopesToImport.add(((PackageViewDescriptor) descriptor).getMemberScope());
             }
             else if (descriptor instanceof ClassDescriptor && ((ClassDescriptor) descriptor).getKind() != ClassKind.OBJECT) {
                 ClassDescriptor classDescriptor = (ClassDescriptor) descriptor;
@@ -109,8 +109,8 @@ public interface Importer {
             if (descriptor instanceof ClassifierDescriptor) {
                 namespaceScope.importClassifierAlias(aliasName, (ClassifierDescriptor) descriptor);
             }
-            else if (descriptor instanceof NamespaceDescriptor) {
-                namespaceScope.importNamespaceAlias(aliasName, (NamespaceDescriptor) descriptor);
+            else if (descriptor instanceof PackageViewDescriptor) {
+                namespaceScope.importPackageAlias(aliasName, (PackageViewDescriptor) descriptor);
             }
             else if (descriptor instanceof FunctionDescriptor) {
                 namespaceScope.importFunctionAlias(aliasName, (FunctionDescriptor) descriptor);

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

@@ -22,6 +22,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
+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.resolve.scopes.WritableScope;
@@ -71,39 +72,39 @@ public class ImportsResolver {
         this.importsFactory = importsFactory;
     }
 
-    public void processTypeImports(@NotNull JetScope rootScope) {
-        processImports(LookupMode.ONLY_CLASSES, rootScope);
+    public void processTypeImports() {
+        processImports(LookupMode.ONLY_CLASSES);
     }
 
-    public void processMembersImports(@NotNull JetScope rootScope) {
-        processImports(LookupMode.EVERYTHING, rootScope);
+    public void processMembersImports() {
+        processImports(LookupMode.EVERYTHING);
     }
 
-    private void processImports(@NotNull LookupMode lookupMode, @NotNull JetScope rootScope) {
-        for (JetFile file : context.getNamespaceDescriptors().keySet()) {
+    private void processImports(@NotNull LookupMode lookupMode) {
+        for (JetFile file : context.getPackageFragments().keySet()) {
             WritableScope namespaceScope = context.getNamespaceScopes().get(file);
-            processImportsInFile(lookupMode, namespaceScope, Lists.newArrayList(file.getImportDirectives()), rootScope);
+            processImportsInFile(lookupMode, namespaceScope, Lists.newArrayList(file.getImportDirectives()));
         }
         for (JetScript script : context.getScripts().keySet()) {
             WritableScope scriptScope = context.getScriptScopes().get(script);
-            processImportsInFile(lookupMode, scriptScope, script.getImportDirectives(), rootScope);
+            processImportsInFile(lookupMode, scriptScope, script.getImportDirectives());
         }
     }
 
-    private void processImportsInFile(@NotNull LookupMode lookupMode, WritableScope scope, List<JetImportDirective> directives, JetScope rootScope) {
-        processImportsInFile(lookupMode, scope, directives, rootScope, moduleDescriptor, trace, qualifiedExpressionResolver, importsFactory);
+    private void processImportsInFile(@NotNull LookupMode lookupMode, WritableScope scope, List<JetImportDirective> directives) {
+        processImportsInFile(lookupMode, scope, directives, moduleDescriptor, trace, qualifiedExpressionResolver, importsFactory);
     }
 
-    public static void processImportsInFile(
+    private static void processImportsInFile(
             LookupMode lookupMode,
             @NotNull WritableScope namespaceScope,
             @NotNull List<JetImportDirective> importDirectives,
-            @NotNull JetScope rootScope,
             @NotNull ModuleDescriptor module,
             @NotNull BindingTrace trace,
             @NotNull QualifiedExpressionResolver qualifiedExpressionResolver,
             @NotNull JetImportsFactory importsFactory
     ) {
+        @NotNull JetScope rootScope = module.getPackage(FqName.ROOT).getMemberScope();
 
         Importer.DelayedImporter delayedImporter = new Importer.DelayedImporter(namespaceScope);
         if (lookupMode == LookupMode.EVERYTHING) {
@@ -185,10 +186,10 @@ public class ImportsResolver {
             else if (wasResolved instanceof VariableDescriptor) {
                 isResolved = namespaceScope.getLocalVariable(aliasName);
             }
-            else if (wasResolved instanceof NamespaceDescriptor) {
-                isResolved = namespaceScope.getNamespace(aliasName);
+            else if (wasResolved instanceof PackageViewDescriptor) {
+                isResolved = namespaceScope.getPackage(aliasName);
             }
-            if (isResolved == null || isResolved == wasResolved) {
+            if (isResolved == null || isResolved.equals(wasResolved)) {
                 uselessHiddenImport = false;
             }
         }

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

@@ -89,7 +89,7 @@ public class ModifiersChecker {
         if (modifierList == null) return;
 
         DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration();
-        if (containingDeclaration instanceof NamespaceDescriptor) {
+        if (containingDeclaration instanceof PackageFragmentDescriptor) {
             if (modifierList.hasModifier(PROTECTED_KEYWORD)) {
                 trace.report(Errors.PACKAGE_MEMBER_CANNOT_BE_PROTECTED.on(modifierList.getModifierNode(PROTECTED_KEYWORD).getPsi()));
             }

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

@@ -0,0 +1,59 @@
+package org.jetbrains.jet.lang.resolve;
+
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+import com.intellij.util.containers.ContainerUtil;
+import com.intellij.util.containers.MultiMap;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider;
+import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+public class MutablePackageFragmentProvider implements PackageFragmentProvider {
+    private final ModuleDescriptor module;
+
+    private final Map<FqName, MutablePackageFragmentDescriptor> fqNameToPackage = Maps.newHashMap();
+    private final MultiMap<FqName, FqName> subPackages = MultiMap.create();
+
+    public MutablePackageFragmentProvider(@NotNull ModuleDescriptor module) {
+        this.module = module;
+        fqNameToPackage.put(FqName.ROOT, new MutablePackageFragmentDescriptor(module, FqName.ROOT));
+    }
+
+    @NotNull
+    @Override
+    public List<PackageFragmentDescriptor> getPackageFragments(@NotNull FqName fqName) {
+        return ContainerUtil.<PackageFragmentDescriptor>createMaybeSingletonList(fqNameToPackage.get(fqName));
+    }
+
+    @NotNull
+    @Override
+    public Collection<FqName> getSubPackagesOf(@NotNull FqName fqName) {
+        return subPackages.get(fqName);
+    }
+
+    @NotNull
+    public MutablePackageFragmentDescriptor getOrCreateFragment(@NotNull FqName fqName) {
+        if (!fqNameToPackage.containsKey(fqName)) {
+            FqName parent = fqName.parent();
+            getOrCreateFragment(parent); // assure that parent exists
+
+            fqNameToPackage.put(fqName, new MutablePackageFragmentDescriptor(module, fqName));
+            subPackages.putValue(parent, fqName);
+        }
+
+        return fqNameToPackage.get(fqName);
+    }
+
+    @NotNull
+    public ModuleDescriptor getModule() {
+        return module;
+    }
+}

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

@@ -17,10 +17,11 @@
 package org.jetbrains.jet.lang.resolve;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 public interface NamespaceFactory {
     @NotNull
-    NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(@NotNull FqName fqName);
+    PackageFragmentDescriptor createNamespaceDescriptorPathIfNeeded(@NotNull FqName fqName);
 }

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

@@ -17,40 +17,35 @@
 package org.jetbrains.jet.lang.resolve;
 
 import com.google.common.collect.Sets;
-import com.intellij.psi.PsiElement;
+import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 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.NamespaceDescriptorImpl;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetNamespaceHeader;
 import org.jetbrains.jet.lang.psi.JetReferenceExpression;
 import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
-import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
-import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
-import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 
 import javax.inject.Inject;
+import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
+import java.util.List;
 
 import static org.jetbrains.jet.lang.resolve.BindingContext.*;
 
 public class NamespaceFactoryImpl implements NamespaceFactory {
 
-    private ModuleDescriptorImpl moduleDescriptor;
+    private ModuleDescriptorImpl module;
+    private MutablePackageFragmentProvider packageFragmentProvider;
     private BindingTrace trace;
 
     @Inject
-    public void setModuleDescriptor(ModuleDescriptorImpl moduleDescriptor) {
-        this.moduleDescriptor = moduleDescriptor;
+    public void setModule(ModuleDescriptorImpl module) {
+        this.module = module;
     }
 
     @Inject
@@ -58,160 +53,72 @@ public class NamespaceFactoryImpl implements NamespaceFactory {
         this.trace = trace;
     }
 
+    @Inject
+    public void setPackageFragmentProvider(MutablePackageFragmentProvider packageFragmentProvider) {
+        this.packageFragmentProvider = packageFragmentProvider;
+    }
+
     @NotNull
-    public NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(@NotNull JetFile file,
-                                                                         @NotNull JetScope outerScope,
-                                                                         @NotNull RedeclarationHandler handler) {
+    public MutablePackageFragmentDescriptor createPackageFragmentIfNeeded(@NotNull JetFile file, @NotNull RedeclarationHandler handler) {
         JetNamespaceHeader namespaceHeader = file.getNamespaceHeader();
 
-        if (moduleDescriptor.getRootNamespaceDescriptorImpl() == null) {
-            createRootNamespaceDescriptorIfNeeded(null, moduleDescriptor, null, handler);
+        // TODO 2 make this code neater
+        List<JetSimpleNameExpression> allNamespaceNames = new ArrayList<JetSimpleNameExpression>(namespaceHeader.getParentNamespaceNames());
+        ContainerUtil.addIfNotNull(allNamespaceNames, namespaceHeader.getLastPartExpression());
+        for (JetSimpleNameExpression nameExpression : allNamespaceNames) {
+            FqName parentFqName = namespaceHeader.getParentFqName(nameExpression);
+            getOrCreatePackageFragment(parentFqName, nameExpression, handler);
+
+            trace.record(RESOLUTION_SCOPE, nameExpression, module.getPackage(parentFqName).getMemberScope());
         }
 
-        NamespaceDescriptorImpl currentOwner = moduleDescriptor.getRootNamespaceDescriptorImpl();
-        if (currentOwner == null) {
-            throw new IllegalStateException("must be initialized 5 lines above");
-        }
-
-        for (JetSimpleNameExpression nameExpression : namespaceHeader.getParentNamespaceNames()) {
-            Name namespaceName = Name.identifier(nameExpression.getReferencedName());
-
-            NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorIfNeeded(
-                    null, currentOwner, namespaceName, nameExpression, handler);
-
-            trace.record(BindingContext.NAMESPACE_IS_SRC, namespaceDescriptor, true);
-            trace.record(RESOLUTION_SCOPE, nameExpression, outerScope);
-
-            outerScope = namespaceDescriptor.getMemberScope();
-            currentOwner = namespaceDescriptor;
-        }
-
-        NamespaceDescriptorImpl namespaceDescriptor;
-        Name name;
-        if (namespaceHeader.isRoot()) {
-            // previous call to createRootNamespaceDescriptorIfNeeded couldn't store occurrence for current file.
-            namespaceDescriptor = moduleDescriptor.getRootNamespaceDescriptorImpl();
-            storeBindingForFileAndExpression(file, null, namespaceDescriptor);
-        }
-        else {
-            name = namespaceHeader.getNameAsName();
-            namespaceDescriptor = createNamespaceDescriptorIfNeeded(
-                    file, currentOwner, name, namespaceHeader.getLastPartExpression(), handler);
-
-            trace.record(RESOLUTION_SCOPE, namespaceHeader, outerScope);
-        }
-        trace.record(BindingContext.NAMESPACE_IS_SRC, namespaceDescriptor, true);
-
-        return namespaceDescriptor;
+        MutablePackageFragmentDescriptor fragment = getOrCreatePackageFragment(
+                namespaceHeader.getFqName(), namespaceHeader.getLastPartExpression(), handler);
+        storeBindingForFile(file, fragment);
+        return fragment;
     }
 
     @Override
     @NotNull
-    public NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(@NotNull FqName fqName) {
-        NamespaceDescriptorImpl owner = null;
+    public PackageFragmentDescriptor createNamespaceDescriptorPathIfNeeded(@NotNull FqName fqName) {
         for (FqName pathElement : fqName.path()) {
             if (pathElement.isRoot()) {
-                owner = createRootNamespaceDescriptorIfNeeded(null,
-                                                              moduleDescriptor,
-                                                              null,
-                                                              RedeclarationHandler.DO_NOTHING);
+                getOrCreatePackageFragment(FqName.ROOT, null, RedeclarationHandler.DO_NOTHING);
             }
             else {
-                assert owner != null : "Should never be null as first element in the path must be root";
-                owner = createNamespaceDescriptorIfNeeded(null,
-                                                          owner,
-                                                          pathElement.shortName(),
-                                                          null,
-                                                          RedeclarationHandler.DO_NOTHING);
+                getOrCreatePackageFragment(pathElement, null, RedeclarationHandler.DO_NOTHING);
             }
 
         }
-
-        assert owner != null : "Should never be null as first element in the path must be root";
-        return owner;
-    }
-
-    private NamespaceDescriptorImpl createRootNamespaceDescriptorIfNeeded(@Nullable JetFile file,
-                                                                          @NotNull ModuleDescriptorImpl owner,
-                                                                          @Nullable JetReferenceExpression expression,
-                                                                          @NotNull RedeclarationHandler handler) {
-        FqName fqName = FqName.ROOT;
-        NamespaceDescriptorImpl namespaceDescriptor = owner.getRootNamespaceDescriptorImpl();
-
-        if (namespaceDescriptor == null) {
-            namespaceDescriptor = createNewNamespaceDescriptor(owner, FqNameUnsafe.ROOT_NAME, expression, handler, fqName);
-        }
-
-        storeBindingForFileAndExpression(file, expression, namespaceDescriptor);
-
-        return namespaceDescriptor;
+        return packageFragmentProvider.getOrCreateFragment(fqName);
     }
 
     @NotNull
-    private NamespaceDescriptorImpl createNamespaceDescriptorIfNeeded(@Nullable JetFile file,
-                                                                      @NotNull NamespaceDescriptorImpl owner,
-                                                                      @NotNull Name name,
-                                                                      @Nullable JetReferenceExpression expression,
-                                                                      @NotNull RedeclarationHandler handler) {
-        FqName ownerFqName = DescriptorUtils.getFQName(owner).toSafe();
-        FqName fqName = ownerFqName.child(name);
-        // !!!
-        NamespaceDescriptorImpl namespaceDescriptor = (NamespaceDescriptorImpl) owner.getMemberScope().getDeclaredNamespace(name);
-
-        if (namespaceDescriptor == null) {
-            namespaceDescriptor = createNewNamespaceDescriptor(owner, name, expression, handler, fqName);
+    private MutablePackageFragmentDescriptor getOrCreatePackageFragment(
+            @NotNull FqName fqName,
+            @Nullable JetReferenceExpression expression,
+            @NotNull RedeclarationHandler handler
+    ) {
+        // TODO 1 use handler
+        MutablePackageFragmentDescriptor fragment = packageFragmentProvider.getOrCreateFragment(fqName);
+        if (expression != null) {
+            trace.record(REFERENCE_TARGET, expression, packageFragmentProvider.getModule().getPackage(fqName));
         }
 
-        storeBindingForFileAndExpression(file, expression, namespaceDescriptor);
-
-        return namespaceDescriptor;
+        return fragment;
     }
 
-    private NamespaceDescriptorImpl createNewNamespaceDescriptor(NamespaceDescriptorParent owner,
-                                                                 Name name,
-                                                                 PsiElement expression,
-                                                                 RedeclarationHandler handler,
-                                                                 FqName fqName) {
-        NamespaceDescriptorImpl namespaceDescriptor;
-        namespaceDescriptor = new NamespaceDescriptorImpl(
-                owner,
-                Collections.<AnnotationDescriptor>emptyList(), // TODO: annotations
-                name
-        );
-        trace.record(FQNAME_TO_NAMESPACE_DESCRIPTOR, fqName, namespaceDescriptor);
+    private void storeBindingForFile(@NotNull JetFile file, @NotNull PackageFragmentDescriptor fragment) {
+        trace.record(BindingContext.FILE_TO_PACKAGE_FRAGMENT, file, fragment);
 
-        WritableScopeImpl scope = new WritableScopeImpl(JetScope.EMPTY, namespaceDescriptor, handler, "Namespace member scope");
-        scope.changeLockLevel(WritableScope.LockLevel.BOTH);
-
-        namespaceDescriptor.initialize(scope);
-        scope.changeLockLevel(WritableScope.LockLevel.BOTH);
-        //
-        moduleDescriptor.getModuleConfiguration().extendNamespaceScope(namespaceDescriptor, scope);
-        owner.addNamespace(namespaceDescriptor);
-        if (expression != null) {
-            trace.record(BindingContext.NAMESPACE, expression, namespaceDescriptor);
-        }
-        return namespaceDescriptor;
-    }
-
-    private void storeBindingForFileAndExpression(@Nullable JetFile file,
-                                                  @Nullable JetReferenceExpression expression,
-                                                  @NotNull NamespaceDescriptor namespaceDescriptor) {
-        if (expression != null) {
-            trace.record(REFERENCE_TARGET, expression, namespaceDescriptor);
-        }
-
-        if (file != null) {
-            trace.record(BindingContext.FILE_TO_NAMESPACE, file, namespaceDescriptor);
-
-            // Register files corresponding to this namespace
-            // The trace currently does not support bi-di multimaps that would handle this task nicer
-            Collection<JetFile> files = trace.get(NAMESPACE_TO_FILES, namespaceDescriptor);
-            if (files == null) {
-                files = Sets.newIdentityHashSet();
-            }
-            files.add(file);
-            trace.record(BindingContext.NAMESPACE_TO_FILES, namespaceDescriptor, files);
+        // Register files corresponding to this namespace
+        // The trace currently does not support bi-di multimaps that would handle this task nicer
+        FqName fqName = fragment.getFqName();
+        Collection<JetFile> files = trace.get(PACKAGE_TO_FILES, fqName);
+        if (files == null) {
+            files = Sets.newIdentityHashSet();
         }
+        files.add(file);
+        trace.record(BindingContext.PACKAGE_TO_FILES, fqName, files);
     }
 }

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

@@ -66,12 +66,12 @@ public class OverloadResolver {
     }
 
     private static class Key extends Pair<String, Name> {
-        Key(String namespace, Name name) {
-            super(namespace, name);
+        Key(String packageName, Name name) {
+            super(packageName, name);
         }
         
-        Key(NamespaceDescriptor namespaceDescriptor, Name name) {
-            this(DescriptorUtils.getFQName(namespaceDescriptor).asString(), name);
+        Key(PackageFragmentDescriptor fragment, Name name) {
+            this(fragment.getFqName().asString(), name);
         }
 
         public String getNamespace() {
@@ -88,7 +88,7 @@ public class OverloadResolver {
             constructorsGrouped()
     {
         MultiMap<ClassDescriptor, ConstructorDescriptor> inClasses = MultiMap.create();
-        MultiMap<Key, ConstructorDescriptor> inNamespaces = MultiMap.create();
+        MultiMap<Key, ConstructorDescriptor> inPackages = MultiMap.create();
 
         for (MutableClassDescriptor klass : context.getClasses().values()) {
             if (klass.getKind().isSingleton()) {
@@ -96,9 +96,9 @@ public class OverloadResolver {
                 continue;
             }
             DeclarationDescriptor containingDeclaration = klass.getContainingDeclaration();
-            if (containingDeclaration instanceof NamespaceDescriptor) {
-                NamespaceDescriptor namespaceDescriptor = (NamespaceDescriptor) containingDeclaration;
-                inNamespaces.put(new Key(namespaceDescriptor, klass.getName()), klass.getConstructors());
+            if (containingDeclaration instanceof PackageFragmentDescriptor) {
+                PackageFragmentDescriptor packageFragment = (PackageFragmentDescriptor) containingDeclaration;
+                inPackages.put(new Key(packageFragment, klass.getName()), klass.getConstructors());
             }
             else if (containingDeclaration instanceof ClassDescriptor) {
                 ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration;
@@ -109,7 +109,7 @@ public class OverloadResolver {
             }
         }
         
-        return Pair.create(inClasses, inNamespaces);
+        return Pair.create(inClasses, inPackages);
     }
 
     private void checkOverloadsInANamespace(MultiMap<Key, ConstructorDescriptor> inNamespaces) {
@@ -118,17 +118,17 @@ public class OverloadResolver {
 
         for (SimpleFunctionDescriptor function : context.getFunctions().values()) {
             DeclarationDescriptor containingDeclaration = function.getContainingDeclaration();
-            if (containingDeclaration instanceof NamespaceDescriptor) {
-                NamespaceDescriptor namespaceDescriptor = (NamespaceDescriptor) containingDeclaration;
-                functionsByName.putValue(new Key(namespaceDescriptor, function.getName()), function);
+            if (containingDeclaration instanceof PackageFragmentDescriptor) {
+                PackageFragmentDescriptor packageFragment = (PackageFragmentDescriptor) containingDeclaration;
+                functionsByName.putValue(new Key(packageFragment, function.getName()), function);
             }
         }
         
         for (PropertyDescriptor property : context.getProperties().values()) {
             DeclarationDescriptor containingDeclaration = property.getContainingDeclaration();
-            if (containingDeclaration instanceof NamespaceDescriptor) {
-                NamespaceDescriptor namespaceDescriptor = (NamespaceDescriptor) containingDeclaration;
-                functionsByName.putValue(new Key(namespaceDescriptor, property.getName()), property);
+            if (containingDeclaration instanceof PackageFragmentDescriptor) {
+                PackageFragmentDescriptor packageFragment = (PackageFragmentDescriptor) containingDeclaration;
+                functionsByName.putValue(new Key(packageFragment, property.getName()), property);
             }
         }
         

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

@@ -38,7 +38,7 @@ public class QualifiedExpressionResolver {
     private static final Predicate<DeclarationDescriptor> CLASSIFIERS_AND_NAMESPACES = new Predicate<DeclarationDescriptor>() {
         @Override
         public boolean apply(@Nullable DeclarationDescriptor descriptor) {
-            return descriptor instanceof ClassifierDescriptor || descriptor instanceof NamespaceDescriptor;
+            return descriptor instanceof ClassifierDescriptor || descriptor instanceof PackageViewDescriptor;
         }
     };
 
@@ -144,7 +144,7 @@ public class QualifiedExpressionResolver {
     ) {
 
         assert lookupMode == LookupMode.EVERYTHING;
-        if (descriptor instanceof NamespaceDescriptor) {
+        if (descriptor instanceof PackageViewDescriptor) {
             return true;
         }
         if (descriptor instanceof ClassDescriptor && !((ClassDescriptor)descriptor).getKind().isSingleton()) {
@@ -211,8 +211,8 @@ public class QualifiedExpressionResolver {
 
         Set<SuccessfulLookupResult> results = Sets.newHashSet();
         for (DeclarationDescriptor declarationDescriptor : declarationDescriptors) {
-            if (declarationDescriptor instanceof NamespaceDescriptor) {
-                addResult(results, lookupSimpleNameReference(selector, ((NamespaceDescriptor)declarationDescriptor).getMemberScope(),
+            if (declarationDescriptor instanceof PackageViewDescriptor) {
+                addResult(results, lookupSimpleNameReference(selector, ((PackageViewDescriptor)declarationDescriptor).getMemberScope(),
                                                              lookupMode, true));
             }
             if (declarationDescriptor instanceof ClassDescriptor) {
@@ -256,9 +256,9 @@ public class QualifiedExpressionResolver {
         Name referencedName = referenceExpression.getReferencedNameAsName();
 
         Set<DeclarationDescriptor> descriptors = Sets.newHashSet();
-        NamespaceDescriptor namespaceDescriptor = outerScope.getNamespace(referencedName);
-        if (namespaceDescriptor != null) {
-            descriptors.add(namespaceDescriptor);
+        PackageViewDescriptor packageDescriptor = outerScope.getPackage(referencedName);
+        if (packageDescriptor != null) {
+            descriptors.add(packageDescriptor);
         }
 
         ClassifierDescriptor classifierDescriptor = outerScope.getClassifier(referencedName);
@@ -389,20 +389,20 @@ public class QualifiedExpressionResolver {
         @NotNull JetScope scopeToCheckVisibility) {
 
         if (filteredDescriptors.size() == 2) {
-            NamespaceDescriptor namespaceDescriptor = null;
+            PackageViewDescriptor packageView = null;
             ClassDescriptor classDescriptor = null;
 
             for (DeclarationDescriptor filteredDescriptor : filteredDescriptors) {
-                if (filteredDescriptor instanceof NamespaceDescriptor) {
-                    namespaceDescriptor = (NamespaceDescriptor)filteredDescriptor;
+                if (filteredDescriptor instanceof PackageViewDescriptor) {
+                    packageView = (PackageViewDescriptor)filteredDescriptor;
                 }
                 else if (filteredDescriptor instanceof ClassDescriptor) {
                     classDescriptor = (ClassDescriptor)filteredDescriptor;
                 }
             }
 
-            if (namespaceDescriptor != null && classDescriptor != null) {
-                if (DescriptorUtils.getFQName(namespaceDescriptor).equalsTo(DescriptorUtils.getFQName(classDescriptor))) {
+            if (packageView != null && classDescriptor != null) {
+                if (DescriptorUtils.getFQName(packageView).equalsTo(DescriptorUtils.getFQName(classDescriptor))) {
                     trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, classDescriptor);
                     trace.record(BindingContext.RESOLUTION_SCOPE, referenceExpression, resolutionScope);
                     checkVisibility(classDescriptor, trace, referenceExpression, scopeToCheckVisibility);

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

@@ -20,6 +20,7 @@ import com.google.common.collect.Lists;
 import com.intellij.openapi.util.Key;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
@@ -121,7 +122,7 @@ public class ScriptHeaderResolver {
         JetFile file = (JetFile) script.getContainingFile();
         JetNamespaceHeader namespaceHeader = file.getNamespaceHeader();
         FqName fqName = namespaceHeader != null ? new FqName(namespaceHeader.getQualifiedName()) : FqName.ROOT;
-        NamespaceDescriptorImpl ns = namespaceFactory.createNamespaceDescriptorPathIfNeeded(fqName);
+        PackageFragmentDescriptor ns = namespaceFactory.createNamespaceDescriptorPathIfNeeded(fqName);
 
         Integer priority = script.getUserData(PRIORITY_KEY);
         if (priority == null) {

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

@@ -25,7 +25,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptorLite;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -42,7 +42,7 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
     private DataFlowInfo outerDataFlowInfo = DataFlowInfo.EMPTY;
 
     private final Map<JetClassOrObject, MutableClassDescriptor> classes = Maps.newLinkedHashMap();
-    protected final Map<JetFile, NamespaceDescriptorImpl> namespaceDescriptors = Maps.newHashMap();
+    protected final Map<JetFile, MutablePackageFragmentDescriptor> packageFragments = Maps.newHashMap();
     private List<MutableClassDescriptorLite> classesTopologicalOrder = null;
 
     private final Map<JetDeclaration, JetScope> declaringScopes = Maps.newHashMap();
@@ -114,13 +114,13 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
         return namespaceScopes;
     }
 
-    public Map<JetFile, NamespaceDescriptorImpl> getNamespaceDescriptors() {
-        return namespaceDescriptors;
+    public Map<JetFile, MutablePackageFragmentDescriptor> getPackageFragments() {
+        return packageFragments;
     }
 
     @Override
     public Collection<JetFile> getFiles() {
-        return namespaceDescriptors.keySet();
+        return packageFragments.keySet();
     }
 
     @Override

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

@@ -33,7 +33,6 @@ 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.resolve.scopes.WritableScope;
-import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingContext;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
@@ -59,7 +58,7 @@ public class TopDownAnalyzer {
     @NotNull
     private ModuleDescriptor moduleDescriptor;
     @NotNull
-    private NamespaceFactoryImpl namespaceFactory;
+    private MutablePackageFragmentProvider packageFragmentProvider;
     @NotNull
     private BodyResolver bodyResolver;
 
@@ -104,8 +103,8 @@ public class TopDownAnalyzer {
     }
 
     @Inject
-    public void setNamespaceFactory(@NotNull NamespaceFactoryImpl namespaceFactory) {
-        this.namespaceFactory = namespaceFactory;
+    public void setPackageFragmentProvider(@NotNull MutablePackageFragmentProvider packageFragmentProvider) {
+        this.packageFragmentProvider = packageFragmentProvider;
     }
 
     @Inject
@@ -168,8 +167,9 @@ public class TopDownAnalyzer {
     private void doProcessStandardLibraryNamespace(
             WritableScope outerScope, NamespaceDescriptorImpl standardLibraryNamespace, List<JetFile> files) {
         ArrayList<JetDeclaration> toAnalyze = new ArrayList<JetDeclaration>();
-        for(JetFile file : files) {
-            context.getNamespaceDescriptors().put(file, standardLibraryNamespace);
+        for (JetFile file : files) {
+            // TODO 1 restore
+            //context.getPackageFragments().put(file, standardLibraryNamespace);
             context.getNamespaceScopes().put(file, standardLibraryNamespace.getMemberScope());
             toAnalyze.addAll(file.getDeclarations());
         }
@@ -231,27 +231,19 @@ public class TopDownAnalyzer {
     public void analyzeFiles(
             @NotNull Collection<JetFile> files,
             @NotNull List<AnalyzerScriptParameter> scriptParameters) {
-        WritableScope scope = new WritableScopeImpl(
-                JetScope.EMPTY, moduleDescriptor,
-                new TraceBasedRedeclarationHandler(trace), "Root scope in analyzeNamespace");
+        ((ModuleDescriptorImpl) moduleDescriptor).addFragmentProvider(packageFragmentProvider);
 
-        scope.changeLockLevel(WritableScope.LockLevel.BOTH);
-
-        NamespaceDescriptorImpl rootNs = namespaceFactory.createNamespaceDescriptorPathIfNeeded(FqName.ROOT);
-
-        // map "jet" namespace into KotlinBuiltIns
-        // @see DefaultModuleConfiguraiton#extendNamespaceScope
-        namespaceFactory.createNamespaceDescriptorPathIfNeeded(KotlinBuiltIns.getInstance().getBuiltInsPackageFqName());
+        // "depend on" builtins module
+        ((ModuleDescriptorImpl) moduleDescriptor).addFragmentProvider(KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
 
         // Import a scope that contains all top-level namespaces that come from dependencies
         // This makes the namespaces visible at all, does not import themselves
-        scope.importScope(rootNs.getMemberScope());
-        
-        scope.changeLockLevel(WritableScope.LockLevel.READING);
+        PackageViewDescriptor rootPackage = moduleDescriptor.getPackage(FqName.ROOT);
+        assert rootPackage != null : "Coulnd't find root package for " + moduleDescriptor;
 
         // dummy builder is used because "root" is module descriptor,
         // namespaces added to module explicitly in
-        doProcess(scope, new NamespaceLikeBuilderDummy(), files);
+        doProcess(rootPackage.getMemberScope(), new NamespaceLikeBuilderDummy(), files);
     }
 
 
@@ -261,6 +253,10 @@ public class TopDownAnalyzer {
     }
 
 
+    @NotNull
+    public MutablePackageFragmentProvider getPackageFragmentProvider() {
+        return packageFragmentProvider;
+    }
 }
 
 

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

@@ -28,10 +28,7 @@ import org.jetbrains.jet.lang.descriptors.impl.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.name.SpecialNames;
-import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
-import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
-import org.jetbrains.jet.lang.resolve.scopes.WriteThroughScope;
+import org.jetbrains.jet.lang.resolve.scopes.*;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.SubstitutionUtils;
 import org.jetbrains.jet.lang.types.TypeConstructor;
@@ -43,8 +40,7 @@ import javax.inject.Inject;
 import java.util.*;
 
 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
-import static org.jetbrains.jet.lang.resolve.BindingContext.FQNAME_TO_CLASS_DESCRIPTOR;
-import static org.jetbrains.jet.lang.resolve.BindingContext.TYPE;
+import static org.jetbrains.jet.lang.resolve.BindingContext.*;
 import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isEnumEntry;
 import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isObject;
 import static org.jetbrains.jet.lang.resolve.ModifiersChecker.getDefaultClassVisibility;
@@ -120,11 +116,11 @@ public class TypeHierarchyResolver {
                                     ((MutableClassDescriptorLite) descriptorForDeferredResolve).getBuilder(),
                                     declarationContainer.getDeclarations()));
                 }
-                else if (descriptorForDeferredResolve instanceof NamespaceDescriptorImpl) {
+                else if (descriptorForDeferredResolve instanceof MutablePackageFragmentDescriptor) {
                     forDeferredResolve.addAll(
                             collectNamespacesAndClassifiers(
                                     scope,
-                                    ((NamespaceDescriptorImpl) descriptorForDeferredResolve).getBuilder(),
+                                    ((MutablePackageFragmentDescriptor) descriptorForDeferredResolve).getBuilder(),
                                     declarationContainer.getDeclarations()));
                 }
                 else {
@@ -133,7 +129,7 @@ public class TypeHierarchyResolver {
             }
         }
 
-        importsResolver.processTypeImports(outerScope);
+        importsResolver.processTypeImports();
 
         createTypeConstructors(); // create type constructors for classes and generic parameters, supertypes are not filled in
         resolveTypesInClassHeaders(); // Generic bounds and types in supertype lists (no expressions or constructor resolution)
@@ -454,20 +450,22 @@ public class TypeHierarchyResolver {
 
         @Override
         public void visitJetFile(@NotNull JetFile file) {
-            NamespaceDescriptorImpl namespaceDescriptor = namespaceFactory.createNamespaceDescriptorPathIfNeeded(
-                    file, outerScope, RedeclarationHandler.DO_NOTHING);
-            context.getNamespaceDescriptors().put(file, namespaceDescriptor);
+            MutablePackageFragmentDescriptor packageFragment =
+                    namespaceFactory.createPackageFragmentIfNeeded(file, RedeclarationHandler.DO_NOTHING);
+            context.getPackageFragments().put(file, packageFragment);
 
-            WriteThroughScope namespaceScope = new WriteThroughScope(outerScope, namespaceDescriptor.getMemberScope(),
-                                                                     new TraceBasedRedeclarationHandler(trace), "namespace in file " + file.getName());
-            namespaceScope.changeLockLevel(WritableScope.LockLevel.BOTH);
-            context.getNamespaceScopes().put(file, namespaceScope);
+            PackageViewDescriptor packageView = packageFragment.getContainingDeclaration().getPackage(packageFragment.getFqName());
+            ChainedScope rootPlusPackageScope = new ChainedScope(packageView, packageView.getMemberScope(), outerScope);
+            WriteThroughScope packageScope = new WriteThroughScope(rootPlusPackageScope, packageFragment.getMemberScope(),
+                                                                     new TraceBasedRedeclarationHandler(trace), "package in file " + file.getName());
+            packageScope.changeLockLevel(WritableScope.LockLevel.BOTH);
+            context.getNamespaceScopes().put(file, packageScope);
 
             if (file.isScript()) {
-                scriptHeaderResolver.processScriptHierarchy(file.getScript(), namespaceScope);
+                scriptHeaderResolver.processScriptHierarchy(file.getScript(), packageScope);
             }
 
-            prepareForDeferredCall(namespaceScope, namespaceDescriptor, file);
+            prepareForDeferredCall(packageScope, packageFragment, file);
         }
 
         @Override

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java

@@ -169,7 +169,7 @@ public class CallExpressionResolver {
         scopes.add(getStaticNestedClassesScope(classDescriptor));
 
         Name referencedName = expression.getReferencedNameAsName();
-        NamespaceDescriptor namespace = context.scope.getNamespace(referencedName);
+        PackageViewDescriptor namespace = context.scope.getPackage(referencedName);
         if (namespace != null) {
             //for enums loaded from java binaries
             scopes.add(namespace.getMemberScope());
@@ -200,7 +200,7 @@ public class CallExpressionResolver {
     @Nullable
     private NamespaceType lookupNamespaceType(@NotNull JetSimpleNameExpression expression, @NotNull ResolutionContext context) {
         Name name = expression.getReferencedNameAsName();
-        NamespaceDescriptor namespace = context.scope.getNamespace(name);
+        PackageViewDescriptor namespace = context.scope.getPackage(name);
         if (namespace == null) {
             return null;
         }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/extension/InlineAnalyzerExtension.java

@@ -99,7 +99,7 @@ public class InlineAnalyzerExtension implements FunctionAnalyzerExtension.Analyz
             return;
         }
 
-        if (functionDescriptor.getContainingDeclaration() instanceof NamespaceDescriptor) {
+        if (functionDescriptor.getContainingDeclaration() instanceof PackageFragmentDescriptor) {
             return;
         }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java

@@ -17,22 +17,15 @@
 package org.jetbrains.jet.lang.resolve.lazy;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.JetClassOrObject;
 import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;
 
 public interface KotlinCodeAnalyzer {
-    ModuleDescriptor getRootModuleDescriptor();
-
-    @Nullable
-    NamespaceDescriptor getPackageDescriptorByFqName(FqName fqName);
+    ModuleDescriptor getModuleDescriptor();
 
     @NotNull
     ClassDescriptor getClassDescriptor(@NotNull JetClassOrObject classOrObject);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java

@@ -44,7 +44,7 @@ import static org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver.LookupM
 
 public class LazyImportScope implements JetScope {
     private final ResolveSession resolveSession;
-    private final NamespaceDescriptor packageDescriptor;
+    private final PackageViewDescriptor packageDescriptor;
     private final ImportsProvider importsProvider;
     private final JetScope rootScope;
     private final BindingTrace traceForImportResolve;
@@ -99,7 +99,7 @@ public class LazyImportScope implements JetScope {
                                 packageDescriptor.getMemberScope(),
                                 importer,
                                 traceForImportResolve,
-                                resolveSession.getRootModuleDescriptor(),
+                                resolveSession.getModuleDescriptor(),
                                 mode);
                     }
                     finally {
@@ -120,7 +120,7 @@ public class LazyImportScope implements JetScope {
 
     public LazyImportScope(
             @NotNull ResolveSession resolveSession,
-            @NotNull NamespaceDescriptor packageDescriptor,
+            @NotNull PackageViewDescriptor packageDescriptor,
             @NotNull List<JetImportDirective> imports,
             @NotNull BindingTrace traceForImportResolve,
             @NotNull String debugName
@@ -138,16 +138,16 @@ public class LazyImportScope implements JetScope {
             }
         });
 
-        NamespaceDescriptor rootPackageDescriptor = resolveSession.getPackageDescriptorByFqName(FqName.ROOT);
-        if (rootPackageDescriptor == null) {
+        PackageViewDescriptor rootPackage = resolveSession.getModuleDescriptor().getPackage(FqName.ROOT);
+        if (rootPackage == null) {
             throw new IllegalStateException("Root package not found");
         }
-        rootScope = rootPackageDescriptor.getMemberScope();
+        rootScope = rootPackage.getMemberScope();
     }
 
     public static LazyImportScope createImportScopeForFile(
             @NotNull ResolveSession resolveSession,
-            @NotNull NamespaceDescriptor packageDescriptor,
+            @NotNull PackageViewDescriptor packageDescriptor,
             @NotNull JetFile jetFile,
             @NotNull BindingTrace traceForImportResolve,
             @NotNull String debugName
@@ -246,8 +246,8 @@ public class LazyImportScope implements JetScope {
 
     @Nullable
     @Override
-    public NamespaceDescriptor getNamespace(@NotNull Name name) {
-        return selectFirstFromImports(name, LookupMode.ONLY_CLASSES, JetScopeSelectorUtil.NAMESPACE_SCOPE_SELECTOR);
+    public PackageViewDescriptor getPackage(@NotNull Name name) {
+        return selectFirstFromImports(name, LookupMode.ONLY_CLASSES, JetScopeSelectorUtil.PACKAGE_SCOPE_SELECTOR);
     }
 
     @NotNull

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java

@@ -18,16 +18,17 @@ package org.jetbrains.jet.lang.resolve.lazy;
 
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
+import com.google.common.collect.Lists;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.Function;
+import com.intellij.util.containers.ContainerUtil;
 import jet.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.di.InjectorForLazyResolve;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
@@ -43,8 +44,10 @@ import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.name.SpecialNames;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
+import org.jetbrains.jet.storage.MemoizedFunctionToNullable;
 
-import java.util.List;
+import java.util.*;
 
 import static org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils.safeNameForLazyResolve;
 
@@ -60,7 +63,6 @@ public class ResolveSession implements KotlinCodeAnalyzer {
     private final LazyResolveStorageManager storageManager;
 
     private final ModuleDescriptor module;
-    private final LazyPackageDescriptor rootPackage;
 
     private final BindingTrace trace;
     private final DeclarationProviderFactory declarationProviderFactory;
@@ -72,6 +74,9 @@ public class ResolveSession implements KotlinCodeAnalyzer {
 
     private final Function<FqName, Name> classifierAliases;
 
+    private final MemoizedFunctionToNullable<FqName, LazyPackageDescriptor> packages;
+    private final PackageFragmentProvider packageFragmentProvider;
+
     public ResolveSession(
             @NotNull Project project,
             @NotNull LazyResolveStorageManager storageManager,
@@ -117,10 +122,54 @@ public class ResolveSession implements KotlinCodeAnalyzer {
         this.module = rootDescriptor;
         PackageMemberDeclarationProvider provider = declarationProviderFactory.getPackageMemberDeclarationProvider(FqName.ROOT);
         assert provider != null : "No declaration provider for root package in " + rootDescriptor;
-        this.rootPackage = new LazyPackageDescriptor(rootDescriptor, FqNameUnsafe.ROOT_NAME, this, provider);
-        rootDescriptor.setRootNamespace(rootPackage);
+
+        this.packages = storageManager.createMemoizedFunctionWithNullableValues(new MemoizedFunctionToNullable<FqName, LazyPackageDescriptor>() {
+            @Nullable
+            @Override
+            public LazyPackageDescriptor invoke(FqName fqName) {
+                return createPackage(fqName);
+            }
+        });
 
         this.declarationProviderFactory = declarationProviderFactory;
+
+        rootDescriptor.addFragmentProvider(KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
+
+        this.packageFragmentProvider = new PackageFragmentProvider() {
+            @NotNull
+            @Override
+            public List<PackageFragmentDescriptor> getPackageFragments(@NotNull FqName fqName) {
+                return ContainerUtil.<PackageFragmentDescriptor>createMaybeSingletonList(getPackageFragment(fqName));
+            }
+
+            @NotNull
+            @Override
+            public Collection<FqName> getSubPackagesOf(@NotNull FqName fqName) {
+                LazyPackageDescriptor packageDescriptor = getPackageFragment(fqName);
+                if (packageDescriptor == null) {
+                    return Collections.emptyList();
+                }
+                return packageDescriptor.getDeclarationProvider().getAllDeclaredPackages();
+            }
+        };
+        rootDescriptor.addFragmentProvider(packageFragmentProvider);
+    }
+
+    @Nullable
+    public LazyPackageDescriptor getPackageFragment(@NotNull FqName fqName) {
+        return packages.invoke(fqName);
+    }
+
+    @Nullable
+    private LazyPackageDescriptor createPackage(FqName fqName) {
+        if (!fqName.isRoot() && getPackageFragment(fqName.parent()) == null) {
+            return null;
+        }
+        PackageMemberDeclarationProvider provider = declarationProviderFactory.getPackageMemberDeclarationProvider(fqName);
+        if (provider == null) {
+            return null;
+        }
+        return new LazyPackageDescriptor(module, fqName, this, provider);
     }
 
     @NotNull
@@ -133,7 +182,7 @@ public class ResolveSession implements KotlinCodeAnalyzer {
     }
 
     @Override
-    public ModuleDescriptor getRootModuleDescriptor() {
+    public ModuleDescriptor getModuleDescriptor() {
         return module;
     }
 
@@ -142,22 +191,6 @@ public class ResolveSession implements KotlinCodeAnalyzer {
         return storageManager;
     }
 
-    @Override
-    @Nullable
-    public NamespaceDescriptor getPackageDescriptorByFqName(FqName fqName) {
-        if (fqName.isRoot()) {
-            return rootPackage;
-        }
-        List<Name> names = fqName.pathSegments();
-        NamespaceDescriptor current = rootPackage.getMemberScope().getNamespace(names.get(0));
-        if (current == null) return null;
-        for (Name name : names.subList(1, names.size())) {
-            current = current.getMemberScope().getNamespace(name);
-            if (current == null) return null;
-        }
-        return current;
-    }
-
     @Override
     @NotNull
     public ClassDescriptor getClassDescriptor(@NotNull JetClassOrObject classOrObject) {
@@ -343,45 +376,29 @@ public class ResolveSession implements KotlinCodeAnalyzer {
         return actualName;
     }
 
+    @NotNull
+    private List<LazyPackageDescriptor> getAllPackages() {
+        return collectAllPackages(Lists.<LazyPackageDescriptor>newArrayList(), getPackageFragment(FqName.ROOT));
+    }
+
+    @NotNull
+    private List<LazyPackageDescriptor> collectAllPackages(
+            @NotNull List<LazyPackageDescriptor> result,
+            @NotNull LazyPackageDescriptor current
+    ) {
+        result.add(current);
+        for (FqName subPackage : packageFragmentProvider.getSubPackagesOf(current.getFqName())) {
+            LazyPackageDescriptor fragment = getPackageFragment(subPackage);
+            assert fragment != null : "Couldn't find fragment for " + subPackage;
+            collectAllPackages(result, fragment);
+        }
+        return result;
+    }
+
     @Override
     public void forceResolveAll() {
-        rootPackage.acceptVoid(new DeclarationDescriptorVisitorEmptyBodies<Void, Void>() {
-
-            @Override
-            public Void visitTypeParameterDescriptor(TypeParameterDescriptor descriptor, Void data) {
-                ForceResolveUtil.forceResolveAllContents(descriptor);
-                return null;
-            }
-
-            @Override
-            public Void visitNamespaceDescriptor(NamespaceDescriptor descriptor, Void data) {
-                ForceResolveUtil.forceResolveAllContents(descriptor);
-                return null;
-            }
-
-            @Override
-            public Void visitPackageViewDescriptor(PackageViewDescriptor descriptor, Void data) {
-                ForceResolveUtil.forceResolveAllContents(descriptor);
-                return super.visitPackageViewDescriptor(descriptor, data);
-            }
-
-            @Override
-            public Void visitClassDescriptor(ClassDescriptor descriptor, Void data) {
-                ForceResolveUtil.forceResolveAllContents(descriptor);
-                return null;
-            }
-
-            @Override
-            public Void visitModuleDeclaration(ModuleDescriptor descriptor, Void data) {
-                ForceResolveUtil.forceResolveAllContents(descriptor);
-                return null;
-            }
-
-            @Override
-            public Void visitScriptDescriptor(ScriptDescriptor scriptDescriptor, Void data) {
-                ForceResolveUtil.forceResolveAllContents(scriptDescriptor);
-                return null;
-            }
-        });
+        for (LazyPackageDescriptor lazyPackage : getAllPackages()) {
+            ForceResolveUtil.forceResolveAllContents(lazyPackage);
+        }
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java

@@ -21,7 +21,7 @@ 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.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.psi.JetNamed;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -63,7 +63,7 @@ public class ResolveSessionUtils {
 
         FqName packageFqName = fqName.parent();
         while (true) {
-            NamespaceDescriptor packageDescriptor = analyzer.getPackageDescriptorByFqName(packageFqName);
+            PackageViewDescriptor packageDescriptor = analyzer.getModuleDescriptor().getPackage(packageFqName);
             if (packageDescriptor != null) {
                 FqName classInPackagePath = new FqName(QualifiedNamesUtil.tail(packageFqName, fqName));
                 Collection<ClassDescriptor> descriptors = getClassOrObjectDescriptorsByFqName(packageDescriptor, classInPackagePath,
@@ -84,7 +84,7 @@ public class ResolveSessionUtils {
 
     @NotNull
     private static Collection<ClassDescriptor> getClassOrObjectDescriptorsByFqName(
-            @NotNull NamespaceDescriptor packageDescriptor,
+            @NotNull PackageViewDescriptor packageDescriptor,
             @NotNull FqName path,
             boolean includeObjectDeclarations
     ) {

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java

@@ -22,7 +22,7 @@ import com.intellij.psi.util.PsiTreeUtil;
 import jet.Function0;
 import jet.Function1;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace;
@@ -67,12 +67,12 @@ public class ScopeProvider {
     }
 
     private JetScope createFileScope(JetFile file) {
-        NamespaceDescriptor rootPackageDescriptor = resolveSession.getPackageDescriptorByFqName(FqName.ROOT);
+        PackageViewDescriptor rootPackageDescriptor = resolveSession.getModuleDescriptor().getPackage(FqName.ROOT);
         if (rootPackageDescriptor == null) {
             throw new IllegalStateException("Root package not found");
         }
 
-        NamespaceDescriptor packageDescriptor = getFilePackageDescriptor(file);
+        PackageViewDescriptor packageDescriptor = getFilePackageDescriptor(file);
 
         JetScope importsScope = LazyImportScope.createImportScopeForFile(
                 resolveSession,
@@ -81,7 +81,7 @@ public class ScopeProvider {
                 resolveSession.getTrace(),
                 "Lazy Imports Scope for file " + file.getName());
 
-        return new ChainedScope(packageDescriptor,
+        return new ChainedScope(resolveSession.getPackageFragment(JetPsiUtil.getFQName(file)),
                                 "File scope: " + file.getName(),
                                 packageDescriptor.getMemberScope(),
                                 rootPackageDescriptor.getMemberScope(),
@@ -90,33 +90,33 @@ public class ScopeProvider {
     }
 
     private JetScope createScopeWithDefaultImports() {
-        NamespaceDescriptor rootPackageDescriptor = resolveSession.getPackageDescriptorByFqName(FqName.ROOT);
-        if (rootPackageDescriptor == null) {
+        PackageViewDescriptor rootPackage = resolveSession.getModuleDescriptor().getPackage(FqName.ROOT);
+        if (rootPackage == null) {
             throw new IllegalStateException("Root package not found");
         }
 
         JetImportsFactory importsFactory = resolveSession.getInjector().getJetImportsFactory();
-        List<ImportPath> defaultImports = resolveSession.getRootModuleDescriptor().getDefaultImports();
+        List<ImportPath> defaultImports = resolveSession.getModuleDescriptor().getDefaultImports();
 
         Collection<JetImportDirective> defaultImportDirectives = importsFactory.createImportDirectives(defaultImports);
 
         return new LazyImportScope(
                 resolveSession,
-                rootPackageDescriptor,
+                rootPackage,
                 Lists.reverse(Lists.newArrayList(defaultImportDirectives)),
                 TemporaryBindingTrace.create(resolveSession.getTrace(), "Transient trace for default imports lazy resolve"),
                 "Lazy default imports scope");
     }
 
     @NotNull
-    private NamespaceDescriptor getFilePackageDescriptor(JetFile file) {
+    private PackageViewDescriptor getFilePackageDescriptor(JetFile file) {
         JetNamespaceHeader header = file.getNamespaceHeader();
         if (header == null) {
             throw new IllegalArgumentException("Scripts are not supported: " + file.getName());
         }
 
         FqName fqName = new FqName(header.getQualifiedName());
-        NamespaceDescriptor packageDescriptor = resolveSession.getPackageDescriptorByFqName(fqName);
+        PackageViewDescriptor packageDescriptor = resolveSession.getModuleDescriptor().getPackage(fqName);
 
         if (packageDescriptor == null) {
             throw new IllegalStateException("Package not found: " + fqName + " maybe the file is not in scope of this resolve session: " + file.getName());

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java

@@ -329,8 +329,9 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
         result.addAll(getFunctions(Name.identifier("copy")));
     }
 
+    @Nullable
     @Override
-    public NamespaceDescriptor getNamespace(@NotNull Name name) {
+    public PackageViewDescriptor getPackage(@NotNull Name name) {
         return null;
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageDescriptor.java

@@ -16,49 +16,39 @@
 
 package org.jetbrains.jet.lang.resolve.lazy.descriptors;
 
-import com.google.common.collect.Iterables;
-import com.intellij.psi.NavigatablePsiElement;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.descriptors.impl.AbstractNamespaceDescriptorImpl;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.lazy.ForceResolveUtil;
 import org.jetbrains.jet.lang.resolve.lazy.LazyDescriptor;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.*;
+import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
 import java.util.Collections;
 
-public class LazyPackageDescriptor extends AbstractNamespaceDescriptorImpl implements LazyDescriptor, NamespaceDescriptor {
+public class LazyPackageDescriptor extends DeclarationDescriptorImpl implements LazyDescriptor, PackageFragmentDescriptor {
+    private final ModuleDescriptor module;
     private final JetScope memberScope;
-    private final JetScope lazyScope;
+    private final FqName fqName;
+    private final PackageMemberDeclarationProvider declarationProvider;
 
     public LazyPackageDescriptor(
-            @NotNull NamespaceDescriptorParent containingDeclaration,
-            @NotNull Name name,
+            @NotNull ModuleDescriptor module,
+            @NotNull FqName fqName,
             @NotNull ResolveSession resolveSession,
             @NotNull PackageMemberDeclarationProvider declarationProvider
     ) {
-        super(containingDeclaration, Collections.<AnnotationDescriptor>emptyList(), name);
+        super(Collections.<AnnotationDescriptor>emptyList(), fqName.shortNameOrSpecial());
+        this.module = module;
+        this.fqName = fqName;
+        this.declarationProvider = declarationProvider;
 
-        WritableScopeImpl scope = new WritableScopeImpl(JetScope.EMPTY, this, RedeclarationHandler.DO_NOTHING, "Package scope");
-        resolveSession.getRootModuleDescriptor().getModuleConfiguration().extendNamespaceScope(this, scope);
-        scope.changeLockLevel(WritableScope.LockLevel.READING);
-
-        this.lazyScope = new LazyPackageMemberScope(resolveSession, declarationProvider, this);
-
-        this.memberScope = new ChainedScope(this, "Lazy package members scope: " + name, lazyScope, scope);
-
-        NavigatablePsiElement declaration = Iterables.getFirst(declarationProvider.getPackageDeclarations(getFqName()), null);
-        if (declaration != null) {
-            resolveSession.getTrace().record(BindingContext.NAMESPACE, declaration, this);
-        }
+        this.memberScope = new LazyPackageMemberScope(resolveSession, declarationProvider, this);
     }
 
     @NotNull
@@ -69,17 +59,34 @@ public class LazyPackageDescriptor extends AbstractNamespaceDescriptorImpl imple
 
     @NotNull
     @Override
-    public FqName getFqName() {
-        return DescriptorUtils.getFQName(this).toSafe();
+    public ModuleDescriptor getContainingDeclaration() {
+        return module;
+    }
+
+    @Nullable
+    @Override
+    public DeclarationDescriptor substitute(@NotNull TypeSubstitutor substitutor) {
+        return this;
     }
 
     @Override
-    public void addNamespace(@NotNull NamespaceDescriptor namespaceDescriptor) {
-        throw new UnsupportedOperationException(); // TODO
+    public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
+        return visitor.visitPackageFragmentDescriptor(this, data);
+    }
+
+    @NotNull
+    @Override
+    public FqName getFqName() {
+        return fqName;
     }
 
     @Override
     public void forceResolveAllContents() {
-        ForceResolveUtil.forceResolveAllContents(lazyScope);
+        ForceResolveUtil.forceResolveAllContents(memberScope);
+    }
+
+    @NotNull
+    public PackageMemberDeclarationProvider getDeclarationProvider() {
+        return declarationProvider;
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageMemberScope.java

@@ -16,7 +16,6 @@
 
 package org.jetbrains.jet.lang.resolve.lazy.descriptors;
 
-import jet.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -28,43 +27,22 @@ import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclaration
 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.storage.MemoizedFunctionToNullable;
 
 import java.util.Collection;
 import java.util.Set;
 
-public class LazyPackageMemberScope extends AbstractLazyMemberScope<NamespaceDescriptor, PackageMemberDeclarationProvider> {
-
-    private final MemoizedFunctionToNullable<Name, NamespaceDescriptor> packageDescriptors;
+public class LazyPackageMemberScope extends AbstractLazyMemberScope<PackageFragmentDescriptor, PackageMemberDeclarationProvider> {
 
     public LazyPackageMemberScope(@NotNull ResolveSession resolveSession,
             @NotNull PackageMemberDeclarationProvider declarationProvider,
-            @NotNull NamespaceDescriptor thisPackage) {
+            @NotNull PackageFragmentDescriptor thisPackage) {
         super(resolveSession, declarationProvider, thisPackage);
-
-        this.packageDescriptors = resolveSession.getStorageManager().createMemoizedFunctionWithNullableValues(
-                new Function1<Name, NamespaceDescriptor>() {
-                    @Override
-                    public NamespaceDescriptor invoke(Name name) {
-                        return createPackageDescriptor(name);
-                    }
-                });
-    }
-
-    @Override
-    public NamespaceDescriptor getNamespace(@NotNull Name name) {
-        return packageDescriptors.invoke(name);
     }
 
     @Nullable
-    public NamespaceDescriptor createPackageDescriptor(@NotNull Name name) {
-        if (!declarationProvider.isPackageDeclared(name)) return null;
-
-        PackageMemberDeclarationProvider packageMemberDeclarationProvider = resolveSession.getDeclarationProviderFactory().getPackageMemberDeclarationProvider(
-                DescriptorUtils.getFQName(thisDescriptor).child(name).toSafe());
-        assert packageMemberDeclarationProvider != null : "Package is declared, but declaration provider is not found: " + name;
-
-        return new LazyPackageDescriptor(thisDescriptor, name, resolveSession, packageMemberDeclarationProvider);
+    @Override
+    public PackageViewDescriptor getPackage(@NotNull Name name) {
+        return null;
     }
 
     @Override
@@ -97,9 +75,6 @@ public class LazyPackageMemberScope extends AbstractLazyMemberScope<NamespaceDes
 
     @Override
     protected void addExtraDescriptors(@NotNull Collection<DeclarationDescriptor> result) {
-        for (FqName packageFqName : declarationProvider.getAllDeclaredPackages()) {
-            result.add(getNamespace(packageFqName.shortName()));
-        }
     }
 
     @Override

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeSelectorUtil.java

@@ -75,12 +75,12 @@ public class JetScopeSelectorUtil {
                 }
             };
 
-    public static final ScopeByNameSelector<NamespaceDescriptor> NAMESPACE_SCOPE_SELECTOR =
-            new ScopeByNameSelector<NamespaceDescriptor>() {
+    public static final ScopeByNameSelector<PackageViewDescriptor> PACKAGE_SCOPE_SELECTOR =
+            new ScopeByNameSelector<PackageViewDescriptor>() {
                 @Nullable
                 @Override
-                public NamespaceDescriptor get(@NotNull JetScope scope, @NotNull Name name) {
-                    return scope.getNamespace(name);
+                public PackageViewDescriptor get(@NotNull JetScope scope, @NotNull Name name) {
+                    return scope.getPackage(name);
                 }
             };
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java

@@ -30,6 +30,11 @@ import org.jetbrains.jet.utils.Printer;
 import java.util.Collection;
 import java.util.Set;
 
+// Reads from:
+// 1. Worker (a.k.a outer)
+// 2. Imports
+
+// Writes to: writable worker
 public class WriteThroughScope extends WritableScopeWithImports {
     private final WritableScope writableWorker;
     private Collection<DeclarationDescriptor> allDescriptors;
@@ -62,13 +67,8 @@ public class WriteThroughScope extends WritableScopeWithImports {
         checkMayRead();
 
         Set<FunctionDescriptor> result = Sets.newLinkedHashSet();
-
-        result.addAll(writableWorker.getFunctions(name));
-
         result.addAll(getWorkerScope().getFunctions(name));
-
         result.addAll(super.getFunctions(name)); // Imports
-
         return result;
     }
 
@@ -78,7 +78,6 @@ public class WriteThroughScope extends WritableScopeWithImports {
         checkMayRead();
 
         Set<VariableDescriptor> properties = Sets.newLinkedHashSet();
-        properties.addAll(writableWorker.getProperties(name));
         properties.addAll(getWorkerScope().getProperties(name));
         properties.addAll(super.getProperties(name)); //imports
         return properties;
@@ -89,10 +88,7 @@ public class WriteThroughScope extends WritableScopeWithImports {
     public VariableDescriptor getLocalVariable(@NotNull Name name) {
         checkMayRead();
 
-        VariableDescriptor variable = writableWorker.getLocalVariable(name);
-        if (variable != null) return variable;
-
-        variable = getWorkerScope().getLocalVariable(name);
+        VariableDescriptor variable = getWorkerScope().getLocalVariable(name);
         if (variable != null) return variable;
 
         return super.getLocalVariable(name); // Imports
@@ -100,16 +96,13 @@ public class WriteThroughScope extends WritableScopeWithImports {
 
     @Override
     @Nullable
-    public NamespaceDescriptor getNamespace(@NotNull Name name) {
+    public PackageViewDescriptor getPackage(@NotNull Name name) {
         checkMayRead();
 
-        NamespaceDescriptor namespace = writableWorker.getNamespace(name);
-        if (namespace != null) return namespace;
+        PackageViewDescriptor aPackage = getWorkerScope().getPackage(name);
+        if (aPackage != null) return aPackage;
 
-        namespace = getWorkerScope().getNamespace(name);
-        if (namespace != null) return namespace;
-
-        return super.getNamespace(name); // Imports
+        return super.getPackage(name); // Imports
     }
 
     @Override
@@ -117,10 +110,7 @@ public class WriteThroughScope extends WritableScopeWithImports {
     public ClassifierDescriptor getClassifier(@NotNull Name name) {
         checkMayRead();
 
-        ClassifierDescriptor classifier = writableWorker.getClassifier(name);
-        if (classifier != null) return classifier;
-
-        classifier = getWorkerScope().getClassifier(name);
+        ClassifierDescriptor classifier = getWorkerScope().getClassifier(name);
         if (classifier != null) return classifier;
 
         return super.getClassifier(name); // Imports
@@ -130,7 +120,7 @@ public class WriteThroughScope extends WritableScopeWithImports {
     public void addLabeledDeclaration(@NotNull DeclarationDescriptor descriptor) {
         checkMayWrite();
 
-        writableWorker.addLabeledDeclaration(descriptor); // TODO : review
+        writableWorker.addLabeledDeclaration(descriptor);
     }
 
     @Override
@@ -176,10 +166,10 @@ public class WriteThroughScope extends WritableScopeWithImports {
     }
 
     @Override
-    public void addNamespaceAlias(@NotNull Name name, @NotNull NamespaceDescriptor namespaceDescriptor) {
+    public void addPackageAlias(@NotNull Name name, @NotNull PackageViewDescriptor packageView) {
         checkMayWrite();
 
-        writableWorker.addNamespaceAlias(name, namespaceDescriptor);
+        writableWorker.addPackageAlias(name, packageView);
     }
 
     @Override
@@ -221,7 +211,7 @@ public class WriteThroughScope extends WritableScopeWithImports {
     public void importScope(@NotNull JetScope imported) {
         checkMayWrite();
 
-        super.importScope(imported); //
+        super.importScope(imported);
     }
 
     @Override
@@ -238,7 +228,6 @@ public class WriteThroughScope extends WritableScopeWithImports {
 
         if (allDescriptors == null) {
             allDescriptors = Lists.newArrayList();
-            allDescriptors.addAll(writableWorker.getAllDescriptors());
             allDescriptors.addAll(getWorkerScope().getAllDescriptors());
 
             for (JetScope imported : getImports()) {

compiler/testData/builtin-classes.txt

@@ -1,4 +1,4 @@
-package jet
+package-fragment jet
 
 public fun </*0*/ T> arrayOfNulls(/*0*/ size: jet.Int): jet.Array<T?>
 public fun </*0*/ R> synchronized(/*0*/ lock: jet.Any, /*1*/ block: () -> R): R

compiler/testData/recursiveProcessor/declarations.txt

@@ -64,7 +64,7 @@ innerTest.<set-propVar>:PropertySetterDescriptor
 innerTest.func:SimpleFunctionDescriptor
 innerTest.prop:PropertyDescriptor
 innerTest.propVar:PropertyDescriptor
-innerTest:NamespaceDescriptor
+innerTest:PackageViewDescriptor
 prop.this:ReceiverParameterDescriptor
 prop.this:ReceiverParameterDescriptor
-test:NamespaceDescriptor
+test:PackageViewDescriptor

compiler/tests/org/jetbrains/jet/JetTestUtils.java

@@ -50,8 +50,7 @@ import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.diagnostics.Severity;
@@ -61,11 +60,8 @@ import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.lazy.LazyResolveTestUtil;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.name.SpecialNames;
-import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
-import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.plugin.JetLanguage;
 import org.jetbrains.jet.test.InnerTestClasses;
 import org.jetbrains.jet.test.TestMetadata;
@@ -711,14 +707,16 @@ public class JetTestUtils {
     }
 
     @NotNull
-    public static NamespaceDescriptorImpl createTestNamespace(@NotNull Name testPackageName) {
-        ModuleDescriptorImpl module = AnalyzerFacadeForJVM.createJavaModule("<test module>");
-        NamespaceDescriptorImpl rootNamespace =
-                new NamespaceDescriptorImpl(module, Collections.<AnnotationDescriptor>emptyList(), SpecialNames.ROOT_NAMESPACE);
-        module.setRootNamespace(rootNamespace);
-        NamespaceDescriptorImpl test = new NamespaceDescriptorImpl(rootNamespace, Collections.<AnnotationDescriptor>emptyList(), testPackageName);
-        test.initialize(new WritableScopeImpl(JetScope.EMPTY, test, RedeclarationHandler.DO_NOTHING, "members of test namespace"));
-        return test;
+    public static MutablePackageFragmentDescriptor createTestPackageFragment(@NotNull Name testPackageName) {
+        return createTestPackageFragment(testPackageName, "<test module>");
+    }
+
+    @NotNull
+    public static MutablePackageFragmentDescriptor createTestPackageFragment(@NotNull Name testPackageName, @NotNull String moduleName) {
+        ModuleDescriptorImpl module = AnalyzerFacadeForJVM.createJavaModule(moduleName);
+        MutablePackageFragmentProvider provider = new MutablePackageFragmentProvider(module);
+        module.addFragmentProvider(provider);
+        return provider.getOrCreateFragment(FqName.topLevel(testPackageName));
     }
 
     @NotNull

compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java

@@ -24,7 +24,7 @@ import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
@@ -61,22 +61,23 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
                 JetTestUtils.createFile(ktFile.getName(), FileUtil.loadFile(ktFile), getProject())
         ), getEnvironment());
 
-        NamespaceDescriptor testNamespace = moduleDescriptor.getNamespace(FqName.topLevel(TEST_PACKAGE_NAME));
-        assert testNamespace != null;
+        PackageFragmentDescriptor testPackage = moduleDescriptor.getPackageFragmentProvider()
+                .getPackageFragments(FqName.topLevel(TEST_PACKAGE_NAME)).get(0); // TODO 2 hack
+        assert testPackage != null;
 
         InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(getProject(), new BindingTraceContext());
         JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
 
-        NamespaceDescriptor deserialized = serializeAndDeserialize(javaDescriptorResolver, testNamespace);
+        PackageFragmentDescriptor deserialized = serializeAndDeserialize(javaDescriptorResolver, testPackage);
 
         RecursiveDescriptorComparator
-                .validateAndCompareDescriptors(testNamespace, deserialized, RecursiveDescriptorComparator.RECURSIVE, null);
+                .validateAndCompareDescriptors(testPackage, deserialized, RecursiveDescriptorComparator.RECURSIVE, null);
     }
 
     @NotNull
-    private static NamespaceDescriptor serializeAndDeserialize(
+    private static PackageFragmentDescriptor serializeAndDeserialize(
             @NotNull JavaDescriptorResolver javaDescriptorResolver,
-            @NotNull NamespaceDescriptor testPackage
+            @NotNull PackageFragmentDescriptor testPackage
     ) {
         List<ClassDescriptor> classesAndObjects = getAllClassesAndObjects(testPackage.getMemberScope());
 
@@ -91,36 +92,36 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
             classDataMap.put(key, value);
         }
 
-        NamespaceDescriptorImpl namespace = JetTestUtils.createTestNamespace(TEST_PACKAGE_NAME);
+        MutablePackageFragmentDescriptor packageFragment = JetTestUtils.createTestPackageFragment(TEST_PACKAGE_NAME, "<fake>");
 
-        DescriptorFinder descriptorFinder = new DescriptorFinderFromClassDataOrJava(javaDescriptorResolver, namespace, classDataMap);
+        DescriptorFinder descriptorFinder = new DescriptorFinderFromClassDataOrJava(javaDescriptorResolver, packageFragment, classDataMap);
 
         for (ClassDescriptor classDescriptor : classesAndObjects) {
             ClassId classId = getClassId(classDescriptor);
             ClassDescriptor descriptor = descriptorFinder.findClass(classId);
             assert descriptor != null : "Class not loaded: " + classId;
-            namespace.getMemberScope().addClassifierDescriptor(descriptor);
+            packageFragment.getMemberScope().addClassifierDescriptor(descriptor);
         }
 
         PackageData data = PackageData.read(serializedPackage, JavaProtoBufUtil.getExtensionRegistry());
 
         DescriptorDeserializer deserializer = DescriptorDeserializer
-                .create(new LockBasedStorageManager(), namespace, data.getNameResolver(), descriptorFinder, UNSUPPORTED);
+                .create(new LockBasedStorageManager(), packageFragment, data.getNameResolver(), descriptorFinder, UNSUPPORTED);
         for (ProtoBuf.Callable proto : data.getPackageProto().getMemberList()) {
             CallableMemberDescriptor descriptor = deserializer.loadCallable(proto);
             if (descriptor instanceof FunctionDescriptor) {
-                namespace.getMemberScope().addFunctionDescriptor((FunctionDescriptor) descriptor);
+                packageFragment.getMemberScope().addFunctionDescriptor((FunctionDescriptor) descriptor);
             }
             else if (descriptor instanceof PropertyDescriptor) {
-                namespace.getMemberScope().addPropertyDescriptor((PropertyDescriptor) descriptor);
+                packageFragment.getMemberScope().addPropertyDescriptor((PropertyDescriptor) descriptor);
             }
             else {
                 throw new IllegalStateException("Unknown descriptor type: " + descriptor);
             }
         }
-        namespace.getMemberScope().changeLockLevel(WritableScope.LockLevel.READING);
+        packageFragment.getMemberScope().changeLockLevel(WritableScope.LockLevel.READING);
 
-        return namespace;
+        return packageFragment;
     }
 
     @NotNull
@@ -135,9 +136,9 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
     }
 
     @NotNull
-    private static byte[] serializePackage(@NotNull NamespaceDescriptor descriptor) {
+    private static byte[] serializePackage(@NotNull PackageFragmentDescriptor descriptor) {
         DescriptorSerializer serializer = new DescriptorSerializer();
-        ProtoBuf.Package proto = serializer.packageProto(descriptor).build();
+        ProtoBuf.Package proto = serializer.packageProto(Collections.singleton(descriptor)).build();
         PackageData data = new PackageData(createNameResolver(serializer.getNameTable()), proto);
         return data.toBytes();
     }
@@ -160,12 +161,12 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
 
     private static class DescriptorFinderFromClassDataOrJava extends AbstractDescriptorFinder {
         private final JavaDescriptorResolver javaDescriptorResolver;
-        private final NamespaceDescriptor packageForClasses;
+        private final PackageFragmentDescriptor packageForClasses;
         private final Map<String, ClassData> classDataMap;
 
         public DescriptorFinderFromClassDataOrJava(
                 @NotNull JavaDescriptorResolver javaDescriptorResolver,
-                @NotNull NamespaceDescriptor packageForClasses,
+                @NotNull PackageFragmentDescriptor packageForClasses,
                 @NotNull Map<String, ClassData> classDataMap
         ) {
             super(new LockBasedStorageManager(), UNSUPPORTED);
@@ -189,7 +190,7 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
 
         @Nullable
         @Override
-        public NamespaceDescriptor findPackage(@NotNull FqName name) {
+        public PackageFragmentDescriptor findPackage(@NotNull FqName name) {
             assert DescriptorUtils.getFQName(packageForClasses).equals(name.toUnsafe()) : name + " : " + packageForClasses;
             return packageForClasses;
         }

compiler/tests/org/jetbrains/jet/descriptors/serialization/BuiltinsDeserializationTest.java

@@ -27,7 +27,7 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer;
 import org.jetbrains.jet.jvm.compiler.ExpectedLoadErrorsUtil;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.lazy.KotlinTestWithEnvironment;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -52,7 +52,7 @@ public class BuiltinsDeserializationTest extends KotlinTestWithEnvironment {
 
     public void testBuiltIns() throws Exception {
         Collection<DeclarationDescriptor> allDescriptors = KotlinBuiltIns.getInstance().getBuiltInsScope().getAllDescriptors();
-        NamespaceDescriptorImpl actualNamespace = getDeserializedDescriptorsAsNamespace(allDescriptors);
+        PackageFragmentDescriptor actualPackage = getDeserializedDescriptorsAsPackage(allDescriptors);
 
         RecursiveDescriptorComparator.Configuration configuration = RecursiveDescriptorComparator.RECURSIVE.withRenderer(
                 new DescriptorRendererBuilder()
@@ -65,26 +65,26 @@ public class BuiltinsDeserializationTest extends KotlinTestWithEnvironment {
                         .build()
         );
         RecursiveDescriptorComparator
-                .validateAndCompareDescriptors(KotlinBuiltIns.getInstance().getBuiltInsPackage(), actualNamespace, configuration, null);
+                .validateAndCompareDescriptors(KotlinBuiltIns.getInstance().getBuiltInsPackageFragment(), actualPackage, configuration, null);
     }
 
-    private static NamespaceDescriptorImpl getDeserializedDescriptorsAsNamespace(Collection<DeclarationDescriptor> allDescriptors) {
+    private static PackageFragmentDescriptor getDeserializedDescriptorsAsPackage(Collection<DeclarationDescriptor> allDescriptors) {
         DescriptorSerializer serializer = new DescriptorSerializer();
 
         final Map<ClassId, ProtoBuf.Class> classProtos = serializeClasses(serializer, allDescriptors);
 
         List<ProtoBuf.Callable> callableProtos = serializeCallables(serializer, allDescriptors);
 
-        final NamespaceDescriptorImpl actualNamespace = JetTestUtils.createTestNamespace(KotlinBuiltIns.BUILT_INS_PACKAGE_NAME);
+        final MutablePackageFragmentDescriptor actualPackage = JetTestUtils.createTestPackageFragment(KotlinBuiltIns.BUILT_INS_PACKAGE_NAME);
 
         final NameResolver nameResolver = NameSerializationUtil.createNameResolver(serializer.getNameTable());
 
         DescriptorFinder finder = new AbstractDescriptorFinder(new LockBasedStorageManager(), AnnotationDeserializer.UNSUPPORTED) {
             @NotNull
             @Override
-            public NamespaceDescriptor findPackage(@NotNull FqName fqName) {
+            public PackageFragmentDescriptor findPackage(@NotNull FqName fqName) {
                 assert fqName.equals(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME) : "Unsupported package: " + fqName;
-                return actualNamespace;
+                return actualPackage;
             }
 
             @NotNull
@@ -110,7 +110,7 @@ public class BuiltinsDeserializationTest extends KotlinTestWithEnvironment {
                     case ENUM_CLASS:
                     case ANNOTATION_CLASS:
                     case OBJECT:
-                        actualNamespace.getMemberScope().addClassifierDescriptor(classDescriptor);
+                        actualPackage.getMemberScope().addClassifierDescriptor(classDescriptor);
                         break;
                     case ENUM_ENTRY:
                         assert false : "Enum entry appears to be a top-level declaration: " + classDescriptor;
@@ -125,10 +125,10 @@ public class BuiltinsDeserializationTest extends KotlinTestWithEnvironment {
             finder.findClass(classId);
         }
 
-        deserializeCallables(callableProtos, actualNamespace, nameResolver, finder);
+        deserializeCallables(callableProtos, actualPackage, nameResolver, finder);
 
-        actualNamespace.getMemberScope().changeLockLevel(WritableScope.LockLevel.READING);
-        return actualNamespace;
+        actualPackage.getMemberScope().changeLockLevel(WritableScope.LockLevel.READING);
+        return actualPackage;
     }
 
     private static Map<ClassId, ProtoBuf.Class> serializeClasses(
@@ -163,21 +163,21 @@ public class BuiltinsDeserializationTest extends KotlinTestWithEnvironment {
 
     private static void deserializeCallables(
             List<ProtoBuf.Callable> callableProtos,
-            NamespaceDescriptorImpl actualNamespace,
+            MutablePackageFragmentDescriptor actualPackage,
             NameResolver nameResolver,
             DescriptorFinder descriptorFinder
     ) {
         DescriptorDeserializer descriptorDeserializer =
-                DescriptorDeserializer.create(new LockBasedStorageManager(), actualNamespace, nameResolver, descriptorFinder, AnnotationDeserializer.UNSUPPORTED);
+                DescriptorDeserializer.create(new LockBasedStorageManager(), actualPackage, nameResolver, descriptorFinder, AnnotationDeserializer.UNSUPPORTED);
         for (ProtoBuf.Callable callableProto : callableProtos) {
             CallableMemberDescriptor callableMemberDescriptor = descriptorDeserializer.loadCallable(callableProto);
             if (callableMemberDescriptor instanceof PropertyDescriptor) {
                 PropertyDescriptor propertyDescriptor = (PropertyDescriptor) callableMemberDescriptor;
-                actualNamespace.getMemberScope().addPropertyDescriptor(propertyDescriptor);
+                actualPackage.getMemberScope().addPropertyDescriptor(propertyDescriptor);
             }
             else if (callableMemberDescriptor instanceof FunctionDescriptor) {
                 FunctionDescriptor functionDescriptor = (FunctionDescriptor) callableMemberDescriptor;
-                actualNamespace.getMemberScope().addFunctionDescriptor(functionDescriptor);
+                actualPackage.getMemberScope().addFunctionDescriptor(functionDescriptor);
             }
         }
     }

compiler/tests/org/jetbrains/jet/descriptors/serialization/ClassSerializationUtil.java

@@ -19,7 +19,7 @@ package org.jetbrains.jet.descriptors.serialization;
 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.name.FqNameUnsafe;
 
 import java.util.Collection;
@@ -63,8 +63,8 @@ public class ClassSerializationUtil {
     @NotNull
     public static ClassId getClassId(@NotNull ClassDescriptor classDescriptor) {
         DeclarationDescriptor owner = classDescriptor.getContainingDeclaration();
-        if (owner instanceof NamespaceDescriptor) {
-            return new ClassId(((NamespaceDescriptor) owner).getFqName(), FqNameUnsafe.topLevel(classDescriptor.getName()));
+        if (owner instanceof PackageFragmentDescriptor) {
+            return new ClassId(((PackageFragmentDescriptor) owner).getFqName(), FqNameUnsafe.topLevel(classDescriptor.getName()));
         }
         return getClassId((ClassDescriptor) owner).createNestedClassId(classDescriptor.getName());
     }

compiler/tests/org/jetbrains/jet/evaluate/AbstractEvaluateExpressionTest.kt

@@ -55,7 +55,7 @@ abstract class AbstractEvaluateExpressionTest: AbstractAnnotationDescriptorResol
     private fun doTest(path: String, getValueToTest: (JetProperty, BindingContext) -> String) {
         val myFile = File(path)
         val fileText = FileUtil.loadFile(myFile)
-        val namespaceDescriptor = getNamespaceDescriptor(fileText)
+        val packageView = getPackage(fileText)
 
         val propertiesForTest = getObjectsToTest(fileText)
 
@@ -66,7 +66,7 @@ abstract class AbstractEvaluateExpressionTest: AbstractAnnotationDescriptorResol
             val expected = InTextDirectivesUtils.findStringWithPrefixes(fileText, expectedProperyPrefix)
             assertNotNull(expected, "Failed to find expected directive: $expectedProperyPrefix")
 
-            val property = AbstractAnnotationDescriptorResolveTest.getPropertyDescriptor(namespaceDescriptor, propertyName)
+            val property = AbstractAnnotationDescriptorResolveTest.getPropertyDescriptor(packageView, propertyName)
             val jetProperty = BindingContextUtils.descriptorToDeclaration(context!!, property) as JetProperty
 
             val testedObject = getValueToTest(jetProperty, context!!)

compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java

@@ -22,8 +22,10 @@ import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope;
-import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.test.TestCaseWithTmpdir;
@@ -55,43 +57,43 @@ public abstract class AbstractLoadCompiledKotlinTest extends TestCaseWithTmpdir
         AnalyzeExhaust exhaust = compileKotlinToDirAndGetAnalyzeExhaust(ktFile, tmpdir, getTestRootDisposable(),
                                                                         ConfigurationKind.JDK_ONLY);
 
-        NamespaceDescriptor namespaceFromSource = exhaust.getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR,
-                                                                                  TEST_PACKAGE_FQNAME);
-        assert namespaceFromSource != null;
-        Assert.assertEquals("test", namespaceFromSource.getName().asString());
+        PackageViewDescriptor packageFromSource = exhaust.getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME);
+        assert packageFromSource != null;
+        Assert.assertEquals("test", packageFromSource.getName().asString());
 
-        NamespaceDescriptor namespaceFromClass = LoadDescriptorUtil.loadTestNamespaceAndBindingContextFromJavaRoot(
+        PackageViewDescriptor packageFromBinary = LoadDescriptorUtil.loadTestPackageAndBindingContextFromJavaRoot(
                 tmpdir, getTestRootDisposable(), ConfigurationKind.JDK_ONLY).first;
 
-        checkUsageOfDeserializedScope(namespaceFromClass);
+        checkUsageOfDeserializedScope(packageFromBinary);
 
-        for (DeclarationDescriptor descriptor : namespaceFromClass.getMemberScope().getAllDescriptors()) {
+        for (DeclarationDescriptor descriptor : packageFromBinary.getMemberScope().getAllDescriptors()) {
             if (descriptor instanceof ClassDescriptor) {
                 assert descriptor instanceof DeserializedClassDescriptor : DescriptorUtils.getFQName(descriptor) + " is loaded as " + descriptor.getClass();
             }
         }
 
-        validateAndCompareDescriptors(namespaceFromSource, namespaceFromClass,
+        validateAndCompareDescriptors(packageFromSource, packageFromBinary,
                                       RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT
                                               .checkPrimaryConstructors(true)
                                               .checkPropertyAccessors(includeAccessors),
                                       txtFile);
     }
 
-    private static void checkUsageOfDeserializedScope(@NotNull NamespaceDescriptor namespaceFromClass) {
-        JetScope scope = namespaceFromClass.getMemberScope();
-        boolean hasOwnMembers = false;
-        for (DeclarationDescriptor declarationDescriptor : scope.getAllDescriptors()) {
-            if (declarationDescriptor instanceof CallableMemberDescriptor) {
-                hasOwnMembers = true;
-            }
-        }
-        if (hasOwnMembers) {
-            assert scope instanceof DeserializedPackageMemberScope : "If namespace has members, members should be inside deserialized scope.";
-        }
-        else {
-            //NOTE: should probably change
-            assert !(scope instanceof DeserializedPackageMemberScope) : "We don't use deserialized scopes for namespaces without members.";
-        }
+    // TODO 2 do something
+    private static void checkUsageOfDeserializedScope(@NotNull PackageViewDescriptor packageFromBinary) {
+        //JetScope scope = packageFromBinary.getMemberScope();
+        //boolean hasOwnMembers = false;
+        //for (DeclarationDescriptor declarationDescriptor : scope.getAllDescriptors()) {
+        //    if (declarationDescriptor instanceof CallableMemberDescriptor) {
+        //        hasOwnMembers = true;
+        //    }
+        //}
+        //if (hasOwnMembers) {
+        //    assert scope instanceof DeserializedPackageMemberScope : "If namespace has members, members should be inside deserialized scope.";
+        //}
+        //else {
+        //    //NOTE: should probably change
+        //    assert !(scope instanceof DeserializedPackageMemberScope) : "We don't use deserialized scopes for namespaces without members.";
+        //}
     }
 }

compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java

@@ -33,13 +33,12 @@ import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.test.TestCaseWithTmpdir;
 import org.junit.Assert;
 
@@ -52,7 +51,6 @@ import java.util.List;
 import java.util.Map;
 
 import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.*;
-import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES;
 import static org.jetbrains.jet.test.util.DescriptorValidator.ValidationVisitor.ALLOW_ERROR_TYPES;
 import static org.jetbrains.jet.test.util.RecursiveDescriptorComparator.*;
 
@@ -66,10 +64,10 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         File javaFile = new File(javaFileName);
         File ktFile = new File(javaFile.getPath().replaceFirst("\\.java$", ".kt"));
         File txtFile = getTxtFile(javaFile.getPath());
-        NamespaceDescriptor kotlinNamespace = analyzeKotlinAndLoadTestNamespace(ktFile, myTestRootDisposable, ConfigurationKind.ALL);
-        Pair<NamespaceDescriptor, BindingContext> javaNamespaceAndContext = compileJavaAndLoadTestNamespaceAndBindingContextFromBinary(
+        PackageViewDescriptor kotlinPackage = analyzeKotlinAndLoadTestPackage(ktFile, myTestRootDisposable, ConfigurationKind.ALL);
+        Pair<PackageViewDescriptor, BindingContext> javaPackageAndContext = compileJavaAndLoadTestPackageAndBindingContextFromBinary(
                 Arrays.asList(javaFile), tmpdir, myTestRootDisposable, ConfigurationKind.ALL);
-        checkLoadedNamespaces(txtFile, kotlinNamespace, javaNamespaceAndContext.first, javaNamespaceAndContext.second);
+        checkLoadedPackages(txtFile, kotlinPackage, javaPackageAndContext.first, javaPackageAndContext.second);
     }
 
     protected void doTestCompiledJava(@NotNull String javaFileName) throws Exception {
@@ -105,10 +103,10 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         JetTestUtils.createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea(
                 getTestRootDisposable(), ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.MOCK_JDK);
 
-        Pair<NamespaceDescriptor, BindingContext> javaNamespaceAndContext = compileJavaAndLoadTestNamespaceAndBindingContextFromBinary(
+        Pair<PackageViewDescriptor, BindingContext> javaPackageAndContext = compileJavaAndLoadTestPackageAndBindingContextFromBinary(
                 srcFiles, compiledDir, getTestRootDisposable(), ConfigurationKind.ALL);
 
-        checkJavaNamespace(getTxtFile(javaFileName), javaNamespaceAndContext.first, javaNamespaceAndContext.second, configuration);
+        checkJavaPackage(getTxtFile(javaFileName), javaPackageAndContext.first, javaPackageAndContext.second, configuration);
     }
 
     protected void doTestSourceJava(@NotNull String javaFileName) throws Exception {
@@ -119,11 +117,11 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         assertTrue(testPackageDir.mkdir());
         FileUtil.copy(originalJavaFile, new File(testPackageDir, originalJavaFile.getName()));
 
-        Pair<NamespaceDescriptor, BindingContext> javaNamespaceAndContext = loadTestNamespaceAndBindingContextFromJavaRoot(
+        Pair<PackageViewDescriptor, BindingContext> javaNamespaceAndContext = loadTestPackageAndBindingContextFromJavaRoot(
                 tmpdir, getTestRootDisposable(), ConfigurationKind.JDK_ONLY);
 
-        checkJavaNamespace(expectedFile, javaNamespaceAndContext.first, javaNamespaceAndContext.second,
-                           DONT_INCLUDE_METHODS_OF_OBJECT.withValidationStrategy(ALLOW_ERROR_TYPES));
+        checkJavaPackage(expectedFile, javaNamespaceAndContext.first, javaNamespaceAndContext.second,
+                         DONT_INCLUDE_METHODS_OF_OBJECT.withValidationStrategy(ALLOW_ERROR_TYPES));
     }
 
     protected void doTestJavaAgainstKotlin(String expectedFileName) throws Exception {
@@ -149,6 +147,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         InjectorForJavaDescriptorResolver injectorForJava = new InjectorForJavaDescriptorResolver(environment.getProject(), trace);
 
         ModuleDescriptorImpl moduleDescriptor = AnalyzerFacadeForJVM.createJavaModule("<test module>");
+
         InjectorForTopDownAnalyzerForJvm injectorForAnalyzer = new InjectorForTopDownAnalyzerForJvm(
                 environment.getProject(),
                 new TopDownAnalysisParameters(
@@ -159,21 +158,20 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
 
         injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles(environment.getSourceFiles(), Collections.<AnalyzerScriptParameter>emptyList());
 
-        JavaDescriptorResolver javaDescriptorResolver = injectorForJava.getJavaDescriptorResolver();
-        NamespaceDescriptor namespaceDescriptor = javaDescriptorResolver.resolveNamespace(TEST_PACKAGE_FQNAME, INCLUDE_KOTLIN_SOURCES);
-        assert namespaceDescriptor != null : "Test namespace not found";
+        PackageViewDescriptor packageView = moduleDescriptor.getPackage(TEST_PACKAGE_FQNAME);
+        assert packageView != null : "Test namespace not found";
 
-        checkJavaNamespace(expectedFile, namespaceDescriptor, trace.getBindingContext(), DONT_INCLUDE_METHODS_OF_OBJECT);
+        checkJavaPackage(expectedFile, packageView, trace.getBindingContext(), DONT_INCLUDE_METHODS_OF_OBJECT);
     }
 
     private static void checkForLoadErrorsAndCompare(
-            @NotNull NamespaceDescriptor javaNamespace,
+            @NotNull PackageViewDescriptor javaPackage,
             @NotNull BindingContext bindingContext,
             @NotNull Runnable compareNamespacesRunnable
     ) {
         boolean fail = false;
         try {
-            ExpectedLoadErrorsUtil.checkForLoadErrors(javaNamespace, bindingContext);
+            ExpectedLoadErrorsUtil.checkForLoadErrors(javaPackage, bindingContext);
         }
         catch (ComparisonFailure e) {
             // to let the next check run even if this one failed
@@ -193,30 +191,30 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         }
     }
 
-    private static void checkLoadedNamespaces(
+    private static void checkLoadedPackages(
             final File txtFile,
-            final NamespaceDescriptor kotlinNamespace,
-            final NamespaceDescriptor javaNamespace,
+            final PackageViewDescriptor kotlinPackage,
+            final PackageViewDescriptor javaPackage,
             BindingContext bindingContext
     ) {
-        checkForLoadErrorsAndCompare(javaNamespace, bindingContext, new Runnable() {
+        checkForLoadErrorsAndCompare(javaPackage, bindingContext, new Runnable() {
             @Override
             public void run() {
-                validateAndCompareDescriptors(kotlinNamespace, javaNamespace, DONT_INCLUDE_METHODS_OF_OBJECT, txtFile);
+                validateAndCompareDescriptors(kotlinPackage, javaPackage, DONT_INCLUDE_METHODS_OF_OBJECT, txtFile);
             }
         });
     }
 
-    private static void checkJavaNamespace(
+    private static void checkJavaPackage(
             final File txtFile,
-            final NamespaceDescriptor javaNamespace,
+            final PackageViewDescriptor javaPackage,
             BindingContext bindingContext,
             final Configuration configuration
     ) {
-        checkForLoadErrorsAndCompare(javaNamespace, bindingContext, new Runnable() {
+        checkForLoadErrorsAndCompare(javaPackage, bindingContext, new Runnable() {
             @Override
             public void run() {
-                validateAndCompareDescriptorWithFile(javaNamespace, configuration, txtFile);
+                validateAndCompareDescriptorWithFile(javaPackage, configuration, txtFile);
             }
         });
     }

compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java

@@ -23,13 +23,11 @@ import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.MockLibraryUtil;
 import org.jetbrains.jet.TestJdkKind;
+import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.config.CompilerConfiguration;
-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.*;
 import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
-import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.test.TestCaseWithTmpdir;
 import org.jetbrains.jet.test.util.DescriptorValidator;
@@ -64,28 +62,27 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir {
     private void doTestWithTxt(@NotNull File... extraClassPath) throws Exception {
         File ktFile = new File(getTestDataDirectory(), getTestName(false) + ".kt");
 
-        NamespaceDescriptor namespace = analyzeFileToNamespace(ktFile, extraClassPath);
+        PackageViewDescriptor packageView = analyzeFileToPackageView(ktFile, extraClassPath);
 
         RecursiveDescriptorComparator.Configuration comparator =
                 RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT.withValidationStrategy(
                         DescriptorValidator.ValidationVisitor.ALLOW_ERROR_TYPES);
         File txtFile = new File(getTestDataDirectory(), FileUtil.getNameWithoutExtension(ktFile) + ".txt");
-        validateAndCompareDescriptorWithFile(namespace, comparator, txtFile);
+        validateAndCompareDescriptorWithFile(packageView, comparator, txtFile);
     }
 
     @NotNull
-    private NamespaceDescriptor analyzeFileToNamespace(@NotNull File ktFile, @NotNull File... extraClassPath) throws IOException {
+    private PackageViewDescriptor analyzeFileToPackageView(@NotNull File ktFile, @NotNull File... extraClassPath) throws IOException {
         Project project = createEnvironment(Arrays.asList(extraClassPath)).getProject();
 
-        BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(
+        AnalyzeExhaust exhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(
                 JetTestUtils.loadJetFile(project, ktFile),
                 Collections.<AnalyzerScriptParameter>emptyList()
-        ).getBindingContext();
+        );
 
-        NamespaceDescriptor namespaceDescriptor = bindingContext.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR,
-                                                                     LoadDescriptorUtil.TEST_PACKAGE_FQNAME);
-        assertNotNull("Failed to find namespace: " + LoadDescriptorUtil.TEST_PACKAGE_FQNAME, namespaceDescriptor);
-        return namespaceDescriptor;
+        PackageViewDescriptor packageView = exhaust.getModuleDescriptor().getPackage(LoadDescriptorUtil.TEST_PACKAGE_FQNAME);
+        assertNotNull("Failed to find namespace: " + LoadDescriptorUtil.TEST_PACKAGE_FQNAME, packageView);
+        return packageView;
     }
 
     @NotNull
@@ -102,7 +99,7 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir {
     @NotNull
     private Collection<DeclarationDescriptor> analyzeAndGetAllDescriptors(@NotNull File... extraClassPath) throws IOException {
         File ktFile = new File(getTestDataDirectory(), getTestName(true) + ".kt");
-        return analyzeFileToNamespace(ktFile, extraClassPath).getMemberScope().getAllDescriptors();
+        return analyzeFileToPackageView(ktFile, extraClassPath).getMemberScope().getAllDescriptors();
     }
 
     @NotNull

compiler/tests/org/jetbrains/jet/jvm/compiler/ExpectedLoadErrorsUtil.java

@@ -38,10 +38,10 @@ public class ExpectedLoadErrorsUtil {
     public static final String ANNOTATION_CLASS_NAME = ExpectLoadError.class.getName();
 
     public static void checkForLoadErrors(
-            @NotNull NamespaceDescriptor namespaceFromJava,
+            @NotNull PackageViewDescriptor packageFromJava,
             @NotNull BindingContext bindingContext
     ) {
-        Map<DeclarationDescriptor, List<String>> expectedErrors = getExpectedLoadErrors(namespaceFromJava);
+        Map<DeclarationDescriptor, List<String>> expectedErrors = getExpectedLoadErrors(packageFromJava);
         Map<DeclarationDescriptor, List<String>> actualErrors = getActualLoadErrors(bindingContext);
 
         for (DeclarationDescriptor descriptor : ContainerUtil.union(expectedErrors.keySet(), actualErrors.keySet())) {
@@ -56,15 +56,10 @@ public class ExpectedLoadErrorsUtil {
         }
     }
 
-    private static Map<DeclarationDescriptor, List<String>> getExpectedLoadErrors(@NotNull NamespaceDescriptor namespaceFromJava) {
+    private static Map<DeclarationDescriptor, List<String>> getExpectedLoadErrors(@NotNull PackageViewDescriptor packageFromJava) {
         final Map<DeclarationDescriptor, List<String>> map = new HashMap<DeclarationDescriptor, List<String>>();
 
-        namespaceFromJava.acceptVoid(new DeclarationDescriptorVisitorEmptyBodies<Void, Void>() {
-            @Override
-            public Void visitNamespaceDescriptor(NamespaceDescriptor descriptor, Void data) {
-                return visitDeclarationRecursively(descriptor, descriptor.getMemberScope());
-            }
-
+        packageFromJava.acceptVoid(new DeclarationDescriptorVisitorEmptyBodies<Void, Void>() {
             @Override
             public Void visitPackageViewDescriptor(PackageViewDescriptor descriptor, Void data) {
                 return visitDeclarationRecursively(descriptor, descriptor.getMemberScope());

compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java

@@ -31,7 +31,7 @@ import org.jetbrains.jet.codegen.GenerationUtils;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -47,7 +47,6 @@ import java.util.Collection;
 import java.util.Collections;
 
 import static org.jetbrains.jet.JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations;
-import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES;
 
 public final class LoadDescriptorUtil {
 
@@ -73,7 +72,7 @@ public final class LoadDescriptorUtil {
     }
 
     @NotNull
-    public static Pair<NamespaceDescriptor, BindingContext> loadTestNamespaceAndBindingContextFromJavaRoot(
+    public static Pair<PackageViewDescriptor, BindingContext> loadTestPackageAndBindingContextFromJavaRoot(
             @NotNull File javaRoot,
             @NotNull Disposable disposable,
             @NotNull ConfigurationKind configurationKind
@@ -87,15 +86,14 @@ public final class LoadDescriptorUtil {
         JetCoreEnvironment jetCoreEnvironment = JetCoreEnvironment.createForTests(disposable, configuration);
         BindingTraceContext trace = new BindingTraceContext();
         InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(jetCoreEnvironment.getProject(), trace);
-        NamespaceDescriptor namespaceDescriptor =
-                injector.getJavaDescriptorResolver().resolveNamespace(TEST_PACKAGE_FQNAME, IGNORE_KOTLIN_SOURCES);
-        assert namespaceDescriptor != null;
+        PackageViewDescriptor packageView = injector.getModule().getPackage(TEST_PACKAGE_FQNAME);
+        assert packageView != null;
 
-        return Pair.create(namespaceDescriptor, trace.getBindingContext());
+        return Pair.create(packageView, trace.getBindingContext());
     }
 
     @NotNull
-    public static Pair<NamespaceDescriptor, BindingContext> compileJavaAndLoadTestNamespaceAndBindingContextFromBinary(
+    public static Pair<PackageViewDescriptor, BindingContext> compileJavaAndLoadTestPackageAndBindingContextFromBinary(
             @NotNull Collection<File> javaFiles,
             @NotNull File outDir,
             @NotNull Disposable disposable,
@@ -103,7 +101,7 @@ public final class LoadDescriptorUtil {
     )
             throws IOException {
         compileJavaWithAnnotationsJar(javaFiles, outDir);
-        return loadTestNamespaceAndBindingContextFromJavaRoot(outDir, disposable, configurationKind);
+        return loadTestPackageAndBindingContextFromJavaRoot(outDir, disposable, configurationKind);
     }
 
     private static void compileJavaWithAnnotationsJar(@NotNull Collection<File> javaFiles, @NotNull File outDir) throws IOException {
@@ -117,12 +115,16 @@ public final class LoadDescriptorUtil {
     }
 
     @NotNull
-    public static NamespaceDescriptor analyzeKotlinAndLoadTestNamespace(@NotNull File ktFile, @NotNull Disposable disposable, @NotNull ConfigurationKind configurationKind) throws Exception {
+    public static PackageViewDescriptor analyzeKotlinAndLoadTestPackage(
+            @NotNull File ktFile,
+            @NotNull Disposable disposable,
+            @NotNull ConfigurationKind configurationKind
+    ) throws Exception {
         JetFileAndExhaust fileAndExhaust = JetFileAndExhaust.createJetFileAndAnalyze(ktFile, disposable, configurationKind);
-        NamespaceDescriptor namespace =
-                fileAndExhaust.getExhaust().getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, TEST_PACKAGE_FQNAME);
-        assert namespace != null: TEST_PACKAGE_FQNAME + " package not found in " + ktFile.getName();
-        return namespace;
+        PackageViewDescriptor packageView =
+                fileAndExhaust.getExhaust().getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME);
+        assert packageView != null: TEST_PACKAGE_FQNAME + " package not found in " + ktFile.getName();
+        return packageView;
     }
 
     private static class JetFileAndExhaust {

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java

@@ -54,7 +54,7 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe
         JetFile psiFile = JetPsiFactory.createFile(getProject(), FileUtil.loadFile(new File(testFile), true));
         Collection<JetFile> files = Lists.newArrayList(psiFile);
 
-        ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule("<lazy module>");
+        final ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule("<lazy module>");
         lazyModule.setModuleConfiguration(injectorForTopDownAnalyzer.getModuleDescriptor().getModuleConfiguration());
         LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager();
         final ResolveSession resolveSession = new ResolveSession(getProject(), storageManager, lazyModule,
@@ -64,9 +64,9 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe
         psiFile.accept(new JetVisitorVoid() {
             @Override
             public void visitJetFile(@NotNull JetFile file) {
-                String qualifiedName = file.getNamespaceHeader().getQualifiedName();
-                if (!qualifiedName.isEmpty()) {
-                    NamespaceDescriptor packageDescriptor = resolveSession.getPackageDescriptorByFqName(new FqName(qualifiedName));
+                FqName fqName = file.getNamespaceHeader().getFqName();
+                if (!fqName.isRoot()) {
+                    PackageViewDescriptor packageDescriptor = lazyModule.getPackage(fqName);
                     descriptors.add(packageDescriptor);
                 }
                 file.acceptChildren(this);

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java

@@ -22,6 +22,7 @@ import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.checkers.AbstractJetDiagnosticsTest;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
@@ -45,8 +46,8 @@ public abstract class AbstractLazyResolveDiagnosticsTest extends AbstractJetDiag
         ModuleDescriptor eagerModule = LazyResolveTestUtil.resolveEagerly(jetFiles, getEnvironment());
 
         String path = JetTestUtils.getFilePath(new File(FileUtil.getRelativePath(TEST_DATA_DIR, testDataFile)));
-        NamespaceDescriptor expected = eagerModule.getNamespace(FqName.ROOT);
-        NamespaceDescriptor actual = lazyModule.getNamespace(FqName.ROOT);
+        PackageViewDescriptor expected = eagerModule.getPackage(FqName.ROOT);
+        PackageViewDescriptor actual = lazyModule.getPackage(FqName.ROOT);
 
         String txtFileRelativePath = path.replaceAll("\\.kt$|\\.ktscript", ".txt");
         File txtFile = new File("compiler/testData/lazyResolve/diagnostics/" + txtFileRelativePath);

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java

@@ -23,6 +23,7 @@ import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -73,10 +74,10 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends KotlinTe
 
         FqName test = new FqName("test");
 
-        NamespaceDescriptor actual = lazyModule.getNamespace(test);
+        PackageViewDescriptor actual = lazyModule.getPackage(test);
         Assert.assertNotNull("Namespace for name " + test + " is null after lazy resolve", actual);
 
-        NamespaceDescriptor expected = eagerModule.getNamespace(test);
+        PackageViewDescriptor expected = eagerModule.getPackage(test);
         Assert.assertNotNull("Namespace for name " + test + " is null after eager resolve", expected);
 
         File serializeResultsTo = new File(FileUtil.getNameWithoutExtension(testFileName) + ".txt");

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java

@@ -24,10 +24,9 @@ import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.resolve.ExpectedResolveData;
 import org.jetbrains.jet.resolve.JetExpectedResolveDataUtil;
 
@@ -75,7 +74,7 @@ public abstract class AbstractLazyResolveTest extends JetLiteFixture {
 
         KotlinCodeAnalyzer resolveSession = LazyResolveTestUtil.resolveLazilyWithSession(files, getEnvironment(), true);
 
-        NamespaceDescriptor actual = resolveSession.getPackageDescriptorByFqName(new FqName("test"));
+        PackageViewDescriptor actual = resolveSession.getModuleDescriptor().getPackage(new FqName("test"));
         Assert.assertNotNull("Package 'test' was not found", actual);
 
         resolveSession.forceResolveAll();

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java

@@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.resolve.lazy;
 
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
 import java.io.File;
@@ -33,7 +33,7 @@ public class LazyResolveBuiltinClassesTest extends KotlinTestWithEnvironment {
     }
 
     public void testBuiltIns() throws Exception {
-        NamespaceDescriptor builtInsPackage = KotlinBuiltIns.getInstance().getBuiltInsPackage();
+        PackageFragmentDescriptor builtInsPackage = KotlinBuiltIns.getInstance().getBuiltInsPackageFragment();
         validateAndCompareDescriptorWithFile(builtInsPackage, RECURSIVE_ALL, new File("compiler/testData/builtin-classes.txt"));
     }
 }

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java

@@ -23,6 +23,7 @@ import org.jetbrains.jet.TestJdkKind;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -52,8 +53,8 @@ public class LazyResolveStdlibLoadingTest extends KotlinTestWithEnvironmentManag
         ModuleDescriptor lazyModule = LazyResolveTestUtil.resolveLazily(files, stdlibEnvironment);
 
         for (Name name : namespaceShortNames) {
-            NamespaceDescriptor eager = module.getNamespace(FqName.topLevel(name));
-            NamespaceDescriptor lazy = lazyModule.getNamespace(FqName.topLevel(name));
+            PackageViewDescriptor eager = module.getPackage(FqName.topLevel(name));
+            PackageViewDescriptor lazy = lazyModule.getPackage(FqName.topLevel(name));
             RecursiveDescriptorComparator.validateAndCompareDescriptors(eager, lazy, RecursiveDescriptorComparator.RECURSIVE, null);
         }
     }

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java

@@ -90,7 +90,7 @@ public class LazyResolveTestUtil {
     }
 
     public static ModuleDescriptor resolveLazily(List<JetFile> files, JetCoreEnvironment environment, boolean addBuiltIns) {
-        return resolveLazilyWithSession(files, environment, addBuiltIns).getRootModuleDescriptor();
+        return resolveLazilyWithSession(files, environment, addBuiltIns).getModuleDescriptor();
     }
 
     @NotNull

compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTest.java

@@ -27,12 +27,14 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.psi.JetElement;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetVisitorVoid;
 import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -94,6 +96,13 @@ public class DescriptorRendererTest extends JetLiteFixture {
                 AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(psiFile, Collections.<AnalyzerScriptParameter>emptyList());
         final BindingContext bindingContext = analyzeExhaust.getBindingContext();
         final List<DeclarationDescriptor> descriptors = new ArrayList<DeclarationDescriptor>();
+
+        FqName fqName = psiFile.getNamespaceHeader().getFqName();
+        if (!fqName.isRoot()) {
+            PackageViewDescriptor packageDescriptor = analyzeExhaust.getModuleDescriptor().getPackage(fqName);
+            descriptors.add(packageDescriptor);
+        }
+
         psiFile.acceptChildren(new JetVisitorVoid() {
             @Override
             public void visitJetElement(@NotNull JetElement element) {

compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java

@@ -261,7 +261,7 @@ public abstract class ExpectedResolveData {
             }
             assert expected != null : "No declaration for " + name;
 
-            if (referenceTarget instanceof NamespaceDescriptor) {
+            if (referenceTarget instanceof PackageViewDescriptor) {
                 JetNamespaceHeader expectedHeader = PsiTreeUtil.getParentOfType(expected, JetNamespaceHeader.class);
                 FqName expectedFqName;
                 if (expectedHeader != null) {
@@ -275,7 +275,7 @@ public abstract class ExpectedResolveData {
                 else {
                     throw new IllegalStateException(expected.getClass().getName() + " name=" + name);
                 }
-                assertEquals(expectedFqName, ((NamespaceDescriptor) referenceTarget).getFqName());
+                assertEquals(expectedFqName, ((PackageViewDescriptor) referenceTarget).getFqName());
                 continue;
             }
 

compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java

@@ -22,6 +22,7 @@ import com.intellij.util.Function;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
@@ -44,9 +45,10 @@ import java.util.List;
 public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFixture {
     private static final String PATH = "compiler/testData/resolveAnnotations/testFile.kt";
 
-    private static final FqName NAMESPACE = new FqName("test");
+    private static final FqName PACKAGE = new FqName("test");
 
     protected BindingContext context;
+    protected AnalyzeExhaust analyzeExhaust;
 
     @Override
     protected JetCoreEnvironment createEnvironment() {
@@ -54,7 +56,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
     }
 
     protected void doTest(@NotNull String content, @NotNull String expectedAnnotation) {
-        NamespaceDescriptor test = getNamespaceDescriptor(content);
+        PackageViewDescriptor test = getPackage(content);
         ClassDescriptor myClass = getClassDescriptor(test, "MyClass");
         checkDescriptor(expectedAnnotation, myClass);
         checkDescriptor(expectedAnnotation, getClassObjectDescriptor(myClass));
@@ -97,11 +99,11 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
     }
 
     @NotNull
-    private static FunctionDescriptor getFunctionDescriptor(@NotNull NamespaceDescriptor namespaceDescriptor, @NotNull String name) {
+    protected static FunctionDescriptor getFunctionDescriptor(@NotNull PackageViewDescriptor packageView, @NotNull String name) {
         Name functionName = Name.identifier(name);
-        JetScope memberScope = namespaceDescriptor.getMemberScope();
+        JetScope memberScope = packageView.getMemberScope();
         Collection<FunctionDescriptor> functions = memberScope.getFunctions(functionName);
-        assert functions.size() == 1 : "Failed to find function " + functionName + " in class" + "." + namespaceDescriptor.getName();
+        assert functions.size() == 1 : "Failed to find function " + functionName + " in class" + "." + packageView.getName();
         return functions.iterator().next();
     }
 
@@ -115,11 +117,11 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
     }
 
     @NotNull
-    protected static PropertyDescriptor getPropertyDescriptor(@NotNull NamespaceDescriptor namespaceDescriptor, @NotNull String name) {
+    protected static PropertyDescriptor getPropertyDescriptor(@NotNull PackageViewDescriptor packageView, @NotNull String name) {
         Name propertyName = Name.identifier(name);
-        JetScope memberScope = namespaceDescriptor.getMemberScope();
+        JetScope memberScope = packageView.getMemberScope();
         Collection<VariableDescriptor> properties = memberScope.getProperties(propertyName);
-        assert properties.size() == 1 : "Failed to find property " + propertyName + " in class " + namespaceDescriptor.getName();
+        assert properties.size() == 1 : "Failed to find property " + propertyName + " in class " + packageView.getName();
         return (PropertyDescriptor) properties.iterator().next();
     }
 
@@ -133,10 +135,10 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
     }
 
     @NotNull
-    protected static ClassDescriptor getClassDescriptor(@NotNull NamespaceDescriptor namespaceDescriptor, @NotNull String name) {
+    protected static ClassDescriptor getClassDescriptor(@NotNull PackageViewDescriptor packageView, @NotNull String name) {
         Name className = Name.identifier(name);
-        ClassifierDescriptor aClass = namespaceDescriptor.getMemberScope().getClassifier(className);
-        assertNotNull("Failed to find class: " + namespaceDescriptor.getName() + "." + className, aClass);
+        ClassifierDescriptor aClass = packageView.getMemberScope().getClassifier(className);
+        assertNotNull("Failed to find class: " + packageView.getName() + "." + className, aClass);
         assert aClass instanceof ClassDescriptor : "Not a class: " + aClass;
         return (ClassDescriptor) aClass;
     }
@@ -257,13 +259,14 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
     }
 
     @NotNull
-    protected NamespaceDescriptor getNamespaceDescriptor(@NotNull String content) {
+    protected PackageViewDescriptor getPackage(@NotNull String content) {
         JetFile ktFile = JetTestUtils.createFile("dummy.kt", content, getProject());
-        context = JetTestUtils.analyzeFile(ktFile).getBindingContext();
+        analyzeExhaust = JetTestUtils.analyzeFile(ktFile);
+        context = analyzeExhaust.getBindingContext();
 
-        NamespaceDescriptor namespaceDescriptor = context.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, NAMESPACE);
-        assertNotNull("Failed to find namespace: " + NAMESPACE, namespaceDescriptor);
-        return namespaceDescriptor;
+        PackageViewDescriptor packageView = analyzeExhaust.getModuleDescriptor().getPackage(PACKAGE);
+        assertNotNull("Failed to find namespace: " + PACKAGE, packageView);
+        return packageView;
     }
 
     protected static String getContent(@NotNull String annotationText) throws IOException {

compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationParameterTest.kt

@@ -24,8 +24,8 @@ import org.jetbrains.jet.JetTestUtils
 public abstract class AbstractAnnotationParameterTest : AbstractAnnotationDescriptorResolveTest() {
     fun doTest(path: String) {
         val fileText = FileUtil.loadFile(File(path))
-        val namespaceDescriptor = getNamespaceDescriptor(fileText)
-        val classDescriptor = AbstractAnnotationDescriptorResolveTest.getClassDescriptor(namespaceDescriptor, "MyClass")
+        val packageView = getPackage(fileText)
+        val classDescriptor = AbstractAnnotationDescriptorResolveTest.getClassDescriptor(packageView, "MyClass")
 
         val expected = InTextDirectivesUtils.findListWithPrefixes(fileText, "// EXPECTED: ").makeString(", ")
         val actual = AbstractAnnotationDescriptorResolveTest.getAnnotations(classDescriptor)

compiler/tests/org/jetbrains/jet/test/util/DescriptorValidator.java

@@ -356,12 +356,13 @@ public class DescriptorValidator {
         private void assertFound(
                 @NotNull JetScope scope,
                 @NotNull DeclarationDescriptor expected,
-                @Nullable DeclarationDescriptor found
+                @Nullable DeclarationDescriptor found,
+                boolean shouldBeSame
         ) {
             if (found == null) {
                 report(expected, "Not found in " + scope);
             }
-            if (expected != found) {
+            if (shouldBeSame ? expected != found : !expected.equals(found)) {
                 report(expected, "Lookup error in " + scope + ": " + found);
             }
         }
@@ -380,8 +381,7 @@ public class DescriptorValidator {
         public Void visitNamespaceDescriptor(
                 NamespaceDescriptor descriptor, JetScope scope
         ) {
-            assertFound(scope, descriptor, scope.getNamespace(descriptor.getName()));
-            return null;
+            throw new IllegalStateException("namespace don't exist");
         }
 
         @Override
@@ -395,8 +395,7 @@ public class DescriptorValidator {
         public Void visitPackageViewDescriptor(
                 PackageViewDescriptor descriptor, JetScope scope
         ) {
-            // TODO
-            //assertFound(scope, descriptor, scope.getPackage(descriptor.getName()));
+            assertFound(scope, descriptor, scope.getPackage(descriptor.getName()), false);
             return null;
         }
 
@@ -420,7 +419,7 @@ public class DescriptorValidator {
         public Void visitTypeParameterDescriptor(
                 TypeParameterDescriptor descriptor, JetScope scope
         ) {
-            assertFound(scope, descriptor, scope.getClassifier(descriptor.getName()));
+            assertFound(scope, descriptor, scope.getClassifier(descriptor.getName()), true);
             return null;
         }
 
@@ -428,7 +427,7 @@ public class DescriptorValidator {
         public Void visitClassDescriptor(
                 ClassDescriptor descriptor, JetScope scope
         ) {
-            assertFound(scope, descriptor, scope.getClassifier(descriptor.getName()));
+            assertFound(scope, descriptor, scope.getClassifier(descriptor.getName()), true);
             return null;
         }
 

compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorComparator.java

@@ -26,7 +26,6 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.jvm.compiler.ExpectedLoadErrorsUtil;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.MemberComparator;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
@@ -78,14 +77,14 @@ public class RecursiveDescriptorComparator {
     }
 
     private void appendDeclarationRecursively(@NotNull DeclarationDescriptor descriptor, @NotNull Printer printer, boolean topLevel) {
-        if (descriptor instanceof ClassOrNamespaceDescriptor && !topLevel) {
+        if ((descriptor instanceof ClassOrNamespaceDescriptor || descriptor instanceof PackageViewDescriptor) && !topLevel) {
             printer.println();
         }
 
         boolean isPrimaryConstructor = descriptor instanceof ConstructorDescriptor && ((ConstructorDescriptor) descriptor).isPrimary();
         printer.print(isPrimaryConstructor && conf.checkPrimaryConstructors ? "/*primary*/ " : "", conf.renderer.render(descriptor));
 
-        if (descriptor instanceof ClassOrNamespaceDescriptor) {
+        if (descriptor instanceof ClassOrNamespaceDescriptor || descriptor instanceof PackageViewDescriptor) {
             if (!topLevel) {
                 printer.printlnWithNoIndent(" {").pushIndent();
             }
@@ -98,8 +97,12 @@ public class RecursiveDescriptorComparator {
                 ClassDescriptor klass = (ClassDescriptor) descriptor;
                 appendSubDescriptors(klass.getDefaultType().getMemberScope(), getConstructorsAndClassObject(klass), printer);
             }
-            else if (descriptor instanceof NamespaceDescriptor) {
-                appendSubDescriptors(((NamespaceDescriptor) descriptor).getMemberScope(),
+            else if (descriptor instanceof PackageFragmentDescriptor) {
+                appendSubDescriptors(((PackageFragmentDescriptor) descriptor).getMemberScope(),
+                                     Collections.<DeclarationDescriptor>emptyList(), printer);
+            }
+            else if (descriptor instanceof PackageViewDescriptor) {
+                appendSubDescriptors(((PackageViewDescriptor) descriptor).getMemberScope(),
                                      Collections.<DeclarationDescriptor>emptyList(), printer);
             }
 
@@ -142,7 +145,7 @@ public class RecursiveDescriptorComparator {
                 && JAVA_OBJECT_METHOD_NAMES.contains(subDescriptor.getName().asString())
                 && !conf.includeMethodsOfJavaObject
             ||
-                subDescriptor instanceof NamespaceDescriptor && !conf.recurseIntoPackage.apply(DescriptorUtils.getFQName(subDescriptor));
+                subDescriptor instanceof PackageViewDescriptor && !conf.recurseIntoPackage.apply(((PackageViewDescriptor) subDescriptor).getFqName().toUnsafe()); // TODO 2 accept safe fq name instead
     }
 
     private void appendSubDescriptors(
@@ -216,7 +219,6 @@ public class RecursiveDescriptorComparator {
 
         if (expected != null) {
             String expectedSerialized = comparator.serializeRecursively(expected);
-            Assert.assertSame(expected.getClass(), actual.getClass());
 
             Assert.assertEquals("Expected and actual descriptors differ", expectedSerialized, actualSerialized);
         }

compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorProcessor.java

@@ -118,7 +118,7 @@ public class RecursiveDescriptorProcessor {
         @Override
         public Boolean visitModuleDeclaration(ModuleDescriptor descriptor, D data) {
             return applyWorker(descriptor, data)
-                   && visitChildren(descriptor.getNamespace(FqName.ROOT), data);
+                   && visitChildren(descriptor.getPackage(FqName.ROOT), data);
         }
 
         @Override

compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorProcessorTest.java

@@ -44,7 +44,7 @@ public class RecursiveDescriptorProcessorTest extends KotlinTestWithEnvironment
         String text = FileUtil.loadFile(ktFile);
         JetFile jetFile = JetTestUtils.createFile("declarations.kt", text, getEnvironment().getProject());
         AnalyzeExhaust exhaust = JetTestUtils.analyzeFile(jetFile);
-        NamespaceDescriptor testPackage = exhaust.getModuleDescriptor().getNamespace(FqName.topLevel(Name.identifier("test")));
+        PackageViewDescriptor testPackage = exhaust.getModuleDescriptor().getPackage(FqName.topLevel(Name.identifier("test")));
         assert testPackage != null;
 
         List<String> descriptors = recursivelyCollectDescriptors(testPackage);
@@ -74,7 +74,7 @@ public class RecursiveDescriptorProcessorTest extends KotlinTestWithEnvironment
         return closestInterface(aClass.getSuperclass());
     }
 
-    private static List<String> recursivelyCollectDescriptors(NamespaceDescriptor testPackage) {
+    private static List<String> recursivelyCollectDescriptors(PackageViewDescriptor testPackage) {
         final List<String> lines = Lists.newArrayList();
         RecursiveDescriptorProcessor.process(testPackage, null, new DeclarationDescriptorVisitor<Boolean, Void>() {
 
@@ -98,9 +98,7 @@ public class RecursiveDescriptorProcessorTest extends KotlinTestWithEnvironment
             }
 
             @Override
-            public Boolean visitPackageFragmentDescriptor(
-                    PackageFragmentDescriptor descriptor, Void data
-            ) {
+            public Boolean visitPackageFragmentDescriptor(PackageFragmentDescriptor descriptor, Void data) {
                 add(descriptor);
                 return true;
             }

compiler/tests/org/jetbrains/jet/types/BoundsSubstitutorTest.java

@@ -72,7 +72,7 @@ public class BoundsSubstitutorTest extends KotlinTestWithEnvironment {
     private void doTest(String text, String expected) {
         JetFile jetFile = JetPsiFactory.createFile(getProject(), "fun.kt", text);
         ModuleDescriptor module = LazyResolveTestUtil.resolveLazily(Collections.singletonList(jetFile), getEnvironment());
-        Collection<FunctionDescriptor> functions = module.getNamespace(FqName.ROOT).getMemberScope().getFunctions(Name.identifier("f"));
+        Collection<FunctionDescriptor> functions = module.getPackage(FqName.ROOT).getMemberScope().getFunctions(Name.identifier("f"));
         assert functions.size() == 1 : "Many functions defined";
         FunctionDescriptor function = ContainerUtil.getFirstItem(functions);
 

compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java

@@ -28,12 +28,13 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.di.InjectorForTests;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.ReceiverParameterDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
+import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
@@ -52,9 +53,6 @@ import java.io.File;
 import java.io.IOException;
 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 class JetTypeCheckerTest extends JetLiteFixture {
 
     private KotlinBuiltIns builtIns;
@@ -578,7 +576,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
                 getEnvironment()
         );
 
-        NamespaceDescriptor testData = moduleDescriptor.getNamespace(new FqName("testData"));
+        PackageFragmentDescriptor testData = moduleDescriptor.getPackageFragmentProvider().getPackageFragments(new FqName("testData")).get(0); // TODO 2 hack
         return addImports(testData.getMemberScope());
     }
 
@@ -588,10 +586,12 @@ public class JetTypeCheckerTest extends JetLiteFixture {
                 scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "JetTypeCheckerTest.addImports");
         InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(getProject(), new BindingTraceContext());
         JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
-        writableScope.importScope(javaDescriptorResolver.resolveNamespace(FqName.ROOT, INCLUDE_KOTLIN_SOURCES).getMemberScope());
-        writableScope.importScope(javaDescriptorResolver.resolveNamespace(new FqName("java.lang"), IGNORE_KOTLIN_SOURCES).getMemberScope());
+        ModuleDescriptor module = javaDescriptorResolver.getPackageFragmentProvider().getModule();
+        for (ImportPath defaultImport : module.getDefaultImports()) {
+            writableScope.importScope(module.getPackage(defaultImport.fqnPart()).getMemberScope());
+        }
+        writableScope.importScope(module.getPackage(FqName.ROOT).getMemberScope());
         writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
-        writableScope.importScope(builtIns.getBuiltInsScope());
         return writableScope;
     }
 

compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java

@@ -83,7 +83,7 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
         String text = FileUtil.loadFile(new File("compiler/testData/type-substitutor.kt"));
         JetFile jetFile = JetPsiFactory.createFile(getProject(), text);
         ModuleDescriptor module = LazyResolveTestUtil.resolveLazily(Collections.singletonList(jetFile), getEnvironment());
-        JetScope topLevelDeclarations = module.getNamespace(FqName.ROOT).getMemberScope();
+        JetScope topLevelDeclarations = module.getPackage(FqName.ROOT).getMemberScope();
         ClassifierDescriptor contextClass = topLevelDeclarations.getClassifier(Name.identifier("___Context"));
         assert contextClass instanceof ClassDescriptor;
         WritableScopeImpl typeParameters = new WritableScopeImpl(JetScope.EMPTY, module, RedeclarationHandler.THROW_EXCEPTION,

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,