Simple (not thread-safe) memoized functions supported

an exception gtom generateToText() used to mask the one from the original run

.idea/runConfigurations/All_Jvm_Backend_Tests.xml

@@ -19,7 +19,7 @@
     <option name="ENV_VARIABLES" />
     <option name="PASS_PARENT_ENVS" value="true" />
     <option name="TEST_SEARCH_SCOPE">
-      <value defaultName="wholeProject" />
+      <value defaultName="moduleWithDependencies" />
     </option>
     <envs />
     <patterns />
@@ -28,6 +28,9 @@
       <option name="TRANSPORT" value="0" />
       <option name="LOCAL" value="true" />
     </RunnerSettings>
+    <RunnerSettings RunnerId="Profile ">
+      <option name="myExternalizedOptions" value="&#10;additional-options2=onexit\=snapshot&#10;" />
+    </RunnerSettings>
     <RunnerSettings RunnerId="Run" />
     <ConfigurationWrapper RunnerId="Debug" />
     <ConfigurationWrapper RunnerId="Run" />

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

@@ -37,7 +37,6 @@ import org.jetbrains.jet.lang.resolve.java.AsmTypeConstants;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lexer.JetTokens;
@@ -263,7 +262,7 @@ public class AsmUtil {
                 return ACC_PROTECTED;
             }
         }
-        if (containingDeclaration instanceof NamespaceDescriptor) {
+        if (DescriptorUtils.isTopLevelDeclaration(memberDescriptor)) {
             return ACC_PUBLIC;
         }
         return null;

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

@@ -25,6 +25,7 @@ import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.state.GenerationStateAware;
 import org.jetbrains.jet.codegen.state.JetTypeMapperMode;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.SubModuleDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
@@ -114,13 +115,25 @@ public final class ClassFileFactory extends GenerationStateAware {
                     );
                 }
             };
-            codegen = new NamespaceCodegen(onDemand, fqName, state, files);
+            codegen = new NamespaceCodegen(onDemand, getSubModule(files), fqName, state, files);
             ns2codegen.put(fqName, codegen);
         }
 
         return codegen;
     }
 
