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

j2k/src/org/jetbrains/jet/j2k/AfterConversionPass.kt

@@ -25,10 +25,13 @@ import org.jetbrains.jet.lang.psi.JetUnaryExpression
 import org.jetbrains.jet.lang.psi.JetProperty
 import com.intellij.psi.PsiFile
 import org.jetbrains.jet.lang.resolve.BindingContext
+import com.intellij.psi.PsiElement
 
 class AfterConversionPass(val project: Project, val postProcessor: PostProcessor) {
     public fun run(kotlinCode: String): String {
-        val kotlinFile = JetPsiFactory(project).createFile(kotlinCode)
+        val kotlinFile = JetPsiFactory(project).createAnalyzableFile(
+                "fileForAfterConversionPass.kt", kotlinCode, postProcessor.contextToAnalyzeIn
+        )
         val bindingContext = postProcessor.analyzeFile(kotlinFile)
 
         val fixes = bindingContext.getDiagnostics().map {

j2k/src/org/jetbrains/jet/j2k/Converter.kt

@@ -37,6 +37,7 @@ public class FilesConversionScope(val files: Collection<PsiJavaFile>) : Conversi
 }
 
 public trait PostProcessor {
+    public val contextToAnalyzeIn: PsiElement
     public fun analyzeFile(file: JetFile): BindingContext
     public fun doAdditionalProcessing(file: JetFile)
 }

j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.kt

@@ -36,10 +36,6 @@ public object JavaToKotlinTranslator {
         return PsiFileFactory.getInstance(javaCoreEnvironment?.getProject()!!)?.createFileFromText("test.java", JavaLanguage.INSTANCE, text)
     }
 
-    fun createFile(project: Project, text: String): PsiJavaFile {
-        return PsiFileFactory.getInstance(project)?.createFileFromText("test.java", JavaLanguage.INSTANCE, text) as PsiJavaFile
-    }
-
     fun setUpJavaCoreEnvironment(): JavaCoreProjectEnvironment {
         val applicationEnvironment = JavaCoreApplicationEnvironment(DISPOSABLE)
         val javaCoreEnvironment = JavaCoreProjectEnvironment(DISPOSABLE, applicationEnvironment)

j2k/tests/test/org/jetbrains/jet/j2k/test/AbstractJavaToKotlinConverterTest.kt

@@ -34,6 +34,8 @@ import org.jetbrains.jet.plugin.j2k.J2kPostProcessor
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
 import com.intellij.testFramework.LightProjectDescriptor
 import org.jetbrains.jet.plugin.JetWithJdkAndRuntimeLightProjectDescriptor
+import com.intellij.psi.PsiJavaFile
+import com.intellij.psi.PsiFile
 
 public abstract class AbstractJavaToKotlinConverterTest() : LightCodeInsightFixtureTestCase() {
     val testHeaderPattern = Pattern.compile("//(element|expression|statement|method|class|file|comp)\n")
@@ -122,15 +124,15 @@ public abstract class AbstractJavaToKotlinConverterTest() : LightCodeInsightFixt
     }
 
     private fun elementToKotlin(text: String, settings: ConverterSettings, project: Project): String {
-        val fileWithText = JavaToKotlinTranslator.createFile(project, text)
-        val converter = Converter.create(project, settings, FilesConversionScope(listOf(fileWithText)), J2kPostProcessor)
+        val fileWithText = createJavaFile(text)
+        val converter = Converter.create(project, settings, FilesConversionScope(listOf(fileWithText)), J2kPostProcessor(fileWithText))
         val element = fileWithText.getFirstChild()!!
         return converter.elementToKotlin(element)
     }
 
     private fun fileToKotlin(text: String, settings: ConverterSettings, project: Project): String {
-        val file = JavaToKotlinTranslator.createFile(project, text)
-        val converter = Converter.create(project, settings, FilesConversionScope(listOf(file)), J2kPostProcessor)
+        val file = createJavaFile(text)
+        val converter = Converter.create(project, settings, FilesConversionScope(listOf(file)), J2kPostProcessor(file))
         return converter.elementToKotlin(file)
     }
 
@@ -161,4 +163,8 @@ public abstract class AbstractJavaToKotlinConverterTest() : LightCodeInsightFixt
         val lastNewLine = lastIndexOf('\n')
         return if (lastNewLine == -1) "" else substring(0, lastNewLine)
     }
-}
+
+    private fun createJavaFile(text: String): PsiJavaFile {
+        return myFixture.configureByText("converterTestFile.java", text) as PsiJavaFile
+    }
+}