Move around some descriptor implementations

- mutable class, mutable package fragment and their dependencies go to module
  'frontend'
- ModuleDescriptorImpl and PackageFragmentDescriptorImpl are moved to the
  package "impl" in their module

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

@@ -19,6 +19,7 @@ package org.jetbrains.jet.codegen;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;

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

@@ -35,8 +35,8 @@ import org.jetbrains.jet.asJava.LightClassConstructionContext;
 import org.jetbrains.jet.asJava.LightClassGenerationSupport;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;

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

@@ -44,7 +44,7 @@ import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.state.Progress;
 import org.jetbrains.jet.config.CommonConfigurationKeys;
 import org.jetbrains.jet.config.CompilerConfiguration;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.parsing.JetScriptDefinition;
 import org.jetbrains.jet.lang.parsing.JetScriptDefinitionProvider;
 import org.jetbrains.jet.lang.psi.JetFile;

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

@@ -42,8 +42,8 @@ import org.jetbrains.jet.codegen.KotlinCodegenFacade;
 import org.jetbrains.jet.codegen.state.GenerationState;
 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.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.PackageLikeBuilderDummy;
 import org.jetbrains.jet.lang.parsing.JetParserDefinition;
 import org.jetbrains.jet.lang.psi.JetFile;

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

@@ -20,7 +20,7 @@ import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.context.GlobalContextImpl;
 import org.jetbrains.jet.storage.LockBasedStorageManager;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver;

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

@@ -21,7 +21,7 @@ import org.jetbrains.jet.context.GlobalContextImpl;
 import org.jetbrains.jet.storage.LockBasedStorageManager;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;

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

@@ -33,7 +33,7 @@ import org.jetbrains.jet.context.GlobalContextImpl;
 import org.jetbrains.jet.di.InjectorForLazyResolveWithJava;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.DependencyKind;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/incremental/IncrementalPackageFragmentProvider.kt

@@ -23,21 +23,14 @@ import com.intellij.util.containers.MultiMap
 import java.util.HashMap
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
 import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider
-import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptorImpl
+import org.jetbrains.jet.lang.descriptors.impl.PackageFragmentDescriptorImpl
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
 import org.jetbrains.jet.storage.StorageManager
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope
 import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver
-import org.jetbrains.jet.descriptors.serialization.ClassId
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor
-import org.jetbrains.jet.lang.resolve.name.Name
-import org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils
-import java.util.Collections
 import org.jetbrains.jet.utils.addToStdlib.singletonOrEmptyList
 import org.jetbrains.jet.storage.NotNullLazyValue
-import org.jetbrains.jet.lang.psi.JetNamedFunction
-import org.jetbrains.jet.lang.psi.JetProperty
 import org.jetbrains.jet.descriptors.serialization.ProtoBuf
 import org.jetbrains.jet.lang.resolve.kotlin.PackagePartClassUtils
 import org.jetbrains.jet.descriptors.serialization.JavaProtoBuf

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

@@ -19,7 +19,7 @@ package org.jetbrains.jet.di;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.context.GlobalContextImpl;
 import org.jetbrains.jet.storage.LockBasedStorageManager;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.BindingTrace;

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorWithResolutionScopes.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2014 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.descriptors;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.ReadOnly;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+
+import java.util.Collection;
+
+public interface ClassDescriptorWithResolutionScopes extends ClassDescriptor {
+    @NotNull
+    JetScope getScopeForClassHeaderResolution();
+
+    @NotNull
+    JetScope getScopeForMemberDeclarationResolution();
+
+    @NotNull
+    JetScope getScopeForInitializerResolution();
+
+    @NotNull
+    JetScope getScopeForMemberLookup();
+
+    @NotNull
+    @ReadOnly
+    Collection<CallableMemberDescriptor> getDeclaredCallableMembers();
+}

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/MutableClassDescriptor.java