+    private SubModuleDescriptor getSubModule(Collection<JetFile> files) {
+        assert !files.isEmpty() : "Don't generate namespaces from no files";
+        SubModuleDescriptor subModule = state.getModuleSourcesManager().getSubModuleForFile(files.iterator().next());
+        for (JetFile file : files) {
+            SubModuleDescriptor fileSubModule = state.getModuleSourcesManager().getSubModuleForFile(file);
+            assert fileSubModule.equals(subModule)
+                    : "Attempt to generate namespace from files originating from different sub-modules: " +
+                        fileSubModule + " != " + subModule;
+        }
+        return subModule;
+    }
+
     public ClassBuilder forClassImplementation(ClassDescriptor aClass, PsiFile sourceFile) {
         Type type = state.getTypeMapper().mapType(aClass.getDefaultType(), JetTypeMapperMode.IMPL);
         if (isPrimitive(type)) {

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

@@ -60,6 +60,7 @@ public class CompilationException extends RuntimeException {
                     message.append("Cause: ").append(causeMessage == null ? cause.toString() : causeMessage).append("\n");
                 }
                 message.append("File being compiled and position: ").append(DiagnosticUtils.atLocation(element)).append("\n");
+                message.append("PsiElement: ").append(element.getText()).append("\n");
                 message.append("The root cause was thrown at: ").append(where());
 
                 return message.toString();

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

@@ -1571,7 +1571,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         if (descriptor instanceof PropertyDescriptor) {
             PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
 
-            boolean isStatic = container instanceof NamespaceDescriptor;
+            boolean isStatic = DescriptorUtils.isTopLevelDeclaration(descriptor);
             final boolean directToField =
                     expression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER && contextKind() != OwnerKind.TRAIT_IMPL;
             JetExpression r = getReceiverForSelector(expression);
@@ -1715,7 +1715,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         assert containingDeclaration != null;
         containingDeclaration = containingDeclaration.getOriginal();
 
-        boolean isStatic = containingDeclaration instanceof NamespaceDescriptor;
+        boolean isStatic = DescriptorUtils.isTopLevelDeclaration(propertyDescriptor);
         boolean overridesTrait = isOverrideForTrait(propertyDescriptor);
         boolean isFakeOverride = propertyDescriptor.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE;
         PropertyDescriptor initialDescriptor = propertyDescriptor;

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

@@ -557,7 +557,7 @@ public class FunctionCodegen extends GenerationStateAware {
         int flags = ACC_PUBLIC | ACC_SYNTHETIC; // TODO.
 
         JvmClassName ownerInternalName;
-        if (contextClass instanceof NamespaceDescriptor) {
+        if (DescriptorUtils.isTopLevelDeclaration(owner.getContextDescriptor())) {
             ownerInternalName = NamespaceCodegen.getJVMClassNameForKotlinNs(DescriptorUtils.getFQName(contextClass).toSafe());
         }
         else {

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

@@ -38,10 +38,7 @@ import org.jetbrains.jet.codegen.state.JetTypeMapper;
 import org.jetbrains.jet.codegen.state.JetTypeMapperMode;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.BindingContextUtils;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.OverridingUtil;
+import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.java.*;
@@ -192,7 +189,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         boolean isObjectLiteral = descriptor.getName().isSpecial() && descriptor.getKind() == ClassKind.OBJECT;
 
         boolean isLocalOrAnonymousClass = isObjectLiteral ||
-                                          !(parentDescriptor instanceof NamespaceDescriptor || parentDescriptor instanceof ClassDescriptor);
+                                          !(DescriptorUtils.isTopLevelDeclaration(descriptor) || parentDescriptor instanceof ClassDescriptor);
         if (isLocalOrAnonymousClass) {
             String outerClassName = getOuterClassName(descriptor, typeMapper, bindingContext, state);
             FunctionDescriptor function = DescriptorUtils.getParentOfType(descriptor, FunctionDescriptor.class);
@@ -222,13 +219,17 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             return typeMapper.mapType(container.getDefaultType(), JetTypeMapperMode.IMPL).getInternalName();
         }
         else {
-            NamespaceDescriptor namespaceDescriptor = DescriptorUtils.getParentOfType(classDescriptor, NamespaceDescriptor.class);
-            assert namespaceDescriptor != null : "Namespace descriptor should be present: " + classDescriptor.getName();
-            FqName namespaceQN = namespaceDescriptor.getFqName();
-            boolean isMultiFile = CodegenBinding.isMultiFileNamespace(state.getBindingContext(), namespaceQN);
+            PackageFragmentDescriptor packageFragmentDescriptor = DescriptorUtils.getParentOfType(classDescriptor, PackageFragmentDescriptor.class);
+            assert packageFragmentDescriptor != null : "Namespace descriptor should be present: " + classDescriptor.getName();
+            FqName namespaceQN = packageFragmentDescriptor.getFqName();
+
+            JetFile containingFile = BindingContextUtils.getContainingFile(bindingContext, classDescriptor);
+            ModuleSourcesManager sourcesManager = state.getModuleSourcesManager();
+            ModuleDescriptor module = sourcesManager.getSubModuleForFile(containingFile).getContainingDeclaration();
+
+            boolean isMultiFile = CodegenBinding.isMultiFileNamespace(sourcesManager, module, namespaceQN);
             return isMultiFile
-                   ? NamespaceCodegen.getNamespacePartInternalName(
-                                     BindingContextUtils.getContainingFile(bindingContext, classDescriptor))
+                   ? NamespaceCodegen.getNamespacePartInternalName(containingFile)
                    : NamespaceCodegen.getJVMClassNameForKotlinNs(namespaceQN).getInternalName();
         }
     }

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

@@ -29,12 +29,16 @@ import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.binding.CodegenBinding;
 import org.jetbrains.jet.codegen.context.CodegenContext;
 import org.jetbrains.jet.codegen.state.GenerationState;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
+import org.jetbrains.jet.lang.descriptors.SubModuleDescriptor;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.java.*;
+import org.jetbrains.jet.lang.resolve.java.JvmAbi;
+import org.jetbrains.jet.lang.resolve.java.JvmClassName;
+import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
+import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
@@ -47,10 +51,12 @@ public class NamespaceCodegen extends MemberCodegen {
     @NotNull
     private final ClassBuilderOnDemand v;
     @NotNull private final FqName name;
+    private final SubModuleDescriptor subModule;
     private final Collection<JetFile> files;
 
     public NamespaceCodegen(
             @NotNull ClassBuilderOnDemand v,
+            @NotNull SubModuleDescriptor subModule,
             @NotNull final FqName fqName,
             GenerationState state,
             Collection<JetFile> namespaceFiles
@@ -59,6 +65,7 @@ public class NamespaceCodegen extends MemberCodegen {
         checkAllFilesHaveSameNamespace(namespaceFiles);
 
         this.v = v;
+        this.subModule = subModule;
         name = fqName;
         this.files = namespaceFiles;
 
@@ -84,7 +91,7 @@ public class NamespaceCodegen extends MemberCodegen {
     }
 
     public void generate(CompilationErrorHandler errorHandler) {
-        boolean multiFile = CodegenBinding.isMultiFileNamespace(state.getBindingContext(), name);
+        boolean multiFile = CodegenBinding.isMultiFileNamespace(state.getModuleSourcesManager(), subModule.getContainingDeclaration(), name);
 
         if (shouldGenerateNSClass(files)) {
             AnnotationVisitor packageClassAnnotation = v.getClassBuilder().newAnnotation(JvmStdlibNames.JET_PACKAGE_CLASS.getDescriptor(), true);
@@ -118,7 +125,7 @@ public class NamespaceCodegen extends MemberCodegen {
     }
 
     private void generate(JetFile file, boolean multiFile) {
-        NamespaceDescriptor descriptor = state.getBindingContext().get(BindingContext.FILE_TO_NAMESPACE, file);
+        PackageViewDescriptor descriptor = subModule.getPackageView(JetPsiUtil.getFQName(file));
         assert descriptor != null : "No namespace found for file " + file + " declared package: " + file.getPackageName();
         for (JetDeclaration declaration : file.getDeclarations()) {
             if (declaration instanceof JetProperty) {
@@ -185,7 +192,7 @@ public class NamespaceCodegen extends MemberCodegen {
         }
     }
 
-    public void generateClassOrObject(@NotNull NamespaceDescriptor descriptor, @NotNull JetClassOrObject classOrObject) {
+    public void generateClassOrObject(@NotNull PackageViewDescriptor descriptor, @NotNull JetClassOrObject classOrObject) {
         CodegenContext context = CodegenContext.STATIC.intoNamespace(descriptor);
         genClassOrObject(context, classOrObject);
     }

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

@@ -259,9 +259,9 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
             super.visitNamedFunction(function);
             nameStack.pop();
         }
-        else if (containingDeclaration instanceof NamespaceDescriptor) {
+        else if (DescriptorUtils.isTopLevelDeclaration(functionDescriptor)) {
             String peek = peekFromStack(nameStack);
-            FqName qualifiedName = ((NamespaceDescriptor) containingDeclaration).getFqName();
+            FqName qualifiedName = ((PackageFragmentDescriptor) containingDeclaration).getFqName();
             String packageClassName = PackageClassUtils.getPackageClassName(qualifiedName);
             if (peek.isEmpty()) {
                 peek = packageClassName;

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.codegen.binding;
 
+import com.google.common.collect.Lists;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
@@ -26,6 +27,8 @@ import org.jetbrains.jet.lang.descriptors.impl.ClassDescriptorImpl;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.ModuleSourcesManager;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -56,9 +59,9 @@ public class CodegenBinding {
     private CodegenBinding() {
     }
 
-    public static void initTrace(BindingTrace bindingTrace, Collection<JetFile> files) {
+    public static void initTrace(@NotNull ModuleSourcesManager moduleManager, @NotNull BindingTrace bindingTrace, @NotNull Collection<JetFile> files) {
         CodegenAnnotatingVisitor visitor = new CodegenAnnotatingVisitor(bindingTrace);
-        for (JetFile file : allFilesInNamespaces(bindingTrace.getBindingContext(), files)) {
+        for (JetFile file : allFilesInNamespaces(moduleManager, files)) {
             file.accept(visitor);
         }
     }
@@ -215,25 +218,27 @@ public class CodegenBinding {
         registerClassNameForScript(bindingTrace, descriptor, className);
     }
 
-    @NotNull public static Collection<JetFile> allFilesInNamespaces(BindingContext bindingContext, Collection<JetFile> files) {
+    @NotNull
+    public static Collection<JetFile> allFilesInNamespaces(@NotNull ModuleSourcesManager moduleManager, @NotNull Collection<JetFile> files) {
         // todo: we use Set and add given files but ignoring other scripts because something non-clear kept in binding
         // for scripts especially in case of REPL
 
-        final HashSet<FqName> names = new HashSet<FqName>();
-        for (JetFile file : files) {
-            if (!file.isScript()) {
-                names.add(JetPsiUtil.getFQName(file));
-            }
-        }
-
-        final HashSet<JetFile> answer = new HashSet<JetFile>();
+        Set<JetFile> answer = new HashSet<JetFile>();
         answer.addAll(files);
 
-        for (FqName name : names) {
-            final NamespaceDescriptor namespaceDescriptor = bindingContext.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, name);
-            final Collection<JetFile> jetFiles = bindingContext.get(NAMESPACE_TO_FILES, namespaceDescriptor);
-            if (jetFiles != null)
-                answer.addAll(jetFiles);
+        for (JetFile file : files) {
+            if (file.isScript()) continue;
+
+            FqName fqName = JetPsiUtil.getFQName(file);
+            ModuleDescriptor module = moduleManager.getSubModuleForFile(file).getContainingDeclaration();
+            Collection<JetFile> filesByPackage = getPackageFragmentSources(moduleManager, module, fqName);
+
+            assert filesByPackage.contains(file) : "Inconsistent behavior of module manager: " +
+                                                   "file " + file + " does not belong to " +
+                                                   "its package " + fqName + " in " +
+                                                   "its module " + module;
+
+            answer.addAll(filesByPackage);
         }
 
         List<JetFile> sortedAnswer = new ArrayList<JetFile>(answer);
@@ -254,10 +259,27 @@ public class CodegenBinding {
         return sortedAnswer;
     }
 
-    public static boolean isMultiFileNamespace(BindingContext bindingContext, FqName fqName) {
-        final NamespaceDescriptor namespaceDescriptor = bindingContext.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, fqName);
-        final Collection<JetFile> jetFiles = bindingContext.get(NAMESPACE_TO_FILES, namespaceDescriptor);
-        return jetFiles != null && jetFiles.size() > 1;
+    @NotNull
+    private static Collection<JetFile> getPackageFragmentSources(
+            @NotNull ModuleSourcesManager moduleManager,
+            @NotNull ModuleDescriptor module,
+            @NotNull FqName packageFqName
+    ) {
+        Collection<JetFile> result = Lists.newArrayList();
+
+        for (SubModuleDescriptor subModule : module.getSubModules()) {
+            Collection<PackageFragmentDescriptor> fragments = subModule.getPackageFragmentProvider().getPackageFragments(packageFqName);
+
+            for (PackageFragmentDescriptor fragment : fragments) {
+                result.addAll(moduleManager.getPackageFragmentSources(fragment));
+            }
+        }
+
+        return result;
+    }
+
+    public static boolean isMultiFileNamespace(@NotNull ModuleSourcesManager moduleSourcesManager, @NotNull ModuleDescriptor module, @NotNull FqName fqName) {
+        return getPackageFragmentSources(moduleSourcesManager, module, fqName).size() > 1;
     }
 
     public static boolean isObjectLiteral(BindingContext bindingContext, ClassDescriptor declaration) {
@@ -341,17 +363,17 @@ public class CodegenBinding {
             }
         }
 
-        DeclarationDescriptor container = descriptor.getContainingDeclaration();
-
-        if (container == null) {
-            throw new IllegalStateException("descriptor has no container: " + descriptor);
-        }
+        DeclarationDescriptor container = DescriptorUtils.getParentInPackageViewHierarchy(descriptor);
 
         Name name = descriptor.getName();
 
+        if (container instanceof PackageViewDescriptor && DescriptorUtils.isRootNamespace((PackageViewDescriptor) container)) {
+            return name.getIdentifier();
+        }
+
         String baseName = getJvmInternalName(bindingTrace, container).getInternalName();
         if (!baseName.isEmpty()) {
-            return baseName + (container instanceof NamespaceDescriptor ? "/" : "$") + name.getIdentifier();
+            return baseName + (DescriptorUtils.isTopLevelDeclaration(descriptor) ? "/" : "$") + name.getIdentifier();
         }
 
         return name.getIdentifier();

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

@@ -25,10 +25,7 @@ import org.jetbrains.jet.codegen.NamespaceCodegen;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.BindingContextUtils;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
+import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
@@ -207,6 +204,7 @@ public final class PsiCodegenPredictor {
     @Nullable
     public static JetFile getFileForCodegenNamedClass(
             @NotNull BindingContext context,
+            @NotNull ModuleSourcesManager moduleSourcesManager,
             @NotNull List<JetFile> allNamespaceFiles,
             @NotNull final JvmClassName className
     ) {
@@ -224,7 +222,7 @@ public final class PsiCodegenPredictor {
             }
         };
 
-        CodegenBinding.initTrace(trace, allNamespaceFiles);
+        CodegenBinding.initTrace(moduleSourcesManager, trace, allNamespaceFiles);
 
         return resultingDescriptor.isNull() ? null
                : BindingContextUtils.getContainingFile(trace.getBindingContext(), resultingDescriptor.get());

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

@@ -90,7 +90,7 @@ public abstract class CodegenContext {
         while (true) {
             assert c != null;
             DeclarationDescriptor contextDescriptor = c.getContextDescriptor();
-            if (!(contextDescriptor instanceof ClassDescriptor) && !(contextDescriptor instanceof NamespaceDescriptor)) {
+            if (!(contextDescriptor instanceof ClassDescriptor) && !(contextDescriptor instanceof PackageViewDescriptor)) {
                 c = c.getParentContext();
             }
             else {
@@ -135,11 +135,11 @@ public abstract class CodegenContext {
         return contextKind;
     }
 
-    public CodegenContext intoNamespace(@NotNull NamespaceDescriptor descriptor) {
+    public CodegenContext intoNamespace(@NotNull PackageViewDescriptor descriptor) {
         return new NamespaceContext(descriptor, this, OwnerKind.NAMESPACE);
     }
 
-    public CodegenContext intoNamespacePart(String delegateTo, NamespaceDescriptor descriptor) {
+    public CodegenContext intoNamespacePart(String delegateTo, PackageViewDescriptor descriptor) {
         return new NamespaceContext(descriptor, this, new OwnerKind.StaticDelegateKind(delegateTo));
     }
 

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

@@ -18,10 +18,10 @@ package org.jetbrains.jet.codegen.context;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.codegen.OwnerKind;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 
 public class NamespaceContext extends CodegenContext {
-    public NamespaceContext(@NotNull NamespaceDescriptor contextDescriptor, CodegenContext parent, @NotNull OwnerKind kind) {
+    public NamespaceContext(@NotNull PackageViewDescriptor contextDescriptor, CodegenContext parent, @NotNull OwnerKind kind) {
         super(contextDescriptor, kind, parent, null, null, null);
     }
 

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

@@ -23,9 +23,7 @@ import org.jetbrains.jet.codegen.binding.CodegenBinding;
 import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethods;
 import org.jetbrains.jet.di.InjectorForJvmCodegen;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
+import org.jetbrains.jet.lang.resolve.*;
 
 import java.util.List;
 
@@ -38,6 +36,9 @@ public class GenerationState {
     @NotNull
     private final List<JetFile> files;
 
+    @NotNull
+    private final ModuleSourcesManager moduleSourcesManager;
+
     @NotNull
     private final ClassBuilderMode classBuilderMode;
 
@@ -69,7 +70,8 @@ public class GenerationState {
     private final boolean generateDeclaredClasses;
 
     public GenerationState(Project project, ClassBuilderFactory builderFactory, BindingContext bindingContext, List<JetFile> files) {
-        this(project, builderFactory, Progress.DEAF, bindingContext, files, BuiltinToJavaTypesMapping.ENABLED, true, false, true);
+        this(project, builderFactory, Progress.DEAF, bindingContext,
+             files, BuiltinToJavaTypesMapping.ENABLED, true, false, true);
     }
 
     public GenerationState(
@@ -84,6 +86,7 @@ public class GenerationState {
             boolean generateDeclaredClasses
     ) {
         this.project = project;
+        this.moduleSourcesManager = KotlinModuleManager.SERVICE.getModuleSourcesManager(project);
         this.progress = progress;
         this.files = files;
         this.classBuilderMode = builderFactory.getClassBuilderMode();
@@ -93,9 +96,7 @@ public class GenerationState {
 
         this.typeMapper = new JetTypeMapper(bindingTrace, builtinToJavaTypesMapping == BuiltinToJavaTypesMapping.ENABLED, classBuilderMode);
 
-        InjectorForJvmCodegen injector = new InjectorForJvmCodegen(
-                typeMapper, this.files,
-                builtinToJavaTypesMapping, this, builderFactory, project);
+        InjectorForJvmCodegen injector = new InjectorForJvmCodegen(typeMapper, this, builderFactory, project);
 
         this.scriptCodegen = injector.getScriptCodegen();
         this.intrinsics = injector.getIntrinsics();
@@ -131,6 +132,11 @@ public class GenerationState {
         return files;
     }
 
+    @NotNull
+    public ModuleSourcesManager getModuleSourcesManager() {
+        return moduleSourcesManager;
+    }
+
     @NotNull
     public ScriptCodegen getScriptCodegen() {
         return scriptCodegen;
@@ -172,7 +178,7 @@ public class GenerationState {
         markUsed();
 
         //noinspection unchecked
-        CodegenBinding.initTrace(getBindingTrace(), getFiles());
+        CodegenBinding.initTrace(moduleSourcesManager, getBindingTrace(), getFiles());
     }
 
     private void markUsed() {

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

@@ -16,6 +16,8 @@
 
 package org.jetbrains.jet.codegen.state;
 
+import com.google.common.collect.Lists;
+import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -34,6 +36,7 @@ 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.java.*;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -65,8 +68,8 @@ public class JetTypeMapper extends BindingTraceAware {
         JetTypeMapperMode mapTypeMode = ownerKindToMapTypeMode(kind);
 
         DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration();
-        if (containingDeclaration instanceof NamespaceDescriptor) {
-            return jvmClassNameForNamespace((NamespaceDescriptor) containingDeclaration);
+        if (DescriptorUtils.isTopLevelDeclaration(descriptor)) {
+            return jvmClassNameForNamespace((PackageFragmentDescriptor) containingDeclaration);
         }
         else if (containingDeclaration instanceof ClassDescriptor) {
             ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration;
@@ -100,59 +103,39 @@ 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);
+    private JvmClassName jvmClassNameForNamespace(@NotNull PackageFragmentDescriptor packageFragment) {
 
-        if (javaNamespaceKind == null && src == null) {
-            throw new IllegalStateException("unknown namespace origin: " + ns);
+        PsiClass psiClass = bindingContext.get(JavaBindingContext.JAVA_STATIC_CLASS_FOR_PACKAGE, packageFragment);
+        if (psiClass == null) {
+            // It's a normal package
+            FqName packageClassFqName = PackageClassUtils.getPackageClassFqName(packageFragment.getFqName());
+            return JvmClassName.byFqNameWithoutInnerClasses(packageClassFqName);
         }
 
-        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;
-        }
+        return getJvmClassNameByPsiClass(psiClass);
     }
 
     @NotNull
-    private JvmClassName jvmClassNameForNamespace(@NotNull NamespaceDescriptor namespace) {
-
-        StringBuilder r = new StringBuilder();
-
-        List<DeclarationDescriptor> path = DescriptorUtils.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());
+    private static JvmClassName getJvmClassNameByPsiClass(@NotNull PsiClass psiClass) {
+        PsiClass outermost = psiClass;
+        List<String> innerClassNames = Lists.newArrayList();
+        while (outermost.getContainingClass() != null) {
+            innerClassNames.add(outermost.getName());
+            outermost = outermost.getContainingClass();
         }
 
-        if (getNsKind(namespace) == JavaNamespaceKind.PROPER) {
-            if (r.length() > 0) {
-                r.append("/");
-            }
-            r.append(PackageClassUtils.getPackageClassName(namespace.getFqName()));
+
+        String qualifiedName = outermost.getQualifiedName();
+        assert qualifiedName != null : "A local class shouldn't have made it to here: " +
+                                       "no static methods are allowed in anonymous classes: " + psiClass;
+        StringBuilder result = new StringBuilder(qualifiedName.replace('.', '/'));
+
+        Collections.reverse(innerClassNames);
+        for (String name : innerClassNames) {
+            result.append("$").append(name);
         }
 
-        if (r.length() == 0) {
-            throw new IllegalStateException("internal error: failed to generate classname for " + namespace);
-        }
-
-        return JvmClassName.byInternalName(r.toString());
+        return JvmClassName.byInternalName(result.toString());
     }
 
     @NotNull
@@ -448,9 +431,9 @@ public class JetTypeMapper extends BindingTraceAware {
         JvmClassName ownerForDefaultParam;
         int invokeOpcode;
         JvmClassName thisClass;
-        if (functionParent instanceof NamespaceDescriptor) {
+        if (DescriptorUtils.isTopLevelDeclaration(functionDescriptor.getOriginal())) {
             assert !superCall;
-            owner = jvmClassNameForNamespace((NamespaceDescriptor) functionParent);
+            owner = jvmClassNameForNamespace((PackageFragmentDescriptor) functionParent);
             ownerForDefaultImpl = ownerForDefaultParam = owner;
             invokeOpcode = INVOKESTATIC;
             thisClass = null;
@@ -516,7 +499,7 @@ public class JetTypeMapper extends BindingTraceAware {
             thisClass = JvmClassName.byType(mapType(receiver.getDefaultType()));
         }
         else {
-            throw new UnsupportedOperationException("unknown function parent");
+            throw new UnsupportedOperationException("unknown function parent: " + functionParent);
         }
 
 

compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java

@@ -17,9 +17,6 @@
 package org.jetbrains.jet.di;
 
 import org.jetbrains.jet.codegen.state.JetTypeMapper;
-import java.util.List;
-import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.codegen.BuiltinToJavaTypesMapping;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.ClassBuilderFactory;
 import com.intellij.openapi.project.Project;
@@ -36,8 +33,6 @@ import javax.annotation.PreDestroy;
 public class InjectorForJvmCodegen {
     
     private final JetTypeMapper jetTypeMapper;
-    private final List<JetFile> listOfJetFile;
-    private final BuiltinToJavaTypesMapping builtinToJavaTypesMapping;
     private final GenerationState generationState;
     private final ClassBuilderFactory classBuilderFactory;
     private final Project project;
@@ -50,15 +45,11 @@ public class InjectorForJvmCodegen {
     
     public InjectorForJvmCodegen(
         @NotNull JetTypeMapper jetTypeMapper,
-        @NotNull List<JetFile> listOfJetFile,
-        @NotNull BuiltinToJavaTypesMapping builtinToJavaTypesMapping,
         @NotNull GenerationState generationState,
         @NotNull ClassBuilderFactory classBuilderFactory,
         @NotNull Project project
     ) {
         this.jetTypeMapper = jetTypeMapper;
-        this.listOfJetFile = listOfJetFile;
-        this.builtinToJavaTypesMapping = builtinToJavaTypesMapping;
         this.generationState = generationState;
         this.classBuilderFactory = classBuilderFactory;
         this.project = project;

compiler/cli/src/org/jetbrains/jet/cli/common/messages/AnalyzerWithCompilerReport.java

@@ -145,13 +145,16 @@ public final class AnalyzerWithCompilerReport {
         assert analyzeExhaust != null;
         BindingContext bindingContext = analyzeExhaust.getBindingContext();
 
-        Collection<PsiClass> psiClasses = bindingContext.getKeys(AbiVersionUtil.ABI_VERSION_ERRORS);
-        for (PsiClass psiClass : psiClasses) {
-            Integer abiVersion = bindingContext.get(AbiVersionUtil.ABI_VERSION_ERRORS, psiClass);
-            messageCollectorWrapper.report(CompilerMessageSeverity.ERROR,
-                                           "Class '" + psiClass.getQualifiedName() + "' was compiled with an incompatible version of Kotlin. " +
-                                           "Its ABI version is " + abiVersion + ", expected ABI version is " + JvmAbi.VERSION,
-                                           MessageUtil.psiElementToMessageLocation(psiClass));
+        for (Diagnostic diagnostic : bindingContext.getDiagnostics()) {
+            if (diagnostic.getFactory() == AbiVersionUtil.INCOMPATIBLE_ABI_VERSION) {
+                //noinspection unchecked
+                DiagnosticWithParameters1<PsiClass, Integer> abiVersionDiagnostic = (DiagnosticWithParameters1<PsiClass, Integer>) diagnostic;
+                PsiClass psiClass = abiVersionDiagnostic.getPsiElement();
+                messageCollectorWrapper.report(CompilerMessageSeverity.ERROR,
+                                               "Class '" + psiClass.getQualifiedName() + "' was compiled with an incompatible version of Kotlin. " +
+                                               "Its ABI version is " + abiVersionDiagnostic.getA() + ", expected ABI version is " + JvmAbi.VERSION,
+                                               MessageUtil.psiElementToMessageLocation(psiClass));
+            }
         }
     }
 

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

@@ -0,0 +1,94 @@
+/*
+ * 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.cli.jvm.compiler;
+
+import com.google.common.collect.*;
+import com.intellij.openapi.components.ServiceManager;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.NotNullLazyValue;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.impl.PackageIndex;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.psi.JetPsiUtil;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+
+import java.util.*;
+
+public class CliIndexManager {
+
+    public static CliIndexManager getInstance(@NotNull Project project) {
+        return ServiceManager.getService(project, CliIndexManager.class);
+    }
+
+    private final NotNullLazyValue<Index> index;
+
+    public CliIndexManager(@NotNull final JetCoreEnvironment jetCoreEnvironment) {
+        this.index = new NotNullLazyValue<Index>() {
+            @NotNull
+            @Override
+            protected Index compute() {
+                return Index.compute(jetCoreEnvironment);
+            }
+        };        
+    }
+
+    @NotNull
+    public Collection<JetFile> getPackageSources(@NotNull FqName packageFqName) {
+        Collection<JetFile> files = index.getValue().packageToSources.get(packageFqName);
+        if (files == null) {
+            return Collections.emptyList();
+        }
+        return files;
+    }
+
+    public boolean packageExists(@NotNull FqName packageFqName) {
+        return index.getValue().packageIndex.getAllPackages().contains(packageFqName);
+    }
+
+    @NotNull
+    public Collection<FqName> getSubpackagesOf(@NotNull FqName parent) {
+        return index.getValue().packageIndex.getSubPackagesOf(parent);
+    }
+
+    private static class Index {
+
+        @NotNull
+        public static Index compute(@NotNull JetCoreEnvironment jetCoreEnvironment) {
+            List<JetFile> files = jetCoreEnvironment.getSourceFiles();
+            Multimap<FqName, JetFile> packageToSources = HashMultimap.create();
+            PackageIndex.Builder packageIndex = new PackageIndex.Builder();
+            for (JetFile jetFile : files) {
+                FqName fqName = JetPsiUtil.getFQName(jetFile);
+                packageToSources.put(fqName, jetFile);
+                packageIndex.addPackage(fqName);
+            }
+            return new Index(packageToSources.asMap(), packageIndex.build());
+        }
+
+        private final Map<FqName, Collection<JetFile>> packageToSources;
+        private final PackageIndex packageIndex;
+
+        private Index(
+                @NotNull Map<FqName, Collection<JetFile>> packageToSources,
+                @NotNull PackageIndex packageIndex
+        ) {
+            this.packageToSources = packageToSources;
+            this.packageIndex = packageIndex;
+        }
+
+    }
+}

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

@@ -30,12 +30,15 @@ import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.asJava.LightClassConstructionContext;
 import org.jetbrains.jet.asJava.LightClassGenerationSupport;
+import org.jetbrains.jet.asJava.TraceBasedLightClassResolver;
 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.psi.*;
-import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.BindingContextUtils;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
+import org.jetbrains.jet.lang.resolve.java.KotlinLightClassResolver;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import java.util.Collection;
@@ -61,8 +64,10 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport
     }
 
     private BindingTrace trace;
+    private final CliIndexManager cliIndexManager;
 
-    public CliLightClassGenerationSupport() {
+    public CliLightClassGenerationSupport(@NotNull Project project) {
+        this.cliIndexManager = CliIndexManager.getInstance(project);
     }
 
     @NotNull
@@ -119,19 +124,13 @@ 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);
-                    }
-                });
-            }
-        }
-        return Collections.emptyList();
+        return Collections2.filter(cliIndexManager.getPackageSources(fqName),
+                                   new Predicate<JetFile>() {
+                                       @Override
+                                       public boolean apply(JetFile file) {
+                                           return PsiSearchScopeUtil.isInScope(searchScope, file);
+                                       }
+                                   });
     }
 
     @NotNull
@@ -152,27 +151,18 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport
     }
 
     @Override
-    public boolean packageExists(
-            @NotNull FqName fqName, @NotNull GlobalSearchScope scope
-    ) {
-        return getTrace().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, fqName) != null;
+    public boolean packageExists(@NotNull FqName fqName, @NotNull GlobalSearchScope scope) {
+        return cliIndexManager.packageExists(fqName);
     }
 
     @NotNull
     @Override
     public Collection<FqName> getSubPackages(@NotNull FqName fqn, @NotNull GlobalSearchScope scope) {
-        NamespaceDescriptor namespaceDescriptor = getTrace().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, fqn);
-        if (namespaceDescriptor == null) return Collections.emptyList();
+        return cliIndexManager.getSubpackagesOf(fqn);
+    }
 
-        Collection<DeclarationDescriptor> allDescriptors = namespaceDescriptor.getMemberScope().getAllDescriptors();
-        return ContainerUtil.mapNotNull(allDescriptors, new Function<DeclarationDescriptor, FqName>() {
-            @Override
-            public FqName fun(DeclarationDescriptor input) {
-                if (input instanceof NamespaceDescriptor) {
-                    return DescriptorUtils.getFQName(input).toSafe();
-                }
-                return null;
-            }
-        });
+    @NotNull
+    public KotlinLightClassResolver getLightClassResolver() {
+        return new TraceBasedLightClassResolver(getTrace().getBindingContext());
     }
 }

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

@@ -30,6 +30,7 @@ import com.intellij.openapi.extensions.Extensions;
 import com.intellij.openapi.fileTypes.PlainTextFileType;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.local.CoreLocalFileSystem;
 import com.intellij.psi.PsiElementFinder;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiManager;
@@ -47,9 +48,14 @@ import org.jetbrains.jet.cli.common.messages.MessageCollector;
 import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.jet.config.CommonConfigurationKeys;
 import org.jetbrains.jet.config.CompilerConfiguration;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.parsing.JetParserDefinition;
 import org.jetbrains.jet.lang.parsing.JetScriptDefinitionProvider;
 import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.KotlinModuleManager;
+import org.jetbrains.jet.lang.resolve.java.JavaToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.java.JetFilesProvider;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.plugin.JetFileType;
@@ -57,6 +63,7 @@ import org.jetbrains.jet.utils.PathUtil;
 
 import java.io.File;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
 import static org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity.ERROR;
@@ -97,8 +104,12 @@ public class JetCoreEnvironment {
         project.registerService(JetScriptDefinitionProvider.class, new JetScriptDefinitionProvider());
         project.registerService(JetFilesProvider.class, new CliJetFilesProvider(this));
         project.registerService(CoreJavaFileManager.class, (CoreJavaFileManager) ServiceManager.getService(project, JavaFileManager.class));
+        project.registerService(CliIndexManager.class, new CliIndexManager(this));
 
-        CliLightClassGenerationSupport cliLightClassGenerationSupport = new CliLightClassGenerationSupport();
+        SimpleKotlinModuleManager moduleManager = new SimpleKotlinModuleManager(this, "cli", createLazyJavaClassMap());
+        project.registerService(KotlinModuleManager.class, moduleManager);
+
+        CliLightClassGenerationSupport cliLightClassGenerationSupport = new CliLightClassGenerationSupport(project);
         project.registerService(LightClassGenerationSupport.class, cliLightClassGenerationSupport);
         project.registerService(CliLightClassGenerationSupport.class, cliLightClassGenerationSupport);
 
@@ -128,6 +139,22 @@ public class JetCoreEnvironment {
         KotlinBuiltIns.initialize(project);
     }
 
+    private static PlatformToKotlinClassMap createLazyJavaClassMap() {
+        return new PlatformToKotlinClassMap() {
+            @NotNull
+            @Override
+            public Collection<ClassDescriptor> mapPlatformClass(@NotNull ClassDescriptor classDescriptor) {
+                return JavaToKotlinClassMap.getInstance().mapPlatformClass(classDescriptor);
+            }
+
+            @NotNull
+            @Override
+            public Collection<ClassDescriptor> mapPlatformClassesInside(@NotNull DeclarationDescriptor containingDeclaration) {
+                return JavaToKotlinClassMap.getInstance().mapPlatformClassesInside(containingDeclaration);
+            }
+        };
+    }
+
     public CompilerConfiguration getConfiguration() {
         return configuration;
     }
@@ -160,7 +187,7 @@ public class JetCoreEnvironment {
             }
         }
         else {
-            VirtualFile fileByPath = applicationEnvironment.getLocalFileSystem().findFileByPath(file.getAbsolutePath());
+            VirtualFile fileByPath = getVirtualFileSystem().findFileByPath(file.getAbsolutePath());
             if (fileByPath != null) {
                 PsiFile psiFile = PsiManager.getInstance(getProject()).findFile(fileByPath);
                 if (psiFile instanceof JetFile) {
@@ -175,7 +202,7 @@ public class JetCoreEnvironment {
             return;
         }
 
-        VirtualFile vFile = applicationEnvironment.getLocalFileSystem().findFileByPath(path);
+        VirtualFile vFile = getVirtualFileSystem().findFileByPath(path);
         if (vFile == null) {
             report(ERROR, "Source file or directory not found: " + path);
             return;
@@ -198,7 +225,7 @@ public class JetCoreEnvironment {
             projectEnvironment.addJarToClassPath(path);
         }
         else {
-            final VirtualFile root = applicationEnvironment.getLocalFileSystem().findFileByPath(path.getAbsolutePath());
+            final VirtualFile root = getVirtualFileSystem().findFileByPath(path.getAbsolutePath());
             if (root == null) {
                 report(WARNING, "Classpath entry points to a non-existent location: " + path);
                 return;
@@ -211,6 +238,11 @@ public class JetCoreEnvironment {
         return sourceFiles;
     }
 
+    @NotNull
+    public CoreLocalFileSystem getVirtualFileSystem() {
+        return applicationEnvironment.getLocalFileSystem();
+    }
+
     private void report(@NotNull CompilerMessageSeverity severity, @NotNull String message) {
         MessageCollector messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY);
         if (messageCollector != null) {

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

@@ -0,0 +1,145 @@
+/*
+ * 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.cli.jvm.compiler;
+
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.NotNullLazyValue;
+import com.intellij.psi.search.GlobalSearchScope;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.asJava.TraceBasedLightClassResolver;
+import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
+import org.jetbrains.jet.lang.DefaultModuleConfiguration;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentKind;
+import org.jetbrains.jet.lang.descriptors.SubModuleDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.MutableModuleDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.MutableSubModuleDescriptor;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
+import org.jetbrains.jet.lang.resolve.java.JavaClassResolutionFacadeImpl;
+import org.jetbrains.jet.lang.resolve.java.JavaPackageFragmentProvider;
+import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager;
+import org.jetbrains.jet.lang.resolve.lazy.storage.StorageManager;
+import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * KotlinModuleManager that assumes that all the sources belong to the same submodule
+ */
+public class SimpleKotlinModuleManager implements KotlinModuleManager {
+
+    private final NotNullLazyValue<Modules> modules;
+
+    public SimpleKotlinModuleManager(
+            @NotNull final JetCoreEnvironment jetCoreEnvironment,
+            @NotNull final String baseName,
+            @NotNull final PlatformToKotlinClassMap classMap
+    ) {
+        this.modules = new NotNullLazyValue<Modules>() {
+            @NotNull
+            @Override
+            protected Modules compute() {
+                return createModules(jetCoreEnvironment, baseName, classMap);
+            }
+        };
+    }
+
+    public static Modules createModules(
+            @NotNull JetCoreEnvironment jetCoreEnvironment,
+            @NotNull String baseName,
+            @NotNull PlatformToKotlinClassMap classMap
+    ) {
+        Project project = jetCoreEnvironment.getProject();
+        MutableModuleSourcesManager sourcesManager = createModuleSourcesManager(project);
+        MutableModuleDescriptor module = new MutableModuleDescriptor(Name.special("<" + baseName + " module>"), classMap);
+        MutableSubModuleDescriptor subModule = new MutableSubModuleDescriptor(module, Name.special("<" + baseName + " sub-module>"));
+        module.addSubModule(subModule);
+        subModule.addDependency(KotlinBuiltIns.getInstance().getBuiltInsSubModule());
+        subModule.addDependency(SubModuleDescriptor.MY_SOURCE);
+
+        for (JetFile file : jetCoreEnvironment.getSourceFiles()) {
+            sourcesManager.registerRoot(subModule, PackageFragmentKind.SOURCE, file.getVirtualFile());
+        }
+
+        addDefaultImports(subModule, JavaBridgeConfiguration.DEFAULT_JAVA_IMPORTS);
+        addDefaultImports(subModule, DefaultModuleConfiguration.DEFAULT_JET_IMPORTS);
+
+        BindingTrace trace = CliLightClassGenerationSupport.getInstanceForCli(project).getTrace();
+
+        StorageManager storageManager = new LockBasedStorageManager();
+        JavaClassResolutionFacadeImpl classResolutionFacade = new JavaClassResolutionFacadeImpl(
+                new TraceBasedLightClassResolver(trace.getBindingContext()));
+        InjectorForJavaDescriptorResolver drInjector = new InjectorForJavaDescriptorResolver(
+                project, trace, classResolutionFacade, storageManager, subModule, GlobalSearchScope.allScope(project)
+        );
+
+        JavaPackageFragmentProvider javaPackageFragmentProvider = drInjector.getJavaPackageFragmentProvider();
+
+        subModule.addPackageFragmentProvider(javaPackageFragmentProvider);
+        classResolutionFacade.addPackageFragmentProvider(javaPackageFragmentProvider);
+
+        return new Modules(module, sourcesManager, drInjector);
+    }
+
+    private static MutableModuleSourcesManager createModuleSourcesManager(@NotNull Project project) {
+        return ApplicationManager.getApplication().isUnitTestMode()
+                    ? new MutableModuleSourcesManagerForTests(project)
+                    : new MutableModuleSourcesManager(project);
+    }
+
+    private static void addDefaultImports(MutableSubModuleDescriptor subModule, List<ImportPath> imports) {
+        for (ImportPath path : imports) {
+            subModule.addDefaultImport(path);
+        }
+    }
+
+    @NotNull
+    @Override
+    public Collection<ModuleDescriptor> getModules() {
+        return Collections.singletonList(modules.getValue().module);
+    }
+
+    @NotNull
+    @Override
+    public ModuleSourcesManager getSourcesManager() {
+        return modules.getValue().moduleSourcesManager;
+    }
+
+    @NotNull
+    public InjectorForJavaDescriptorResolver getInjectorForJavaDescriptorResolver() {
+        return modules.getValue().drInjector;
+    }
+
+    private static class Modules {
+        private final ModuleDescriptor module;
+        private final ModuleSourcesManager moduleSourcesManager;
+        private final InjectorForJavaDescriptorResolver drInjector;
+
+        private Modules(ModuleDescriptor module, ModuleSourcesManager moduleSourcesManager, InjectorForJavaDescriptorResolver drInjector) {
+            this.module = module;
+            this.moduleSourcesManager = moduleSourcesManager;
+            this.drInjector = drInjector;
+        }
+    }
+}

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

@@ -40,15 +40,14 @@ import org.jetbrains.jet.codegen.CompilationErrorHandler;
 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.ModuleDescriptor;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceLikeBuilderDummy;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
+import org.jetbrains.jet.lang.descriptors.SubModuleDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.NamespaceLikeBuilderDummy;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.*;
 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 org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
@@ -82,19 +81,20 @@ public class ReplInterpreter {
     @NotNull
     private final BindingTraceContext trace;
     @NotNull
-    private final ModuleDescriptor module;
+    private final ModuleSourcesManager moduleSourcesManager;
 
     public ReplInterpreter(@NotNull Disposable disposable, @NotNull CompilerConfiguration configuration) {
         jetCoreEnvironment = new JetCoreEnvironment(disposable, configuration);
         Project project = jetCoreEnvironment.getProject();
         trace = new BindingTraceContext();
-        module = new ModuleDescriptor(Name.special("<repl>"));
+        KotlinModuleManager moduleManager = KotlinModuleManager.SERVICE.getService(project);
+        moduleSourcesManager = moduleManager.getSourcesManager();
         TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
                 Predicates.<PsiFile>alwaysTrue(),
                 false,
                 true,
                 Collections.<AnalyzerScriptParameter>emptyList());
-        injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module);
+        injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, moduleSourcesManager);
 
         List<URL> classpath = Lists.newArrayList();
 
@@ -224,7 +224,7 @@ public class ReplInterpreter {
             earierScripts.add(Pair.create(earlierLine.getScriptDescriptor(), earlierLine.getClassName()));
         }
 
-        BindingContext bindingContext = AnalyzeExhaust.success(trace.getBindingContext(), injector.getModuleConfiguration()).getBindingContext();
+        BindingContext bindingContext = AnalyzeExhaust.success(trace.getBindingContext(), moduleSourcesManager).getBindingContext();
         GenerationState generationState = new GenerationState(psiFile.getProject(), ClassBuilderFactories.binaries(false),
                                                               bindingContext, Collections.singletonList(psiFile));
         generationState.getScriptCodegen().compileScript(psiFile.getScript(), scriptClassName, earierScripts,
@@ -269,21 +269,22 @@ public class ReplInterpreter {
 
     @Nullable
     private ScriptDescriptor doAnalyze(@NotNull JetFile psiFile, @NotNull MessageCollector messageCollector) {
+        SubModuleDescriptor subModule = moduleSourcesManager.getSubModuleForFile(psiFile);
         final WritableScope scope = new WritableScopeImpl(
-                JetScope.EMPTY, module,
+                JetScope.EMPTY, subModule,
                 new TraceBasedRedeclarationHandler(trace), "Root scope in analyzeNamespace");
 
         scope.changeLockLevel(WritableScope.LockLevel.BOTH);
 
-        NamespaceDescriptorImpl rootNs = injector.getNamespaceFactory().createNamespaceDescriptorPathIfNeeded(FqName.ROOT);
+        PackageViewDescriptor rootPackage = DescriptorUtils.getRootPackage(subModule);
 
         // map "jet" namespace into KotlinBuiltIns
         // @see DefaultModuleConfiguraiton#extendNamespaceScope
-        injector.getNamespaceFactory().createNamespaceDescriptorPathIfNeeded(KotlinBuiltIns.getInstance().getBuiltInsPackageFqName());
+        //TODO injector.getNamespaceFactory().createNamespaceDescriptorPathIfNeeded(KotlinBuiltIns.getInstance().getBuiltInsPackageFqName());
 
         // 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(rootPackage.getMemberScope());
 
         if (lastLineScope != null) {
             scope.importScope(lastLineScope);

compiler/frontend.java/src/org/jetbrains/jet/asJava/KotlinLightClass.java

@@ -0,0 +1,38 @@
+/*
+ * 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.asJava;
+
+import com.intellij.psi.PsiClass;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.psi.JetClassOrObject;
+import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+
+public interface KotlinLightClass extends PsiClass, JetJavaMirrorMarker {
+    @NotNull
+    FqName getFqName();
+
+    @NotNull
+    PsiClass getDelegate();
+
+    /**
+     * @return {@code null} for package classes
+     */
+    @Nullable
+    JetClassOrObject getSourceElement();
+}

compiler/frontend.java/src/org/jetbrains/jet/asJava/TraceBasedLightClassResolver.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.asJava;
+
+import com.intellij.psi.PsiClass;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.psi.JetClassOrObject;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.java.KotlinLightClassResolver;
+
+public class TraceBasedLightClassResolver implements KotlinLightClassResolver {
+    private final BindingContext bindingContext;
+
+    public TraceBasedLightClassResolver(@NotNull BindingContext bindingContext) {
+        this.bindingContext = bindingContext;
+    }
+
+    @Nullable
+    @Override
+    public ClassDescriptor resolveLightClass(@NotNull PsiClass kotlinLightClass) {
+        assert kotlinLightClass instanceof KotlinLightClass
+                : "Wrong light class: " + kotlinLightClass + " " + kotlinLightClass.getClass();
+        JetClassOrObject sourceElement = ((KotlinLightClass) kotlinLightClass).getSourceElement();
+        if (sourceElement == null) {
+            return null; // package class, invisible from Kotlin
+        }
+        ClassDescriptor classDescriptor = bindingContext.get(BindingContext.CLASS, sourceElement);
+        assert classDescriptor != null : "No class descriptor found for" +
+                                         "\nlight class " + kotlinLightClass.getQualifiedName() +
+                                         "\nkotlin psi element " + sourceElement +
+                                         "\nfile:" + sourceElement.getContainingFile() +
+                                         "\n" + sourceElement.getContainingFile().getText();
+        return classDescriptor;
+    }
+}

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

@@ -18,25 +18,28 @@ package org.jetbrains.jet.di;
 
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
+import org.jetbrains.jet.lang.resolve.java.JavaClassResolutionFacade;
+import org.jetbrains.jet.lang.resolve.lazy.storage.StorageManager;
+import org.jetbrains.jet.lang.descriptors.SubModuleDescriptor;
+import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.resolve.java.JavaDependencyByQualifiedNameResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl;
-import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory;
-import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver;
+import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl;
+import org.jetbrains.jet.lang.resolve.java.JavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
+import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver;
+import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -45,107 +48,87 @@ public class InjectorForJavaDescriptorResolver {
     
     private final Project project;
     private final BindingTrace bindingTrace;
-    private final ModuleDescriptor moduleDescriptor;
+    private final JavaClassResolutionFacade javaClassResolutionFacade;
+    private final StorageManager storageManager;
+    private final SubModuleDescriptor subModuleDescriptor;
+    private final GlobalSearchScope globalSearchScope;
     private JavaBridgeConfiguration javaBridgeConfiguration;
-    private JavaSemanticServices javaSemanticServices;
+    private JavaDependencyByQualifiedNameResolver javaDependencyByQualifiedNameResolver;
     private JavaDescriptorResolver javaDescriptorResolver;
-    private PsiClassFinderImpl psiClassFinder;
-    private PsiDeclarationProviderFactory psiDeclarationProviderFactory;
-    private JavaTypeTransformer javaTypeTransformer;
     private JavaClassResolver javaClassResolver;
-    private JavaAnnotationResolver javaAnnotationResolver;
-    private JavaCompileTimeConstResolver javaCompileTimeConstResolver;
-    private JavaClassObjectResolver javaClassObjectResolver;
-    private JavaSupertypeResolver javaSupertypeResolver;
-    private JavaNamespaceResolver javaNamespaceResolver;
-    private JavaSignatureResolver javaSignatureResolver;
+    private PsiClassFinderImpl psiClassFinder;
+    private JavaPackageFragmentProvider javaPackageFragmentProvider;
     private JavaConstructorResolver javaConstructorResolver;
+    private JavaTypeTransformer javaTypeTransformer;
     private JavaValueParameterResolver javaValueParameterResolver;
     private JavaFunctionResolver javaFunctionResolver;
+    private JavaAnnotationResolver javaAnnotationResolver;
+    private JavaCompileTimeConstResolver javaCompileTimeConstResolver;
+    private JavaSignatureResolver javaSignatureResolver;
     private JavaInnerClassResolver javaInnerClassResolver;
     private JavaPropertyResolver javaPropertyResolver;
+    private JavaClassObjectResolver javaClassObjectResolver;
+    private PsiDeclarationProviderFactory psiDeclarationProviderFactory;
+    private JavaSupertypeResolver javaSupertypeResolver;
     
     public InjectorForJavaDescriptorResolver(
         @NotNull Project project,
         @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptor moduleDescriptor
+        @NotNull JavaClassResolutionFacade javaClassResolutionFacade,
+        @NotNull StorageManager storageManager,
+        @NotNull SubModuleDescriptor subModuleDescriptor,
+        @NotNull GlobalSearchScope globalSearchScope
     ) {
         this.project = project;
         this.bindingTrace = bindingTrace;
-        this.moduleDescriptor = moduleDescriptor;
+        this.javaClassResolutionFacade = javaClassResolutionFacade;
+        this.storageManager = storageManager;
+        this.subModuleDescriptor = subModuleDescriptor;
+        this.globalSearchScope = globalSearchScope;
         this.javaBridgeConfiguration = new JavaBridgeConfiguration();
-        this.javaSemanticServices = new JavaSemanticServices();
+        this.javaDependencyByQualifiedNameResolver = new JavaDependencyByQualifiedNameResolver(subModuleDescriptor);
         this.javaDescriptorResolver = new JavaDescriptorResolver();
-        this.psiClassFinder = new PsiClassFinderImpl();
-        this.psiDeclarationProviderFactory = new PsiDeclarationProviderFactory(getPsiClassFinder());
-        this.javaTypeTransformer = new JavaTypeTransformer();
         this.javaClassResolver = new JavaClassResolver();
-        this.javaAnnotationResolver = new JavaAnnotationResolver();
-        this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver();
-        this.javaClassObjectResolver = new JavaClassObjectResolver();
-        this.javaSupertypeResolver = new JavaSupertypeResolver();
-        this.javaNamespaceResolver = new JavaNamespaceResolver();
-        this.javaSignatureResolver = new JavaSignatureResolver();
+        this.psiClassFinder = new PsiClassFinderImpl(getProject(), globalSearchScope);
+        this.psiDeclarationProviderFactory = new PsiDeclarationProviderFactory(getPsiClassFinder());
+        this.javaPackageFragmentProvider = new JavaPackageFragmentProvider(getBindingTrace(), storageManager, psiDeclarationProviderFactory, getJavaDescriptorResolver(), getPsiClassFinder(), subModuleDescriptor);
         this.javaConstructorResolver = new JavaConstructorResolver();
+        this.javaTypeTransformer = new JavaTypeTransformer();
         this.javaValueParameterResolver = new JavaValueParameterResolver();
         this.javaFunctionResolver = new JavaFunctionResolver();
+        this.javaAnnotationResolver = new JavaAnnotationResolver();
+        this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver();
+        this.javaSignatureResolver = new JavaSignatureResolver();
         this.javaInnerClassResolver = new JavaInnerClassResolver();
         this.javaPropertyResolver = new JavaPropertyResolver();
+        this.javaClassObjectResolver = new JavaClassObjectResolver();
+        this.javaSupertypeResolver = new JavaSupertypeResolver();
 
-        javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices);
-
-        this.javaSemanticServices.setDescriptorResolver(javaDescriptorResolver);
-        this.javaSemanticServices.setPsiClassFinder(psiClassFinder);
-        this.javaSemanticServices.setPsiDeclarationProviderFactory(psiDeclarationProviderFactory);
-        this.javaSemanticServices.setTrace(bindingTrace);
-        this.javaSemanticServices.setTypeTransformer(javaTypeTransformer);
-
+        this.javaDescriptorResolver.setClassResolutionFacade(javaClassResolutionFacade);
         this.javaDescriptorResolver.setClassResolver(javaClassResolver);
         this.javaDescriptorResolver.setConstructorResolver(javaConstructorResolver);
         this.javaDescriptorResolver.setFunctionResolver(javaFunctionResolver);
         this.javaDescriptorResolver.setInnerClassResolver(javaInnerClassResolver);
-        this.javaDescriptorResolver.setNamespaceResolver(javaNamespaceResolver);
         this.javaDescriptorResolver.setPropertiesResolver(javaPropertyResolver);
 
-        this.psiClassFinder.setProject(project);
-
-        javaTypeTransformer.setJavaSemanticServices(javaSemanticServices);
-        javaTypeTransformer.setResolver(javaDescriptorResolver);
-
-        javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
-        javaClassResolver.setClassObjectResolver(javaClassObjectResolver);
-        javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
-        javaClassResolver.setPsiClassFinder(psiClassFinder);
-        javaClassResolver.setSemanticServices(javaSemanticServices);
-        javaClassResolver.setSignatureResolver(javaSignatureResolver);
-        javaClassResolver.setSupertypesResolver(javaSupertypeResolver);
-        javaClassResolver.setTrace(bindingTrace);
-
-        javaAnnotationResolver.setClassResolver(javaClassResolver);
-        javaAnnotationResolver.setCompileTimeConstResolver(javaCompileTimeConstResolver);
-
-        javaCompileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
-        javaCompileTimeConstResolver.setClassResolver(javaClassResolver);
-
-        javaClassObjectResolver.setSemanticServices(javaSemanticServices);
-        javaClassObjectResolver.setSupertypesResolver(javaSupertypeResolver);
-        javaClassObjectResolver.setTrace(bindingTrace);
-
-        javaSupertypeResolver.setClassResolver(javaClassResolver);
-        javaSupertypeResolver.setSemanticServices(javaSemanticServices);
-        javaSupertypeResolver.setTrace(bindingTrace);
-        javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
-
-        javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices);
-        javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
-        javaNamespaceResolver.setTrace(bindingTrace);
-
-        javaSignatureResolver.setJavaSemanticServices(javaSemanticServices);
+        this.javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
+        this.javaClassResolver.setClassObjectResolver(javaClassObjectResolver);
+        this.javaClassResolver.setClassResolutionFacade(javaClassResolutionFacade);
+        this.javaClassResolver.setJavaDescriptorResolver(javaDescriptorResolver);
+        this.javaClassResolver.setPackageFragmentProvider(javaPackageFragmentProvider);
+        this.javaClassResolver.setPsiDeclarationProviderFactory(psiDeclarationProviderFactory);
+        this.javaClassResolver.setSignatureResolver(javaSignatureResolver);
+        this.javaClassResolver.setSupertypesResolver(javaSupertypeResolver);
+        this.javaClassResolver.setTrace(bindingTrace);
 
         javaConstructorResolver.setTrace(bindingTrace);
         javaConstructorResolver.setTypeTransformer(javaTypeTransformer);
         javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver);
 
+        javaTypeTransformer.setClassResolutionFacade(javaClassResolutionFacade);
+        javaTypeTransformer.setProject(project);
+        javaTypeTransformer.setSubModule(subModuleDescriptor);
+
         javaValueParameterResolver.setTypeTransformer(javaTypeTransformer);
 
         javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver);
@@ -154,17 +137,35 @@ public class InjectorForJavaDescriptorResolver {
         javaFunctionResolver.setTrace(bindingTrace);
         javaFunctionResolver.setTypeTransformer(javaTypeTransformer);
 
+        javaAnnotationResolver.setClassResolver(javaClassResolver);
+        javaAnnotationResolver.setCompileTimeConstResolver(javaCompileTimeConstResolver);
+
+        javaCompileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
+        javaCompileTimeConstResolver.setClassResolver(javaClassResolver);
+
+        javaSignatureResolver.setDependencyClassByQualifiedNameResolver(javaDependencyByQualifiedNameResolver);
+        javaSignatureResolver.setTypeTransformer(javaTypeTransformer);
+
         javaInnerClassResolver.setClassResolver(javaClassResolver);
 
         javaPropertyResolver.setAnnotationResolver(javaAnnotationResolver);
         javaPropertyResolver.setJavaSignatureResolver(javaSignatureResolver);
-        javaPropertyResolver.setSemanticServices(javaSemanticServices);
         javaPropertyResolver.setTrace(bindingTrace);
+        javaPropertyResolver.setTypeTransformer(javaTypeTransformer);
+
+        javaClassObjectResolver.setJavaDescriptorResolver(javaDescriptorResolver);
+        javaClassObjectResolver.setPsiDeclarationProviderFactory(psiDeclarationProviderFactory);
+        javaClassObjectResolver.setSupertypesResolver(javaSupertypeResolver);
+        javaClassObjectResolver.setTrace(bindingTrace);
+
+        javaSupertypeResolver.setClassResolver(javaClassResolver);
+        javaSupertypeResolver.setProject(project);
+        javaSupertypeResolver.setSubModule(subModuleDescriptor);
+        javaSupertypeResolver.setTrace(bindingTrace);
+        javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
 
         javaBridgeConfiguration.init();
 
-        psiClassFinder.initialize();
-
     }
     
     @PreDestroy
@@ -179,20 +180,20 @@ public class InjectorForJavaDescriptorResolver {
         return this.bindingTrace;
     }
     
-    public ModuleDescriptor getModuleDescriptor() {
-        return this.moduleDescriptor;
-    }
-    
-    public JavaSemanticServices getJavaSemanticServices() {
-        return this.javaSemanticServices;
-    }
-    
     public JavaDescriptorResolver getJavaDescriptorResolver() {
         return this.javaDescriptorResolver;
     }
     
+    public JavaClassResolver getJavaClassResolver() {
+        return this.javaClassResolver;
+    }
+    
     public PsiClassFinderImpl getPsiClassFinder() {
         return this.psiClassFinder;
     }
     
+    public JavaPackageFragmentProvider getJavaPackageFragmentProvider() {
+        return this.javaPackageFragmentProvider;
+    }
+    
 }

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

@@ -16,21 +16,25 @@
 
 package org.jetbrains.jet.di;
 
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
+import org.jetbrains.jet.lang.resolve.java.JavaDependencyByQualifiedNameResolver;
 import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import com.intellij.openapi.project.Project;
-import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory;
-import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
+import org.jetbrains.jet.lang.resolve.java.JavaClassResolutionFacade;
+import org.jetbrains.jet.lang.resolve.lazy.storage.StorageManager;
+import org.jetbrains.jet.lang.descriptors.SubModuleDescriptor;
+import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver;
+import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
+import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
+import org.jetbrains.jet.lang.resolve.java.JavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
@@ -43,21 +47,25 @@ import javax.annotation.PreDestroy;
 /* This file is generated by org.jetbrains.jet.generators.injectors.GenerateInjectors. DO NOT EDIT! */
 public class InjectorForJavaSemanticServices {
     
-    private JavaSemanticServices javaSemanticServices;
     private JavaDescriptorResolver javaDescriptorResolver;
     private BindingTrace bindingTrace;
     private JavaBridgeConfiguration javaBridgeConfiguration;
+    private JavaDependencyByQualifiedNameResolver javaDependencyByQualifiedNameResolver;
     private PsiClassFinderImpl psiClassFinder;
     private ModuleDescriptor moduleDescriptor;
     private final Project project;
-    private PsiDeclarationProviderFactory psiDeclarationProviderFactory;
-    private JavaTypeTransformer javaTypeTransformer;
+    private final JavaClassResolutionFacade javaClassResolutionFacade;
+    private final StorageManager storageManager;
+    private final SubModuleDescriptor subModuleDescriptor;
+    private final GlobalSearchScope globalSearchScope;
     private JavaClassResolver javaClassResolver;
     private JavaAnnotationResolver javaAnnotationResolver;
     private JavaCompileTimeConstResolver javaCompileTimeConstResolver;
     private JavaClassObjectResolver javaClassObjectResolver;
+    private PsiDeclarationProviderFactory psiDeclarationProviderFactory;
     private JavaSupertypeResolver javaSupertypeResolver;
-    private JavaNamespaceResolver javaNamespaceResolver;
+    private JavaTypeTransformer javaTypeTransformer;
+    private JavaPackageFragmentProvider javaPackageFragmentProvider;
     private JavaSignatureResolver javaSignatureResolver;
     private JavaConstructorResolver javaConstructorResolver;
     private JavaValueParameterResolver javaValueParameterResolver;
@@ -66,23 +74,31 @@ public class InjectorForJavaSemanticServices {
     private JavaPropertyResolver javaPropertyResolver;
     
     public InjectorForJavaSemanticServices(
-        @NotNull Project project
+        @NotNull Project project,
+        @NotNull JavaClassResolutionFacade javaClassResolutionFacade,
+        @NotNull StorageManager storageManager,
+        @NotNull SubModuleDescriptor subModuleDescriptor,
+        @NotNull GlobalSearchScope globalSearchScope
     ) {
-        this.javaSemanticServices = new JavaSemanticServices();
         this.javaDescriptorResolver = new JavaDescriptorResolver();
         this.bindingTrace = new org.jetbrains.jet.lang.resolve.BindingTraceContext();
         this.javaBridgeConfiguration = new JavaBridgeConfiguration();
-        this.psiClassFinder = new PsiClassFinderImpl();
-        this.moduleDescriptor = new org.jetbrains.jet.lang.descriptors.ModuleDescriptor(org.jetbrains.jet.lang.resolve.name.Name.special("<dummy>"));
+        this.subModuleDescriptor = subModuleDescriptor;
+        this.javaDependencyByQualifiedNameResolver = new JavaDependencyByQualifiedNameResolver(subModuleDescriptor);
         this.project = project;
-        this.psiDeclarationProviderFactory = new PsiDeclarationProviderFactory(getPsiClassFinder());
-        this.javaTypeTransformer = new JavaTypeTransformer();
+        this.globalSearchScope = globalSearchScope;
+        this.psiClassFinder = new PsiClassFinderImpl(getProject(), globalSearchScope);
+        this.moduleDescriptor = new org.jetbrains.jet.lang.descriptors.impl.MutableModuleDescriptor(org.jetbrains.jet.lang.resolve.name.Name.special("<dummy>"), org.jetbrains.jet.lang.resolve.java.JavaToKotlinClassMap.getInstance());
+        this.javaClassResolutionFacade = javaClassResolutionFacade;
+        this.storageManager = storageManager;
         this.javaClassResolver = new JavaClassResolver();
         this.javaAnnotationResolver = new JavaAnnotationResolver();
         this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver();
         this.javaClassObjectResolver = new JavaClassObjectResolver();
+        this.psiDeclarationProviderFactory = new PsiDeclarationProviderFactory(getPsiClassFinder());
         this.javaSupertypeResolver = new JavaSupertypeResolver();
-        this.javaNamespaceResolver = new JavaNamespaceResolver();
+        this.javaTypeTransformer = new JavaTypeTransformer();
+        this.javaPackageFragmentProvider = new JavaPackageFragmentProvider(getBindingTrace(), storageManager, psiDeclarationProviderFactory, getJavaDescriptorResolver(), getPsiClassFinder(), subModuleDescriptor);
         this.javaSignatureResolver = new JavaSignatureResolver();
         this.javaConstructorResolver = new JavaConstructorResolver();
         this.javaValueParameterResolver = new JavaValueParameterResolver();
@@ -90,31 +106,19 @@ public class InjectorForJavaSemanticServices {
         this.javaInnerClassResolver = new JavaInnerClassResolver();
         this.javaPropertyResolver = new JavaPropertyResolver();
 
-        this.javaSemanticServices.setDescriptorResolver(javaDescriptorResolver);
-        this.javaSemanticServices.setPsiClassFinder(psiClassFinder);
-        this.javaSemanticServices.setPsiDeclarationProviderFactory(psiDeclarationProviderFactory);
-        this.javaSemanticServices.setTrace(bindingTrace);
-        this.javaSemanticServices.setTypeTransformer(javaTypeTransformer);
-
+        this.javaDescriptorResolver.setClassResolutionFacade(javaClassResolutionFacade);
         this.javaDescriptorResolver.setClassResolver(javaClassResolver);
         this.javaDescriptorResolver.setConstructorResolver(javaConstructorResolver);
         this.javaDescriptorResolver.setFunctionResolver(javaFunctionResolver);
         this.javaDescriptorResolver.setInnerClassResolver(javaInnerClassResolver);
-        this.javaDescriptorResolver.setNamespaceResolver(javaNamespaceResolver);
         this.javaDescriptorResolver.setPropertiesResolver(javaPropertyResolver);
 
-        javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices);
-
-        this.psiClassFinder.setProject(project);
-
-        javaTypeTransformer.setJavaSemanticServices(javaSemanticServices);
-        javaTypeTransformer.setResolver(javaDescriptorResolver);
-
         javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
         javaClassResolver.setClassObjectResolver(javaClassObjectResolver);
-        javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
-        javaClassResolver.setPsiClassFinder(psiClassFinder);
-        javaClassResolver.setSemanticServices(javaSemanticServices);
+        javaClassResolver.setClassResolutionFacade(javaClassResolutionFacade);
+        javaClassResolver.setJavaDescriptorResolver(javaDescriptorResolver);
+        javaClassResolver.setPackageFragmentProvider(javaPackageFragmentProvider);
+        javaClassResolver.setPsiDeclarationProviderFactory(psiDeclarationProviderFactory);
         javaClassResolver.setSignatureResolver(javaSignatureResolver);
         javaClassResolver.setSupertypesResolver(javaSupertypeResolver);
         javaClassResolver.setTrace(bindingTrace);
@@ -125,20 +129,23 @@ public class InjectorForJavaSemanticServices {
         javaCompileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
         javaCompileTimeConstResolver.setClassResolver(javaClassResolver);
 
-        javaClassObjectResolver.setSemanticServices(javaSemanticServices);
+        javaClassObjectResolver.setJavaDescriptorResolver(javaDescriptorResolver);
+        javaClassObjectResolver.setPsiDeclarationProviderFactory(psiDeclarationProviderFactory);
         javaClassObjectResolver.setSupertypesResolver(javaSupertypeResolver);
         javaClassObjectResolver.setTrace(bindingTrace);
 
         javaSupertypeResolver.setClassResolver(javaClassResolver);
-        javaSupertypeResolver.setSemanticServices(javaSemanticServices);
+        javaSupertypeResolver.setProject(project);
+        javaSupertypeResolver.setSubModule(subModuleDescriptor);
         javaSupertypeResolver.setTrace(bindingTrace);
         javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
 
-        javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices);
-        javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
-        javaNamespaceResolver.setTrace(bindingTrace);
+        javaTypeTransformer.setClassResolutionFacade(javaClassResolutionFacade);
+        javaTypeTransformer.setProject(project);
+        javaTypeTransformer.setSubModule(subModuleDescriptor);
 
-        javaSignatureResolver.setJavaSemanticServices(javaSemanticServices);
+        javaSignatureResolver.setDependencyClassByQualifiedNameResolver(javaDependencyByQualifiedNameResolver);
+        javaSignatureResolver.setTypeTransformer(javaTypeTransformer);
 
         javaConstructorResolver.setTrace(bindingTrace);
         javaConstructorResolver.setTypeTransformer(javaTypeTransformer);
@@ -156,23 +163,17 @@ public class InjectorForJavaSemanticServices {
 
         javaPropertyResolver.setAnnotationResolver(javaAnnotationResolver);
         javaPropertyResolver.setJavaSignatureResolver(javaSignatureResolver);
-        javaPropertyResolver.setSemanticServices(javaSemanticServices);
         javaPropertyResolver.setTrace(bindingTrace);
+        javaPropertyResolver.setTypeTransformer(javaTypeTransformer);
 
         javaBridgeConfiguration.init();
 
-        psiClassFinder.initialize();
-
     }
     
     @PreDestroy
     public void destroy() {
     }
     
-    public JavaSemanticServices getJavaSemanticServices() {
-        return this.javaSemanticServices;
-    }
-    
     public JavaDescriptorResolver getJavaDescriptorResolver() {
         return this.javaDescriptorResolver;
     }

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

@@ -22,14 +22,11 @@ import org.jetbrains.jet.lang.resolve.BodyResolver;
 import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer;
 import org.jetbrains.jet.lang.resolve.DeclarationsChecker;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
+import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl;
-import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl;
+import org.jetbrains.jet.lang.resolve.ModuleSourcesManager;
 import org.jetbrains.jet.lang.resolve.DeclarationResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
@@ -46,22 +43,6 @@ import org.jetbrains.jet.lang.resolve.OverloadResolver;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
 import org.jetbrains.jet.lang.resolve.ScriptBodyResolver;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
-import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory;
-import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver;
-import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -74,14 +55,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private ControlFlowAnalyzer controlFlowAnalyzer;
     private DeclarationsChecker declarationsChecker;
     private DescriptorResolver descriptorResolver;
+    private DependencyClassByQualifiedNameResolverDummyImpl dependencyClassByQualifiedNameResolverDummy;
     private final Project project;
     private final TopDownAnalysisParameters topDownAnalysisParameters;
     private final BindingTrace bindingTrace;
-    private final ModuleDescriptor moduleDescriptor;
-    private JavaBridgeConfiguration moduleConfiguration;
-    private JavaDescriptorResolver javaDescriptorResolver;
-    private PsiClassFinderImpl psiClassFinder;
-    private NamespaceFactoryImpl namespaceFactory;
+    private final ModuleSourcesManager moduleSourcesManager;
     private DeclarationResolver declarationResolver;
     private AnnotationResolver annotationResolver;
     private CallResolver callResolver;
@@ -98,27 +76,12 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private OverrideResolver overrideResolver;
     private TypeHierarchyResolver typeHierarchyResolver;
     private ScriptBodyResolver scriptBodyResolver;
-    private JavaSemanticServices javaSemanticServices;
-    private PsiDeclarationProviderFactory psiDeclarationProviderFactory;
-    private JavaTypeTransformer javaTypeTransformer;
-    private JavaClassResolver javaClassResolver;
-    private JavaAnnotationResolver javaAnnotationResolver;
-    private JavaCompileTimeConstResolver javaCompileTimeConstResolver;
-    private JavaClassObjectResolver javaClassObjectResolver;
-    private JavaSupertypeResolver javaSupertypeResolver;
-    private JavaNamespaceResolver javaNamespaceResolver;
-    private JavaSignatureResolver javaSignatureResolver;
-    private JavaConstructorResolver javaConstructorResolver;
-    private JavaValueParameterResolver javaValueParameterResolver;
-    private JavaFunctionResolver javaFunctionResolver;
-    private JavaInnerClassResolver javaInnerClassResolver;
-    private JavaPropertyResolver javaPropertyResolver;
     
     public InjectorForTopDownAnalyzerForJvm(
         @NotNull Project project,
         @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
         @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptor moduleDescriptor
+        @NotNull ModuleSourcesManager moduleSourcesManager
     ) {
         this.topDownAnalyzer = new TopDownAnalyzer();
         this.topDownAnalysisContext = new TopDownAnalysisContext();
@@ -126,14 +89,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.controlFlowAnalyzer = new ControlFlowAnalyzer();
         this.declarationsChecker = new DeclarationsChecker();
         this.descriptorResolver = new DescriptorResolver();
+        this.dependencyClassByQualifiedNameResolverDummy = new DependencyClassByQualifiedNameResolverDummyImpl();
         this.project = project;
         this.topDownAnalysisParameters = topDownAnalysisParameters;
         this.bindingTrace = bindingTrace;
-        this.moduleDescriptor = moduleDescriptor;
-        this.moduleConfiguration = new JavaBridgeConfiguration();
-        this.javaDescriptorResolver = new JavaDescriptorResolver();
-        this.psiClassFinder = new PsiClassFinderImpl();
-        this.namespaceFactory = new NamespaceFactoryImpl();
+        this.moduleSourcesManager = moduleSourcesManager;
         this.declarationResolver = new DeclarationResolver();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
@@ -150,31 +110,13 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.overrideResolver = new OverrideResolver();
         this.typeHierarchyResolver = new TypeHierarchyResolver();
         this.scriptBodyResolver = new ScriptBodyResolver();
-        this.javaSemanticServices = new JavaSemanticServices();
-        this.psiDeclarationProviderFactory = new PsiDeclarationProviderFactory(psiClassFinder);
-        this.javaTypeTransformer = new JavaTypeTransformer();
-        this.javaClassResolver = new JavaClassResolver();
-        this.javaAnnotationResolver = new JavaAnnotationResolver();
-        this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver();
-        this.javaClassObjectResolver = new JavaClassObjectResolver();
-        this.javaSupertypeResolver = new JavaSupertypeResolver();
-        this.javaNamespaceResolver = new JavaNamespaceResolver();
-        this.javaSignatureResolver = new JavaSignatureResolver();
-        this.javaConstructorResolver = new JavaConstructorResolver();
-        this.javaValueParameterResolver = new JavaValueParameterResolver();
-        this.javaFunctionResolver = new JavaFunctionResolver();
-        this.javaInnerClassResolver = new JavaInnerClassResolver();
-        this.javaPropertyResolver = new JavaPropertyResolver();
 
         this.topDownAnalyzer.setBodyResolver(bodyResolver);
         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.setTopDownAnalysisParameters(topDownAnalysisParameters);
-        this.topDownAnalyzer.setTrace(bindingTrace);
         this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
 
         this.topDownAnalysisContext.setTopDownAnalysisParameters(topDownAnalysisParameters);
@@ -198,25 +140,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
         this.descriptorResolver.setTypeResolver(typeResolver);
 
-        this.moduleConfiguration.setJavaSemanticServices(javaSemanticServices);
-
-        javaDescriptorResolver.setClassResolver(javaClassResolver);
-        javaDescriptorResolver.setConstructorResolver(javaConstructorResolver);
-        javaDescriptorResolver.setFunctionResolver(javaFunctionResolver);
-        javaDescriptorResolver.setInnerClassResolver(javaInnerClassResolver);
-        javaDescriptorResolver.setNamespaceResolver(javaNamespaceResolver);
-        javaDescriptorResolver.setPropertiesResolver(javaPropertyResolver);
-
-        psiClassFinder.setProject(project);
-
-        this.namespaceFactory.setConfiguration(moduleConfiguration);
-        this.namespaceFactory.setModuleDescriptor(moduleDescriptor);
-        this.namespaceFactory.setTrace(bindingTrace);
-
         declarationResolver.setAnnotationResolver(annotationResolver);
         declarationResolver.setContext(topDownAnalysisContext);
         declarationResolver.setDescriptorResolver(descriptorResolver);
         declarationResolver.setImportsResolver(importsResolver);
+        declarationResolver.setModuleManager(moduleSourcesManager);
         declarationResolver.setScriptHeaderResolver(scriptHeaderResolver);
         declarationResolver.setTrace(bindingTrace);
 
@@ -234,6 +162,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
         expressionTypingServices.setCallResolver(callResolver);
         expressionTypingServices.setDescriptorResolver(descriptorResolver);
+        expressionTypingServices.setModuleSourcesManager(moduleSourcesManager);
         expressionTypingServices.setProject(project);
         expressionTypingServices.setTypeResolver(typeResolver);
 
@@ -241,22 +170,22 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
 
         typeResolver.setAnnotationResolver(annotationResolver);
         typeResolver.setDescriptorResolver(descriptorResolver);
-        typeResolver.setModuleConfiguration(moduleConfiguration);
+        typeResolver.setModuleSourcesManager(moduleSourcesManager);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
 
-        importsResolver.setConfiguration(moduleConfiguration);
         importsResolver.setContext(topDownAnalysisContext);
         importsResolver.setImportsFactory(jetImportsFactory);
+        importsResolver.setModuleSourcesManager(moduleSourcesManager);
         importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
         importsResolver.setTrace(bindingTrace);
 
         jetImportsFactory.setProject(project);
 
         scriptHeaderResolver.setContext(topDownAnalysisContext);
-        scriptHeaderResolver.setDependencyClassByQualifiedNameResolver(javaDescriptorResolver);
-        scriptHeaderResolver.setNamespaceFactory(namespaceFactory);
+        scriptHeaderResolver.setDependencyClassByQualifiedNameResolver(dependencyClassByQualifiedNameResolverDummy);
+        scriptHeaderResolver.setModuleSourcesManager(moduleSourcesManager);
         scriptHeaderResolver.setTopDownAnalysisParameters(topDownAnalysisParameters);
         scriptHeaderResolver.setTrace(bindingTrace);
 
@@ -270,7 +199,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         typeHierarchyResolver.setContext(topDownAnalysisContext);
         typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
         typeHierarchyResolver.setImportsResolver(importsResolver);
-        typeHierarchyResolver.setNamespaceFactory(namespaceFactory);
+        typeHierarchyResolver.setModuleManager(moduleSourcesManager);
         typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver);
         typeHierarchyResolver.setTrace(bindingTrace);
 
@@ -278,68 +207,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
         scriptBodyResolver.setTrace(bindingTrace);
 
-        javaSemanticServices.setDescriptorResolver(javaDescriptorResolver);
-        javaSemanticServices.setPsiClassFinder(psiClassFinder);
-        javaSemanticServices.setPsiDeclarationProviderFactory(psiDeclarationProviderFactory);
-        javaSemanticServices.setTrace(bindingTrace);
-        javaSemanticServices.setTypeTransformer(javaTypeTransformer);
-
-        javaTypeTransformer.setJavaSemanticServices(javaSemanticServices);
-        javaTypeTransformer.setResolver(javaDescriptorResolver);
-
-        javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
-        javaClassResolver.setClassObjectResolver(javaClassObjectResolver);
-        javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
-        javaClassResolver.setPsiClassFinder(psiClassFinder);
-        javaClassResolver.setSemanticServices(javaSemanticServices);
-        javaClassResolver.setSignatureResolver(javaSignatureResolver);
-        javaClassResolver.setSupertypesResolver(javaSupertypeResolver);
-        javaClassResolver.setTrace(bindingTrace);
-
-        javaAnnotationResolver.setClassResolver(javaClassResolver);
-        javaAnnotationResolver.setCompileTimeConstResolver(javaCompileTimeConstResolver);
-
-        javaCompileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
-        javaCompileTimeConstResolver.setClassResolver(javaClassResolver);
-
-        javaClassObjectResolver.setSemanticServices(javaSemanticServices);
-        javaClassObjectResolver.setSupertypesResolver(javaSupertypeResolver);
-        javaClassObjectResolver.setTrace(bindingTrace);
-
-        javaSupertypeResolver.setClassResolver(javaClassResolver);
-        javaSupertypeResolver.setSemanticServices(javaSemanticServices);
-        javaSupertypeResolver.setTrace(bindingTrace);
-        javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
-
-        javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices);
-        javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
-        javaNamespaceResolver.setTrace(bindingTrace);
-
-        javaSignatureResolver.setJavaSemanticServices(javaSemanticServices);
-
-        javaConstructorResolver.setTrace(bindingTrace);
-        javaConstructorResolver.setTypeTransformer(javaTypeTransformer);
-        javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver);
-
-        javaValueParameterResolver.setTypeTransformer(javaTypeTransformer);
-
-        javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver);
-        javaFunctionResolver.setParameterResolver(javaValueParameterResolver);
-        javaFunctionResolver.setSignatureResolver(javaSignatureResolver);
-        javaFunctionResolver.setTrace(bindingTrace);
-        javaFunctionResolver.setTypeTransformer(javaTypeTransformer);
-
-        javaInnerClassResolver.setClassResolver(javaClassResolver);
-
-        javaPropertyResolver.setAnnotationResolver(javaAnnotationResolver);
-        javaPropertyResolver.setJavaSignatureResolver(javaSignatureResolver);
-        javaPropertyResolver.setSemanticServices(javaSemanticServices);
-        javaPropertyResolver.setTrace(bindingTrace);
-
-        moduleConfiguration.init();
-
-        psiClassFinder.initialize();
-
     }
     
     @PreDestroy
@@ -382,12 +249,4 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         return this.bindingTrace;
     }
     
-    public ModuleConfiguration getModuleConfiguration() {
-        return this.moduleConfiguration;
-    }
-    
-    public NamespaceFactoryImpl getNamespaceFactory() {
-        return this.namespaceFactory;
-    }
-    
 }

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

@@ -18,15 +18,18 @@ package org.jetbrains.jet.lang.resolve.java;
 
 import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.diagnostics.AbstractDiagnosticFactory;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory1;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticHolder;
+import org.jetbrains.jet.lang.diagnostics.Severity;
 import org.jetbrains.jet.lang.resolve.java.kt.PsiAnnotationWithAbiVersion;
-import org.jetbrains.jet.util.slicedmap.BasicWritableSlice;
-import org.jetbrains.jet.util.slicedmap.Slices;
-import org.jetbrains.jet.util.slicedmap.WritableSlice;
 
 public class AbiVersionUtil {
-    public static final WritableSlice<PsiClass, Integer> ABI_VERSION_ERRORS =
-            new BasicWritableSlice<PsiClass, Integer>(Slices.ONLY_REWRITE_TO_EQUAL, true);
+    public static final DiagnosticFactory1<PsiClass, Integer> INCOMPATIBLE_ABI_VERSION = DiagnosticFactory1.create(Severity.ERROR);
+    static {
+        AbstractDiagnosticFactory.writeFieldNamesToDiagnostics(AbiVersionUtil.class);
+    }
+
     public static final int INVALID_VERSION = -1;
 
     public static boolean isAbiVersionCompatible(int abiVersion) {
@@ -36,12 +39,12 @@ public class AbiVersionUtil {
     public static void checkAbiVersion(
             @NotNull PsiClass psiClass,
             @NotNull PsiAnnotationWithAbiVersion versionAnnotation,
-            @NotNull BindingTrace trace) {
+            @NotNull DiagnosticHolder diagnosticHolder) {
         if (!versionAnnotation.isDefined()) return;
 
         int abiVersion = versionAnnotation.getAbiVersion();
         if (isAbiVersionCompatible(abiVersion)) return;
 
-        trace.record(ABI_VERSION_ERRORS, psiClass, abiVersion);
+        diagnosticHolder.report(INCOMPATIBLE_ABI_VERSION.on(psiClass, abiVersion));
     }
 }

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

@@ -17,11 +17,11 @@
 package org.jetbrains.jet.lang.resolve.java;
 
 import com.google.common.base.Predicate;
-import com.google.common.base.Predicates;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiFile;
+import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.analyzer.AnalyzerFacade;
@@ -32,12 +32,15 @@ import org.jetbrains.jet.lang.DefaultModuleConfiguration;
 import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 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.descriptors.SubModuleDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.MutableModuleDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.MutableSubModuleDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager;
-import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -45,7 +48,6 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
 import java.util.Collection;
-import java.util.Collections;
 import java.util.LinkedHashSet;
 import java.util.List;
 
@@ -62,7 +64,10 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             @NotNull Collection<JetFile> files,
             @NotNull List<AnalyzerScriptParameter> scriptParameters,
             @NotNull Predicate<PsiFile> filesToAnalyzeCompletely) {
-        return analyzeFilesWithJavaIntegration(project, files, scriptParameters, filesToAnalyzeCompletely, true);
+        BindingTraceContext bindingTraceContext = new BindingTraceContext();
+
+        return analyzeFilesWithJavaIntegration(project, files, bindingTraceContext, scriptParameters, filesToAnalyzeCompletely,
+                                               true);
     }
 
     @NotNull
@@ -72,22 +77,31 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
                                                @NotNull Predicate<PsiFile> filesForBodiesResolve,
                                                @NotNull BindingTrace headersTraceContext,
                                                @NotNull BodiesResolveContext bodiesResolveContext,
-                                               @NotNull ModuleConfiguration configuration
+                                               @NotNull ModuleSourcesManager moduleSourcesManager
     ) {
         return AnalyzerFacadeForEverything.analyzeBodiesInFilesWithJavaIntegration(
                 project, scriptParameters, filesForBodiesResolve,
-                headersTraceContext, bodiesResolveContext, configuration);
+                headersTraceContext, bodiesResolveContext, moduleSourcesManager);
     }
 
     @NotNull
     @Override
     public ResolveSession getLazyResolveSession(@NotNull final Project fileProject, @NotNull Collection<JetFile> files) {
-        ModuleDescriptor javaModule = new ModuleDescriptor(Name.special("<java module>"));
+        MutableModuleDescriptor javaModule = new MutableModuleDescriptor(Name.special("<java module>"), JavaToKotlinClassMap.getInstance());
+        SubModuleDescriptor subModule =
+                javaModule.addSubModule(new MutableSubModuleDescriptor(javaModule, Name.special("<java submodule>")));
 
         BindingTraceContext javaResolverTrace = new BindingTraceContext();
-        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(fileProject, javaResolverTrace, javaModule);
+        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(
+                fileProject,
+                javaResolverTrace,
+                null, // TODO light class resolver
+                new LockBasedStorageManager(),
+                subModule,
+                GlobalSearchScope.allScope(fileProject)
+        );
 
-        final PsiClassFinder psiClassFinder = injector.getPsiClassFinder();
+        final PsiClassFinder psiClassFinder = null; // TODO
 
         // TODO: Replace with stub declaration provider
         LockBasedStorageManager storageManager = new LockBasedStorageManager();
@@ -111,7 +125,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             @Override
             public void extendNamespaceScope(
                     @NotNull BindingTrace trace,
-                    @NotNull NamespaceDescriptor namespaceDescriptor,
+                    @NotNull PackageViewDescriptor namespaceDescriptor,
                     @NotNull WritableScope namespaceMemberScope
             ) {
                 FqName fqName = DescriptorUtils.getFQName(namespaceDescriptor).toSafe();
@@ -132,65 +146,11 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             }
         };
 
-        ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
+        ModuleDescriptor lazyModule = new MutableModuleDescriptor(Name.special("<lazy module>"), JavaToKotlinClassMap.getInstance());
 
         return new ResolveSession(fileProject, storageManager, lazyModule, moduleConfiguration, declarationProviderFactory, javaResolverTrace);
     }
 
-    public static AnalyzeExhaust analyzeOneFileWithJavaIntegrationAndCheckForErrors(
-            JetFile file, List<AnalyzerScriptParameter> scriptParameters) {
-        AnalyzingUtils.checkForSyntacticErrors(file);
-
-        AnalyzeExhaust analyzeExhaust = analyzeOneFileWithJavaIntegration(file, scriptParameters);
-
-        AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
-
-        return analyzeExhaust;
-    }
-
-    public static AnalyzeExhaust analyzeOneFileWithJavaIntegration(
-            JetFile file, List<AnalyzerScriptParameter> scriptParameters) {
-        return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file), scriptParameters,
-                                               Predicates.<PsiFile>alwaysTrue());
-    }
-
-    public static AnalyzeExhaust analyzeFilesWithJavaIntegrationAndCheckForErrors(
-            Project project,
-            Collection<JetFile> files,
-            List<AnalyzerScriptParameter> scriptParameters,
-            Predicate<PsiFile> filesToAnalyzeCompletely
-    ) {
-        for (JetFile file : files) {
-            AnalyzingUtils.checkForSyntacticErrors(file); 
-        }
-       
-        AnalyzeExhaust analyzeExhaust = analyzeFilesWithJavaIntegration(
-                project, files, scriptParameters, filesToAnalyzeCompletely, false);
-
-        AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
-
-        return analyzeExhaust;
-    }
-
-    public static AnalyzeExhaust analyzeFilesWithJavaIntegration(
-            Project project,
-            Collection<JetFile> files,
-            List<AnalyzerScriptParameter> scriptParameters,
-            Predicate<PsiFile> filesToAnalyzeCompletely
-    ) {
-        return analyzeFilesWithJavaIntegration(
-                project, files, scriptParameters, filesToAnalyzeCompletely, false);
-    }
-
-    public static AnalyzeExhaust analyzeFilesWithJavaIntegration(
-            Project project, Collection<JetFile> files, List<AnalyzerScriptParameter> scriptParameters, Predicate<PsiFile> filesToAnalyzeCompletely,
-            boolean storeContextForBodiesResolve) {
-        BindingTraceContext bindingTraceContext = new BindingTraceContext();
-
-        return analyzeFilesWithJavaIntegration(project, files, bindingTraceContext, scriptParameters, filesToAnalyzeCompletely,
-                                               storeContextForBodiesResolve);
-    }
-
     public static AnalyzeExhaust analyzeFilesWithJavaIntegration(
             Project project,
             Collection<JetFile> files,
@@ -199,31 +159,25 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             Predicate<PsiFile> filesToAnalyzeCompletely,
             boolean storeContextForBodiesResolve
     ) {
-        final ModuleDescriptor owner = new ModuleDescriptor(Name.special("<module>"));
-
         TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
                 filesToAnalyzeCompletely, false, false, scriptParameters);
 
+        MutableModuleSourcesManager sourcesManager =
+                (MutableModuleSourcesManager) KotlinModuleManager.SERVICE.getModuleSourcesManager(project);
+
         InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(
                 project, topDownAnalysisParameters,
-                new ObservableBindingTrace(trace), owner);
+                trace, sourcesManager);
         try {
             injector.getTopDownAnalyzer().analyzeFiles(files, scriptParameters);
             BodiesResolveContext bodiesResolveContext = storeContextForBodiesResolve ?
                                                         new CachedBodiesResolveContext(injector.getTopDownAnalysisContext()) :
                                                         null;
-            return AnalyzeExhaust.success(trace.getBindingContext(), bodiesResolveContext, injector.getModuleConfiguration());
-        } finally {
+            return AnalyzeExhaust.success(trace.getBindingContext(), bodiesResolveContext, sourcesManager);
+        }
+        finally {
             injector.destroy();
         }
     }
 
-    public static AnalyzeExhaust shallowAnalyzeFiles(Collection<JetFile> files) {
-        assert files.size() > 0;
-
-        Project project = files.iterator().next().getProject();
-
-        return analyzeFilesWithJavaIntegration(project,
-                files, Collections.<AnalyzerScriptParameter>emptyList(), Predicates.<PsiFile>alwaysFalse());
-    }
 }

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

@@ -51,9 +51,9 @@ public final class DescriptorResolverUtils {
     }
 
     @NotNull
-    public static Collection<JetType> getSupertypes(@NotNull ClassOrNamespaceDescriptor classOrNamespaceDescriptor) {
-        if (classOrNamespaceDescriptor instanceof ClassDescriptor) {
-            return ((ClassDescriptor) classOrNamespaceDescriptor).getTypeConstructor().getSupertypes();
+    public static Collection<JetType> getSupertypes(@NotNull ClassOrPackageDescriptor classOrPackageDescriptor) {
+        if (classOrPackageDescriptor instanceof ClassDescriptor) {
+            return ((ClassDescriptor) classOrPackageDescriptor).getTypeConstructor().getSupertypes();
         }
         return Collections.emptyList();
     }
@@ -127,11 +127,15 @@ public final class DescriptorResolverUtils {
     }
 
     public static void checkPsiClassIsNotJet(@Nullable PsiClass psiClass) {
-        if (psiClass instanceof JetJavaMirrorMarker) {
+        if (isKotlinLightClass(psiClass)) {
             throw new IllegalStateException("trying to resolve fake jet PsiClass as regular PsiClass: " + psiClass.getQualifiedName());
         }
     }
 
+    public static boolean isKotlinLightClass(@Nullable PsiClass psiClass) {
+        return psiClass instanceof JetJavaMirrorMarker;
+    }
+
     @NotNull
     public static FqNameUnsafe getFqNameForClassObject(@NotNull PsiClass psiClass) {
         String psiClassQualifiedName = psiClass.getQualifiedName();

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

@@ -16,7 +16,8 @@
 
 package org.jetbrains.jet.lang.resolve.java;
 
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import com.intellij.psi.PsiClass;
+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;
@@ -26,11 +27,8 @@ import org.jetbrains.jet.util.slicedmap.WritableSlice;
  */
 public class JavaBindingContext {
 
-    /**
-     * @see BindingContext#NAMESPACE_IS_SRC
-     */
-    public static final WritableSlice<NamespaceDescriptor, JavaNamespaceKind> JAVA_NAMESPACE_KIND =
-            Slices.createSimpleSlice();
+    // Static members of this class constitute the package
+    public static final WritableSlice<PackageFragmentDescriptor, PsiClass> JAVA_STATIC_CLASS_FOR_PACKAGE = Slices.createSimpleSlice();
 
     private JavaBindingContext() {
     }

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

@@ -23,29 +23,22 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.DefaultModuleConfiguration;
 import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.ImportPath;
-import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 
 import javax.annotation.PostConstruct;
-import javax.inject.Inject;
 import java.util.List;
 import java.util.Set;
 
+@Deprecated
 public class JavaBridgeConfiguration implements ModuleConfiguration {
 
     public static final List<ImportPath> DEFAULT_JAVA_IMPORTS = ImmutableList.of(new ImportPath("java.lang.*"));
 
-    private JavaSemanticServices javaSemanticServices;
     private ModuleConfiguration delegateConfiguration;
 
-    @Inject
-    public void setJavaSemanticServices(@NotNull JavaSemanticServices javaSemanticServices) {
-        this.javaSemanticServices = javaSemanticServices;
-    }
-
     @PostConstruct
     public void init() {
         this.delegateConfiguration = DefaultModuleConfiguration.createStandardConfiguration();
@@ -60,12 +53,12 @@ public class JavaBridgeConfiguration implements ModuleConfiguration {
     }
 
     @Override
-    public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) {
-        JetScope javaPackageScope = javaSemanticServices.getDescriptorResolver().getJavaPackageScope(namespaceDescriptor);
-        if (javaPackageScope != null) {
-            namespaceMemberScope.importScope(javaPackageScope);
-        }
-        delegateConfiguration.extendNamespaceScope(trace, namespaceDescriptor, namespaceMemberScope);
+    public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull PackageViewDescriptor packageViewDescriptor, @NotNull WritableScope namespaceMemberScope) {
+        //JetScope javaPackageScope = javaDescriptorResolver.getJavaPackageScope(packageViewDescriptor);
+        //if (javaPackageScope != null) {
+        //    namespaceMemberScope.importScope(javaPackageScope);
+        //}
+        delegateConfiguration.extendNamespaceScope(trace, packageViewDescriptor, namespaceMemberScope);
     }
 
     @NotNull

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

@@ -14,16 +14,14 @@
  * limitations under the License.
  */
 
-package org.jetbrains.jet.asJava;
+package org.jetbrains.jet.lang.resolve.java;
 
 import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 
-public interface KotlinLightClass extends PsiClass {
-    @NotNull
-    FqName getFqName();
-
-    @NotNull
-    PsiClass getDelegate();
+public interface JavaClassResolutionFacade {
+    @Nullable
+    ClassDescriptor getClassDescriptor(@NotNull PsiClass psiClass);
 }

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

@@ -0,0 +1,61 @@
+/*
+ * 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;
+
+import com.google.common.collect.Lists;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiClass;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+
+import java.util.List;
+
+public class JavaClassResolutionFacadeImpl implements JavaClassResolutionFacade {
+
+    private final KotlinLightClassResolver lightClassResolver;
+
+    private final List<JavaPackageFragmentProvider> providers = Lists.newArrayList();
+
+    public JavaClassResolutionFacadeImpl(@NotNull KotlinLightClassResolver lightClassResolver) {
+        this.lightClassResolver = lightClassResolver;
+    }
+
+    public void addPackageFragmentProvider(@NotNull JavaPackageFragmentProvider provider) {
+        providers.add(provider);
+    }
+
+    @Override
+    @Nullable
+    public ClassDescriptor getClassDescriptor(@NotNull PsiClass psiClass) {
+        if (DescriptorResolverUtils.isKotlinLightClass(psiClass)) {
+            return lightClassResolver.resolveLightClass(psiClass);
+        }
+
+        VirtualFile virtualFile = psiClass.getContainingFile().getVirtualFile();
+        assert virtualFile != null : "No virtual file for psiClass: " + psiClass.getText();
+
+        // NOTE: This may become slow if we have too many providers
+        for (JavaPackageFragmentProvider provider : providers) {
+            if (provider.isResponsibleFor(virtualFile)) {
+                return provider.getClassDescriptor(psiClass);
+            }
+        }
+
+        throw new IllegalArgumentException("Not in scope: " + psiClass + " from " + virtualFile);
+    }
+}

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

@@ -0,0 +1,86 @@
+/*
+ * 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;
+
+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.PackageViewDescriptor;
+import org.jetbrains.jet.lang.descriptors.SubModuleDescriptor;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.ChainedScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
+
+import java.util.Iterator;
+
+public class JavaDependencyByQualifiedNameResolver implements DependencyClassByQualifiedNameResolver {
+
+    private final JetScope rootScope;
+
+    public JavaDependencyByQualifiedNameResolver(@NotNull SubModuleDescriptor subModule) {
+        this.rootScope = DescriptorUtils.getRootPackage(subModule).getMemberScope();
+    }
+
+    @Nullable
+    @Override
+    public ClassDescriptor resolveClass(@NotNull FqName fqName) {
+        assert !fqName.isRoot() : "A class can not have an empty fqName";
+
+        if (fqName.parent().isRoot()) {
+            return getClass(rootScope, fqName.shortName());
+        }
+
+        JetScope currentScope = rootScope;
+        for (Iterator<Name> iterator = fqName.pathSegments().iterator(); iterator.hasNext(); ) {
+            Name name = iterator.next();
+
+            ClassDescriptor classDescriptor = getClass(currentScope, name);
+            if (!iterator.hasNext()) return classDescriptor;
+
+            PackageViewDescriptor packageView = currentScope.getPackage(name);
+
+
+            if (packageView == null && classDescriptor == null) {
+                return null;
+            }
+            if (packageView != null && classDescriptor != null) {
+                currentScope = new ChainedScope(null, packageView.getMemberScope(), classDescriptor.getUnsubstitutedInnerClassesScope());
+            }
+            else if (packageView != null) {
+                currentScope = packageView.getMemberScope();
+            }
+            else {
+                currentScope = classDescriptor.getUnsubstitutedInnerClassesScope();
+            }
+        }
+
+        return null;
+    }
+
+    @Nullable
+    private static ClassDescriptor getClass(@NotNull JetScope scope, @NotNull Name name) {
+        ClassifierDescriptor classifier = scope.getClassifier(name);
+        if (classifier != null) {
+            assert classifier instanceof ClassDescriptor : "Only classes should appear as classifiers in this context: " + classifier;
+        }
+        return (ClassDescriptor) classifier;
+    }
+}

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.lang.resolve.java;
 
+import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -26,7 +27,6 @@ import org.jetbrains.jet.lang.resolve.java.resolver.*;
 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 org.jetbrains.jet.lang.types.JetType;
 
 import javax.inject.Inject;
@@ -34,14 +34,14 @@ import java.util.Collection;
 import java.util.List;
 import java.util.Set;
 
-public class JavaDescriptorResolver implements DependencyClassByQualifiedNameResolver {
+public class JavaDescriptorResolver {
 
     public static final Name JAVA_ROOT = Name.special("<java_root>");
 
-    public static Visibility PACKAGE_VISIBILITY = new Visibility("package", false) {
+    public static final Visibility PACKAGE_VISIBILITY = new Visibility("package", false) {
         @Override
         protected boolean isVisible(@NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) {
-            return DescriptorUtils.isInSameNamespace(what, from);
+            return DescriptorUtils.isInSamePackage(what, from);
         }
 
         @Override
@@ -78,9 +78,9 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
             }
             // protected static function or property
             else {
-                DeclarationDescriptor whatDeclarationDescriptor = what.getContainingDeclaration();
-                assert whatDeclarationDescriptor instanceof NamespaceDescriptor : "Only static declarations can have protected_static visibility";
-                whatClass = DescriptorUtils.getClassForCorrespondingJavaNamespace((NamespaceDescriptor) whatDeclarationDescriptor);
+                assert DescriptorUtils.isTopLevelDeclaration(what) : "Only static declarations can have protected_static visibility";
+                DeclarationDescriptor whatDeclarationDescriptor = DescriptorUtils.getParentInPackageViewHierarchy(what);
+                whatClass = DescriptorUtils.getClassForCorrespondingJavaNamespace((PackageViewDescriptor) whatDeclarationDescriptor);
             }
 
             assert whatClass != null : "Couldn't find ClassDescriptor for protected static member " + what;
@@ -106,7 +106,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     public static final Visibility PROTECTED_AND_PACKAGE = new Visibility("protected_and_package", false) {
         @Override
         protected boolean isVisible(@NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) {
-            if (DescriptorUtils.isInSameNamespace(what, from)) {
+            if (DescriptorUtils.isInSamePackage(what, from)) {
                 return true;
             }
 
@@ -146,8 +146,8 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     private JavaClassResolver classResolver;
     private JavaConstructorResolver constructorResolver;
     private JavaFunctionResolver functionResolver;
-    private JavaNamespaceResolver namespaceResolver;
     private JavaInnerClassResolver innerClassResolver;
+    private JavaClassResolutionFacade classResolutionFacade;
 
     @Inject
     public void setFunctionResolver(JavaFunctionResolver functionResolver) {
@@ -159,11 +159,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         this.classResolver = classResolver;
     }
 
-    @Inject
-    public void setNamespaceResolver(JavaNamespaceResolver namespaceResolver) {
-        this.namespaceResolver = namespaceResolver;
-    }
-
     @Inject
     public void setPropertiesResolver(JavaPropertyResolver propertiesResolver) {
         this.propertiesResolver = propertiesResolver;
@@ -179,14 +174,19 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         this.innerClassResolver = innerClassResolver;
     }
 
-    @Nullable
-    public ClassDescriptor resolveClass(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
-        return classResolver.resolveClass(qualifiedName, searchRule);
+    @Inject
+    public void setClassResolutionFacade(JavaClassResolutionFacade classResolutionFacade) {
+        this.classResolutionFacade = classResolutionFacade;
     }
 
-    @Override
-    public ClassDescriptor resolveClass(@NotNull FqName qualifiedName) {
-        return classResolver.resolveClass(qualifiedName);
+    @Nullable
+    public ClassDescriptor resolveClass(@NotNull PsiClass psiClass, @NotNull DescriptorSearchRule searchRule) {
+        return classResolver.resolveClass(psiClass, searchRule);
+    }
+
+    @Nullable
+    public ClassDescriptor resolveClass(@NotNull PsiClass psiClass) {
+        return classResolver.resolveClass(psiClass);
     }
 
     @NotNull
@@ -196,33 +196,38 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         return constructorResolver.resolveConstructors(classData, classDescriptor);
     }
 
+    @Deprecated
     @Nullable
-    public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
-        return namespaceResolver.resolveNamespace(qualifiedName, searchRule);
+    public PackageViewDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
+        //return namespaceResolver.resolveNamespace(qualifiedName, searchRule);
+        throw new UnsupportedOperationException();
     }
 
-    @Override
-    public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName) {
-        return namespaceResolver.resolveNamespace(qualifiedName);
+    @Deprecated
+    public PackageViewDescriptor resolveNamespace(@NotNull FqName qualifiedName) {
+        //return namespaceResolver.resolveNamespace(qualifiedName);
+        throw new UnsupportedOperationException();
     }
 
+    @Deprecated
     @Nullable
-    public JetScope getJavaPackageScope(@NotNull NamespaceDescriptor namespaceDescriptor) {
-        return namespaceResolver.getJavaPackageScopeForExistingNamespaceDescriptor(namespaceDescriptor);
+    public JetScope getJavaPackageScope(@NotNull PackageViewDescriptor packageViewDescriptor) {
+        //return namespaceResolver.getJavaPackageScopeForExistingNamespaceDescriptor(packageViewDescriptor);
+        throw new UnsupportedOperationException();
     }
 
     @NotNull
     public Set<VariableDescriptor> resolveFieldGroupByName(
             @NotNull Name name,
             @NotNull PsiDeclarationProvider data,
-            @NotNull ClassOrNamespaceDescriptor ownerDescriptor
+            @NotNull ClassOrPackageDescriptor ownerDescriptor
     ) {
         return propertiesResolver.resolveFieldGroupByName(name, data, ownerDescriptor);
     }
 
     @Nullable
-    public ClassDescriptor resolveClass(@NotNull FqName name, @NotNull DescriptorSearchRule searchRule, @NotNull PostponedTasks tasks) {
-        return classResolver.resolveClass(name, searchRule, tasks);
+    public ClassDescriptor getClassDescriptor(@NotNull PsiClass psiClass) {
+        return classResolutionFacade.getClassDescriptor(psiClass);
     }
 
     public static class ValueParameterDescriptors {
@@ -249,7 +254,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     public Set<FunctionDescriptor> resolveFunctionGroup(
             @NotNull Name methodName,
             @NotNull ClassPsiDeclarationProvider scopeData,
-            @NotNull ClassOrNamespaceDescriptor ownerDescriptor
+            @NotNull ClassOrPackageDescriptor ownerDescriptor
     ) {
         return functionResolver.resolveFunctionGroup(methodName, scopeData, ownerDescriptor);
     }

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

@@ -0,0 +1,270 @@
+/*
+ * 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;
+
+import com.google.common.collect.Lists;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiPackage;
+import com.intellij.util.NotNullFunction;
+import com.intellij.util.NullableFunction;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.impl.PackageLikeDescriptorBase;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.java.kt.JetPackageClassAnnotation;
+import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory;
+import org.jetbrains.jet.lang.resolve.java.scope.JavaClassStaticMembersScope;
+import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScopeWithoutMembers;
+import org.jetbrains.jet.lang.resolve.java.scope.JavaScopeForKotlinNamespace;
+import org.jetbrains.jet.lang.resolve.lazy.storage.MemoizedFunctionToNullable;
+import org.jetbrains.jet.lang.resolve.lazy.storage.StorageManager;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+public class JavaPackageFragmentProvider implements PackageFragmentProvider {
+
+    public static final PackageFragmentKind JAVA = new PackageFragmentKind() {
+        @Override
+        public String toString() {
+            return "JAVA";
+        }
+    };
+
+    private final BindingTrace trace;
+    private final PsiDeclarationProviderFactory declarationProviderFactory;
+    private final PsiClassFinder psiClassFinder;
+    private final JavaDescriptorResolver javaDescriptorResolver;
+    private final SubModuleDescriptor subModule;
+    private final MemoizedFunctionToNullable<FqName, PackageFragmentDescriptor> packageFragments;
+
+    public JavaPackageFragmentProvider(
+            @NotNull BindingTrace trace,
+            @NotNull StorageManager storageManager,
+            @NotNull PsiDeclarationProviderFactory declarationProviderFactory,
+            @NotNull JavaDescriptorResolver javaDescriptorResolver,
+            @NotNull PsiClassFinder psiClassFinder,
+            @NotNull SubModuleDescriptor subModule
+    ) {
+        this.trace = trace;
+        this.javaDescriptorResolver = javaDescriptorResolver;
+        this.packageFragments = storageManager.createMemoizedFunctionWithNullableValues(
+                new NullableFunction<FqName, PackageFragmentDescriptor>() {
+                    @Nullable
+                    @Override
+                    public PackageFragmentDescriptor fun(FqName fqName) {
+                        return createPackageFragment(fqName);
+                    }
+                },
+                StorageManager.ReferenceKind.STRONG
+        );
+        this.declarationProviderFactory = declarationProviderFactory;
+        this.psiClassFinder = psiClassFinder;
+        this.subModule = subModule;
+    }
+
+    public boolean isResponsibleFor(@NotNull VirtualFile virtualFile) {
+        return psiClassFinder.getDefiningSearchScope().contains(virtualFile);
+    }
+
+    @Nullable
+    public ClassDescriptor getClassDescriptor(@NotNull PsiClass psiClass) {
+        assertInMyScope(psiClass);
+        return javaDescriptorResolver.resolveClass(psiClass);
+    }
+
+    protected void assertInMyScope(@NotNull PsiClass psiClass) {
+        VirtualFile file = psiClass.getContainingFile().getVirtualFile();
+        assert file != null : "No virtual file for psiClass: " + psiClass.getText();
+        assert isResponsibleFor(file) : "Not in scope\n psiClass " + psiClass.getText() + "\nscope: " + psiClassFinder;
+    }
+
+    @NotNull
+    @Override
+    public List<PackageFragmentDescriptor> getPackageFragments(@NotNull FqName fqName) {
+        PackageFragmentDescriptor fragment = getPackageFragment(fqName);
+        if (fragment == null) {
+            return Collections.emptyList();
+        }
+        return Collections.singletonList(fragment);
+    }
+
+    @NotNull
+    @Override
+    public Collection<FqName> getSubPackagesOf(@NotNull FqName fqName) {
+        PsiPackage psiPackage = psiClassFinder.findPsiPackage(fqName);
+        if (psiPackage == null) {
+            return Collections.emptyList();
+        }
+        PsiPackage[] subPackages = psiPackage.getSubPackages(psiClassFinder.getDefiningSearchScope());
+        Collection<FqName> result = Lists.newArrayList();
+        for (PsiPackage subPackage : subPackages) {
+            result.add(new FqName(subPackage.getQualifiedName()));
+        }
+        return result;
+    }
+
+    // This particular provider creates no more than one fragment per package
+    @Nullable
+    public PackageFragmentDescriptor getPackageFragment(@NotNull FqName fqName) {
+        return packageFragments.fun(fqName);
+    }
+
+    @Nullable
+    private PackageFragmentDescriptor createPackageFragment(@NotNull FqName fqName) {
+        final PsiClass staticClass = psiClassFinder.findPsiClass(fqName);
+        if (staticClass != null) {
+            if (staticClass.isEnum()) {
+                // TODO: this is a bug. but reproduces the existing behavior
+                // http://youtrack.jetbrains.com/issue/KT-3377
+
+                // old comment:
+                // NOTE: we don't want to create namespace for enum classes because we put
+                // static members of enum class into class object descriptor
+                return null;
+            }
+
+            return createPackageFragmentForStaticClass(fqName, staticClass);
+        }
+
+        final PsiPackage psiPackage = psiClassFinder.findPsiPackage(fqName);
+        if (psiPackage == null) return null;
+
+        final PsiClass packageClass = psiClassFinder.findPsiClass(PackageClassUtils.getPackageClassFqName(fqName));
+
+        if (packageClass == null) {
+            return createPackageFragmentForPackageWithoutMembers(fqName, psiPackage);
+        }
+
+        AbiVersionUtil.checkAbiVersion(packageClass, JetPackageClassAnnotation.get(packageClass), trace);
+        return createPackageFragmentForPackageWithMembers(fqName, psiPackage, packageClass);
+    }
+
+    private PackageFragmentDescriptor createPackageFragmentForStaticClass(final FqName fqName, final PsiClass staticClass) {
+        JavaPackageFragment fragment = new JavaPackageFragment(
+                "static class",
+                subModule, fqName,
+                new NotNullFunction<PackageFragmentDescriptor, JetScope>() {
+                   @NotNull
+                   @Override
+                   public JetScope fun(PackageFragmentDescriptor fragment) {
+                       return new JavaClassStaticMembersScope(
+                               fragment,
+                               declarationProviderFactory
+                                       .createDeclarationProviderForClassStaticMembers(
+                                               staticClass),
+                               fqName,
+                               javaDescriptorResolver);
+                   }
+               });
+        trace.record(JavaBindingContext.JAVA_STATIC_CLASS_FOR_PACKAGE, fragment, staticClass);
+        return fragment;
+    }
+
+    private PackageFragmentDescriptor createPackageFragmentForPackageWithoutMembers(
+            final FqName fqName,
+            final PsiPackage psiPackage
+    ) {
+        return new JavaPackageFragment(
+                "simple package",
+                subModule, fqName,
+                new NotNullFunction<PackageFragmentDescriptor, JetScope>() {
+                   @NotNull
+                   @Override
+                   public JetScope fun(PackageFragmentDescriptor fragment) {
+                       return new JavaPackageScopeWithoutMembers(
+                                           fragment,
+                                           declarationProviderFactory.createDeclarationProviderForNamespaceWithoutMembers(
+                                                   psiPackage),
+                                           fqName, javaDescriptorResolver);
+                   }
+               });
+    }
+
+    private PackageFragmentDescriptor createPackageFragmentForPackageWithMembers(
+            final FqName fqName,
+            final PsiPackage psiPackage,
+            final PsiClass packageClass
+    ) {
+        return new JavaPackageFragment(
+                "package class (from Kotlin)",
+                subModule, fqName,
+                new NotNullFunction<PackageFragmentDescriptor, JetScope>() {
+                   @NotNull
+                   @Override
+                   public JetScope fun(PackageFragmentDescriptor fragment) {
+                       return new JavaScopeForKotlinNamespace(
+                               fragment,
+                               declarationProviderFactory.createDeclarationForKotlinNamespace(
+                                       psiPackage, packageClass),
+                               fqName, javaDescriptorResolver);
+                   }
+               });
+    }
+
+    private static class JavaPackageFragment extends PackageLikeDescriptorBase implements PackageFragmentDescriptor {
+
+        private final String debugName;
+        private final SubModuleDescriptor subModule;
+        private final JetScope memberScope;
+
+        public JavaPackageFragment(
+                @NotNull String debugName,
+                @NotNull SubModuleDescriptor subModule,
+                @NotNull FqName fqName,
+                @NotNull NotNullFunction<PackageFragmentDescriptor, JetScope> memberScope
+        ) {
+            super(fqName);
+            this.debugName = debugName;
+            this.subModule = subModule;
+            this.memberScope = memberScope.fun(this);
+        }
+
+        @NotNull
+        @Override
+        public PackageFragmentKind getKind() {
+            return JAVA;
+        }
+
+        @NotNull
+        @Override
+        public SubModuleDescriptor getContainingDeclaration() {
+            return subModule;
+        }
+
+        @NotNull
+        @Override
+        public JetScope getMemberScope() {
+            return memberScope;
+        }
+
+        @Override
+        public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
+            return visitor.visitPackageFragmentDescriptor(this, data);
+        }
+
+        @Override
+        public String toString() {
+            return "[" + debugName + "]" + super.toString();
+        }
+    }
+}

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

@@ -1,108 +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;
-
-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.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
-
-import javax.inject.Inject;
-
-public class JavaSemanticServices {
-    @NotNull
-    private JavaTypeTransformer typeTransformer;
-    @NotNull
-    private JavaDescriptorResolver descriptorResolver;
-    @NotNull
-    private PsiClassFinder psiClassFinder;
-    @NotNull
-    private BindingTrace trace;
-    @NotNull
-    private PsiDeclarationProviderFactory psiDeclarationProviderFactory;
-
-    @Inject
-    public void setTypeTransformer(@NotNull JavaTypeTransformer typeTransformer) {
-        this.typeTransformer = typeTransformer;
-    }
-
-    @Inject
-    public void setDescriptorResolver(@NotNull JavaDescriptorResolver descriptorResolver) {
-        this.descriptorResolver = descriptorResolver;
-    }
-
-    @Inject
-    public void setPsiClassFinder(@NotNull PsiClassFinder psiClassFinder) {
-        this.psiClassFinder = psiClassFinder;
-    }
-
-    @Inject
-    public void setTrace(@NotNull BindingTrace trace) {
-        this.trace = trace;
-    }
-
-    @NotNull
-    public JavaTypeTransformer getTypeTransformer() {
-        return typeTransformer;
-    }
-
-    @Inject
-    public void setPsiDeclarationProviderFactory(PsiDeclarationProviderFactory psiDeclarationProviderFactory) {
-        this.psiDeclarationProviderFactory = psiDeclarationProviderFactory;
-    }
-
-    @NotNull
-    public JavaDescriptorResolver getDescriptorResolver() {
-        return descriptorResolver;
-    }
-
-    @Nullable
-    public ClassDescriptor getKotlinClassDescriptor(@NotNull FqName qualifiedName) {
-        return trace.get(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, qualifiedName);
-    }
-
-    @NotNull
-    public PsiClassFinder getPsiClassFinder() {
-        return psiClassFinder;
-    }
-
-    @NotNull
-    public PsiDeclarationProviderFactory getPsiDeclarationProviderFactory() {
-        return psiDeclarationProviderFactory;
-    }
-
-    @Nullable
-    public ClassDescriptor getKotlinBuiltinClassDescriptor(@NotNull FqName qualifiedName) {
-        if (qualifiedName.firstSegmentIs(Name.identifier("jet")) && qualifiedName.pathSegments().size() == 2) {
-            return (ClassDescriptor) KotlinBuiltIns.getInstance().getBuiltInsScope().getClassifier(qualifiedName.pathSegments().get(1));
-        }
-        else {
-            return null;
-        }
-    }
-
-    @Nullable
-    public NamespaceDescriptor getKotlinNamespaceDescriptor(@NotNull FqName qualifiedName) {
-        return trace.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, qualifiedName);
-    }
-}

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

@@ -116,12 +116,12 @@ public class JavaToKotlinMethodMap {
             String[] kotlinNames = kotlinQualifiedName.split("\\.");
             assert kotlinNames.length == 2 : "unexpected qualified name " + kotlinQualifiedName;
 
-            ClassDescriptor outerClass = KotlinBuiltIns.getInstance().getBuiltInClassByName(Name.identifier(kotlinNames[0]));
+            ClassDescriptor outerClass = KotlinBuiltIns.getInstance().getBuiltInClassByShortName(Name.identifier(kotlinNames[0]));
             kotlinClass = DescriptorUtils.getInnerClassByName(outerClass, kotlinNames[1]);
             assert kotlinClass != null : "Class not found: " + kotlinQualifiedName;
         }
         else {
-            kotlinClass = KotlinBuiltIns.getInstance().getBuiltInClassByName(Name.identifier(kotlinQualifiedName));
+            kotlinClass = KotlinBuiltIns.getInstance().getBuiltInClassByShortName(Name.identifier(kotlinQualifiedName));
         }
 
         builder.put(javaFqName, new ClassData(kotlinClass, methods2FunctionsMap));

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

@@ -19,9 +19,12 @@ package org.jetbrains.jet.lang.resolve.java;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.project.Project;
 import com.intellij.psi.*;
+import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.SubModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -42,16 +45,23 @@ public class JavaTypeTransformer {
 
     private static final Logger LOG = Logger.getInstance(JavaTypeTransformer.class);
 
-    private JavaSemanticServices javaSemanticServices;
-    private JavaDescriptorResolver resolver;
+    private JavaClassResolutionFacade classResolutionFacade;
+    private Project project;
+    private SubModuleDescriptor subModule;
+
     @Inject
-    public void setJavaSemanticServices(JavaSemanticServices javaSemanticServices) {
-        this.javaSemanticServices = javaSemanticServices;
+    public void setClassResolutionFacade(JavaClassResolutionFacade classResolutionFacade) {
+        this.classResolutionFacade = classResolutionFacade;
     }
 
     @Inject
-    public void setResolver(JavaDescriptorResolver resolver) {
-        this.resolver = resolver;
+    public void setProject(@NotNull Project project) {
+        this.project = project;
+    }
+
+    @Inject
+    public void setSubModule(SubModuleDescriptor subModule) {
+        this.subModule = subModule;
     }
 
     @NotNull
@@ -88,9 +98,10 @@ public class JavaTypeTransformer {
     }
 
     @NotNull
-    public JetType transformToType(@NotNull String kotlinSignature, TypeVariableResolver typeVariableResolver) {
+    public JetType transformToType(@NotNull GlobalSearchScope searchScope, @NotNull String kotlinSignature, TypeVariableResolver typeVariableResolver) {
+        JavaDependencyByQualifiedNameResolver resolver = new JavaDependencyByQualifiedNameResolver(subModule);
         final JetType[] r = new JetType[1];
-        JetTypeJetSignatureReader reader = new JetTypeJetSignatureReader(javaSemanticServices, KotlinBuiltIns.getInstance(), typeVariableResolver) {
+        JetTypeJetSignatureReader reader = new JetTypeJetSignatureReader(resolver, KotlinBuiltIns.getInstance(), typeVariableResolver) {
             @Override
             protected void done(@NotNull JetType jetType) {
                 r[0] = jetType;
@@ -154,7 +165,7 @@ public class JavaTypeTransformer {
                                                                                                     howThisTypeIsUsed);
 
                     if (classData == null) {
-                        classData = resolver.resolveClass(new FqName(psiClass.getQualifiedName()), DescriptorSearchRule.INCLUDE_KOTLIN);
+                        classData = classResolutionFacade.getClassDescriptor(psiClass);
                     }
                     if (classData == null) {
                         return ErrorUtils.createErrorType("Unresolved java class: " + classType.getPresentableText());

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

@@ -36,14 +36,12 @@ import java.util.regex.Pattern;
 
 public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAdapter {
     
-    private final JavaSemanticServices javaSemanticServices;
-    private final JavaDescriptorResolver javaDescriptorResolver;
+    private final DependencyClassByQualifiedNameResolver classByQualifiedNameResolver;
     private final KotlinBuiltIns kotlinBuiltIns;
     private final TypeVariableResolver typeVariableResolver;
 
-    public JetTypeJetSignatureReader(JavaSemanticServices javaSemanticServices, KotlinBuiltIns kotlinBuiltIns, TypeVariableResolver typeVariableResolver) {
-        this.javaSemanticServices = javaSemanticServices;
-        this.javaDescriptorResolver = javaSemanticServices.getDescriptorResolver();
+    public JetTypeJetSignatureReader(DependencyClassByQualifiedNameResolver classByQualifiedNameResolver, KotlinBuiltIns kotlinBuiltIns, TypeVariableResolver typeVariableResolver) {
+        this.classByQualifiedNameResolver = classByQualifiedNameResolver;
         this.kotlinBuiltIns = kotlinBuiltIns;
         this.typeVariableResolver = typeVariableResolver;
     }
@@ -124,7 +122,7 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd
         }
 
 
-        return javaDescriptorResolver.resolveClass(ourName, DescriptorSearchRule.INCLUDE_KOTLIN);
+        return classByQualifiedNameResolver.resolveClass(ourName);
     }
 
     @Override
@@ -148,7 +146,7 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd
 
     @Override
     public JetSignatureVisitor visitTypeArgument(final JetSignatureVariance variance) {
-        return new JetTypeJetSignatureReader(javaSemanticServices, kotlinBuiltIns, typeVariableResolver) {
+        return new JetTypeJetSignatureReader(classByQualifiedNameResolver, kotlinBuiltIns, typeVariableResolver) {
 
             @Override
             protected void done(@NotNull JetType jetType) {
@@ -159,7 +157,7 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd
 
     @Override
     public JetSignatureVisitor visitArrayType(final boolean nullable, final JetSignatureVariance wildcard) {
-        return new JetTypeJetSignatureReader(javaSemanticServices, kotlinBuiltIns, typeVariableResolver) {
+        return new JetTypeJetSignatureReader(classByQualifiedNameResolver, kotlinBuiltIns, typeVariableResolver) {
             @Override
             public void visitBaseType(char descriptor, boolean nullable) {
                 JetType primitiveType = getPrimitiveType(descriptor, nullable);

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

@@ -82,8 +82,6 @@ public class JvmStdlibNames {
     public static final JvmClassName JET_OBJECT = JvmClassName.byFqNameWithoutInnerClasses("jet.JetObject");
 
 
-    public static final JvmClassName ASSERT_INVISIBLE_IN_RESOLVER = JvmClassName.byFqNameWithoutInnerClasses("org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver");
-
     public static final JvmClassName KOTLIN_SIGNATURE = JvmClassName.byFqNameWithoutInnerClasses("jet.runtime.typeinfo.KotlinSignature");
     public static final String KOTLIN_SIGNATURE_VALUE_METHOD = "value";
 

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

@@ -14,13 +14,14 @@
  * limitations under the License.
  */
 
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.java;
 
+import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
-import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 
-public interface NamespaceFactory {
-    @NotNull
-    NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(@NotNull FqName fqName);
+public interface KotlinLightClassResolver {
+    @Nullable
+    ClassDescriptor resolveLightClass(@NotNull PsiClass kotlinLightClass);
 }

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

@@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.resolve.java;
 
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiPackage;
+import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -25,13 +26,12 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
 import java.util.List;
 
 public interface PsiClassFinder {
-    enum RuntimeClassesHandleMode {
-        THROW,
-        IGNORE,
-    }
+
+    @NotNull
+    GlobalSearchScope getDefiningSearchScope();
 
     @Nullable
-    PsiClass findPsiClass(@NotNull FqName fqName, @NotNull RuntimeClassesHandleMode runtimeClassesHandleMode);
+    PsiClass findPsiClass(@NotNull FqName fqName);
 
     @Nullable
     PsiPackage findPsiPackage(@NotNull FqName fqName);

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

@@ -21,39 +21,31 @@ import com.google.common.collect.Sets;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.psi.PsiAnnotation;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiPackage;
 import com.intellij.psi.search.DelegatingGlobalSearchScope;
 import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.plugin.JetFileType;
 
-import javax.annotation.PostConstruct;
-import javax.inject.Inject;
 import java.util.List;
 import java.util.Set;
 
 public class PsiClassFinderImpl implements PsiClassFinder {
 
-    @NotNull
-    private Project project;
+    private final GlobalSearchScope javaSearchScope;
+    private final JavaPsiFacadeKotlinHacks javaFacade;
 
-    private GlobalSearchScope javaSearchScope;
-    private JavaPsiFacadeKotlinHacks javaFacade;
-
-    @Inject
-    public void setProject(@NotNull Project project) {
-        this.project = project;
+    public PsiClassFinderImpl(@NotNull Project project, @NotNull GlobalSearchScope javaSearchScope) {
+        this.javaSearchScope = fileBasedOrdering(javaSearchScope);
+        this.javaFacade = new JavaPsiFacadeKotlinHacks(project);
     }
 
-    @PostConstruct
-    public void initialize() {
-        javaSearchScope = new DelegatingGlobalSearchScope(GlobalSearchScope.allScope(project)) {
+    @NotNull
+    private static GlobalSearchScope fileBasedOrdering(@NotNull GlobalSearchScope javaSearchScope) {
+        return new DelegatingGlobalSearchScope(javaSearchScope) {
             @Override
             public boolean contains(VirtualFile file) {
                 return myBaseScope.contains(file) && file.getFileType() != JetFileType.INSTANCE;
@@ -76,13 +68,17 @@ public class PsiClassFinderImpl implements PsiClassFinder {
                 return compare;
             }
         };
-        javaFacade = new JavaPsiFacadeKotlinHacks(project);
     }
 
+    @NotNull
+    @Override
+    public GlobalSearchScope getDefiningSearchScope() {
+        return javaSearchScope;
+    }
 
     @Override
     @Nullable
-    public PsiClass findPsiClass(@NotNull FqName qualifiedName, @NotNull RuntimeClassesHandleMode runtimeClassesHandleMode) {
+    public PsiClass findPsiClass(@NotNull FqName qualifiedName) {
         PsiClass original = javaFacade.findClass(qualifiedName.getFqName(), javaSearchScope);
 
         if (original != null) {
@@ -93,7 +89,7 @@ public class PsiClassFinderImpl implements PsiClassFinder {
             }
         }
 
-        if (original instanceof JetJavaMirrorMarker) {
+        if (DescriptorResolverUtils.isKotlinLightClass(original)) {
             throw new IllegalStateException("JetJavaMirrorMaker is not possible in resolve.java, resolving: " + qualifiedName);
         }
 
@@ -101,25 +97,6 @@ public class PsiClassFinderImpl implements PsiClassFinder {
             return null;
         }
 
-        if (KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(qualifiedName.parent())) {
-            PsiAnnotation assertInvisibleAnnotation = JavaAnnotationResolver.findOwnAnnotation(
-                    original, JvmStdlibNames.ASSERT_INVISIBLE_IN_RESOLVER.getFqName().getFqName());
-
-            if (assertInvisibleAnnotation != null) {
-                if (runtimeClassesHandleMode == RuntimeClassesHandleMode.IGNORE) {
-                    return null;
-                }
-                else if (runtimeClassesHandleMode == RuntimeClassesHandleMode.THROW) {
-                    throw new IllegalStateException(
-                            "classpath is configured incorrectly:" +
-                            " class " + qualifiedName + " from runtime must not be loaded by compiler");
-                }
-                else {
-                    throw new IllegalStateException("unknown parameter value: " + runtimeClassesHandleMode);
-                }
-            }
-        }
-
         return original;
     }
 

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

@@ -17,7 +17,7 @@
 package org.jetbrains.jet.lang.resolve.java;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassOrPackageDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 
@@ -69,7 +69,7 @@ public class TypeVariableResolverFromTypeDescriptors implements TypeVariableReso
         if (containingDeclaration != null) {
             return getTypeVariable(
                     name,
-                    TypeVariableResolvers.getTypeParameterDescriptors((ClassOrNamespaceDescriptor) containingDeclaration),
+                    TypeVariableResolvers.getTypeParameterDescriptors((ClassOrPackageDescriptor) containingDeclaration),
                     containingDeclaration,
                     context);
         }

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

@@ -25,7 +25,7 @@ import java.util.List;
 public class TypeVariableResolvers {
 
     @NotNull
-    public static List<TypeParameterDescriptor> getTypeParameterDescriptors(@NotNull ClassOrNamespaceDescriptor clazz) {
+    public static List<TypeParameterDescriptor> getTypeParameterDescriptors(@NotNull ClassOrPackageDescriptor clazz) {
         if (clazz instanceof ClassDescriptor) {
             return ((ClassDescriptor) clazz).getTypeConstructor().getParameters();
         }
@@ -35,7 +35,7 @@ public class TypeVariableResolvers {
     }
 
     @NotNull
-    public static TypeVariableResolver classTypeVariableResolver(@NotNull ClassOrNamespaceDescriptor clazz, @NotNull String context) {
+    public static TypeVariableResolver classTypeVariableResolver(@NotNull ClassOrPackageDescriptor clazz, @NotNull String context) {
         return typeVariableResolverFromTypeParameters(getTypeParameterDescriptors(clazz), clazz, context);
     }
 

compiler/frontend.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;
-    }
-}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/KotlinPackagePsiDeclarationProvider.java

@@ -19,15 +19,20 @@ package org.jetbrains.jet.lang.resolve.java.provider;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiPackage;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.Name;
+
+import java.util.Collection;
 
 import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.KOTLIN;
 
-public final class KotlinNamespacePsiDeclarationProvider extends ClassPsiDeclarationProviderImpl implements PackagePsiDeclarationProvider {
+public final class KotlinPackagePsiDeclarationProvider extends ClassPsiDeclarationProviderImpl implements PackagePsiDeclarationProvider {
     @NotNull
     private final PsiPackage psiPackage;
 
-    public KotlinNamespacePsiDeclarationProvider(
+    public KotlinPackagePsiDeclarationProvider(
             @NotNull PsiPackage psiPackage,
             @NotNull PsiClass psiClass,
             @NotNull PsiClassFinder psiClassFinder
@@ -36,6 +41,19 @@ public final class KotlinNamespacePsiDeclarationProvider extends ClassPsiDeclara
         this.psiPackage = psiPackage;
     }
 
+    @NotNull
+    @Override
+    public Collection<PsiClass> getAllPsiClasses() {
+        return psiClassFinder.findPsiClasses(psiPackage);
+    }
+
+    @Nullable
+    @Override
+    public PsiClass getPsiClass(@NotNull Name name) {
+        return psiClassFinder.findPsiClass(new FqName(psiPackage.getQualifiedName()).child(name)
+        );
+    }
+
     @NotNull
     @Override
     public PsiPackage getPsiPackage() {

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/PackagePsiDeclarationProvider.java

@@ -16,11 +16,22 @@
 
 package org.jetbrains.jet.lang.resolve.java.provider;
 
+import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiPackage;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.resolve.name.Name;
+
+import java.util.Collection;
 
 public interface PackagePsiDeclarationProvider extends PsiDeclarationProvider {
 
     @NotNull
     PsiPackage getPsiPackage();
+
+    @NotNull
+    Collection<PsiClass> getAllPsiClasses();
+
+    @Nullable
+    PsiClass getPsiClass(@NotNull Name name);
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/PackagePsiDeclarationProviderImpl.java

@@ -16,9 +16,15 @@
 
 package org.jetbrains.jet.lang.resolve.java.provider;
 
+import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiPackage;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.Name;
+
+import java.util.Collection;
 
 import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.JAVA;
 import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.KOTLIN;
@@ -45,6 +51,19 @@ public final class PackagePsiDeclarationProviderImpl extends PsiDeclarationProvi
         return psiPackage;
     }
 
+    @NotNull
+    @Override
+    public Collection<PsiClass> getAllPsiClasses() {
+        return psiClassFinder.findPsiClasses(psiPackage);
+    }
+
+    @Nullable
+    @Override
+    public PsiClass getPsiClass(@NotNull Name name) {
+        return psiClassFinder.findPsiClass(new FqName(psiPackage.getQualifiedName()).child(name)
+        );
+    }
+
     @NotNull
     @Override
     protected MembersCache buildMembersCache() {

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/PsiDeclarationProviderFactory.java

@@ -39,9 +39,9 @@ public final class PsiDeclarationProviderFactory {
     }
 
     @NotNull
-    public KotlinNamespacePsiDeclarationProvider createDeclarationForKotlinNamespace(
+    public KotlinPackagePsiDeclarationProvider createDeclarationForKotlinNamespace(
             @NotNull PsiPackage psiPackage, @NotNull PsiClass psiClass) {
-        return new KotlinNamespacePsiDeclarationProvider(psiPackage, psiClass, psiClassFinder);
+        return new KotlinPackagePsiDeclarationProvider(psiPackage, psiClass, psiClassFinder);
     }
 
     @NotNull

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

@@ -24,6 +24,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
@@ -31,6 +32,9 @@ import org.jetbrains.jet.lang.resolve.java.JavaToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.types.DeferredType;
+import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.util.lazy.RecursionIntolerantLazyValue;
 
 import javax.inject.Inject;
 import java.util.ArrayList;
@@ -55,11 +59,11 @@ public final class JavaAnnotationResolver {
     }
 
     @NotNull
-    public List<AnnotationDescriptor> resolveAnnotations(@NotNull PsiModifierListOwner owner, @NotNull PostponedTasks tasks) {
+    public List<AnnotationDescriptor> resolveAnnotations(@NotNull PsiModifierListOwner owner) {
         PsiAnnotation[] psiAnnotations = getAllAnnotations(owner);
         List<AnnotationDescriptor> r = Lists.newArrayListWithCapacity(psiAnnotations.length);
         for (PsiAnnotation psiAnnotation : psiAnnotations) {
-            AnnotationDescriptor annotation = resolveAnnotation(psiAnnotation, tasks);
+            AnnotationDescriptor annotation = resolveAnnotation(psiAnnotation);
             if (annotation != null) {
                 r.add(annotation);
             }
@@ -67,16 +71,8 @@ public final class JavaAnnotationResolver {
         return r;
     }
 
-    @NotNull
-    public List<AnnotationDescriptor> resolveAnnotations(@NotNull PsiModifierListOwner owner) {
-        PostponedTasks postponedTasks = new PostponedTasks();
-        List<AnnotationDescriptor> annotations = resolveAnnotations(owner, postponedTasks);
-        postponedTasks.performTasks();
-        return annotations;
-    }
-
     @Nullable
-    public AnnotationDescriptor resolveAnnotation(PsiAnnotation psiAnnotation, @NotNull PostponedTasks postponedTasks) {
+    public AnnotationDescriptor resolveAnnotation(PsiAnnotation psiAnnotation) {
         final AnnotationDescriptor annotation = new AnnotationDescriptor();
         String qname = psiAnnotation.getQualifiedName();
         if (qname == null) {
@@ -94,20 +90,21 @@ public final class JavaAnnotationResolver {
         if (mappedClassDescriptor != null) {
             return mappedClassDescriptor;
         }
+        PsiClass annotationPsiClass = getAnnotationPsiClass(psiAnnotation);
+        if (annotationPsiClass == null) return null;
 
         final ClassDescriptor annotationClass =
-                classResolver.resolveClass(annotationFqName, DescriptorSearchRule.INCLUDE_KOTLIN, postponedTasks);
+                classResolver.resolveClass(annotationPsiClass, DescriptorSearchRule.INCLUDE_KOTLIN);
         if (annotationClass == null) {
             return null;
         }
 
-        postponedTasks.addTask(new Runnable() {
+        annotation.setAnnotationType(DeferredType.create(BindingTrace.EMPTY, new RecursionIntolerantLazyValue<JetType>() {
             @Override
-            public void run() {
-                annotation.setAnnotationType(annotationClass.getDefaultType());
+            protected JetType compute() {
+                return annotationClass.getDefaultType();
             }
-        });
-
+        }));
 
         PsiAnnotationParameterList parameterList = psiAnnotation.getParameterList();
         for (PsiNameValuePair psiNameValuePair : parameterList.getAttributes()) {
@@ -118,7 +115,7 @@ public final class JavaAnnotationResolver {
 
             assert value != null;
             CompileTimeConstant compileTimeConst =
-                    compileTimeConstResolver.getCompileTimeConstFromExpression(annotationFqName, identifier, value, postponedTasks);
+                    compileTimeConstResolver.getCompileTimeConstFromExpression(annotationPsiClass, identifier, value);
             if (compileTimeConst != null) {
                 ValueParameterDescriptor valueParameterDescriptor =
                         DescriptorResolverUtils.getValueParameterDescriptorForAnnotationParameter(identifier, annotationClass);
@@ -131,6 +128,17 @@ public final class JavaAnnotationResolver {
         return annotation;
     }
 
+    @Nullable
+    private static PsiClass getAnnotationPsiClass(@NotNull PsiAnnotation psiAnnotation) {
+        PsiJavaCodeReferenceElement nameReferenceElement = psiAnnotation.getNameReferenceElement();
+        if (nameReferenceElement == null) return null;
+        PsiElement annotationResolvedTo = nameReferenceElement.resolve();
+        if (annotationResolvedTo == null) return null;
+        assert annotationResolvedTo instanceof PsiClass : "Annotation " + psiAnnotation.getText() +
+                                                        " resolved to something other than a class: " + annotationResolvedTo.getText();
+        return (PsiClass) annotationResolvedTo;
+    }
+
     @NotNull
     private static PsiAnnotation[] getAllAnnotations(@NotNull PsiModifierListOwner owner) {
         List<PsiAnnotation> result = new ArrayList<PsiAnnotation>();

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

@@ -25,8 +25,7 @@ import org.jetbrains.jet.lang.descriptors.Modality;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
-import org.jetbrains.jet.lang.resolve.java.JvmAbi;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
 import org.jetbrains.jet.lang.resolve.java.kt.JetClassObjectAnnotation;
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
@@ -51,8 +50,9 @@ import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName;
 public final class JavaClassObjectResolver {
 
     private BindingTrace trace;
-    private JavaSemanticServices semanticServices;
     private JavaSupertypeResolver supertypesResolver;
+    private PsiDeclarationProviderFactory psiDeclarationProviderFactory;
+    private JavaDescriptorResolver javaDescriptorResolver;
 
     @Inject
     public void setSupertypesResolver(JavaSupertypeResolver supertypesResolver) {
@@ -65,23 +65,24 @@ public final class JavaClassObjectResolver {
     }
 
     @Inject
-    public void setSemanticServices(JavaSemanticServices semanticServices) {
-        this.semanticServices = semanticServices;
+    public void setPsiDeclarationProviderFactory(PsiDeclarationProviderFactory psiDeclarationProviderFactory) {
+        this.psiDeclarationProviderFactory = psiDeclarationProviderFactory;
+    }
+
+    @Inject
+    public void setJavaDescriptorResolver(JavaDescriptorResolver javaDescriptorResolver) {
+        this.javaDescriptorResolver = javaDescriptorResolver;
     }
 
     @Nullable
-    public ClassDescriptorFromJvmBytecode createClassObjectDescriptor(
+    public Result createClassObjectDescriptor(
             @NotNull ClassDescriptor containing,
             @NotNull PsiClass psiClass
     ) {
         DescriptorResolverUtils.checkPsiClassIsNotJet(psiClass);
 
         if (psiClass.isEnum()) {
-            return createClassObjectDescriptorForEnum(containing, psiClass);
-        }
-
-        if (!DescriptorResolverUtils.isKotlinClass(psiClass)) {
-            return null;
+            return new Result(createClassObjectDescriptorForEnum(containing, psiClass), null);
         }
 
         PsiClass classObjectPsiClass = getClassObjectPsiClass(psiClass);
@@ -93,14 +94,14 @@ public final class JavaClassObjectResolver {
     }
 
     @NotNull
-    private ClassDescriptorFromJvmBytecode createClassObjectFromPsi(
+    public Result createClassObjectFromPsi(
             @NotNull ClassDescriptor containing,
             @NotNull PsiClass classObjectPsiClass
     ) {
         String qualifiedName = classObjectPsiClass.getQualifiedName();
         assert qualifiedName != null;
         FqName fqName = new FqName(qualifiedName);
-        ClassPsiDeclarationProvider classObjectData = semanticServices.getPsiDeclarationProviderFactory().createBinaryClassData(classObjectPsiClass);
+        ClassPsiDeclarationProvider classObjectData = psiDeclarationProviderFactory.createBinaryClassData(classObjectPsiClass);
         ClassDescriptorFromJvmBytecode classObjectDescriptor
                 = new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false);
         classObjectDescriptor.setSupertypes(supertypesResolver.getSupertypes(classObjectDescriptor,
@@ -108,7 +109,7 @@ public final class JavaClassObjectResolver {
                                                                              classObjectData,
                                                                              Collections.<TypeParameterDescriptor>emptyList()));
         setUpClassObjectDescriptor(classObjectDescriptor, containing, fqName, classObjectData, getClassObjectName(containing.getName()));
-        return classObjectDescriptor;
+        return new Result(classObjectDescriptor, classObjectPsiClass);
     }
 
     @NotNull
@@ -132,7 +133,7 @@ public final class JavaClassObjectResolver {
         FqNameUnsafe fqName = DescriptorResolverUtils.getFqNameForClassObject(psiClass);
         ClassDescriptorFromJvmBytecode classObjectDescriptor =
                 new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false);
-        ClassPsiDeclarationProvider data = semanticServices.getPsiDeclarationProviderFactory().createSyntheticClassObjectClassData(psiClass);
+        ClassPsiDeclarationProvider data = psiDeclarationProviderFactory.createSyntheticClassObjectClassData(psiClass);
         setUpClassObjectDescriptor(classObjectDescriptor, containing, fqName, data, getClassObjectName(containing.getName().getName()));
         return classObjectDescriptor;
     }
@@ -149,7 +150,7 @@ public final class JavaClassObjectResolver {
         classObjectDescriptor.setVisibility(containing.getVisibility());
         classObjectDescriptor.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
         classObjectDescriptor.createTypeConstructor();
-        JavaClassNonStaticMembersScope classMembersScope = new JavaClassNonStaticMembersScope(classObjectDescriptor, data, semanticServices);
+        JavaClassNonStaticMembersScope classMembersScope = new JavaClassNonStaticMembersScope(classObjectDescriptor, data, javaDescriptorResolver);
         WritableScopeImpl writableScope =
                 new WritableScopeImpl(classMembersScope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION, fqName.toString());
         writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
@@ -160,6 +161,10 @@ public final class JavaClassObjectResolver {
 
     @Nullable
     private static PsiClass getClassObjectPsiClass(@NotNull PsiClass ownerClass) {
+        if (!DescriptorResolverUtils.isKotlinClass(ownerClass)) {
+            return null;
+        }
+
         for (PsiClass inner : ownerClass.getInnerClasses()) {
             if (JetClassObjectAnnotation.get(inner).isDefined()) {
                 return inner;
@@ -167,4 +172,24 @@ public final class JavaClassObjectResolver {
         }
         return null;
     }
+
+    public static final class Result {
+        private final ClassDescriptorFromJvmBytecode classObjectDescriptor;
+        private final PsiClass classObjectPsiClass;
+
+        public Result(@NotNull ClassDescriptorFromJvmBytecode classObjectDescriptor, @Nullable PsiClass classObjectPsiClass) {
+            this.classObjectDescriptor = classObjectDescriptor;
+            this.classObjectPsiClass = classObjectPsiClass;
+        }
+
+        @NotNull
+        public ClassDescriptorFromJvmBytecode getClassObjectDescriptor() {
+            return classObjectDescriptor;
+        }
+
+        @Nullable
+        public PsiClass getClassObjectPsiClass() {
+            return classObjectPsiClass;
+        }
+    }
 }

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

@@ -17,68 +17,42 @@
 package org.jetbrains.jet.lang.resolve.java.resolver;
 
 import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
-import com.intellij.openapi.util.text.StringUtil;
+import com.google.common.collect.Maps;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiModifier;
-import gnu.trove.THashMap;
-import gnu.trove.TObjectHashingStrategy;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
 import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
+import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaClassNonStaticMembersScope;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiClassWrapper;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.FqNameBase;
-import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.JetType;
 
 import javax.inject.Inject;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 
 public final class JavaClassResolver {
 
-    // NOTE: this complexity is introduced because class descriptors do not always have valid fqnames (class objects)
-    @NotNull
-    private final Map<FqNameBase, ClassDescriptor> classDescriptorCache =
-            new THashMap<FqNameBase, ClassDescriptor>(new TObjectHashingStrategy<FqNameBase>() {
-                @Override
-                public int computeHashCode(FqNameBase o) {
-                    if (o instanceof FqName) {
-                        return ((FqName) o).toUnsafe().hashCode();
-                    }
-                    assert o instanceof FqNameUnsafe;
-                    return o.hashCode();
-                }
-
-                @Override
-                public boolean equals(FqNameBase n1, FqNameBase n2) {
-                    return n1.equalsTo(n2.toString()) && n2.equalsTo(n1.toString());
-                }
-            });
-
-    @NotNull
-    private final Set<FqNameBase> unresolvedCache = Sets.newHashSet();
+    private final Map<PsiClass, ClassDescriptor> classDescriptorCache = Maps.newHashMap();
 
     private BindingTrace trace;
     private JavaSignatureResolver signatureResolver;
-    private JavaSemanticServices semanticServices;
+    private JavaClassResolutionFacade classResolutionFacade;
+    private JavaPackageFragmentProvider packageFragmentProvider;
     private JavaAnnotationResolver annotationResolver;
-    private PsiClassFinder psiClassFinder;
-    private JavaNamespaceResolver namespaceResolver;
     private JavaClassObjectResolver classObjectResolver;
     private JavaSupertypeResolver supertypesResolver;
+    private PsiDeclarationProviderFactory psiDeclarationProviderFactory;
+    private JavaDescriptorResolver javaDescriptorResolver;
 
     public JavaClassResolver() {
     }
@@ -99,8 +73,8 @@ public final class JavaClassResolver {
     }
 
     @Inject
-    public void setSemanticServices(JavaSemanticServices semanticServices) {
-        this.semanticServices = semanticServices;
+    public void setClassResolutionFacade(JavaClassResolutionFacade classResolutionFacade) {
+        this.classResolutionFacade = classResolutionFacade;
     }
 
     @Inject
@@ -108,79 +82,67 @@ public final class JavaClassResolver {
         this.annotationResolver = annotationResolver;
     }
 
-    @Inject
-    public void setPsiClassFinder(PsiClassFinder psiClassFinder) {
-        this.psiClassFinder = psiClassFinder;
-    }
-
-    @Inject
-    public void setNamespaceResolver(JavaNamespaceResolver namespaceResolver) {
-        this.namespaceResolver = namespaceResolver;
-    }
-
     @Inject
     public void setSupertypesResolver(JavaSupertypeResolver supertypesResolver) {
         this.supertypesResolver = supertypesResolver;
     }
 
+    @Inject
+    public void setPsiDeclarationProviderFactory(PsiDeclarationProviderFactory psiDeclarationProviderFactory) {
+        this.psiDeclarationProviderFactory = psiDeclarationProviderFactory;
+    }
+
+    @Inject
+    public void setPackageFragmentProvider(JavaPackageFragmentProvider packageFragmentProvider) {
+        this.packageFragmentProvider = packageFragmentProvider;
+    }
+
+    @Inject
+    public void setJavaDescriptorResolver(JavaDescriptorResolver javaDescriptorResolver) {
+        this.javaDescriptorResolver = javaDescriptorResolver;
+    }
+
     @Nullable
-    public ClassDescriptor resolveClass(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
-        PostponedTasks postponedTasks = new PostponedTasks();
-        ClassDescriptor classDescriptor = resolveClass(qualifiedName, searchRule, postponedTasks);
-        postponedTasks.performTasks();
-        return classDescriptor;
+    public ClassDescriptor resolveClass(@NotNull PsiClass psiClass) {
+        return resolveClass(psiClass, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
     }
 
     @Nullable
     public ClassDescriptor resolveClass(
-            @NotNull FqName qualifiedName,
-            @NotNull DescriptorSearchRule searchRule,
-            @NotNull PostponedTasks tasks
+            @NotNull PsiClass psiClass,
+            @NotNull DescriptorSearchRule searchRule
     ) {
-        if (isTraitImplementation(qualifiedName)) {
+        FqName fqName = getFqName(psiClass);
+
+        if (isTraitImplementation(fqName)) {
+            // TODO must report an error
             return null;
         }
 
-        ClassDescriptor builtinClassDescriptor = semanticServices.getKotlinBuiltinClassDescriptor(qualifiedName);
-        if (builtinClassDescriptor != null) {
-            return builtinClassDescriptor;
+        if (DescriptorResolverUtils.isKotlinLightClass(psiClass)) {
+            return searchRule.processFoundInKotlin(classResolutionFacade.getClassDescriptor(psiClass));
         }
 
-        // First, let's check that this is a real Java class, not a Java's view on a Kotlin class:
-        ClassDescriptor kotlinClassDescriptor = semanticServices.getKotlinClassDescriptor(qualifiedName);
-        if (kotlinClassDescriptor != null) {
-            return searchRule.processFoundInKotlin(kotlinClassDescriptor);
+        if (isClassObject(psiClass)) {
+            JavaClassObjectResolver.Result result =
+                    classObjectResolver.createClassObjectFromPsi(resolveParentClass(psiClass), psiClass);
+            cache(psiClass, result.getClassObjectDescriptor());
+            return result.getClassObjectDescriptor();
         }
 
-        // Not let's take a descriptor of a Java class
-        FqNameUnsafe fqName = javaClassToKotlinFqName(qualifiedName);
-        ClassDescriptor cachedDescriptor = classDescriptorCache.get(fqName);
+        ClassDescriptor cachedDescriptor = classDescriptorCache.get(psiClass);
         if (cachedDescriptor != null) {
             return cachedDescriptor;
         }
 
-        if (unresolvedCache.contains(fqName)) {
-            return null;
-        }
-
-        return doResolveClass(qualifiedName, tasks);
+        return createJavaClassDescriptor(psiClass);
     }
 
-    @Nullable
-    private ClassDescriptor doResolveClass(@NotNull FqName qualifiedName, @NotNull PostponedTasks tasks) {
-        PsiClass psiClass = psiClassFinder.findPsiClass(qualifiedName, PsiClassFinder.RuntimeClassesHandleMode.THROW);
-        if (psiClass == null) {
-            cacheNegativeValue(javaClassToKotlinFqName(qualifiedName));
-            return null;
-        }
-        return createJavaClassDescriptor(qualifiedName, psiClass, tasks);
-    }
-
-    private void cacheNegativeValue(@NotNull FqNameBase qualifiedName) {
-        if (unresolvedCache.contains(qualifiedName) || classDescriptorCache.containsKey(qualifiedName)) {
-            throw new IllegalStateException("rewrite at " + qualifiedName);
-        }
-        unresolvedCache.add(qualifiedName);
+    private static boolean isClassObject(@NotNull PsiClass psiClass) {
+        if (!JvmAbi.CLASS_OBJECT_CLASS_NAME.equals(psiClass.getName())) return false;
+        PsiClass containingClass = psiClass.getContainingClass();
+        if (containingClass == null) return false;
+        return DescriptorResolverUtils.isKotlinClass(containingClass);
     }
 
     private static boolean isTraitImplementation(@NotNull FqName qualifiedName) {
@@ -190,41 +152,34 @@ public final class JavaClassResolver {
 
     @NotNull
     private ClassDescriptor createJavaClassDescriptor(
-            @NotNull FqName fqName, @NotNull final PsiClass psiClass,
-            @NotNull PostponedTasks taskList
+            @NotNull final PsiClass psiClass
     ) {
-
-        checkFqNamesAreConsistent(psiClass, fqName);
         DescriptorResolverUtils.checkPsiClassIsNotJet(psiClass);
 
-        ClassOrNamespaceDescriptor containingDeclaration = resolveParentDescriptor(psiClass);
+        ClassOrPackageDescriptor containingDeclaration = resolveParentDescriptor(psiClass);
         // class may be resolved during resolution of parent
-        ClassDescriptor cachedDescriptor = classDescriptorCache.get(javaClassToKotlinFqName(fqName));
+        ClassDescriptor cachedDescriptor = classDescriptorCache.get(psiClass);
         if (cachedDescriptor != null) {
             return cachedDescriptor;
         }
 
-        assert (!unresolvedCache.contains(fqName)) : "We can resolve the class, so it can't be 'unresolved' during parent resolution";
-
-        return doCreateClassDescriptor(fqName, psiClass, taskList, containingDeclaration);
+        return doCreateClassDescriptor(psiClass, containingDeclaration);
     }
 
     @NotNull
     private ClassDescriptorFromJvmBytecode doCreateClassDescriptor(
-            @NotNull FqName fqName,
             @NotNull PsiClass psiClass,
-            @NotNull PostponedTasks taskList,
-            @NotNull ClassOrNamespaceDescriptor containingDeclaration
+            @NotNull ClassOrPackageDescriptor containingDeclaration
     ) {
         JetClassAnnotation jetClassAnnotation = JetClassAnnotation.get(psiClass);
         AbiVersionUtil.checkAbiVersion(psiClass, jetClassAnnotation, trace);
 
         ClassKind kind = getClassKind(psiClass, jetClassAnnotation);
-        ClassPsiDeclarationProvider classData = semanticServices.getPsiDeclarationProviderFactory().createBinaryClassData(psiClass);
+        ClassPsiDeclarationProvider classData = psiDeclarationProviderFactory.createBinaryClassData(psiClass);
         ClassDescriptorFromJvmBytecode classDescriptor = new ClassDescriptorFromJvmBytecode(containingDeclaration, kind,
                                                                                             isInnerClass(psiClass));
 
-        cache(javaClassToKotlinFqName(fqName), classDescriptor);
+        cache(psiClass, classDescriptor);
         classDescriptor.setName(Name.identifier(psiClass.getName()));
 
         List<JavaSignatureResolver.TypeParameterDescriptorInitialization> typeParameterDescriptorInitializations
@@ -236,7 +191,7 @@ public final class JavaClassResolver {
         classDescriptor.setVisibility(DescriptorResolverUtils.resolveVisibility(psiClass, jetClassAnnotation));
         classDescriptor.setModality(resolveModality(psiClass, classDescriptor));
         classDescriptor.createTypeConstructor();
-        JavaClassNonStaticMembersScope membersScope = new JavaClassNonStaticMembersScope(classDescriptor, classData, semanticServices);
+        JavaClassNonStaticMembersScope membersScope = new JavaClassNonStaticMembersScope(classDescriptor, classData, javaDescriptorResolver);
         classDescriptor.setScopeForMemberLookup(membersScope);
         classDescriptor.setScopeForConstructorResolve(membersScope);
 
@@ -247,27 +202,26 @@ public final class JavaClassResolver {
         List<TypeParameterDescriptor> classTypeParameters = classDescriptor.getTypeConstructor().getParameters();
         supertypes.addAll(supertypesResolver.getSupertypes(classDescriptor, new PsiClassWrapper(psiClass), classData, classTypeParameters));
 
-        ClassDescriptorFromJvmBytecode classObjectDescriptor = classObjectResolver.createClassObjectDescriptor(classDescriptor, psiClass);
-        cache(DescriptorResolverUtils.getFqNameForClassObject(psiClass), classObjectDescriptor);
-        if (classObjectDescriptor != null) {
-            classDescriptor.getBuilder().setClassObjectDescriptor(classObjectDescriptor);
+        JavaClassObjectResolver.Result classObject = classObjectResolver.createClassObjectDescriptor(classDescriptor, psiClass);
+        if (classObject != null) {
+            PsiClass classObjectPsiClass = classObject.getClassObjectPsiClass();
+            if (classObjectPsiClass != null) {
+                cache(classObjectPsiClass, classObject.getClassObjectDescriptor());
+
+            }
+            classDescriptor.getBuilder().setClassObjectDescriptor(classObject.getClassObjectDescriptor());
         }
 
-        classDescriptor.setAnnotations(annotationResolver.resolveAnnotations(psiClass, taskList));
+        classDescriptor.setAnnotations(annotationResolver.resolveAnnotations(psiClass));
 
         trace.record(BindingContext.CLASS, psiClass, classDescriptor);
 
         return classDescriptor;
     }
 
-    private void cache(@NotNull FqNameBase fqName, @Nullable ClassDescriptor classDescriptor) {
-        if (classDescriptor == null) {
-            cacheNegativeValue(fqName);
-        }
-        else {
-            ClassDescriptor oldValue = classDescriptorCache.put(fqName, classDescriptor);
-            assert oldValue == null;
-        }
+    private void cache(@NotNull PsiClass psiClass, @NotNull ClassDescriptor classDescriptor) {
+        ClassDescriptor oldValue = classDescriptorCache.put(psiClass, classDescriptor);
+        assert oldValue == null;
     }
 
     @NotNull
@@ -291,25 +245,13 @@ public final class JavaClassResolver {
                 !psiClass.hasModifierProperty(PsiModifier.FINAL));
     }
 
-    void checkFqNamesAreConsistent(@NotNull PsiClass psiClass, @NotNull FqName desiredFqName) {
-        final String qualifiedName = psiClass.getQualifiedName();
-        assert qualifiedName != null;
-
-        FqName fqName = new FqName(qualifiedName);
-        assert fqName.equals(desiredFqName);
-        FqNameUnsafe correctedName = javaClassToKotlinFqName(fqName);
-        if (classDescriptorCache.containsKey(correctedName) || unresolvedCache.contains(correctedName)) {
-            throw new IllegalStateException(qualifiedName);
-        }
-    }
-
     @NotNull
-    private ClassOrNamespaceDescriptor resolveParentDescriptor(@NotNull PsiClass psiClass) {
+    private ClassOrPackageDescriptor resolveParentDescriptor(@NotNull PsiClass psiClass) {
         if (isContainedInClass(psiClass)) {
             return resolveParentClass(psiClass);
         }
         else {
-            return resolveParentNamespace(psiClass);
+            return packageFragmentProvider.getPackageFragment(getFqName(psiClass).parent());
         }
     }
 
@@ -320,23 +262,6 @@ public final class JavaClassResolver {
         return new FqName(qualifiedName);
     }
 
-    // This method replaces "object" segments of FQ name to "<class-object-for-...>"
-    @NotNull
-    private static FqNameUnsafe javaClassToKotlinFqName(@NotNull FqName rawFqName) {
-        List<Name> correctedSegments = new ArrayList<Name>();
-        for (Name segment : rawFqName.pathSegments()) {
-            if (JvmAbi.CLASS_OBJECT_CLASS_NAME.equals(segment.getName())) {
-                assert !correctedSegments.isEmpty();
-                Name previous = correctedSegments.get(correctedSegments.size() - 1);
-                correctedSegments.add(DescriptorUtils.getClassObjectName(previous));
-            }
-            else {
-                correctedSegments.add(segment);
-            }
-        }
-        return new FqNameUnsafe(StringUtil.join(correctedSegments, "."));
-    }
-
     private static boolean isContainedInClass(@NotNull PsiClass psiClass) {
         return psiClass.getContainingClass() != null;
     }
@@ -346,29 +271,17 @@ public final class JavaClassResolver {
     }
 
     @NotNull
-    private ClassOrNamespaceDescriptor resolveParentClass(@NotNull PsiClass psiClass) {
+    private ClassDescriptor resolveParentClass(@NotNull PsiClass psiClass) {
         PsiClass containingClass = psiClass.getContainingClass();
         assert containingClass != null;
-        FqName containerFqName = getFqName(containingClass);
-        ClassDescriptor parentClass = resolveClass(containerFqName, DescriptorSearchRule.INCLUDE_KOTLIN);
+        ClassDescriptor parentClass = resolveClass(containingClass, DescriptorSearchRule.INCLUDE_KOTLIN);
         if (parentClass == null) {
             throw new IllegalStateException(
-                    "PsiClass not found by name " + containerFqName + ", required to be container declaration of " + getFqName(psiClass));
+                    "PsiClass not found by name " + getFqName(containingClass) + ", required to be container declaration of " + getFqName(psiClass));
         }
         return parentClass;
     }
 
-    @NotNull
-    private ClassOrNamespaceDescriptor resolveParentNamespace(@NotNull PsiClass psiClass) {
-        FqName namespaceFqName = getFqName(psiClass).parent();
-        NamespaceDescriptor parentNamespace = namespaceResolver.resolveNamespace(namespaceFqName, DescriptorSearchRule.INCLUDE_KOTLIN);
-        if (parentNamespace == null) {
-            throw new IllegalStateException("cannot resolve namespace " + namespaceFqName +
-                                            ", required to be container for " + getFqName(psiClass));
-        }
-        return parentNamespace;
-    }
-
     @NotNull
     private static ClassKind getClassKind(@NotNull PsiClass psiClass, @NotNull JetClassAnnotation jetClassAnnotation) {
         if (psiClass.isInterface()) {
@@ -382,8 +295,4 @@ public final class JavaClassResolver {
         }
     }
 
-    @Nullable
-    public ClassDescriptor resolveClass(FqName name) {
-        return resolveClass(name, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
-    }
 }

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

@@ -19,13 +19,15 @@ package org.jetbrains.jet.lang.resolve.java.resolver;
 import com.google.common.collect.Lists;
 import com.intellij.psi.*;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
+import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
+import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.constants.*;
 import org.jetbrains.jet.lang.resolve.constants.StringValue;
 import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
-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;
@@ -55,31 +57,30 @@ public final class JavaCompileTimeConstResolver {
 
     @Nullable
     public CompileTimeConstant<?> getCompileTimeConstFromExpression(
-            FqName annotationFqName, Name parameterName,
-            PsiAnnotationMemberValue value, PostponedTasks postponedTasks
+            PsiClass annotationPsiClass, Name parameterName,
+            PsiAnnotationMemberValue value
     ) {
         if (value instanceof PsiLiteralExpression) {
             return getCompileTimeConstFromLiteralExpression((PsiLiteralExpression) value);
         }
         // Enum
         else if (value instanceof PsiReferenceExpression) {
-            return getCompileTimeConstFromReferenceExpression((PsiReferenceExpression) value, postponedTasks);
+            return getCompileTimeConstFromReferenceExpression((PsiReferenceExpression) value);
         }
         // Array
         else if (value instanceof PsiArrayInitializerMemberValue) {
-            return getCompileTimeConstFromArrayExpression(annotationFqName, parameterName, (PsiArrayInitializerMemberValue) value,
-                                                          postponedTasks);
+            return getCompileTimeConstFromArrayExpression(annotationPsiClass, parameterName, (PsiArrayInitializerMemberValue) value);
         }
         // Annotation
         else if (value instanceof PsiAnnotation) {
-            return getCompileTimeConstFromAnnotation((PsiAnnotation) value, postponedTasks);
+            return getCompileTimeConstFromAnnotation((PsiAnnotation) value);
         }
         return null;
     }
 
     @Nullable
-    private CompileTimeConstant<?> getCompileTimeConstFromAnnotation(PsiAnnotation value, PostponedTasks taskList) {
-        AnnotationDescriptor annotationDescriptor = annotationResolver.resolveAnnotation(value, taskList);
+    private CompileTimeConstant<?> getCompileTimeConstFromAnnotation(PsiAnnotation value) {
+        AnnotationDescriptor annotationDescriptor = annotationResolver.resolveAnnotation(value);
         if (annotationDescriptor != null) {
             return new AnnotationValue(annotationDescriptor);
         }
@@ -88,15 +89,14 @@ public final class JavaCompileTimeConstResolver {
 
     @Nullable
     private CompileTimeConstant<?> getCompileTimeConstFromArrayExpression(
-            FqName annotationFqName,
-            Name valueName, PsiArrayInitializerMemberValue value,
-            PostponedTasks taskList
+            PsiClass annotationPsiClass,
+            Name valueName, PsiArrayInitializerMemberValue value
     ) {
         PsiAnnotationMemberValue[] initializers = value.getInitializers();
-        List<CompileTimeConstant<?>> values = getCompileTimeConstantForArrayValues(annotationFqName, valueName, taskList, initializers);
+        List<CompileTimeConstant<?>> values = getCompileTimeConstantForArrayValues(annotationPsiClass, valueName, initializers);
 
         ClassDescriptor classDescriptor =
-                classResolver.resolveClass(annotationFqName, DescriptorSearchRule.INCLUDE_KOTLIN, taskList);
+                classResolver.resolveClass(annotationPsiClass, DescriptorSearchRule.INCLUDE_KOTLIN);
 
         //TODO: nullability issues
         ValueParameterDescriptor valueParameterDescriptor =
@@ -109,15 +109,14 @@ public final class JavaCompileTimeConstResolver {
     }
 
     private List<CompileTimeConstant<?>> getCompileTimeConstantForArrayValues(
-            FqName annotationQualifiedName,
+            PsiClass annotationPsiClass,
             Name valueName,
-            PostponedTasks taskList,
             PsiAnnotationMemberValue[] initializers
     ) {
         List<CompileTimeConstant<?>> values = new ArrayList<CompileTimeConstant<?>>();
         for (PsiAnnotationMemberValue initializer : initializers) {
             CompileTimeConstant<?> compileTimeConstant =
-                    getCompileTimeConstFromExpression(annotationQualifiedName, valueName, initializer, taskList);
+                    getCompileTimeConstFromExpression(annotationPsiClass, valueName, initializer);
             if (compileTimeConstant == null) {
                 compileTimeConstant = NullValue.NULL;
             }
@@ -127,19 +126,14 @@ public final class JavaCompileTimeConstResolver {
     }
 
     @Nullable
-    private CompileTimeConstant<?> getCompileTimeConstFromReferenceExpression(PsiReferenceExpression value, PostponedTasks taskList) {
+    private CompileTimeConstant<?> getCompileTimeConstFromReferenceExpression(PsiReferenceExpression value) {
         PsiElement resolveElement = value.resolve();
         if (resolveElement instanceof PsiEnumConstant) {
             PsiElement psiElement = resolveElement.getParent();
             if (psiElement instanceof PsiClass) {
                 PsiClass psiClass = (PsiClass) psiElement;
-                String fqName = psiClass.getQualifiedName();
-                if (fqName == null) {
-                    return null;
-                }
 
-                JetScope scope;
-                ClassDescriptor classDescriptor = classResolver.resolveClass(new FqName(fqName), DescriptorSearchRule.INCLUDE_KOTLIN, taskList);
+                ClassDescriptor classDescriptor = classResolver.resolveClass(psiClass, DescriptorSearchRule.INCLUDE_KOTLIN);
                 if (classDescriptor == null) {
                     return null;
                 }
@@ -147,7 +141,7 @@ public final class JavaCompileTimeConstResolver {
                 if (classObjectDescriptor == null) {
                     return null;
                 }
-                scope = classObjectDescriptor.getMemberScope(Lists.<TypeProjection>newArrayList());
+                JetScope scope = classObjectDescriptor.getMemberScope(Lists.<TypeProjection>newArrayList());
 
                 Name identifier = Name.identifier(((PsiEnumConstant) resolveElement).getName());
                 Collection<VariableDescriptor> properties = scope.getProperties(identifier);

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

@@ -92,7 +92,7 @@ public final class JavaFunctionResolver {
     @Nullable
     private SimpleFunctionDescriptor resolveMethodToFunctionDescriptor(
             @NotNull final PsiClass psiClass, final PsiMethodWrapper method,
-            @NotNull PsiDeclarationProvider scopeData, @NotNull ClassOrNamespaceDescriptor ownerDescriptor
+            @NotNull PsiDeclarationProvider scopeData, @NotNull ClassOrPackageDescriptor ownerDescriptor
     ) {
         PsiType returnPsiType = method.getReturnType();
         if (returnPsiType == null) {
@@ -255,7 +255,7 @@ public final class JavaFunctionResolver {
 
     @NotNull
     private Set<FunctionDescriptor> resolveNamedGroupFunctions(
-            @NotNull ClassOrNamespaceDescriptor owner, @NotNull PsiClass psiClass,
+            @NotNull ClassOrPackageDescriptor owner, @NotNull PsiClass psiClass,
             NamedMembers namedMembers, Name methodName, PsiDeclarationProvider scopeData
     ) {
         final Set<FunctionDescriptor> functions = new HashSet<FunctionDescriptor>();
@@ -311,7 +311,7 @@ public final class JavaFunctionResolver {
     public Set<FunctionDescriptor> resolveFunctionGroup(
             @NotNull Name methodName,
             @NotNull ClassPsiDeclarationProvider scopeData,
-            @NotNull ClassOrNamespaceDescriptor ownerDescriptor
+            @NotNull ClassOrPackageDescriptor ownerDescriptor
     ) {
 
         NamedMembers namedMembers = scopeData.getMembersCache().get(methodName);
@@ -332,7 +332,7 @@ public final class JavaFunctionResolver {
 
         JetType transformedType;
         if (returnTypeFromAnnotation.length() > 0) {
-            transformedType = typeTransformer.transformToType(returnTypeFromAnnotation, typeVariableResolver);
+            transformedType = typeTransformer.transformToType(method.getPsiMember().getResolveScope(), returnTypeFromAnnotation, typeVariableResolver);
         }
         else {
             transformedType = typeTransformer.transformToType(
@@ -350,10 +350,10 @@ public final class JavaFunctionResolver {
 
     @NotNull
     private static Set<SimpleFunctionDescriptor> getFunctionsFromSupertypes(
-            @NotNull Name methodName, @NotNull ClassOrNamespaceDescriptor classOrNamespaceDescriptor
+            @NotNull Name methodName, @NotNull ClassOrPackageDescriptor classOrPackageDescriptor
     ) {
         Set<SimpleFunctionDescriptor> r = Sets.newLinkedHashSet();
-        for (JetType supertype : DescriptorResolverUtils.getSupertypes(classOrNamespaceDescriptor)) {
+        for (JetType supertype : DescriptorResolverUtils.getSupertypes(classOrPackageDescriptor)) {
             for (FunctionDescriptor function : supertype.getMemberScope().getFunctions(methodName)) {
                 r.add((SimpleFunctionDescriptor) function);
             }

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

@@ -23,7 +23,6 @@ import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.java.kt.JetClassObjectAnnotation;
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
-import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import javax.inject.Inject;
 import java.util.ArrayList;
@@ -71,10 +70,8 @@ public final class JavaInnerClassResolver {
 
     @NotNull
     private ClassDescriptor resolveInnerClass(@NotNull PsiClass innerPsiClass) {
-        String name = innerPsiClass.getQualifiedName();
-        assert name != null : "Inner class has no qualified name";
-        ClassDescriptor classDescriptor = classResolver.resolveClass(new FqName(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
-        assert classDescriptor != null : "Couldn't resolve class " + name;
+        ClassDescriptor classDescriptor = classResolver.resolveClass(innerPsiClass, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
+        assert classDescriptor != null : "Couldn't resolve class " + innerPsiClass.getText();
         return classDescriptor;
     }
 }

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

@@ -1,210 +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.resolver;
-
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiPackage;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
-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.kt.JetPackageClassAnnotation;
-import org.jetbrains.jet.lang.resolve.java.scope.JavaBaseScope;
-import org.jetbrains.jet.lang.resolve.java.scope.JavaClassStaticMembersScope;
-import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScopeWithoutMembers;
-import org.jetbrains.jet.lang.resolve.java.scope.JavaScopeForKotlinNamespace;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-
-import javax.inject.Inject;
-import java.util.Collections;
-import java.util.Map;
-import java.util.Set;
-
-public final class JavaNamespaceResolver {
-
-    @NotNull
-    public static final ModuleDescriptor FAKE_ROOT_MODULE = new ModuleDescriptor(JavaDescriptorResolver.JAVA_ROOT);
-    @NotNull
-    private final Map<FqName, JavaBaseScope> resolvedNamespaceCache = Maps.newHashMap();
-    @NotNull
-    private final Set<FqName> unresolvedCache = Sets.newHashSet();
-
-    private PsiClassFinder psiClassFinder;
-    private BindingTrace trace;
-    private JavaSemanticServices javaSemanticServices;
-
-    public JavaNamespaceResolver() {
-    }
-
-    @Inject
-    public void setPsiClassFinder(PsiClassFinder psiClassFinder) {
-        this.psiClassFinder = psiClassFinder;
-    }
-
-    @Inject
-    public void setTrace(BindingTrace trace) {
-        this.trace = trace;
-    }
-
-    @Inject
-    public void setJavaSemanticServices(JavaSemanticServices javaSemanticServices) {
-        this.javaSemanticServices = javaSemanticServices;
-    }
-
-    @Nullable
-    public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
-        // First, let's check that there is no Kotlin package:
-        NamespaceDescriptor kotlinNamespaceDescriptor = javaSemanticServices.getKotlinNamespaceDescriptor(qualifiedName);
-        if (kotlinNamespaceDescriptor != null) {
-            return searchRule.processFoundInKotlin(kotlinNamespaceDescriptor);
-        }
-
-        if (unresolvedCache.contains(qualifiedName)) {
-            return null;
-        }
-        JavaBaseScope scope = resolvedNamespaceCache.get(qualifiedName);
-        if (scope != null) {
-            return (NamespaceDescriptor) scope.getContainingDeclaration();
-        }
-
-        NamespaceDescriptorParent parentNs = resolveParentNamespace(qualifiedName);
-        if (parentNs == null) {
-            return null;
-        }
-
-        JavaNamespaceDescriptor javaNamespaceDescriptor = new JavaNamespaceDescriptor(
-                parentNs,
-                Collections.<AnnotationDescriptor>emptyList(), // TODO
-                qualifiedName
-        );
-
-        JavaBaseScope newScope = createNamespaceScope(qualifiedName, javaNamespaceDescriptor);
-        if (newScope == null) {
-            return null;
-        }
-
-        trace.record(BindingContext.NAMESPACE, newScope.getPsiElement(), javaNamespaceDescriptor);
-
-        javaNamespaceDescriptor.setMemberScope(newScope);
-
-        return javaNamespaceDescriptor;
-    }
-
-    @Nullable
-    public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName) {
-        return resolveNamespace(qualifiedName, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
-    }
-
-    @Nullable
-    private NamespaceDescriptorParent resolveParentNamespace(@NotNull FqName fqName) {
-        if (fqName.isRoot()) {
-            return FAKE_ROOT_MODULE;
-        }
-        else {
-            return resolveNamespace(fqName.parent(), DescriptorSearchRule.INCLUDE_KOTLIN);
-        }
-    }
-
-    @Nullable
-    private JavaBaseScope createNamespaceScope(
-            @NotNull FqName fqName,
-            @NotNull NamespaceDescriptor namespaceDescriptor
-    ) {
-        JavaBaseScope namespaceScope = doCreateNamespaceScope(fqName, namespaceDescriptor);
-        cache(fqName, namespaceScope);
-        return namespaceScope;
-    }
-
-    @Nullable
-    private JavaBaseScope doCreateNamespaceScope(
-            @NotNull FqName fqName,
-            @NotNull NamespaceDescriptor namespaceDescriptor
-    ) {
-        PsiPackage psiPackage = psiClassFinder.findPsiPackage(fqName);
-        if (psiPackage != null) {
-            PsiClass psiClass = getPsiClassForJavaPackageScope(fqName);
-            trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, namespaceDescriptor, JavaNamespaceKind.PROPER);
-            if (psiClass == null) {
-                return new JavaPackageScopeWithoutMembers(
-                        namespaceDescriptor,
-                        javaSemanticServices.getPsiDeclarationProviderFactory().createDeclarationProviderForNamespaceWithoutMembers(psiPackage),
-                        fqName, javaSemanticServices);
-            }
-
-            AbiVersionUtil.checkAbiVersion(psiClass, JetPackageClassAnnotation.get(psiClass), trace);
-            return new JavaScopeForKotlinNamespace(
-                    namespaceDescriptor,
-                    javaSemanticServices.getPsiDeclarationProviderFactory().createDeclarationForKotlinNamespace(psiPackage, psiClass),
-                    fqName, javaSemanticServices);
-        }
-
-        PsiClass psiClass = psiClassFinder.findPsiClass(fqName, PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
-        if (psiClass == null) {
-            return null;
-        }
-        if (psiClass.isEnum()) {
-            // NOTE: we don't want to create namespace for enum classes because we put
-            // static members of enum class into class object descriptor
-            return null;
-        }
-        trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, namespaceDescriptor, JavaNamespaceKind.CLASS_STATICS);
-        return new JavaClassStaticMembersScope(
-                namespaceDescriptor,
-                javaSemanticServices.getPsiDeclarationProviderFactory().createDeclarationProviderForClassStaticMembers(psiClass),
-                fqName, javaSemanticServices);
-    }
-
-    private void cache(@NotNull FqName fqName, @Nullable JavaBaseScope packageScope) {
-        if (packageScope == null) {
-            unresolvedCache.add(fqName);
-            return;
-        }
-        JavaBaseScope oldValue = resolvedNamespaceCache.put(fqName, packageScope);
-        if (oldValue != null) {
-            throw new IllegalStateException("rewrite at " + fqName);
-        }
-    }
-
-    @Nullable
-    public JavaBaseScope 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);
-        }
-        JavaBaseScope alreadyResolvedScope = resolvedNamespaceCache.get(fqName);
-        if (alreadyResolvedScope != null) {
-            return alreadyResolvedScope;
-        }
-        return createNamespaceScope(fqName, namespaceDescriptor);
-    }
-
-    @Nullable
-    private PsiClass getPsiClassForJavaPackageScope(@NotNull FqName packageFQN) {
-        return psiClassFinder.findPsiClass(PackageClassUtils.getPackageClassFqName(packageFQN), PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
-    }
-}

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

@@ -17,6 +17,7 @@
 package org.jetbrains.jet.lang.resolve.java.resolver;
 
 import com.google.common.collect.Sets;
+import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -48,19 +49,14 @@ import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.JAV
 
 public final class JavaPropertyResolver {
 
-    private JavaSemanticServices semanticServices;
     private JavaSignatureResolver javaSignatureResolver;
     private BindingTrace trace;
     private JavaAnnotationResolver annotationResolver;
+    private JavaTypeTransformer typeTransformer;
 
     public JavaPropertyResolver() {
     }
 
-    @Inject
-    public void setSemanticServices(JavaSemanticServices semanticServices) {
-        this.semanticServices = semanticServices;
-    }
-
     @Inject
     public void setTrace(BindingTrace trace) {
         this.trace = trace;
@@ -76,11 +72,16 @@ public final class JavaPropertyResolver {
         this.annotationResolver = annotationResolver;
     }
 
+    @Inject
+    public void setTypeTransformer(JavaTypeTransformer typeTransformer) {
+        this.typeTransformer = typeTransformer;
+    }
+
     @NotNull
     public Set<VariableDescriptor> resolveFieldGroupByName(
             @NotNull Name fieldName,
             @NotNull PsiDeclarationProvider scopeData,
-            @NotNull ClassOrNamespaceDescriptor ownerDescriptor
+            @NotNull ClassOrPackageDescriptor ownerDescriptor
     ) {
         NamedMembers namedMembers = scopeData.getMembersCache().get(fieldName);
         if (namedMembers == null) {
@@ -93,7 +94,7 @@ public final class JavaPropertyResolver {
 
     @NotNull
     private Set<VariableDescriptor> resolveNamedGroupProperties(
-            @NotNull ClassOrNamespaceDescriptor ownerDescriptor,
+            @NotNull ClassOrPackageDescriptor ownerDescriptor,
             @NotNull PsiDeclarationProvider scopeData,
             @NotNull NamedMembers namedMembers,
             @NotNull Name propertyName,
@@ -129,7 +130,7 @@ public final class JavaPropertyResolver {
     }
 
     private static void generateOverrides(
-            @NotNull ClassOrNamespaceDescriptor owner,
+            @NotNull ClassOrPackageDescriptor owner,
             @NotNull Name propertyName,
             @NotNull Set<PropertyDescriptor> propertiesFromCurrent,
             @NotNull Set<PropertyDescriptor> propertiesFromSupertypes,
@@ -160,7 +161,7 @@ public final class JavaPropertyResolver {
 
     @NotNull
     private PropertyDescriptor resolveProperty(
-            @NotNull ClassOrNamespaceDescriptor owner,
+            @NotNull ClassOrPackageDescriptor owner,
             @NotNull PsiDeclarationProvider scopeData,
             @NotNull Name propertyName,
             @NotNull String context,
@@ -375,10 +376,11 @@ public final class JavaPropertyResolver {
             TypeVariableResolver typeVariableResolverForPropertyInternals
     ) {
         if (!characteristicMember.getType().getTypeString().isEmpty()) {
-            return semanticServices.getTypeTransformer().transformToType(
-                    characteristicMember.getType().getTypeString(), typeVariableResolverForPropertyInternals);
+            GlobalSearchScope resolveScope = characteristicMember.getMember().getPsiMember().getResolveScope();
+            return typeTransformer.transformToType(
+                    resolveScope, characteristicMember.getType().getTypeString(), typeVariableResolverForPropertyInternals);
         }
-        JetType propertyType = semanticServices.getTypeTransformer().transformToType(
+        JetType propertyType = typeTransformer.transformToType(
                 characteristicMember.getType().getPsiType(), typeVariableResolverForPropertyInternals);
 
         boolean hasNotNullAnnotation = JavaAnnotationResolver.findAnnotationWithExternal(
@@ -400,9 +402,12 @@ public final class JavaPropertyResolver {
             return null;
         }
         if (!characteristicMember.getReceiverType().getTypeString().isEmpty()) {
-            return semanticServices.getTypeTransformer().transformToType(characteristicMember.getReceiverType().getTypeString(), typeVariableResolverForPropertyInternals);
+            GlobalSearchScope resolveScope = characteristicMember.getMember().getPsiMember().getResolveScope();
+            return typeTransformer.transformToType(resolveScope, characteristicMember.getReceiverType().getTypeString(),
+                                                   typeVariableResolverForPropertyInternals);
         }
-        return semanticServices.getTypeTransformer().transformToType(characteristicMember.getReceiverType().getPsiType(), typeVariableResolverForPropertyInternals);
+        return typeTransformer.transformToType(characteristicMember.getReceiverType().getPsiType(),
+                                               typeVariableResolverForPropertyInternals);
     }
 
     private static int getNumberOfNonExtensionProperties(@NotNull Collection<PropertyPsiData> propertyPsiDataCollection) {
@@ -424,7 +429,7 @@ public final class JavaPropertyResolver {
 
     @NotNull
     private static Set<PropertyDescriptor> getPropertiesFromSupertypes(
-            @NotNull Name propertyName, @NotNull ClassOrNamespaceDescriptor ownerDescriptor
+            @NotNull Name propertyName, @NotNull ClassOrPackageDescriptor ownerDescriptor
     ) {
         Set<PropertyDescriptor> r = new HashSet<PropertyDescriptor>();
         for (JetType supertype : DescriptorResolverUtils.getSupertypes(ownerDescriptor)) {

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

@@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.Variance;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -45,11 +46,17 @@ import java.util.List;
 public final class JavaSignatureResolver {
 
     @NotNull
-    private JavaSemanticServices semanticServices;
+    private DependencyClassByQualifiedNameResolver classByQualifiedNameResolver;
+    private JavaTypeTransformer typeTransformer;
 
     @Inject
-    public void setJavaSemanticServices(@NotNull JavaSemanticServices javaSemanticServices) {
-        this.semanticServices = javaSemanticServices;
+    public void setDependencyClassByQualifiedNameResolver(@NotNull DependencyClassByQualifiedNameResolver classByQualifiedNameResolver) {
+        this.classByQualifiedNameResolver = classByQualifiedNameResolver;
+    }
+
+    @Inject
+    public void setTypeTransformer(JavaTypeTransformer typeTransformer) {
+        this.typeTransformer = typeTransformer;
     }
 
     private static boolean isJavaLangObject(@NotNull JetType type) {
@@ -140,7 +147,7 @@ public final class JavaSignatureResolver {
 
         @Override
         public JetSignatureVisitor visitClassBound() {
-            return new JetTypeJetSignatureReader(semanticServices, KotlinBuiltIns.getInstance(), typeVariableResolver) {
+            return new JetTypeJetSignatureReader(classByQualifiedNameResolver, KotlinBuiltIns.getInstance(), typeVariableResolver) {
                 @Override
                 protected void done(@NotNull JetType jetType) {
                     if (isJavaLangObject(jetType)) {
@@ -153,7 +160,7 @@ public final class JavaSignatureResolver {
 
         @Override
         public JetSignatureVisitor visitInterfaceBound() {
-            return new JetTypeJetSignatureReader(semanticServices, KotlinBuiltIns.getInstance(), typeVariableResolver) {
+            return new JetTypeJetSignatureReader(classByQualifiedNameResolver, KotlinBuiltIns.getInstance(), typeVariableResolver) {
                 @Override
                 protected void done(@NotNull JetType jetType) {
                     upperBounds.add(jetType);
@@ -293,11 +300,13 @@ public final class JavaSignatureResolver {
                 typeParameterDescriptor.addUpperBound(KotlinBuiltIns.getInstance().getNullableAnyType());
             }
             else if (referencedTypes.length == 1) {
-                typeParameterDescriptor.addUpperBound(semanticServices.getTypeTransformer().transformToType(referencedTypes[0], TypeUsage.UPPER_BOUND, typeVariableByPsiResolver));
+                typeParameterDescriptor.addUpperBound(typeTransformer.transformToType(referencedTypes[0], TypeUsage.UPPER_BOUND,
+                                                                                      typeVariableByPsiResolver));
             }
             else {
                 for (PsiClassType referencedType : referencedTypes) {
-                    typeParameterDescriptor.addUpperBound(semanticServices.getTypeTransformer().transformToType(referencedType, TypeUsage.UPPER_BOUND, typeVariableByPsiResolver));
+                    typeParameterDescriptor.addUpperBound(typeTransformer.transformToType(referencedType, TypeUsage.UPPER_BOUND,
+                                                                                          typeVariableByPsiResolver));
                 }
             }
         }

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

@@ -16,13 +16,17 @@
 
 package org.jetbrains.jet.lang.resolve.java.resolver;
 
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.JavaPsiFacade;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiClassType;
+import com.intellij.psi.search.GlobalSearchScope;
 import jet.typeinfo.TypeInfoVariance;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassKind;
+import org.jetbrains.jet.lang.descriptors.SubModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
@@ -48,20 +52,16 @@ import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.KOT
 public final class JavaSupertypeResolver {
 
     private BindingTrace trace;
-    private JavaSemanticServices semanticServices;
     private JavaTypeTransformer typeTransformer;
     private JavaClassResolver classResolver;
+    private Project project;
+    private SubModuleDescriptor subModule;
 
     @Inject
     public void setTrace(BindingTrace trace) {
         this.trace = trace;
     }
 
-    @Inject
-    public void setSemanticServices(JavaSemanticServices semanticServices) {
-        this.semanticServices = semanticServices;
-    }
-
     @Inject
     public void setTypeTransformer(JavaTypeTransformer typeTransformer) {
         this.typeTransformer = typeTransformer;
@@ -72,6 +72,16 @@ public final class JavaSupertypeResolver {
         this.classResolver = classResolver;
     }
 
+    @Inject
+    public void setProject(Project project) {
+        this.project = project;
+    }
+
+    @Inject
+    public void setSubModule(@NotNull SubModuleDescriptor subModule) {
+        this.subModule = subModule;
+    }
+
     public Collection<JetType> getSupertypes(
             @NotNull ClassDescriptor classDescriptor,
             @NotNull PsiClassWrapper psiClass,
@@ -102,7 +112,7 @@ public final class JavaSupertypeResolver {
     }
 
     private void readSuperTypes(
-            PsiClassWrapper psiClass,
+            final PsiClassWrapper psiClass,
             List<TypeParameterDescriptor> typeParameters,
             ClassDescriptor classDescriptor,
             final List<JetType> result,
@@ -120,8 +130,8 @@ public final class JavaSupertypeResolver {
 
             @Override
             public JetSignatureVisitor visitSuperclass() {
-                return new JetTypeJetSignatureReader(semanticServices, KotlinBuiltIns.getInstance(),
-                                                     typeVariableResolver) {
+                JavaDependencyByQualifiedNameResolver resolver = new JavaDependencyByQualifiedNameResolver(subModule);
+                return new JetTypeJetSignatureReader(resolver, KotlinBuiltIns.getInstance(), typeVariableResolver) {
                     @Override
                     protected void done(@NotNull JetType jetType) {
                         if (!jetType.equals(KotlinBuiltIns.getInstance().getAnyType())) {
@@ -151,7 +161,7 @@ public final class JavaSupertypeResolver {
             result.add(KotlinBuiltIns.getInstance().getAnyType());
         }
         else {
-            ClassDescriptor object = resolveJavaLangObject();
+            ClassDescriptor object = resolveJavaLangObject(psiClass.getPsiClass().getResolveScope());
             if (object != null) {
                 result.add(object.getDefaultType());
             }
@@ -198,9 +208,12 @@ public final class JavaSupertypeResolver {
 
 
     @Nullable
-    private ClassDescriptor resolveJavaLangObject() {
-        ClassDescriptor clazz = classResolver.resolveClass(DescriptorResolverUtils.OBJECT_FQ_NAME,
-                                                           DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
+    private ClassDescriptor resolveJavaLangObject(@NotNull GlobalSearchScope scope) {
+        JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(project);
+        PsiClass psiClass = javaPsiFacade.findClass(DescriptorResolverUtils.OBJECT_FQ_NAME.getFqName(), scope);
+        if (psiClass == null) return null;
+
+        ClassDescriptor clazz = classResolver.resolveClass(psiClass, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
         if (clazz == null) {
             // TODO: warning
         }

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

@@ -68,7 +68,7 @@ public final class JavaValueParameterResolver {
 
         JetType outType;
         if (typeFromAnnotation.length() > 0) {
-            outType = getTypeTransformer().transformToType(typeFromAnnotation, typeVariableResolver);
+            outType = getTypeTransformer().transformToType(parameter.getPsiParameter().getResolveScope(), typeFromAnnotation, typeVariableResolver);
         }
         else {
             outType = getTypeTransformer().transformToType(psiType, TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT,

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaBaseScope.java

@@ -25,7 +25,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers;
 import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProvider;
@@ -40,8 +39,8 @@ import java.util.Set;
 
 public abstract class JavaBaseScope extends JetScopeImpl {
 
-    @NotNull
-    protected final JavaSemanticServices semanticServices;
+    protected final JavaDescriptorResolver javaDescriptorResolver;
+
     @NotNull
     protected final PsiDeclarationProvider declarationProvider;
     @NotNull
@@ -51,17 +50,17 @@ public abstract class JavaBaseScope extends JetScopeImpl {
     @Nullable
     private Collection<DeclarationDescriptor> allDescriptors = null;
     @NotNull
-    protected final ClassOrNamespaceDescriptor descriptor;
+    protected final ClassOrPackageDescriptor descriptor;
 
     private Collection<ClassDescriptor> innerClasses = null;
 
 
     protected JavaBaseScope(
-            @NotNull ClassOrNamespaceDescriptor descriptor,
-            @NotNull JavaSemanticServices semanticServices,
+            @NotNull ClassOrPackageDescriptor descriptor,
+            @NotNull JavaDescriptorResolver javaDescriptorResolver,
             @NotNull PsiDeclarationProvider declarationProvider
     ) {
-        this.semanticServices = semanticServices;
+        this.javaDescriptorResolver = javaDescriptorResolver;
         this.declarationProvider = declarationProvider;
         this.descriptor = descriptor;
     }
@@ -89,7 +88,7 @@ public abstract class JavaBaseScope extends JetScopeImpl {
 
     @NotNull
     private Set<VariableDescriptor> computePropertyDescriptors(@NotNull Name name) {
-        return getResolver().resolveFieldGroupByName(name, declarationProvider, descriptor);
+        return javaDescriptorResolver.resolveFieldGroupByName(name, declarationProvider, descriptor);
     }
 
     @NotNull
@@ -150,11 +149,6 @@ public abstract class JavaBaseScope extends JetScopeImpl {
         return result;
     }
 
-    @NotNull
-    protected JavaDescriptorResolver getResolver() {
-        return semanticServices.getDescriptorResolver();
-    }
-
     //TODO: remove this method
     @NotNull
     public PsiElement getPsiElement() {

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

@@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.resolve.java.scope;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -35,11 +35,11 @@ public abstract class JavaClassMembersScope extends JavaBaseScope {
     private Map<Name, ClassDescriptor> innerClassesMap = null;
 
     protected JavaClassMembersScope(
-            @NotNull ClassOrNamespaceDescriptor descriptor,
+            @NotNull ClassOrPackageDescriptor descriptor,
             @NotNull ClassPsiDeclarationProvider declarationProvider,
-            @NotNull JavaSemanticServices semanticServices
+            @NotNull JavaDescriptorResolver javaDescriptorResolver
     ) {
-        super(descriptor, semanticServices, declarationProvider);
+        super(descriptor, javaDescriptorResolver, declarationProvider);
         this.declarationProvider = declarationProvider;
     }
 
@@ -53,7 +53,7 @@ public abstract class JavaClassMembersScope extends JavaBaseScope {
     @NotNull
     @Override
     protected Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name) {
-        return getResolver().resolveFunctionGroup(name, declarationProvider, descriptor);
+        return javaDescriptorResolver.resolveFunctionGroup(name, declarationProvider, descriptor);
     }
 
     @NotNull
@@ -71,7 +71,7 @@ public abstract class JavaClassMembersScope extends JavaBaseScope {
     @NotNull
     @Override
     protected Collection<ClassDescriptor> computeInnerClasses() {
-        return getResolver().resolveInnerClasses(declarationProvider);
+        return javaDescriptorResolver.resolveInnerClasses(declarationProvider);
     }
 
     @Override

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassNonStaticMembersScope.java

@@ -20,7 +20,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
 
 import java.util.Collection;
@@ -35,9 +35,9 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope
     public JavaClassNonStaticMembersScope(
             @NotNull ClassDescriptor descriptor,
             @NotNull ClassPsiDeclarationProvider psiDeclarationProvider,
-            @NotNull JavaSemanticServices semanticServices
+            @NotNull JavaDescriptorResolver javaDescriptorResolver
     ) {
-        super(descriptor, psiDeclarationProvider, semanticServices);
+        super(descriptor, psiDeclarationProvider, javaDescriptorResolver);
         this.descriptor = descriptor;
     }
 
@@ -56,7 +56,7 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope
 
     private void initConstructorsIfNeeded() {
         if (constructors == null) {
-            constructors = getResolver().resolveConstructors(declarationProvider, descriptor);
+            constructors = javaDescriptorResolver.resolveConstructors(declarationProvider, descriptor);
 
             for (ConstructorDescriptor constructor : constructors) {
                 if (constructor.isPrimary()) {

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java

@@ -17,30 +17,29 @@
 package org.jetbrains.jet.lang.resolve.java.scope;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
 public final class JavaClassStaticMembersScope extends JavaClassMembersScope {
     @NotNull
-    private final FqName packageFQN;
+    private final FqName classFqName;
 
     public JavaClassStaticMembersScope(
-            @NotNull NamespaceDescriptor descriptor,
+            @NotNull PackageFragmentDescriptor descriptor,
             @NotNull ClassPsiDeclarationProvider declarationProvider,
-            @NotNull FqName packageFQN,
-            @NotNull JavaSemanticServices semanticServices
+            @NotNull FqName classFqName,
+            @NotNull JavaDescriptorResolver javaDescriptorResolver
     ) {
-        super(descriptor, declarationProvider, semanticServices);
-        this.packageFQN = packageFQN;
+        super(descriptor, declarationProvider, javaDescriptorResolver);
+        this.classFqName = classFqName;
     }
 
     @Override
-    public NamespaceDescriptor getNamespace(@NotNull Name name) {
-        return getResolver().resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN);
+    public PackageViewDescriptor getPackage(@NotNull Name name) {
+        return null;
     }
 }

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

@@ -16,22 +16,19 @@
 
 package org.jetbrains.jet.lang.resolve.java.scope;
 
+import com.google.common.collect.Sets;
+import com.intellij.openapi.progress.ProgressIndicatorProvider;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiModifier;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
 import java.util.Collection;
 
-import static org.jetbrains.jet.lang.resolve.java.scope.ScopeUtils.computeAllPackageDeclarations;
-
 public abstract class JavaPackageScope extends JavaBaseScope {
 
     @NotNull
@@ -40,20 +37,22 @@ public abstract class JavaPackageScope extends JavaBaseScope {
     private final FqName packageFQN;
 
     protected JavaPackageScope(
-            @NotNull NamespaceDescriptor descriptor,
+            @NotNull PackageFragmentDescriptor descriptor,
             @NotNull PackagePsiDeclarationProvider declarationProvider,
             @NotNull FqName packageFQN,
-            @NotNull JavaSemanticServices semanticServices
+            @NotNull JavaDescriptorResolver javaDescriptorResolver
     ) {
-        super(descriptor, semanticServices, declarationProvider);
+        super(descriptor, javaDescriptorResolver, declarationProvider);
         this.declarationProvider = declarationProvider;
         this.packageFQN = packageFQN;
     }
 
     @Override
     public ClassifierDescriptor getClassifier(@NotNull Name name) {
-        ClassDescriptor classDescriptor =
-                getResolver().resolveClass(packageFQN.child(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
+        PsiClass psiClass = declarationProvider.getPsiClass(name);
+        if (psiClass == null) return null;
+
+        ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(psiClass, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
         if (classDescriptor == null || classDescriptor.getKind().isObject()) {
             return null;
         }
@@ -62,8 +61,10 @@ public abstract class JavaPackageScope extends JavaBaseScope {
 
     @Override
     public ClassDescriptor getObjectDescriptor(@NotNull Name name) {
-        ClassDescriptor classDescriptor =
-                getResolver().resolveClass(packageFQN.child(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
+        PsiClass psiClass = declarationProvider.getPsiClass(name);
+        if (psiClass == null) return null;
+
+        ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(psiClass, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
         if (classDescriptor != null && classDescriptor.getKind().isObject()) {
             return classDescriptor;
         }
@@ -71,17 +72,33 @@ public abstract class JavaPackageScope extends JavaBaseScope {
     }
 
     @Override
-    public NamespaceDescriptor getNamespace(@NotNull Name name) {
-        return getResolver().resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN);
+    public PackageViewDescriptor getPackage(@NotNull Name name) {
+        return null;
     }
 
     @NotNull
     @Override
     protected Collection<DeclarationDescriptor> computeAllDescriptors() {
-        Collection<DeclarationDescriptor> result = super.computeAllDescriptors();
-        result.addAll(computeAllPackageDeclarations(declarationProvider.getPsiPackage(),
-                                                    semanticServices,
-                                                    DescriptorUtils.getFQName(descriptor).toSafe()));
+        Collection<DeclarationDescriptor> result = Sets.newLinkedHashSet(super.computeAllDescriptors());
+
+        for (PsiClass psiClass : declarationProvider.getAllPsiClasses()) {
+            if (PackageClassUtils.isPackageClass(psiClass)) {
+                continue;
+            }
+
+            if (DescriptorResolverUtils.isKotlinLightClass(psiClass)) {
+                continue;
+            }
+
+            if (psiClass.hasModifierProperty(PsiModifier.PUBLIC)) {
+                ProgressIndicatorProvider.checkCanceled();
+                ClassDescriptor classDescriptor = javaDescriptorResolver.getClassDescriptor(psiClass);
+                if (classDescriptor != null) {
+                    result.add(classDescriptor);
+                }
+            }
+        }
+
         return result;
     }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScopeWithoutMembers.java

@@ -19,8 +19,9 @@ package org.jetbrains.jet.lang.resolve.java.scope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
+import org.jetbrains.jet.lang.resolve.java.JavaClassResolutionFacade;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -31,12 +32,12 @@ import java.util.Set;
 
 public final class JavaPackageScopeWithoutMembers extends JavaPackageScope {
     public JavaPackageScopeWithoutMembers(
-            @NotNull NamespaceDescriptor descriptor,
+            @NotNull PackageFragmentDescriptor descriptor,
             @NotNull PackagePsiDeclarationProvider declarationProvider,
             @NotNull FqName packageFQN,
-            @NotNull JavaSemanticServices semanticServices
+            @NotNull JavaDescriptorResolver javaDescriptorResolver
     ) {
-        super(descriptor, declarationProvider, packageFQN, semanticServices);
+        super(descriptor, declarationProvider, packageFQN, javaDescriptorResolver);
     }
 
     @Override

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaScopeForKotlinNamespace.java

@@ -19,9 +19,9 @@ package org.jetbrains.jet.lang.resolve.java.scope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
-import org.jetbrains.jet.lang.resolve.java.provider.KotlinNamespacePsiDeclarationProvider;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.java.provider.KotlinPackagePsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
@@ -30,27 +30,27 @@ import java.util.Set;
 
 public final class JavaScopeForKotlinNamespace extends JavaPackageScope {
     @NotNull
-    private final KotlinNamespacePsiDeclarationProvider declarationProvider;
+    private final KotlinPackagePsiDeclarationProvider declarationProvider;
 
     public JavaScopeForKotlinNamespace(
-            @NotNull NamespaceDescriptor descriptor,
-            @NotNull KotlinNamespacePsiDeclarationProvider declarationProvider,
+            @NotNull PackageFragmentDescriptor descriptor,
+            @NotNull KotlinPackagePsiDeclarationProvider declarationProvider,
             @NotNull FqName packageFQN,
-            @NotNull JavaSemanticServices semanticServices
+            @NotNull JavaDescriptorResolver javaDescriptorResolver
     ) {
-        super(descriptor, declarationProvider, packageFQN, semanticServices);
+        super(descriptor, declarationProvider, packageFQN, javaDescriptorResolver);
         this.declarationProvider = declarationProvider;
     }
 
     @NotNull
     @Override
     protected Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name) {
-        return getResolver().resolveFunctionGroup(name, declarationProvider, descriptor);
+        return javaDescriptorResolver.resolveFunctionGroup(name, declarationProvider, descriptor);
     }
 
     @NotNull
     @Override
     protected Collection<ClassDescriptor> computeInnerClasses() {
-        return getResolver().resolveInnerClasses(declarationProvider);
+        return javaDescriptorResolver.resolveInnerClasses(declarationProvider);
     }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/ScopeUtils.java

@@ -1,80 +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.scope;
-
-import com.google.common.collect.Sets;
-import com.intellij.openapi.progress.ProgressIndicatorProvider;
-import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiModifier;
-import com.intellij.psi.PsiPackage;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.resolve.java.*;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-
-import java.util.Collection;
-
-public final class ScopeUtils {
-    private ScopeUtils() {
-    }
-
-    @NotNull
-    public static Collection<DeclarationDescriptor> computeAllPackageDeclarations(
-            PsiPackage psiPackage,
-            JavaSemanticServices javaSemanticServices,
-            FqName packageFqName
-    ) {
-        Collection<DeclarationDescriptor> result = Sets.newHashSet();
-        boolean isKotlinNamespace = packageFqName != null && javaSemanticServices.getKotlinNamespaceDescriptor(packageFqName) != null;
-        final JavaDescriptorResolver descriptorResolver = javaSemanticServices.getDescriptorResolver();
-
-        for (PsiPackage psiSubPackage : psiPackage.getSubPackages()) {
-            NamespaceDescriptor childNs = descriptorResolver.resolveNamespace(
-                    new FqName(psiSubPackage.getQualifiedName()), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
-            if (childNs != null) {
-                result.add(childNs);
-            }
-        }
-
-        for (PsiClass psiClass : javaSemanticServices.getPsiClassFinder().findPsiClasses(psiPackage)) {
-            if (isKotlinNamespace && PackageClassUtils.isPackageClass(psiClass)) {
-                continue;
-            }
-
-            if (psiClass instanceof JetJavaMirrorMarker) {
-                continue;
-            }
-
-            // TODO: Temp hack for collection function descriptors from java
-            if (PackageClassUtils.isPackageClass(psiClass)) {
-                continue;
-            }
-
-            if (psiClass.hasModifierProperty(PsiModifier.PUBLIC)) {
-                ProgressIndicatorProvider.checkCanceled();
-                ClassDescriptor classDescriptor = descriptorResolver
-                        .resolveClass(new FqName(psiClass.getQualifiedName()), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
-                if (classDescriptor != null) {
-                    result.add(classDescriptor);
-                }
-            }
-        }
-        return result;
-    }
-}

compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java

@@ -16,72 +16,68 @@
 
 package org.jetbrains.jet.analyzer;
 
+import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.ModuleConfiguration;
-import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
+import org.jetbrains.jet.lang.descriptors.SubModuleDescriptor;
+import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.BodiesResolveContext;
-import org.jetbrains.jet.lang.resolve.ImportPath;
-import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+import org.jetbrains.jet.lang.resolve.ModuleSourcesManager;
 
-import java.util.Collections;
-import java.util.List;
+import java.util.Collection;
 
 public class AnalyzeExhaust {
-    private static final ModuleConfiguration ERROR_CONFIGURATION = new ModuleConfiguration() {
-        @Override
-        public List<ImportPath> getDefaultImports() {
-            return Collections.emptyList();
-        }
 
+    private static final ModuleSourcesManager ERROR_MANAGER = new ModuleSourcesManager() {
+        @NotNull
         @Override
-        public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) {
+        public SubModuleDescriptor getSubModuleForFile(@NotNull PsiFile file) {
+            throw new UnsupportedOperationException(); // TODO
         }
 
         @NotNull
         @Override
-        public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
-            return PlatformToKotlinClassMap.EMPTY;
+        public Collection<JetFile> getPackageFragmentSources(@NotNull PackageFragmentDescriptor packageFragment) {
+            throw new UnsupportedOperationException(); // TODO
         }
 
         @Override
         public String toString() {
-            return "ERROR_CONFIGURATION";
+            return "ERROR";
         }
     };
 
-    public static AnalyzeExhaust success(@NotNull BindingContext bindingContext, @NotNull ModuleConfiguration configuration) {
-        return new AnalyzeExhaust(bindingContext, configuration, null, null);
+    public static AnalyzeExhaust success(@NotNull BindingContext bindingContext, @NotNull ModuleSourcesManager moduleSourcesManager) {
+        return new AnalyzeExhaust(bindingContext, moduleSourcesManager, null, null);
     }
     public static AnalyzeExhaust success(@NotNull BindingContext bindingContext,
             @Nullable BodiesResolveContext bodiesResolveContext,
-            @NotNull ModuleConfiguration configuration
+            @NotNull ModuleSourcesManager moduleSourcesManager
     ) {
-        return new AnalyzeExhaust(bindingContext, configuration, bodiesResolveContext, null);
+        return new AnalyzeExhaust(bindingContext, moduleSourcesManager, bodiesResolveContext, null);
     }
 
     public static AnalyzeExhaust error(@NotNull BindingContext bindingContext, @NotNull Throwable error) {
-        return new AnalyzeExhaust(bindingContext, ERROR_CONFIGURATION, null, error);
+        return new AnalyzeExhaust(bindingContext, ERROR_MANAGER, null, error);
     }
 
     private final BindingContext bindingContext;
     private final Throwable error;
     private final BodiesResolveContext bodiesResolveContext;
-    private final ModuleConfiguration configuration;
+    private final ModuleSourcesManager moduleSourcesManager;
 
     private AnalyzeExhaust(
             @NotNull BindingContext bindingContext,
-            @NotNull ModuleConfiguration configuration,
+            @NotNull ModuleSourcesManager moduleSourcesManager,
             @Nullable BodiesResolveContext bodiesResolveContext,
             @Nullable Throwable error
     ) {
         this.bindingContext = bindingContext;
         this.error = error;
         this.bodiesResolveContext = bodiesResolveContext;
-        this.configuration = configuration;
+        this.moduleSourcesManager = moduleSourcesManager;
     }
 
     @Nullable
@@ -110,7 +106,7 @@ public class AnalyzeExhaust {
     }
 
     @NotNull
-    public ModuleConfiguration getModuleConfiguration() {
-        return configuration;
+    public ModuleSourcesManager getModuleSourcesManager() {
+        return moduleSourcesManager;
     }
 }

compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacade.java

@@ -20,11 +20,11 @@ import com.google.common.base.Predicate;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.BodiesResolveContext;
+import org.jetbrains.jet.lang.resolve.ModuleSourcesManager;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 
 import java.util.Collection;
@@ -47,7 +47,7 @@ public interface AnalyzerFacade {
             @NotNull Predicate<PsiFile> filesForBodiesResolve,
             @NotNull BindingTrace traceContext,
             @NotNull BodiesResolveContext bodiesResolveContext,
-            @NotNull ModuleConfiguration configuration
+            @NotNull ModuleSourcesManager moduleSourcesManager
     );
 
     @NotNull

compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacadeForEverything.java

@@ -21,12 +21,7 @@ import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.di.InjectorForBodyResolve;
-import org.jetbrains.jet.lang.ModuleConfiguration;
-import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.BodiesResolveContext;
-import org.jetbrains.jet.lang.resolve.ObservableBindingTrace;
-import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
+import org.jetbrains.jet.lang.resolve.*;
 
 import java.util.List;
 
@@ -39,7 +34,7 @@ public class AnalyzerFacadeForEverything {
             Project project, List<AnalyzerScriptParameter> scriptParameters, Predicate<PsiFile> filesToAnalyzeCompletely,
             @NotNull BindingTrace traceContext,
             @NotNull BodiesResolveContext bodiesResolveContext,
-            @NotNull ModuleConfiguration configuration) {
+            @NotNull ModuleSourcesManager moduleSourcesManager) {
 
         TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
                 filesToAnalyzeCompletely, false, false, scriptParameters);
@@ -49,11 +44,11 @@ public class AnalyzerFacadeForEverything {
         InjectorForBodyResolve injector = new InjectorForBodyResolve(
                 project, topDownAnalysisParameters,
                 new ObservableBindingTrace(traceContext),
-                bodiesResolveContext, configuration);
+                bodiesResolveContext, moduleSourcesManager);
 
         try {
             injector.getBodyResolver().resolveBodies();
-            return AnalyzeExhaust.success(traceContext.getBindingContext(), configuration);
+            return AnalyzeExhaust.success(traceContext.getBindingContext(), moduleSourcesManager);
         } finally {
             injector.destroy();
         }

compiler/frontend/src/org/jetbrains/jet/checkers/CheckerTestUtil.java

@@ -25,9 +25,9 @@ import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiErrorElement;
 import com.intellij.psi.PsiFile;
+import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.containers.Stack;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.diagnostics.AbstractDiagnosticFactory;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.diagnostics.Severity;
@@ -68,9 +68,15 @@ public class CheckerTestUtil {
     private static final Pattern RANGE_START_OR_END_PATTERN = Pattern.compile("(<!\\w+(,\\s*\\w+)*!>)|(<!>)");
     private static final Pattern INDIVIDUAL_DIAGNOSTIC_PATTERN = Pattern.compile("\\w+");
 
-    public static List<Diagnostic> getDiagnosticsIncludingSyntaxErrors(BindingContext bindingContext, PsiElement root) {
+    public static List<Diagnostic> getDiagnosticsIncludingSyntaxErrors(BindingContext bindingContext, final PsiElement root) {
         ArrayList<Diagnostic> diagnostics = new ArrayList<Diagnostic>();
-        diagnostics.addAll(bindingContext.getDiagnostics());
+        diagnostics.addAll(Collections2.filter(bindingContext.getDiagnostics(),
+                                               new Predicate<Diagnostic>() {
+                                                   @Override
+                                                   public boolean apply(Diagnostic diagnostic) {
+                                                       return  PsiTreeUtil.isAncestor(root, diagnostic.getPsiElement(), false);
+                                                   }
+                                               }));
         for (PsiErrorElement errorElement : AnalyzingUtils.getSyntaxErrorRanges(root)) {
             diagnostics.add(new SyntaxErrorDiagnostic(errorElement));
         }
@@ -105,12 +111,17 @@ public class CheckerTestUtil {
     }
 
     public interface DiagnosticDiffCallbacks {
-        @NotNull PsiFile getFile();
         void missingDiagnostic(String type, int expectedStart, int expectedEnd);
         void unexpectedDiagnostic(String type, int actualStart, int actualEnd);
     }
 
-    public static void diagnosticsDiff(List<DiagnosedRange> expected, Collection<Diagnostic> actual, DiagnosticDiffCallbacks callbacks) {
+    public static void diagnosticsDiff(
+            List<DiagnosedRange> expected,
+            Collection<Diagnostic> actual,
+            DiagnosticDiffCallbacks callbacks
+    ) {
+        assertSameFile(actual);
+
         Iterator<DiagnosedRange> expectedDiagnostics = expected.iterator();
         List<DiagnosticDescriptor> sortedDiagnosticDescriptors = getSortedDiagnosticDescriptors(actual);
         Iterator<DiagnosticDescriptor> actualDiagnostics = sortedDiagnosticDescriptors.iterator();
@@ -155,7 +166,7 @@ public class CheckerTestUtil {
                             expectedCopy.removeAll(actualDiagnosticTypes);
                             Multiset<String> actualCopy = HashMultiset.create(actualDiagnosticTypes);
                             actualCopy.removeAll(expectedDiagnosticTypes);
-                            
+
                             for (String type : expectedCopy) {
                                 callbacks.missingDiagnostic(type, expectedStart, expectedEnd);
                             }
@@ -166,7 +177,6 @@ public class CheckerTestUtil {
                         currentExpected = safeAdvance(expectedDiagnostics);
                         currentActual = safeAdvance(actualDiagnostics);
                     }
-
                 }
             }
             else {
@@ -178,14 +188,20 @@ public class CheckerTestUtil {
                     break;
                 }
             }
+        }
+    }
 
-//            assert expectedDiagnostics.hasNext() || actualDiagnostics.hasNext();
+    private static void assertSameFile(Collection<Diagnostic> actual) {
+        if (actual.isEmpty()) return;
+        PsiFile file = actual.iterator().next().getPsiElement().getContainingFile();
+        for (Diagnostic diagnostic : actual) {
+            assert diagnostic.getPsiFile().equals(file)
+                    : "All diagnostics should come from the same file: " + diagnostic.getPsiFile() + ", " + file;
         }
     }
 
     private static void unexpectedDiagnostics(List<Diagnostic> actual, DiagnosticDiffCallbacks callbacks) {
         for (Diagnostic diagnostic : actual) {
-            if (!diagnostic.getPsiFile().equals(callbacks.getFile())) continue;
             List<TextRange> textRanges = diagnostic.getTextRanges();
             for (TextRange textRange : textRanges) {
                 callbacks.unexpectedDiagnostic(diagnostic.getFactory().getName(), textRange.getStartOffset(), textRange.getEndOffset());
@@ -195,7 +211,6 @@ public class CheckerTestUtil {
 
     private static void missingDiagnostics(DiagnosticDiffCallbacks callbacks, DiagnosedRange currentExpected) {
         for (String type : currentExpected.getDiagnostics()) {
-            if (!currentExpected.getFile().equals(callbacks.getFile())) return;
             callbacks.missingDiagnostic(type, currentExpected.getStart(), currentExpected.getEnd());
         }
     }
@@ -240,9 +255,8 @@ public class CheckerTestUtil {
         String text = psiFile.getText();
         diagnostics = Collections2.filter(diagnostics, new Predicate<Diagnostic>() {
             @Override
-            public boolean apply(@Nullable Diagnostic diagnostic) {
-                if (diagnostic == null || !psiFile.equals(diagnostic.getPsiFile())) return false;
-                return true;
+            public boolean apply(Diagnostic diagnostic) {
+                return psiFile.equals(diagnostic.getPsiFile());
             }
         });
         if (!diagnostics.isEmpty()) {
@@ -465,7 +479,6 @@ public class CheckerTestUtil {
         private final int start;
         private int end;
         private final Multiset<String> diagnostics = HashMultiset.create();
-        private PsiFile file;
 
         private DiagnosedRange(int start) {
             this.start = start;
@@ -490,14 +503,5 @@ public class CheckerTestUtil {
         public void addDiagnostic(String diagnostic) {
             diagnostics.add(diagnostic);
         }
-
-        public void setFile(@NotNull PsiFile file) {
-            this.file = file;
-        }
-
-        @NotNull
-        public PsiFile getFile() {
-            return file;
-        }
     }
 }

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

@@ -21,7 +21,7 @@ import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.BodiesResolveContext;
-import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.resolve.ModuleSourcesManager;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
@@ -46,7 +46,7 @@ public class InjectorForBodyResolve {
     private final TopDownAnalysisParameters topDownAnalysisParameters;
     private final BindingTrace bindingTrace;
     private final BodiesResolveContext bodiesResolveContext;
-    private final ModuleConfiguration moduleConfiguration;
+    private final ModuleSourcesManager moduleSourcesManager;
     private CallResolver callResolver;
     private ArgumentTypeResolver argumentTypeResolver;
     private ExpressionTypingServices expressionTypingServices;
@@ -66,14 +66,14 @@ public class InjectorForBodyResolve {
         @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
         @NotNull BindingTrace bindingTrace,
         @NotNull BodiesResolveContext bodiesResolveContext,
-        @NotNull ModuleConfiguration moduleConfiguration
+        @NotNull ModuleSourcesManager moduleSourcesManager
     ) {
         this.bodyResolver = new BodyResolver();
         this.project = project;
         this.topDownAnalysisParameters = topDownAnalysisParameters;
         this.bindingTrace = bindingTrace;
         this.bodiesResolveContext = bodiesResolveContext;
-        this.moduleConfiguration = moduleConfiguration;
+        this.moduleSourcesManager = moduleSourcesManager;
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
         this.expressionTypingServices = new ExpressionTypingServices();
@@ -109,6 +109,7 @@ public class InjectorForBodyResolve {
         expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
         expressionTypingServices.setCallResolver(callResolver);
         expressionTypingServices.setDescriptorResolver(descriptorResolver);
+        expressionTypingServices.setModuleSourcesManager(moduleSourcesManager);
         expressionTypingServices.setProject(project);
         expressionTypingServices.setTypeResolver(typeResolver);
 
@@ -123,7 +124,7 @@ public class InjectorForBodyResolve {
 
         typeResolver.setAnnotationResolver(annotationResolver);
         typeResolver.setDescriptorResolver(descriptorResolver);
-        typeResolver.setModuleConfiguration(moduleConfiguration);
+        typeResolver.setModuleSourcesManager(moduleSourcesManager);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         candidateResolver.setArgumentTypeResolver(argumentTypeResolver);

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

@@ -17,9 +17,8 @@
 package org.jetbrains.jet.di;
 
 import com.intellij.openapi.project.Project;
-import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.resolve.ModuleSourcesManager;
+import org.jetbrains.jet.lang.resolve.lazy.LazyCodeAnalyzer;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
@@ -38,9 +37,8 @@ import javax.annotation.PreDestroy;
 public class InjectorForLazyResolve {
     
     private final Project project;
-    private final ResolveSession resolveSession;
-    private final BindingTrace bindingTrace;
-    private final ModuleConfiguration moduleConfiguration;
+    private final ModuleSourcesManager moduleSourcesManager;
+    private final LazyCodeAnalyzer lazyCodeAnalyzer;
     private DescriptorResolver descriptorResolver;
     private ExpressionTypingServices expressionTypingServices;
     private TypeResolver typeResolver;
@@ -55,18 +53,16 @@ public class InjectorForLazyResolve {
     
     public InjectorForLazyResolve(
         @NotNull Project project,
-        @NotNull ResolveSession resolveSession,
-        @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleConfiguration moduleConfiguration
+        @NotNull ModuleSourcesManager moduleSourcesManager,
+        @NotNull LazyCodeAnalyzer lazyCodeAnalyzer
     ) {
         this.project = project;
-        this.resolveSession = resolveSession;
-        this.bindingTrace = bindingTrace;
-        this.moduleConfiguration = moduleConfiguration;
+        this.moduleSourcesManager = moduleSourcesManager;
+        this.lazyCodeAnalyzer = lazyCodeAnalyzer;
         this.descriptorResolver = new DescriptorResolver();
         this.expressionTypingServices = new ExpressionTypingServices();
         this.typeResolver = new TypeResolver();
-        this.scopeProvider = new ScopeProvider(resolveSession);
+        this.scopeProvider = new ScopeProvider(lazyCodeAnalyzer);
         this.annotationResolver = new AnnotationResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
         this.jetImportsFactory = new JetImportsFactory();
@@ -82,12 +78,13 @@ public class InjectorForLazyResolve {
         this.expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
         this.expressionTypingServices.setCallResolver(callResolver);
         this.expressionTypingServices.setDescriptorResolver(descriptorResolver);
+        this.expressionTypingServices.setModuleSourcesManager(moduleSourcesManager);
         this.expressionTypingServices.setProject(project);
         this.expressionTypingServices.setTypeResolver(typeResolver);
 
         this.typeResolver.setAnnotationResolver(annotationResolver);
         this.typeResolver.setDescriptorResolver(descriptorResolver);
-        this.typeResolver.setModuleConfiguration(moduleConfiguration);
+        this.typeResolver.setModuleSourcesManager(moduleSourcesManager);
         this.typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         this.annotationResolver.setCallResolver(callResolver);

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

@@ -18,7 +18,7 @@ package org.jetbrains.jet.di;
 
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import com.intellij.openapi.project.Project;
-import org.jetbrains.jet.lang.ModuleConfiguration;
+import org.jetbrains.jet.lang.resolve.ModuleSourcesManager;
 import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
@@ -35,7 +35,7 @@ public class InjectorForMacros {
     
     private ExpressionTypingServices expressionTypingServices;
     private final Project project;
-    private final ModuleConfiguration moduleConfiguration;
+    private final ModuleSourcesManager moduleSourcesManager;
     private CallExpressionResolver callExpressionResolver;
     private CallResolver callResolver;
     private ArgumentTypeResolver argumentTypeResolver;
@@ -47,11 +47,11 @@ public class InjectorForMacros {
     
     public InjectorForMacros(
         @NotNull Project project,
-        @NotNull ModuleConfiguration moduleConfiguration
+        @NotNull ModuleSourcesManager moduleSourcesManager
     ) {
         this.expressionTypingServices = new ExpressionTypingServices();
         this.project = project;
-        this.moduleConfiguration = moduleConfiguration;
+        this.moduleSourcesManager = moduleSourcesManager;
         this.callExpressionResolver = new CallExpressionResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
@@ -64,6 +64,7 @@ public class InjectorForMacros {
         this.expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
         this.expressionTypingServices.setCallResolver(callResolver);
         this.expressionTypingServices.setDescriptorResolver(descriptorResolver);
+        this.expressionTypingServices.setModuleSourcesManager(moduleSourcesManager);
         this.expressionTypingServices.setProject(project);
         this.expressionTypingServices.setTypeResolver(typeResolver);
 
@@ -79,7 +80,7 @@ public class InjectorForMacros {
 
         typeResolver.setAnnotationResolver(annotationResolver);
         typeResolver.setDescriptorResolver(descriptorResolver);
-        typeResolver.setModuleConfiguration(moduleConfiguration);
+        typeResolver.setModuleSourcesManager(moduleSourcesManager);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         annotationResolver.setCallResolver(callResolver);

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

@@ -16,11 +16,8 @@
 
 package org.jetbrains.jet.di;
 
-import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
 
 public interface InjectorForTopDownAnalyzer {
-    ModuleConfiguration getModuleConfiguration();
-
     TopDownAnalyzer getTopDownAnalyzer();
 }

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

@@ -22,13 +22,11 @@ import org.jetbrains.jet.lang.resolve.BodyResolver;
 import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer;
 import org.jetbrains.jet.lang.resolve.DeclarationsChecker;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
+import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.ModuleConfiguration;
-import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl;
-import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl;
+import org.jetbrains.jet.lang.resolve.ModuleSourcesManager;
 import org.jetbrains.jet.lang.resolve.DeclarationResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
@@ -57,13 +55,11 @@ public class InjectorForTopDownAnalyzerBasic {
     private ControlFlowAnalyzer controlFlowAnalyzer;
     private DeclarationsChecker declarationsChecker;
     private DescriptorResolver descriptorResolver;
+    private DependencyClassByQualifiedNameResolverDummyImpl dependencyClassByQualifiedNameResolverDummy;
     private final Project project;
     private final TopDownAnalysisParameters topDownAnalysisParameters;
     private final BindingTrace bindingTrace;
-    private final ModuleDescriptor moduleDescriptor;
-    private final ModuleConfiguration moduleConfiguration;
-    private DependencyClassByQualifiedNameResolverDummyImpl dependencyClassByQualifiedNameResolverDummy;
-    private NamespaceFactoryImpl namespaceFactory;
+    private final ModuleSourcesManager moduleSourcesManager;
     private DeclarationResolver declarationResolver;
     private AnnotationResolver annotationResolver;
     private CallResolver callResolver;
@@ -85,8 +81,7 @@ public class InjectorForTopDownAnalyzerBasic {
         @NotNull Project project,
         @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
         @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptor moduleDescriptor,
-        @NotNull ModuleConfiguration moduleConfiguration
+        @NotNull ModuleSourcesManager moduleSourcesManager
     ) {
         this.topDownAnalyzer = new TopDownAnalyzer();
         this.topDownAnalysisContext = new TopDownAnalysisContext();
@@ -94,13 +89,11 @@ public class InjectorForTopDownAnalyzerBasic {
         this.controlFlowAnalyzer = new ControlFlowAnalyzer();
         this.declarationsChecker = new DeclarationsChecker();
         this.descriptorResolver = new DescriptorResolver();
+        this.dependencyClassByQualifiedNameResolverDummy = new DependencyClassByQualifiedNameResolverDummyImpl();
         this.project = project;
         this.topDownAnalysisParameters = topDownAnalysisParameters;
         this.bindingTrace = bindingTrace;
-        this.moduleDescriptor = moduleDescriptor;
-        this.moduleConfiguration = moduleConfiguration;
-        this.dependencyClassByQualifiedNameResolverDummy = new DependencyClassByQualifiedNameResolverDummyImpl();
-        this.namespaceFactory = new NamespaceFactoryImpl();
+        this.moduleSourcesManager = moduleSourcesManager;
         this.declarationResolver = new DeclarationResolver();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
@@ -121,12 +114,9 @@ public class InjectorForTopDownAnalyzerBasic {
         this.topDownAnalyzer.setBodyResolver(bodyResolver);
         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.setTopDownAnalysisParameters(topDownAnalysisParameters);
-        this.topDownAnalyzer.setTrace(bindingTrace);
         this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
 
         this.topDownAnalysisContext.setTopDownAnalysisParameters(topDownAnalysisParameters);
@@ -150,14 +140,11 @@ public class InjectorForTopDownAnalyzerBasic {
         this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
         this.descriptorResolver.setTypeResolver(typeResolver);
 
-        namespaceFactory.setConfiguration(moduleConfiguration);
-        namespaceFactory.setModuleDescriptor(moduleDescriptor);
-        namespaceFactory.setTrace(bindingTrace);
-
         declarationResolver.setAnnotationResolver(annotationResolver);
         declarationResolver.setContext(topDownAnalysisContext);
         declarationResolver.setDescriptorResolver(descriptorResolver);
         declarationResolver.setImportsResolver(importsResolver);
+        declarationResolver.setModuleManager(moduleSourcesManager);
         declarationResolver.setScriptHeaderResolver(scriptHeaderResolver);
         declarationResolver.setTrace(bindingTrace);
 
@@ -175,6 +162,7 @@ public class InjectorForTopDownAnalyzerBasic {
         expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
         expressionTypingServices.setCallResolver(callResolver);
         expressionTypingServices.setDescriptorResolver(descriptorResolver);
+        expressionTypingServices.setModuleSourcesManager(moduleSourcesManager);
         expressionTypingServices.setProject(project);
         expressionTypingServices.setTypeResolver(typeResolver);
 
@@ -182,14 +170,14 @@ public class InjectorForTopDownAnalyzerBasic {
 
         typeResolver.setAnnotationResolver(annotationResolver);
         typeResolver.setDescriptorResolver(descriptorResolver);
-        typeResolver.setModuleConfiguration(moduleConfiguration);
+        typeResolver.setModuleSourcesManager(moduleSourcesManager);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
         candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
 
-        importsResolver.setConfiguration(moduleConfiguration);
         importsResolver.setContext(topDownAnalysisContext);
         importsResolver.setImportsFactory(jetImportsFactory);
+        importsResolver.setModuleSourcesManager(moduleSourcesManager);
         importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
         importsResolver.setTrace(bindingTrace);
 
@@ -197,7 +185,7 @@ public class InjectorForTopDownAnalyzerBasic {
 
         scriptHeaderResolver.setContext(topDownAnalysisContext);
         scriptHeaderResolver.setDependencyClassByQualifiedNameResolver(dependencyClassByQualifiedNameResolverDummy);
-        scriptHeaderResolver.setNamespaceFactory(namespaceFactory);
+        scriptHeaderResolver.setModuleSourcesManager(moduleSourcesManager);
         scriptHeaderResolver.setTopDownAnalysisParameters(topDownAnalysisParameters);
         scriptHeaderResolver.setTrace(bindingTrace);
 
@@ -211,7 +199,7 @@ public class InjectorForTopDownAnalyzerBasic {
         typeHierarchyResolver.setContext(topDownAnalysisContext);
         typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
         typeHierarchyResolver.setImportsResolver(importsResolver);
-        typeHierarchyResolver.setNamespaceFactory(namespaceFactory);
+        typeHierarchyResolver.setModuleManager(moduleSourcesManager);
         typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver);
         typeHierarchyResolver.setTrace(bindingTrace);
 

compiler/frontend/src/org/jetbrains/jet/lang/DefaultModuleConfiguration.java

@@ -18,7 +18,7 @@ package org.jetbrains.jet.lang;
 
 import com.google.common.collect.ImmutableList;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.ImportPath;
@@ -46,8 +46,8 @@ public class DefaultModuleConfiguration implements ModuleConfiguration {
     }
 
     @Override
-    public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) {
-        if (DescriptorUtils.getFQName(namespaceDescriptor).equalsTo(KotlinBuiltIns.getInstance().getBuiltInsPackageFqName())) {
+    public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull PackageViewDescriptor packageViewDescriptor, @NotNull WritableScope namespaceMemberScope) {
+        if (DescriptorUtils.getFQName(packageViewDescriptor).equalsTo(KotlinBuiltIns.getInstance().getBuiltInsPackageFqName())) {
             namespaceMemberScope.importScope(KotlinBuiltIns.getInstance().getBuiltInsScope());
         }
     }

compiler/frontend/src/org/jetbrains/jet/lang/ModuleConfiguration.java

@@ -17,7 +17,8 @@
 package org.jetbrains.jet.lang;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
+import org.jetbrains.jet.lang.descriptors.SubModuleDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
@@ -25,6 +26,7 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import java.util.Collections;
 import java.util.List;
 
+@Deprecated
 public interface ModuleConfiguration {
     ModuleConfiguration EMPTY = new ModuleConfiguration() {
         @Override
@@ -33,7 +35,7 @@ public interface ModuleConfiguration {
         }
 
         @Override
-        public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) {
+        public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull PackageViewDescriptor packageViewDescriptor, @NotNull WritableScope namespaceMemberScope) {
         }
 
         @NotNull
@@ -48,13 +50,40 @@ public interface ModuleConfiguration {
         }
     };
 
+    class UTIL {
+        public static ModuleConfiguration fromSubModule(@NotNull final SubModuleDescriptor subModule) {
+            return new ModuleConfiguration() {
+                @Override
+                public List<ImportPath> getDefaultImports() {
+                    return subModule.getDefaultImports();
+                }
+
+                @Override
+                public void extendNamespaceScope(
+                        @NotNull BindingTrace trace,
+                        @NotNull PackageViewDescriptor packageViewDescriptor,
+                        @NotNull WritableScope namespaceMemberScope
+                ) {
+                    // Do nothing
+                }
+
+                @NotNull
+                @Override
+                public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
+                    return subModule.getContainingDeclaration().getPlatformToKotlinClassMap();
+                }
+            };
+        }
+    }
+
     List<ImportPath> getDefaultImports();
 
     /**
      * This method is called every time a namespace descriptor is created. Use it to add extra descriptors to the namespace, e.g. merge a
      * Java package with a Kotlin one
      */
-    void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope);
+    @Deprecated
+    void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull PackageViewDescriptor packageViewDescriptor, @NotNull WritableScope namespaceMemberScope);
 
     @NotNull
     PlatformToKotlinClassMap getPlatformToKotlinClassMap();

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

@@ -26,7 +26,7 @@ import org.jetbrains.jet.lang.types.TypeSubstitutor;
 import java.util.Collection;
 import java.util.List;
 
-public interface ClassDescriptor extends ClassifierDescriptor, MemberDescriptor, ClassOrNamespaceDescriptor {
+public interface ClassDescriptor extends ClassifierDescriptor, MemberDescriptor, ClassOrPackageDescriptor {
 
     @NotNull
     JetScope getMemberScope(List<TypeProjection> typeArguments);

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

@@ -16,5 +16,5 @@
 
 package org.jetbrains.jet.lang.descriptors;
 
-public interface ClassOrNamespaceDescriptor extends DeclarationDescriptorNonRoot {
+public interface ClassOrPackageDescriptor extends DeclarationDescriptorNonRoot {
 }

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

@@ -17,8 +17,6 @@
 package org.jetbrains.jet.lang.descriptors;
 
 public interface DeclarationDescriptorVisitor<R, D> {
-    R visitNamespaceDescriptor(NamespaceDescriptor descriptor, D data);
-
     R visitVariableDescriptor(VariableDescriptor descriptor, D data);
 
     R visitFunctionDescriptor(FunctionDescriptor descriptor, D data);
@@ -27,8 +25,6 @@ public interface DeclarationDescriptorVisitor<R, D> {
 
     R visitClassDescriptor(ClassDescriptor descriptor, D data);
 
-    R visitModuleDeclaration(ModuleDescriptor descriptor, D data);
-
     R visitConstructorDescriptor(ConstructorDescriptor constructorDescriptor, D data);
 
     R visitScriptDescriptor(ScriptDescriptor scriptDescriptor, D data);
@@ -42,4 +38,12 @@ public interface DeclarationDescriptorVisitor<R, D> {
     R visitPropertySetterDescriptor(PropertySetterDescriptor descriptor, D data);
 
     R visitReceiverParameterDescriptor(ReceiverParameterDescriptor descriptor, D data);
+
+    R visitModuleDescriptor(ModuleDescriptor descriptor, D data);
+
+    R visitSubModuleDescriptor(SubModuleDescriptor descriptor, D data);
+
+    R visitPackageFragmentDescriptor(PackageFragmentDescriptor descriptor, D data);
+
+    R visitPackageViewDescriptor(PackageViewDescriptor descriptor, D data);
 }

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

@@ -0,0 +1,56 @@
+/*
+ * 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;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.impl.PackageLikeDescriptorBase;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+
+public class EmptyPackageFragment extends PackageLikeDescriptorBase implements PackageFragmentDescriptor {
+    private final SubModuleDescriptor subModule;
+    private final PackageFragmentKind kind;
+
+    public EmptyPackageFragment(@NotNull SubModuleDescriptor subModule, @NotNull PackageFragmentKind kind, @NotNull FqName fqName) {
+        super(fqName);
+        this.subModule = subModule;
+        this.kind = kind;
+    }
+
+    @NotNull
+    @Override
+    public SubModuleDescriptor getContainingDeclaration() {
+        return subModule;
+    }
+
+    @NotNull
+    @Override
+    public PackageFragmentKind getKind() {
+        return kind;
+    }
+
+    @NotNull
+    @Override
+    public JetScope getMemberScope() {
+        return JetScope.EMPTY;
+    }
+
+    @Override
+    public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
+        return visitor.visitPackageFragmentDescriptor(this, data);
+    }
+}

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

@@ -17,65 +17,14 @@
 package org.jetbrains.jet.lang.descriptors;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorImpl;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent;
-import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.types.TypeSubstitutor;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 
-import java.util.Collections;
+import java.util.Collection;
 
-public class ModuleDescriptor extends DeclarationDescriptorImpl implements ClassOrNamespaceDescriptor, NamespaceDescriptorParent {
-    private NamespaceDescriptor rootNamepsace;
-
-    public ModuleDescriptor(@NotNull Name name) {
-        super(Collections.<AnnotationDescriptor>emptyList(), name);
-        if (!name.isSpecial()) {
-            throw new IllegalArgumentException("module name must be special: " + name);
-        }
-    }
-
-    public void setRootNamespace(@NotNull NamespaceDescriptor rootNs) {
-        if (this.rootNamepsace != null) {
-            throw new IllegalStateException("setRootNamespace() is called twice");
-        }
-        this.rootNamepsace = rootNs;
-    }
-
-    @Override
-    @Nullable
-    public DeclarationDescriptor getContainingDeclaration() {
-        return null;
-    }
-
-    public NamespaceDescriptor getRootNamespace() {
-        return rootNamepsace;
-    }
-
-    public NamespaceDescriptorImpl getRootNamespaceDescriptorImpl() {
-        return (NamespaceDescriptorImpl) rootNamepsace;
-    }
+public interface ModuleDescriptor extends DeclarationDescriptor {
+    @NotNull
+    Collection<SubModuleDescriptor> getSubModules();
 
     @NotNull
-    @Override
-    public ModuleDescriptor substitute(@NotNull TypeSubstitutor substitutor) {
-        return this;
-    }
-
-    @Override
-    public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
-        return visitor.visitModuleDeclaration(this, data);
-    }
-
-
-    @Override
-    public void addNamespace(@NotNull NamespaceDescriptor namespaceDescriptor) {
-        if (namespaceDescriptor.getContainingDeclaration() != this) {
-            throw new IllegalStateException();
-        }
-        setRootNamespace(namespaceDescriptor);
-    }
-
+    PlatformToKotlinClassMap getPlatformToKotlinClassMap();
 }

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

@@ -0,0 +1,116 @@
+/*
+ * 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;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.ImportPath;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.types.TypeSubstitutor;
+
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * The order of dependencies matters, in particular, it is important what dependencies come before
+ * the sources of the subModule, and what come later. The instance of this class in the dependency list
+ * identifies the position of the subModule itself in the resolution of packages. E.g.:
+ *
+ *   sm0
+ *     lib1
+ *     MY_SOURCES
+ *     sm2
+ *
+ * Means that package fragments from lib1 come first, then come fragments from sm0 (identified by MY_SOURCES), and then sm2
+ *
+ */
+/*package*/ class MySourceFakeSubModule implements SubModuleDescriptor {
+    public static final SubModuleDescriptor MY_SOURCE = new MySourceFakeSubModule();
+
+    private MySourceFakeSubModule() {
+    }
+
+    @NotNull
+    @Override
+    public ModuleDescriptor getContainingDeclaration() {
+        throw new UnsupportedOperationException();
+    }
+
+    @NotNull
+    @Override
+    public PackageFragmentProvider getPackageFragmentProvider() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Nullable
+    @Override
+    public PackageViewDescriptor getPackageView(@NotNull FqName fqName) {
+        throw new UnsupportedOperationException();
+    }
+
+    @NotNull
+    @Override
+    public Collection<SubModuleDescriptor> getDependencies() {
+        throw new UnsupportedOperationException();
+    }
+
+    @NotNull
+    @Override
+    public List<ImportPath> getDefaultImports() {
+        throw new UnsupportedOperationException();
+    }
+
+    @NotNull
+    @Override
+    public DeclarationDescriptor getOriginal() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Nullable
+    @Override
+    public DeclarationDescriptor substitute(@NotNull TypeSubstitutor substitutor) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void acceptVoid(DeclarationDescriptorVisitor<Void, Void> visitor) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public List<AnnotationDescriptor> getAnnotations() {
+        throw new UnsupportedOperationException();
+    }
+
+    @NotNull
+    @Override
+    public Name getName() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public String toString() {
+        return "MY_SOURCE";
+    }
+}

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

@@ -17,14 +17,16 @@
 package org.jetbrains.jet.lang.descriptors;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
-import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 
-public interface NamespaceDescriptor extends Annotated, Named, FqNamed, ClassOrNamespaceDescriptor, NamespaceDescriptorParent {
+public interface PackageFragmentDescriptor extends FqNamed, ClassOrPackageDescriptor {
     @NotNull
-    JetScope getMemberScope();
+    @Override
+    SubModuleDescriptor getContainingDeclaration();
 
     @NotNull
-    NamespaceDescriptorParent getContainingDeclaration();
+    PackageFragmentKind getKind();
+
+    @NotNull
+    JetScope getMemberScope();
 }

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

@@ -14,9 +14,13 @@
  * limitations under the License.
  */
 
-package org.jetbrains.jet.lang.resolve.java;
+package org.jetbrains.jet.lang.descriptors;
 
-public enum JavaNamespaceKind {
-    PROPER,
-    CLASS_STATICS,
+public interface PackageFragmentKind {
+    PackageFragmentKind SOURCE = new PackageFragmentKind() {
+        @Override
+        public String toString() {
+            return "SOURCE";
+        }
+    };
 }

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

@@ -14,25 +14,21 @@
  * limitations under the License.
  */
 
-package org.jetbrains.jet.lang.resolve.java.resolver;
+package org.jetbrains.jet.lang.descriptors;
 
-import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 
+import java.util.Collection;
 import java.util.List;
 
-public final class PostponedTasks {
-
+public interface PackageFragmentProvider {
     @NotNull
-    private final List<Runnable> tasks = Lists.newArrayList();
+    List<PackageFragmentDescriptor> getPackageFragments(@NotNull FqName fqName);
 
-    public void addTask(@NotNull Runnable runnable) {
-        tasks.add(runnable);
-    }
-
-    public void performTasks() {
-        for (Runnable task : tasks) {
-            task.run();
-        }
-    }
+    /**
+     * @return declared subpackages of {@code fqName}
+     */
+    @NotNull
+    Collection<FqName> getSubPackagesOf(@NotNull FqName fqName);
 }

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

@@ -0,0 +1,36 @@
+/*
+ * 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;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+
+/**
+ * A package, as viewed from a particular point in code (typically a submodule), {@see #getViewContext()}
+ */
+public interface PackageViewDescriptor extends FqNamed, DeclarationDescriptor {
+    @Override
+    @Nullable
+    PackageViewDescriptor getContainingDeclaration();
+
+    @NotNull
+    DeclarationDescriptor getViewContext();
+
+    @NotNull
+    JetScope getMemberScope();
+}

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

@@ -0,0 +1,53 @@
+/*
+ * 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;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.resolve.ImportPath;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * Submodules roughly correspond to root types, i.e. 'src" and 'test'
+ */
+public interface SubModuleDescriptor extends DeclarationDescriptor {
+
+    SubModuleDescriptor MY_SOURCE = MySourceFakeSubModule.MY_SOURCE;
+
+    @NotNull
+    @Override
+    ModuleDescriptor getContainingDeclaration();
+
+    @NotNull
+    PackageFragmentProvider getPackageFragmentProvider();
+
+    /**
+     * @return a package as seen from this submodule (i.e. including its own declarations and immediate dependencies)
+     *         {@code null} is this package does not exist from the point of view of this submodule
+     */
+    @Nullable
+    PackageViewDescriptor getPackageView(@NotNull FqName fqName);
+
+    @NotNull
+    Collection<SubModuleDescriptor> getDependencies();
+
+    @NotNull
+    List<ImportPath> getDefaultImports();
+}

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

@@ -29,20 +29,20 @@ public class Visibilities {
     public static final Visibility PRIVATE = new Visibility("private", false) {
         @Override
         protected boolean isVisible(@NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) {
-            DeclarationDescriptor parent = what;
+            DeclarationDescriptor parent = DescriptorUtils.getCorrespondingInPackageViewHierarchy(what);
             while (parent != null) {
-                parent = parent.getContainingDeclaration();
+                parent = DescriptorUtils.getParentInPackageViewHierarchy(parent);
                 if ((parent instanceof ClassDescriptor && !DescriptorUtils.isClassObject(parent)) ||
-                    parent instanceof NamespaceDescriptor) {
+                    parent instanceof PackageViewDescriptor) {
                     break;
                 }
             }
-            DeclarationDescriptor fromParent = from;
+            DeclarationDescriptor fromParent = DescriptorUtils.getCorrespondingInPackageViewHierarchy(from);
             while (fromParent != null) {
-                if (parent == fromParent) {
+                if (fromParent.equals(parent)) {
                     return true;
                 }
-                fromParent = fromParent.getContainingDeclaration();
+                fromParent = DescriptorUtils.getParentInPackageViewHierarchy(fromParent);
             }
             return false;
         }
@@ -67,8 +67,10 @@ public class Visibilities {
         @Override
         protected boolean isVisible(@NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) {
             ModuleDescriptor parentModule = DescriptorUtils.getParentOfType(what, ModuleDescriptor.class, false);
+            assert parentModule != null : "No module parent found for [what=]" + what;
             ModuleDescriptor fromModule = DescriptorUtils.getParentOfType(from, ModuleDescriptor.class, false);
-            assert parentModule != null && fromModule != null;
+            assert fromModule != null : "No module parent found for [from=]" + from +
+                                        "\n[what=]" + what;
             return parentModule.equals(fromModule);
         }
     };

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

@@ -1,64 +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.descriptors.impl;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitor;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.types.TypeSubstitutor;
-
-import java.util.List;
-
-public abstract class AbstractNamespaceDescriptorImpl extends DeclarationDescriptorNonRootImpl implements NamespaceDescriptor {
-    public AbstractNamespaceDescriptorImpl(
-            @NotNull NamespaceDescriptorParent containingDeclaration,
-            List<AnnotationDescriptor> annotations,
-            @NotNull Name name) {
-
-        super(containingDeclaration, annotations, name);
-
-        boolean rootAccordingToContainer = containingDeclaration instanceof ModuleDescriptor;
-        if (rootAccordingToContainer != name.isSpecial()) {
-            throw new IllegalStateException("something is wrong, name: " + name + ", container: " + containingDeclaration);
-        }
-    }
-
-    @Override
-    @NotNull
-    public NamespaceDescriptorParent getContainingDeclaration() {
-        return (NamespaceDescriptorParent) super.getContainingDeclaration();
-    }
-
-    @Override
-    public void addNamespace(@NotNull NamespaceDescriptor namespaceDescriptor) {
-        throw new IllegalStateException("immutable");
-    }
-
-    @NotNull
-    @Override
-    public NamespaceDescriptor substitute(@NotNull TypeSubstitutor substitutor) {
-        throw new UnsupportedOperationException("This operation does not make sense for a namespace");
-    }
-
-    @Override
-    public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
-        return visitor.visitNamespaceDescriptor(this, data);
-    }
-}

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

@@ -0,0 +1,69 @@
+/*
+ * 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.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.types.TypeSubstitutor;
+
+import java.util.Collections;
+import java.util.List;
+
+public abstract class AbstractSubModuleDescriptor extends DeclarationDescriptorImpl implements SubModuleDescriptor {
+    private final ModuleDescriptor module;
+
+    public AbstractSubModuleDescriptor(@NotNull ModuleDescriptor module, @NotNull Name name) {
+        super(Collections.<AnnotationDescriptor>emptyList(), name);
+        this.module = module;
+    }
+
+    @Nullable
+    @Override
+    public PackageViewDescriptor getPackageView(@NotNull FqName fqName) {
+        List<PackageFragmentDescriptor> fragments = DescriptorUtils.getPackageFragmentsIncludingDependencies(this, fqName);
+        if (fragments.isEmpty()) return null;
+
+        return new PackageViewFromSubModule(this, fqName, fragments);
+    }
+
+    @NotNull
+    @Override
+    public ModuleDescriptor getContainingDeclaration() {
+        return module;
+    }
+
+    @Nullable
+    @Override
+    public DeclarationDescriptor substitute(@NotNull TypeSubstitutor substitutor) {
+        return this;
+    }
+
+    @Override
+    public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
+        return visitor.visitSubModuleDescriptor(this, data);
+    }
+
+    @Override
+    public void acceptVoid(DeclarationDescriptorVisitor<Void, Void> visitor) {
+        visitor.visitSubModuleDescriptor(this, null);
+    }
+}

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

@@ -0,0 +1,60 @@
+/*
+ * 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.Lists;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+public class CompositePackageFragmentProvider implements PackageFragmentProvider {
+
+    private final Collection<PackageFragmentProvider> children;
+
+    public CompositePackageFragmentProvider(@NotNull PackageFragmentProvider... children) {
+        this(Arrays.asList(children));
+    }
+
+    public CompositePackageFragmentProvider(@NotNull Collection<PackageFragmentProvider> children) {
+        this.children = children;
+    }
+
+    @NotNull
+    @Override
+    public List<PackageFragmentDescriptor> getPackageFragments(@NotNull FqName fqName) {
+        List<PackageFragmentDescriptor> result = Lists.newArrayList();
+        for (PackageFragmentProvider child : children) {
+            result.addAll(child.getPackageFragments(fqName));
+        }
+        return result;
+    }
+
+    @NotNull
+    @Override
+    public Collection<FqName> getSubPackagesOf(@NotNull FqName fqName) {
+        List<FqName> result = Lists.newArrayList();
+        for (PackageFragmentProvider child : children) {
+            result.addAll(child.getSubPackagesOf(fqName));
+        }
+        return result;
+    }
+}

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

@@ -19,6 +19,7 @@ package org.jetbrains.jet.lang.descriptors.impl;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorNonRoot;
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
@@ -37,6 +38,8 @@ public abstract class DeclarationDescriptorNonRootImpl
             @NotNull Name name) {
         super(annotations, name);
 
+        assert !(containingDeclaration instanceof PackageViewDescriptor)
+                : "Nothing other than package views can be contained in a package view";
         this.containingDeclaration = containingDeclaration;
     }
 

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

@@ -38,21 +38,11 @@ public class DeclarationDescriptorVisitorEmptyBodies<R, D> implements Declaratio
         return visitDeclarationDescriptor(descriptor, data);
     }
 
-    @Override
-    public R visitNamespaceDescriptor(NamespaceDescriptor descriptor, D data) {
-        return visitDeclarationDescriptor(descriptor, data);
-    }
-
     @Override
     public R visitClassDescriptor(ClassDescriptor descriptor, D data) {
         return visitDeclarationDescriptor(descriptor, data);
     }
 
-    @Override
-    public R visitModuleDeclaration(ModuleDescriptor descriptor, D data) {
-        return visitDeclarationDescriptor(descriptor, data);
-    }
-
     @Override
     public R visitConstructorDescriptor(ConstructorDescriptor constructorDescriptor, D data) {
         return visitFunctionDescriptor(constructorDescriptor, data);
@@ -91,4 +81,24 @@ public class DeclarationDescriptorVisitorEmptyBodies<R, D> implements Declaratio
     public R visitReceiverParameterDescriptor(ReceiverParameterDescriptor descriptor, D data) {
         return visitDeclarationDescriptor(descriptor, data);
     }
+
+    @Override
+    public R visitModuleDescriptor(ModuleDescriptor descriptor, D data) {
+        return visitDeclarationDescriptor(descriptor, data);
+    }
+
+    @Override
+    public R visitSubModuleDescriptor(SubModuleDescriptor descriptor, D data) {
+        return visitDeclarationDescriptor(descriptor, data);
+    }
+
+    @Override
+    public R visitPackageFragmentDescriptor(PackageFragmentDescriptor descriptor, D data) {
+        return visitDeclarationDescriptor(descriptor, data);
+    }
+
+    @Override
+    public R visitPackageViewDescriptor(PackageViewDescriptor descriptor, D data) {
+        return visitDeclarationDescriptor(descriptor, data);
+    }
 }

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

@@ -0,0 +1,82 @@
+/*
+ * 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.Lists;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
+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.SubModuleDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.types.TypeSubstitutor;
+
+import java.util.Collection;
+import java.util.Collections;
+
+public class MutableModuleDescriptor extends DeclarationDescriptorImpl implements ModuleDescriptor {
+
+    private final Collection<SubModuleDescriptor> subModules = Lists.newArrayList();
+    private final PlatformToKotlinClassMap platformToKotlinClassMap;
+
+    public MutableModuleDescriptor(@NotNull Name name, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) {
+        super(Collections.<AnnotationDescriptor>emptyList(), name);
+        this.platformToKotlinClassMap = platformToKotlinClassMap;
+    }
+
+    @NotNull
+    @Override
+    public Collection<SubModuleDescriptor> getSubModules() {
+        return subModules;
+    }
+
+    public SubModuleDescriptor addSubModule(@NotNull SubModuleDescriptor subModule) {
+        subModules.add(subModule);
+        return subModule;
+    }
+
+    @Nullable
+    @Override
+    public DeclarationDescriptor getContainingDeclaration() {
+        return null;
+    }
+
+    @NotNull
+    @Override
+    public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
+        return platformToKotlinClassMap;
+    }
+
+    @Nullable
+    @Override
+    public DeclarationDescriptor substitute(@NotNull TypeSubstitutor substitutor) {
+        return this;
+    }
+
+    @Override
+    public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
+        return visitor.visitModuleDescriptor(this, data);
+    }
+
+    @Override
+    public void acceptVoid(DeclarationDescriptorVisitor<Void, Void> visitor) {
+        visitor.visitModuleDescriptor(this, null);
+    }
+}