Implement modules in IDE

IDE:
Rewrite AnalyzerFacade and implementations for JS and JVM to support creating separate analyzers for each module
Introduce ModuleInfo which is an intermediate entity between configuration (tests or idea modules) and ModuleDescriptor
Implement IdeaModuleInfos which represent IDEA modules, sdks and libraries
Add (somewhat thin) test checking their behaviour
Implement getModuleInfo() - utility to obtain IdeaModuleInfo for PsiElement
Drop Project.getLazyResolveSession() - not possible to obtain resolve session for the whole project any more
Adjust JavaResolveExtension accordingly
KotlinSignature Intention/Marker - make sure that analyzed element is cls element (he's not in resolve scope otherwise)

LightClasses:
Create separate package light classes for each module
Java code can only reference light class from the first module among it's dependencies
Duplicate jvm signature is only reported on package declarations inside one module

Injectors:
Receive GlobalSearchScope as paramer for VirtualFileFinder and JavaClassFinder
which allows to narrow analyzer scope

JDR:
Introduce ModuleClassResolver resolves java classes in correct java descriptor resolver (corresponding ModuleDescriptor)
Add test checking that java classes belong to correct module

Debugger:
Provide context to analyze files created by debugger in

Converter:
Postprocessor now needs a context to analyze resulting code in

JetPsiFactory:
Add verification that files created by psi factory are not analyzed without context (that is almost never a good idea)

Other:
Use new API in various tests, utilities, run configuration producers and builtin serializers
Various "TODO: (module refactoring)" which mark the unfinished parts

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

@@ -23,6 +23,7 @@ import org.jetbrains.jet.storage.LockBasedStorageManager;
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
+import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedJavaResolverCache;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedErrorReporter;
@@ -30,6 +31,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureCheck
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaPropertyInitializerEvaluatorImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSourceElementFactoryImpl;
+import org.jetbrains.jet.lang.resolve.java.lazy.SingleModuleClassResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
@@ -53,6 +55,7 @@ public class InjectorForJavaDescriptorResolver {
     private final ModuleDescriptorImpl module;
     private final JavaDescriptorResolver javaDescriptorResolver;
     private final JavaClassFinderImpl javaClassFinder;
+    private final GlobalSearchScope globalSearchScope;
     private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
     private final TraceBasedJavaResolverCache traceBasedJavaResolverCache;
     private final TraceBasedErrorReporter traceBasedErrorReporter;
@@ -60,6 +63,7 @@ public class InjectorForJavaDescriptorResolver {
     private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
     private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator;
     private final JavaSourceElementFactoryImpl javaSourceElementFactory;
+    private final SingleModuleClassResolver singleModuleClassResolver;
     private final VirtualFileFinder virtualFileFinder;
     private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
     private final GlobalJavaResolverContext globalJavaResolverContext;
@@ -89,9 +93,11 @@ public class InjectorForJavaDescriptorResolver {
         this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache();
         this.javaPropertyInitializerEvaluator = new JavaPropertyInitializerEvaluatorImpl();
         this.javaSourceElementFactory = new JavaSourceElementFactoryImpl();
-        this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, getJavaClassFinder(), virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, javaPropertyInitializerEvaluator, javaSourceElementFactory);
+        this.singleModuleClassResolver = new SingleModuleClassResolver();
+        this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, getJavaClassFinder(), virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, javaPropertyInitializerEvaluator, javaSourceElementFactory, singleModuleClassResolver);
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule());
         this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
+        this.globalSearchScope = com.intellij.psi.search.GlobalSearchScope.allScope(project);
         this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);
         this.annotationDescriptorLoader = new AnnotationDescriptorLoader();
         this.constantDescriptorLoader = new ConstantDescriptorLoader();