@@ -0,0 +1,376 @@
+/*
+ * 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.descriptors.impl;
+
+import com.google.common.collect.Sets;
+import org.jetbrains.annotations.NotNull;
+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.annotations.Annotations;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationsImpl;
+import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.*;
+import org.jetbrains.jet.lang.types.*;
+import org.jetbrains.jet.storage.LockBasedStorageManager;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+public class MutableClassDescriptor extends ClassDescriptorBase implements ClassDescriptorWithResolutionScopes {
+    private final ClassKind kind;
+    private final boolean isInner;
+
+    private Annotations annotations;
+    private Modality modality;
+    private Visibility visibility;
+    private TypeConstructor typeConstructor;
+    private List<TypeParameterDescriptor> typeParameters;
+    private Collection<JetType> supertypes = new ArrayList<JetType>();
+
+    private ClassDescriptor classObjectDescriptor;
+
+    private final Set<ConstructorDescriptor> constructors = Sets.newLinkedHashSet();
+    private ConstructorDescriptor primaryConstructor;
+
+    private final Set<CallableMemberDescriptor> declaredCallableMembers = Sets.newLinkedHashSet();
+    private final Set<CallableMemberDescriptor> allCallableMembers = Sets.newLinkedHashSet(); // includes fake overrides
+    private final Set<PropertyDescriptor> properties = Sets.newLinkedHashSet();
+    private final Set<SimpleFunctionDescriptor> functions = Sets.newLinkedHashSet();
+
+    private final WritableScope scopeForMemberResolution;
+    // This scope contains type parameters but does not contain inner classes
+    private final WritableScope scopeForSupertypeResolution;
+    private WritableScope scopeForInitializers = null; //contains members + primary constructor value parameters + map for backing fields
+    private JetScope scopeForMemberLookup;
+
+    public MutableClassDescriptor(
+            @NotNull DeclarationDescriptor containingDeclaration,
+            @NotNull JetScope outerScope,
+            @NotNull ClassKind kind,
+            boolean isInner,
+            @NotNull Name name
+    ) {
+        super(LockBasedStorageManager.NO_LOCKS, containingDeclaration, name);
+        this.kind = kind;
+        this.isInner = isInner;
+
+        RedeclarationHandler redeclarationHandler = RedeclarationHandler.DO_NOTHING;
+
+        setScopeForMemberLookup(new WritableScopeImpl(JetScope.EMPTY, this, redeclarationHandler, "MemberLookup")
+                                        .changeLockLevel(WritableScope.LockLevel.BOTH));
+        this.scopeForSupertypeResolution = new WritableScopeImpl(outerScope, this, redeclarationHandler, "SupertypeResolution")
+                .changeLockLevel(WritableScope.LockLevel.BOTH);
+        this.scopeForMemberResolution = new WritableScopeImpl(scopeForSupertypeResolution, this, redeclarationHandler, "MemberResolution")
+                .changeLockLevel(WritableScope.LockLevel.BOTH);
+        if (getKind() == ClassKind.TRAIT) {
+            setUpScopeForInitializers(this);
+        }
+
+        scopeForMemberResolution.addLabeledDeclaration(this);
+    }
+
+    @Nullable
+    @Override
+    public ClassDescriptor getClassObjectDescriptor() {
+        return classObjectDescriptor;
+    }
+
+    @NotNull
+    @Override
+    public Annotations getAnnotations() {
+        if (annotations == null) {
+            annotations = new AnnotationsImpl(new ArrayList<AnnotationDescriptor>(0));
+        }
+        return annotations;
+    }
+
+    public void addAnnotations(@NotNull Iterable<AnnotationDescriptor> annotationsToAdd) {
+        List<AnnotationDescriptor> annotations = ((AnnotationsImpl) getAnnotations()).getAnnotationDescriptors();
+        for (AnnotationDescriptor annotationDescriptor : annotationsToAdd) {
+            annotations.add(annotationDescriptor);
+        }
+    }
+
+    public void setModality(@NotNull Modality modality) {
+        this.modality = modality;
+    }
+
+    @Override
+    @NotNull
+    public Modality getModality() {
+        return modality;
+    }
+
+    @NotNull
+    @Override
+    public ClassKind getKind() {
+        return kind;
+    }
+
+    public void setVisibility(@NotNull Visibility visibility) {
+        this.visibility = visibility;
+    }
+
+    @NotNull
+    @Override
+    public Visibility getVisibility() {
+        return visibility;
+    }
+
+    @Override
+    public boolean isInner() {
+        return isInner;
+    }
+
+    @NotNull
+    @Override
+    public TypeConstructor getTypeConstructor() {
+        return typeConstructor;
+    }
+
+    @NotNull
+    public Collection<JetType> getSupertypes() {
+        return supertypes;
+    }
+
+    public void setSupertypes(@NotNull Collection<JetType> supertypes) {
+        this.supertypes = supertypes;
+    }
+
+    public void addSupertype(@NotNull JetType supertype) {
+        assert !supertype.isError() : "Error types must be filtered out in DescriptorResolver";
+        if (TypeUtils.getClassDescriptor(supertype) != null) {
+            // See the Errors.SUPERTYPE_NOT_A_CLASS_OR_TRAIT
+            supertypes.add(supertype);
+        }
+    }
+
+    public void setPrimaryConstructor(@NotNull ConstructorDescriptor constructorDescriptor) {
+        assert primaryConstructor == null : "Primary constructor assigned twice " + this;
+        primaryConstructor = constructorDescriptor;
+
+        constructors.add(constructorDescriptor);
+
+        ((ConstructorDescriptorImpl) constructorDescriptor).setReturnType(new DelegatingType() {
+            @Override
+            protected JetType getDelegate() {
+                return getDefaultType();
+            }
+        });
+
+        if (constructorDescriptor.isPrimary()) {
+            setUpScopeForInitializers(constructorDescriptor);
+        }
+    }
+
+    public void addConstructorParametersToInitializersScope(@NotNull Collection<? extends VariableDescriptor> variables) {
+        WritableScope scope = getWritableScopeForInitializers();
+        for (VariableDescriptor variable : variables) {
+            scope.addVariableDescriptor(variable);
+        }
+    }
+
+    @NotNull
+    @Override
+    public Set<ConstructorDescriptor> getConstructors() {
+        return constructors;
+    }
+
+    @Override
+    @Nullable
+    public ConstructorDescriptor getUnsubstitutedPrimaryConstructor() {
+        return primaryConstructor;
+    }
+
+    @NotNull
+    public Set<SimpleFunctionDescriptor> getFunctions() {
+        return functions;
+    }
+
+    @NotNull
+    public Set<PropertyDescriptor> getProperties() {
+        return properties;
+    }
+
+    @Override
+    @NotNull
+    public Set<CallableMemberDescriptor> getDeclaredCallableMembers() {
+        return declaredCallableMembers;
+    }
+
+    @NotNull
+    public Set<CallableMemberDescriptor> getAllCallableMembers() {
+        return allCallableMembers;
+    }
+
+    public void setTypeParameterDescriptors(@NotNull List<TypeParameterDescriptor> typeParameters) {
+        if (this.typeParameters != null) {
+            throw new IllegalStateException("Type parameters are already set for " + getName());
+        }
+        this.typeParameters = new ArrayList<TypeParameterDescriptor>(typeParameters);
+        for (TypeParameterDescriptor typeParameterDescriptor : typeParameters) {
+            scopeForSupertypeResolution.addTypeParameterDescriptor(typeParameterDescriptor);
+        }
+        scopeForSupertypeResolution.changeLockLevel(WritableScope.LockLevel.READING);
+    }
+
+    public void createTypeConstructor() {
+        assert typeConstructor == null : typeConstructor;
+        this.typeConstructor = TypeConstructorImpl.createForClass(
+                this,
+                Annotations.EMPTY, // TODO : pass annotations from the class?
+                !getModality().isOverridable(),
+                getName().asString(),
+                typeParameters,
+                supertypes
+        );
+        for (FunctionDescriptor functionDescriptor : getConstructors()) {
+            ((ConstructorDescriptorImpl) functionDescriptor).setReturnType(getDefaultType());
+        }
+        scopeForMemberResolution.setImplicitReceiver(getThisAsReceiverParameter());
+    }
+
+    @Override
+    @NotNull
+    public JetScope getScopeForClassHeaderResolution() {
+        return scopeForSupertypeResolution;
+    }
+
+    @Override
+    @NotNull
+    public JetScope getScopeForMemberDeclarationResolution() {
+        return scopeForMemberResolution;
+    }
+
+    private WritableScope getWritableScopeForInitializers() {
+        if (scopeForInitializers == null) {
+            throw new IllegalStateException("Scope for initializers queried before the primary constructor is set");
+        }
+        return scopeForInitializers;
+    }
+
+    @Override
+    @NotNull
+    public JetScope getScopeForInitializerResolution() {
+        return getWritableScopeForInitializers();
+    }
+
+    private void setUpScopeForInitializers(@NotNull DeclarationDescriptor containingDeclaration) {
+        this.scopeForInitializers = new WritableScopeImpl(
+                scopeForMemberResolution, containingDeclaration, RedeclarationHandler.DO_NOTHING, "Initializers")
+                    .changeLockLevel(WritableScope.LockLevel.BOTH);
+    }
+
+    public void setScopeForMemberLookup(@NotNull JetScope scopeForMemberLookup) {
+        this.scopeForMemberLookup = scopeForMemberLookup;
+    }
+
+    @Override
+    @NotNull
+    public JetScope getScopeForMemberLookup() {
+        return scopeForMemberLookup;
+    }
+
+    @NotNull
+    private WritableScope getScopeForMemberLookupAsWritableScope() {
+        // hack
+        return (WritableScope) scopeForMemberLookup;
+    }
+
+    public void lockScopes() {
+        getScopeForMemberLookupAsWritableScope().changeLockLevel(WritableScope.LockLevel.READING);
+        if (classObjectDescriptor instanceof MutableClassDescriptor) {
+            ((MutableClassDescriptor) classObjectDescriptor).lockScopes();
+        }
+        scopeForSupertypeResolution.changeLockLevel(WritableScope.LockLevel.READING);
+        scopeForMemberResolution.changeLockLevel(WritableScope.LockLevel.READING);
+        getWritableScopeForInitializers().changeLockLevel(WritableScope.LockLevel.READING);
+    }
+
+    private PackageLikeBuilder builder = null;
+
+    @NotNull
+    public PackageLikeBuilder getBuilder() {
+        if (builder == null) {
+            builder = new PackageLikeBuilder() {
+                @NotNull
+                @Override
+                public DeclarationDescriptor getOwnerForChildren() {
+                    return MutableClassDescriptor.this;
+                }
+
+                @Override
+                public void addClassifierDescriptor(@NotNull MutableClassDescriptor classDescriptor) {
+                    getScopeForMemberLookupAsWritableScope().addClassifierDescriptor(classDescriptor);
+                    scopeForMemberResolution.addClassifierDescriptor(classDescriptor);
+                }
+
+                @Override
+                public void addFunctionDescriptor(@NotNull SimpleFunctionDescriptor functionDescriptor) {
+                    getScopeForMemberLookupAsWritableScope().addFunctionDescriptor(functionDescriptor);
+                    functions.add(functionDescriptor);
+                    if (functionDescriptor.getKind().isReal()) {
+                        declaredCallableMembers.add(functionDescriptor);
+                    }
+                    allCallableMembers.add(functionDescriptor);
+                    scopeForMemberResolution.addFunctionDescriptor(functionDescriptor);
+                }
+
+                @Override
+                public ClassObjectStatus setClassObjectDescriptor(@NotNull ClassDescriptor classObjectDescriptor) {
+                    if (getKind() == ClassKind.CLASS_OBJECT || isInner()) {
+                        return ClassObjectStatus.NOT_ALLOWED;
+                    }
+
+                    if (MutableClassDescriptor.this.classObjectDescriptor != null) {
+                        return ClassObjectStatus.DUPLICATE;
+                    }
+
+                    assert classObjectDescriptor.getKind() == ClassKind.CLASS_OBJECT;
+                    MutableClassDescriptor.this.classObjectDescriptor = classObjectDescriptor;
+
+                    // Members of the class object are accessible from the class
+                    // The scope must be lazy, because classObjectDescriptor may not by fully built yet
+                    scopeForMemberResolution.importScope(new ClassObjectMixinScope(classObjectDescriptor));
+
+                    return ClassObjectStatus.OK;
+                }
+
+                @Override
+                public void addPropertyDescriptor(@NotNull PropertyDescriptor propertyDescriptor) {
+                    getScopeForMemberLookupAsWritableScope().addPropertyDescriptor(propertyDescriptor);
+                    properties.add(propertyDescriptor);
+                    if (propertyDescriptor.getKind().isReal()) {
+                        declaredCallableMembers.add(propertyDescriptor);
+                    }
+                    allCallableMembers.add(propertyDescriptor);
+                    scopeForMemberResolution.addPropertyDescriptor(propertyDescriptor);
+                }
+            };
+        }
+
+        return builder;
+    }
+
+    @Override
+    public String toString() {
+        return DeclarationDescriptorImpl.toString(this);
+    }
+}

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/MutablePackageFragmentDescriptor.java

@@ -0,0 +1,49 @@
+/*
+ * 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.descriptors.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+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;
+
+public class MutablePackageFragmentDescriptor extends PackageFragmentDescriptorImpl {
+    private final WritableScope scope;
+    private final PackageLikeBuilder builder;
+
+    public MutablePackageFragmentDescriptor(@NotNull ModuleDescriptor module, @NotNull FqName fqName) {
+        super(module, fqName);
+
+        scope = new WritableScopeImpl(JetScope.EMPTY, this, RedeclarationHandler.DO_NOTHING, "Members of " + fqName + " in " + module);
+        scope.changeLockLevel(WritableScope.LockLevel.BOTH);
+        builder = new ScopeBasedPackageLikeBuilder(this, scope);
+    }
+
+    @NotNull
+    @Override
+    public WritableScope getMemberScope() {
+        return scope;
+    }
+
+    @NotNull
+    public PackageLikeBuilder getBuilder() {
+        return builder;
+    }
+}

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/PackageLikeBuilder.java

@@ -0,0 +1,42 @@
+/*
+ * 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.descriptors.impl;
+
+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.PropertyDescriptor;
+import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
+
+public interface PackageLikeBuilder {
+    @NotNull
+    DeclarationDescriptor getOwnerForChildren();
+
+    void addClassifierDescriptor(@NotNull MutableClassDescriptor classDescriptor);
+
+    void addFunctionDescriptor(@NotNull SimpleFunctionDescriptor functionDescriptor);
+
+    void addPropertyDescriptor(@NotNull PropertyDescriptor propertyDescriptor);
+
+    enum ClassObjectStatus {
+        OK,
+        DUPLICATE,
+        NOT_ALLOWED
+    }
+
+    ClassObjectStatus setClassObjectDescriptor(@NotNull ClassDescriptor classObjectDescriptor);
+}

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/PackageLikeBuilderDummy.java

@@ -0,0 +1,51 @@
+/*
+ * 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.descriptors.impl;
+
+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.PropertyDescriptor;
+import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
+
+public class PackageLikeBuilderDummy implements PackageLikeBuilder {
+    @NotNull
+    @Override
+    public DeclarationDescriptor getOwnerForChildren() {
+        throw new IllegalStateException();
+    }
+
+    @Override
+    public void addClassifierDescriptor(@NotNull MutableClassDescriptor classDescriptor) {
+        throw new IllegalStateException();
+    }
+
+    @Override
+    public void addFunctionDescriptor(@NotNull SimpleFunctionDescriptor functionDescriptor) {
+        throw new IllegalStateException();
+    }
+
+    @Override
+    public void addPropertyDescriptor(@NotNull PropertyDescriptor propertyDescriptor) {
+        throw new IllegalStateException();
+    }
+
+    @Override
+    public ClassObjectStatus setClassObjectDescriptor(@NotNull ClassDescriptor classObjectDescriptor) {
+        throw new IllegalStateException();
+    }
+}

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/ScopeBasedPackageLikeBuilder.java

@@ -0,0 +1,63 @@
+/*
+ * 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.descriptors.impl;
+
+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.PropertyDescriptor;
+import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+
+public class ScopeBasedPackageLikeBuilder implements PackageLikeBuilder {
+    private final DeclarationDescriptor containingDeclaration;
+    private final WritableScope scope;
+
+    ScopeBasedPackageLikeBuilder(
+            @NotNull DeclarationDescriptor containingDeclaration,
+            @NotNull WritableScope scope
+    ) {
+        this.containingDeclaration = containingDeclaration;
+        this.scope = scope;
+    }
+
+    @NotNull
+    @Override
+    public DeclarationDescriptor getOwnerForChildren() {
+        return containingDeclaration;
+    }
+
+    @Override
+    public void addClassifierDescriptor(@NotNull MutableClassDescriptor classDescriptor) {
+        scope.addClassifierDescriptor(classDescriptor);
+    }
+
+    @Override
+    public void addFunctionDescriptor(@NotNull SimpleFunctionDescriptor functionDescriptor) {
+        scope.addFunctionDescriptor(functionDescriptor);
+    }
+
+    @Override
+    public void addPropertyDescriptor(@NotNull PropertyDescriptor propertyDescriptor) {
+        scope.addPropertyDescriptor(propertyDescriptor);
+    }
+
+    @Override
+    public ClassObjectStatus setClassObjectDescriptor(@NotNull ClassDescriptor classObjectDescriptor) {
+        throw new IllegalStateException("Must be guaranteed not to happen by the parser");
+    }
+}

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

@@ -29,10 +29,7 @@ import org.jetbrains.jet.context.GlobalContextImpl;
 import org.jetbrains.jet.di.InjectorForLazyResolve;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerBasic;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor;
-import org.jetbrains.jet.lang.descriptors.impl.PackageLikeBuilder;
-import org.jetbrains.jet.lang.descriptors.impl.PackageLikeBuilderDummy;
+import org.jetbrains.jet.lang.descriptors.impl.*;
 import org.jetbrains.jet.lang.psi.JetClassOrObject;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;

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

@@ -28,6 +28,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.ReadOnly;
 import org.jetbrains.jet.context.GlobalContextImpl;
 import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo;

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

@@ -17,10 +17,8 @@
 package org.jetbrains.jet.lang.resolve.lazy.descriptors;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
-import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.PackageFragmentDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.lazy.ForceResolveUtil;
@@ -29,10 +27,8 @@ 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.scopes.JetScope;
-import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
 public class LazyPackageDescriptor extends PackageFragmentDescriptorImpl implements LazyEntity {
-    private final ResolveSession resolveSession;
     private final JetScope memberScope;
     private final PackageMemberDeclarationProvider declarationProvider;
 
@@ -43,13 +39,12 @@ public class LazyPackageDescriptor extends PackageFragmentDescriptorImpl impleme
             @NotNull PackageMemberDeclarationProvider declarationProvider
     ) {
         super(module, fqName);
-        this.resolveSession = resolveSession;
         this.declarationProvider = declarationProvider;
 
         this.memberScope = new LazyPackageMemberScope(resolveSession, declarationProvider, this);
 
         for (JetFile file : declarationProvider.getPackageFiles()) {
-            this.resolveSession.getTrace().record(BindingContext.FILE_TO_PACKAGE_FRAGMENT, file, this);
+            resolveSession.getTrace().record(BindingContext.FILE_TO_PACKAGE_FRAGMENT, file, this);
         }
     }
 

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

@@ -51,7 +51,7 @@ import org.jetbrains.jet.config.CommonConfigurationKeys;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.DependencyKind;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.diagnostics.Errors;

compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTest.java

@@ -27,7 +27,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.jet.lang.descriptors.DependencyKind;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.diagnostics.*;
 import org.jetbrains.jet.lang.psi.JetElement;
 import org.jetbrains.jet.lang.psi.JetExpression;

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

@@ -34,7 +34,11 @@ import org.jetbrains.jet.config.CommonConfigurationKeys;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.DependencyKind;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;

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

@@ -25,10 +25,11 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
-import org.jetbrains.jet.di.InjectorForLazyResolve;
 import org.jetbrains.jet.context.ContextPackage;
 import org.jetbrains.jet.context.GlobalContextImpl;
+import org.jetbrains.jet.di.InjectorForLazyResolve;
 import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;

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

@@ -30,7 +30,7 @@ import org.jetbrains.jet.context.GlobalContextImpl;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.DependencyKind;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;

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

@@ -25,6 +25,7 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForTests;
 import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;

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

@@ -28,7 +28,11 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil;
 import org.jetbrains.jet.di.InjectorForTests;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.DependencyKind;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
+import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.ReceiverParameterDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;