@@ -99,6 +105,7 @@ public class InjectorForJavaDescriptorResolver {
         this.descriptorLoadersStorage = new DescriptorLoadersStorage(lockBasedStorageManager);
 
         this.javaClassFinder.setProject(project);
+        this.javaClassFinder.setScope(globalSearchScope);
 
         traceBasedExternalSignatureResolver.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
         traceBasedExternalSignatureResolver.setProject(project);
@@ -111,6 +118,8 @@ public class InjectorForJavaDescriptorResolver {
         psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
         psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
 
+        singleModuleClassResolver.setResolver(javaDescriptorResolver);
+
         deserializedDescriptorResolver.setContext(deserializationGlobalContextForJava);
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
 

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

@@ -17,12 +17,14 @@
 package org.jetbrains.jet.di;
 
 import com.intellij.openapi.project.Project;
-import org.jetbrains.jet.context.GlobalContextImpl;
-import org.jetbrains.jet.storage.LockBasedStorageManager;
-import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.context.GlobalContext;
+import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
+import com.intellij.psi.search.GlobalSearchScope;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
+import org.jetbrains.jet.lang.resolve.java.lazy.ModuleClassResolver;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
@@ -70,12 +72,14 @@ import javax.annotation.PreDestroy;
 public class InjectorForLazyResolveWithJava {
     
     private final Project project;
-    private final GlobalContextImpl globalContext;
-    private final LockBasedStorageManager lockBasedStorageManager;
-    private final DeclarationProviderFactory declarationProviderFactory;
-    private final BindingTrace bindingTrace;
+    private final GlobalContext globalContext;
+    private final StorageManager storageManager;
     private final ModuleDescriptorImpl module;
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
+    private final GlobalSearchScope moduleContentScope;
+    private final BindingTrace bindingTrace;
+    private final DeclarationProviderFactory declarationProviderFactory;
+    private final ModuleClassResolver moduleClassResolver;
     private final ResolveSession resolveSession;
     private final JavaDescriptorResolver javaDescriptorResolver;
     private final VirtualFileFinder virtualFileFinder;
@@ -118,20 +122,25 @@ public class InjectorForLazyResolveWithJava {
     
     public InjectorForLazyResolveWithJava(
         @NotNull Project project,
-        @NotNull GlobalContextImpl globalContext,
+        @NotNull GlobalContext globalContext,
+        @NotNull ModuleDescriptorImpl module,
+        @NotNull GlobalSearchScope moduleContentScope,
+        @NotNull BindingTrace bindingTrace,
         @NotNull DeclarationProviderFactory declarationProviderFactory,
-        @NotNull BindingTrace bindingTrace
+        @NotNull ModuleClassResolver moduleClassResolver
     ) {
         this.project = project;
         this.globalContext = globalContext;
-        this.lockBasedStorageManager = globalContext.getStorageManager();
-        this.declarationProviderFactory = declarationProviderFactory;
-        this.bindingTrace = bindingTrace;
-        this.module = org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM.createJavaModule("<fake-jdr-module>");
+        this.storageManager = globalContext.getStorageManager();
+        this.module = module;
         this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
-        this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
+        this.moduleContentScope = moduleContentScope;
+        this.bindingTrace = bindingTrace;
+        this.declarationProviderFactory = declarationProviderFactory;
+        this.moduleClassResolver = moduleClassResolver;
+        this.resolveSession = new ResolveSession(project, globalContext, module, declarationProviderFactory, bindingTrace);
         this.javaClassFinder = new JavaClassFinderImpl();
-        this.virtualFileFinder = org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder.SERVICE.getInstance(project);
+        this.virtualFileFinder = org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinderFactory.SERVICE.getInstance(project).create(moduleContentScope);
         this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
         this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver();
         this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver();
@@ -140,9 +149,9 @@ public class InjectorForLazyResolveWithJava {
         this.lazyResolveBasedCache = new LazyResolveBasedCache();
         this.javaPropertyInitializerEvaluator = new JavaPropertyInitializerEvaluatorImpl();
         this.javaSourceElementFactory = new JavaSourceElementFactoryImpl();
-        this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, javaSourceElementFactory);
-        this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule());
-        this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
+        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, javaSourceElementFactory, moduleClassResolver);
+        this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, module);
+        this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, module);
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
@@ -151,7 +160,7 @@ public class InjectorForLazyResolveWithJava {
         this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
         this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver);
         this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.reflectionTypes = new ReflectionTypes(getModule());
+        this.reflectionTypes = new ReflectionTypes(module);
         this.callExpressionResolver = new CallExpressionResolver();
         this.descriptorResolver = new DescriptorResolver();
         this.delegatedPropertyResolver = new DelegatedPropertyResolver();
@@ -166,8 +175,8 @@ public class InjectorForLazyResolveWithJava {
         this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);
         this.annotationDescriptorLoader = new AnnotationDescriptorLoader();
         this.constantDescriptorLoader = new ConstantDescriptorLoader();
-        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(lockBasedStorageManager, getModule(), javaClassDataFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider);
-        this.descriptorLoadersStorage = new DescriptorLoadersStorage(lockBasedStorageManager);
+        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(storageManager, module, javaClassDataFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider);
+        this.descriptorLoadersStorage = new DescriptorLoadersStorage(storageManager);
 
         this.resolveSession.setAnnotationResolve(annotationResolver);
         this.resolveSession.setDescriptorResolver(descriptorResolver);
@@ -178,6 +187,7 @@ public class InjectorForLazyResolveWithJava {
         this.resolveSession.setTypeResolver(typeResolver);
 
         javaClassFinder.setProject(project);
+        javaClassFinder.setScope(moduleContentScope);
 
         traceBasedExternalSignatureResolver.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
         traceBasedExternalSignatureResolver.setProject(project);
@@ -191,7 +201,7 @@ public class InjectorForLazyResolveWithJava {
         psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
 
         annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setStorageManager(lockBasedStorageManager);
+        annotationResolver.setStorageManager(storageManager);
         annotationResolver.setTypeResolver(typeResolver);
 
         callResolver.setArgumentTypeResolver(argumentTypeResolver);
@@ -229,7 +239,7 @@ public class InjectorForLazyResolveWithJava {
         descriptorResolver.setAnnotationResolver(annotationResolver);
         descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
         descriptorResolver.setExpressionTypingServices(expressionTypingServices);
-        descriptorResolver.setStorageManager(lockBasedStorageManager);
+        descriptorResolver.setStorageManager(storageManager);
         descriptorResolver.setTypeResolver(typeResolver);
 
         delegatedPropertyResolver.setCallResolver(callResolver);
@@ -268,10 +278,6 @@ public class InjectorForLazyResolveWithJava {
     public void destroy() {
     }
     
-    public ModuleDescriptorImpl getModule() {
-        return this.module;
-    }
-    
     public ResolveSession getResolveSession() {
         return this.resolveSession;
     }

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

@@ -27,6 +27,7 @@ import org.jetbrains.jet.lang.resolve.LazyTopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava;
+import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedJavaResolverCache;
@@ -35,6 +36,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureCheck
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaPropertyInitializerEvaluatorImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSourceElementFactoryImpl;
+import org.jetbrains.jet.lang.resolve.java.lazy.SingleModuleClassResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
 import org.jetbrains.jet.lang.resolve.BodyResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
@@ -90,6 +92,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
     private final JavaDescriptorResolver javaDescriptorResolver;
     private final DeserializationGlobalContextForJava deserializationGlobalContextForJava;
+    private final GlobalSearchScope globalSearchScope;
     private final JavaClassFinderImpl javaClassFinder;
     private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
     private final TraceBasedJavaResolverCache traceBasedJavaResolverCache;
@@ -98,6 +101,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
     private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator;
     private final JavaSourceElementFactoryImpl javaSourceElementFactory;
+    private final SingleModuleClassResolver singleModuleClassResolver;
     private final VirtualFileFinder virtualFileFinder;
     private final BodyResolver bodyResolver;
     private final AnnotationResolver annotationResolver;
@@ -161,13 +165,15 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache();
         this.javaPropertyInitializerEvaluator = new JavaPropertyInitializerEvaluatorImpl();
         this.javaSourceElementFactory = new JavaSourceElementFactoryImpl();
-        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, javaPropertyInitializerEvaluator, javaSourceElementFactory);
+        this.singleModuleClassResolver = new SingleModuleClassResolver();
+        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, javaPropertyInitializerEvaluator, javaSourceElementFactory, singleModuleClassResolver);
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModuleDescriptor());
         this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModuleDescriptor());
         this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);
         this.annotationDescriptorLoader = new AnnotationDescriptorLoader();
         this.constantDescriptorLoader = new ConstantDescriptorLoader();
         this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(storageManager, getModuleDescriptor(), javaClassDataFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider);
+        this.globalSearchScope = com.intellij.psi.search.GlobalSearchScope.allScope(project);
         this.bodyResolver = new BodyResolver();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
@@ -218,6 +224,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.lazyTopDownAnalyzer.setTrace(bindingTrace);
 
         javaClassFinder.setProject(project);
+        javaClassFinder.setScope(globalSearchScope);
 
         traceBasedExternalSignatureResolver.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
         traceBasedExternalSignatureResolver.setProject(project);
@@ -230,6 +237,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
         psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
 
+        singleModuleClassResolver.setResolver(javaDescriptorResolver);
+
         bodyResolver.setAnnotationResolver(annotationResolver);
         bodyResolver.setCallResolver(callResolver);
         bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);

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

@@ -19,41 +19,30 @@ package org.jetbrains.jet.lang.resolve.java;
 import com.google.common.base.Predicate;
 import com.google.common.collect.ImmutableList;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiFile;
-import com.intellij.psi.search.GlobalSearchScope;
-import kotlin.Function1;
-import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
-import org.jetbrains.jet.analyzer.AnalyzerFacade;
 import org.jetbrains.jet.context.ContextPackage;
 import org.jetbrains.jet.context.GlobalContext;
-import org.jetbrains.jet.context.GlobalContextImpl;
-import org.jetbrains.jet.di.InjectorForLazyResolveWithJava;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider;
-import org.jetbrains.jet.lang.descriptors.impl.CompositePackageFragmentProvider;
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
 import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.kotlin.incremental.cache.IncrementalCache;
 import org.jetbrains.jet.lang.resolve.kotlin.incremental.cache.IncrementalCacheProvider;
-import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
-import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
-import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactoryService;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
 
-public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
+public enum AnalyzerFacadeForJVM  {
 
     INSTANCE;
 
@@ -64,85 +53,9 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             new ImportPath("kotlin.io.*")
     );
 
-    public static class JvmSetup extends BasicSetup {
-
-        private final JavaDescriptorResolver javaDescriptorResolver;
-
-        public JvmSetup(@NotNull ResolveSession session, @NotNull JavaDescriptorResolver javaDescriptorResolver) {
-            super(session);
-            this.javaDescriptorResolver = javaDescriptorResolver;
-        }
-
-        @NotNull
-        public JavaDescriptorResolver getJavaDescriptorResolver() {
-            return javaDescriptorResolver;
-        }
-    }
-
     private AnalyzerFacadeForJVM() {
     }
 
-    @NotNull
-    @Override
-    public JvmSetup createSetup(
-            @NotNull Project fileProject,
-            @NotNull Collection<JetFile> syntheticFiles,
-            @NotNull GlobalSearchScope filesScope
-    ) {
-        return createSetup(fileProject, syntheticFiles, filesScope, new BindingTraceContext(), true);
-    }
-
-    @NotNull
-    public static ResolveSession createLazyResolveSession(
-            @NotNull Project project,
-            @NotNull Collection<JetFile> files,
-            @NotNull BindingTrace trace,
-            boolean addBuiltIns
-    ) {
-        List<VirtualFile> virtualFiles = KotlinPackage.map(files, new Function1<JetFile, VirtualFile>() {
-            @Override
-            public VirtualFile invoke(JetFile file) {
-                return file.getVirtualFile();
-            }
-        });
-        return createSetup(project, Collections.<JetFile>emptyList(),
-                           GlobalSearchScope.filesScope(project, virtualFiles), trace, addBuiltIns).getLazyResolveSession();
-    }
-
-    public static JvmSetup createSetup(
-            @NotNull Project project,
-            @NotNull Collection<JetFile> syntheticFiles,
-            @NotNull GlobalSearchScope filesScope,
-            @NotNull BindingTrace trace,
-            boolean addBuiltIns
-    ) {
-        GlobalContextImpl globalContext = ContextPackage.GlobalContext();
-
-        DeclarationProviderFactory declarationProviderFactory = DeclarationProviderFactoryService.OBJECT$
-                .createDeclarationProviderFactory(project, globalContext.getStorageManager(), syntheticFiles, filesScope);
-
-        InjectorForLazyResolveWithJava resolveWithJava = new InjectorForLazyResolveWithJava(
-                project,
-                globalContext,
-                declarationProviderFactory,
-                trace);
-
-        ModuleDescriptorImpl module = resolveWithJava.getModule();
-        module.initialize(
-                new CompositePackageFragmentProvider(
-                        Arrays.asList(
-                                resolveWithJava.getResolveSession().getPackageFragmentProvider(),
-                                resolveWithJava.getJavaDescriptorResolver().getPackageFragmentProvider()
-                        )));
-
-        module.addDependencyOnModule(module);
-        if (addBuiltIns) {
-            module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
-        }
-        module.seal();
-        return new JvmSetup(resolveWithJava.getResolveSession(), resolveWithJava.getJavaDescriptorResolver());
-    }
-
     @NotNull
     public static AnalyzeExhaust analyzeFilesWithJavaIntegration(
             Project project,

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

@@ -38,6 +38,8 @@ import javax.inject.Inject;
 public class JavaClassFinderImpl implements JavaClassFinder {
     @NotNull
     private Project project;
+    @NotNull
+    private GlobalSearchScope baseScope;
 
     private GlobalSearchScope javaSearchScope;
     private JavaPsiFacadeKotlinHacks javaFacade;
@@ -47,9 +49,14 @@ public class JavaClassFinderImpl implements JavaClassFinder {
         this.project = project;
     }
 
+    @Inject
+    public void setScope(@NotNull GlobalSearchScope scope) {
+        this.baseScope = scope;
+    }
+
     @PostConstruct
     public void initialize() {
-        javaSearchScope = new DelegatingGlobalSearchScope(GlobalSearchScope.allScope(project)) {
+        javaSearchScope = new DelegatingGlobalSearchScope(baseScope) {
             @Override
             public boolean contains(VirtualFile file) {
                 return myBaseScope.contains(file) && file.getFileType() != JetFileType.INSTANCE;
@@ -57,6 +64,7 @@ public class JavaClassFinderImpl implements JavaClassFinder {
 
             @Override
             public int compare(VirtualFile file1, VirtualFile file2) {
+                //TODO_r: delete this code?
                 // TODO: this is a hackish workaround for the following problem:
                 // since we are working with the allScope(), if the same class FqName
                 // to be on the class path twice, because it is included into different libraries

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

@@ -17,6 +17,7 @@
 package org.jetbrains.jet.lang.resolve.java;
 
 import com.google.common.collect.Lists;
+import com.intellij.core.CoreJavaFileManager;
 import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.progress.ProgressIndicatorProvider;
 import com.intellij.openapi.project.Project;
@@ -41,9 +42,11 @@ public class JavaPsiFacadeKotlinHacks {
 
     private final JavaFileManager javaFileManager;
     private final List<PsiElementFinder> extensionPsiElementFinders;
+    private final boolean isCoreJavaFileManager;
 
     public JavaPsiFacadeKotlinHacks(@NotNull Project project) {
         this.javaFileManager = findJavaFileManager(project);
+        this.isCoreJavaFileManager = javaFileManager instanceof CoreJavaFileManager;
         this.extensionPsiElementFinders = Lists.newArrayList();
         for (PsiElementFinder finder : project.getExtensions(PsiElementFinder.EP_NAME)) {
             if (!(finder instanceof KotlinFinderMarker)) {
@@ -82,7 +85,10 @@ public class JavaPsiFacadeKotlinHacks {
 
         PsiClass aClass = javaFileManager.findClass(qualifiedName, scope);
         if (aClass != null) {
-            return aClass;
+            //TODO: (module refactoring) CoreJavaFileManager should check scope
+            if (!isCoreJavaFileManager || scope.contains(aClass.getContainingFile().getOriginalFile().getVirtualFile())) {
+                return aClass;
+            }
         }
 
         for (PsiElementFinder finder : extensionPsiElementFinders) {

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmAnalyzerFacade.kt

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.java
+
+import org.jetbrains.jet.analyzer.AnalyzerFacade
+import org.jetbrains.jet.analyzer.ResolverForModule
+import org.jetbrains.jet.lang.resolve.lazy.ResolveSession
+import org.jetbrains.jet.analyzer.PlatformAnalysisParameters
+import org.jetbrains.jet.analyzer.ResolverForProject
+import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap
+import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactoryService
+import org.jetbrains.jet.lang.resolve.BindingTraceContext
+import com.intellij.openapi.project.Project
+import org.jetbrains.jet.context.GlobalContext
+import org.jetbrains.jet.lang.descriptors.impl.CompositePackageFragmentProvider
+import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
+import org.jetbrains.jet.lang.resolve.java.lazy.ModuleClassResolverImpl
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.jet.analyzer.ModuleInfo
+import org.jetbrains.jet.analyzer.ModuleContent
+import org.jetbrains.jet.di.InjectorForLazyResolveWithJava
+
+public class JvmResolverForModule(
+        override val lazyResolveSession: ResolveSession,
+        public val javaDescriptorResolver: JavaDescriptorResolver
+) : ResolverForModule
+
+public class JvmPlatformParameters(
+        public val moduleByJavaClass: (JavaClass) -> ModuleInfo
+) : PlatformAnalysisParameters
+
+
+public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatformParameters> {
+    override fun <M : ModuleInfo> createResolverForModule(
+            project: Project,
+            globalContext: GlobalContext,
+            moduleDescriptor: ModuleDescriptorImpl,
+            moduleContent: ModuleContent,
+            platformParameters: JvmPlatformParameters,
+            resolverForProject: ResolverForProject<M, JvmResolverForModule>
+    ): JvmResolverForModule {
+        val (syntheticFiles, moduleContentScope) = moduleContent
+        val declarationProviderFactory = DeclarationProviderFactoryService.createDeclarationProviderFactory(
+                project, globalContext.storageManager, syntheticFiles, moduleContentScope
+        )
+
+        val moduleClassResolver = ModuleClassResolverImpl { javaClass ->
+            val moduleInfo = platformParameters.moduleByJavaClass(javaClass)
+            resolverForProject.resolverForModule(moduleInfo as M).javaDescriptorResolver
+        }
+        val injector = InjectorForLazyResolveWithJava(
+                project, globalContext, moduleDescriptor, moduleContentScope, BindingTraceContext(), declarationProviderFactory, moduleClassResolver
+        )
+
+        val resolveSession = injector.getResolveSession()!!
+        val javaDescriptorResolver = injector.getJavaDescriptorResolver()!!
+        val providersForModule = listOf(resolveSession.getPackageFragmentProvider(), javaDescriptorResolver.packageFragmentProvider)
+        moduleDescriptor.initialize(CompositePackageFragmentProvider(providersForModule))
+        return JvmResolverForModule(resolveSession, javaDescriptorResolver)
+    }
+
+    override val defaultImports = AnalyzerFacadeForJVM.DEFAULT_IMPORTS
+    override val platformToKotlinClassMap = JavaToKotlinClassMap.getInstance()
+
+}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/VirtualFileFinderFactory.java

@@ -16,10 +16,19 @@
 
 package org.jetbrains.jet.lang.resolve.kotlin;
 
+import com.intellij.openapi.components.ServiceManager;
+import com.intellij.openapi.project.Project;
 import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
 
 public interface VirtualFileFinderFactory {
     @NotNull
     VirtualFileFinder create(@NotNull GlobalSearchScope scope);
+
+    class SERVICE {
+        @NotNull
+        public static VirtualFileFinderFactory getInstance(@NotNull Project project) {
+            return ServiceManager.getService(project, VirtualFileFinderFactory.class);
+        }
+    }
 }