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

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinder.java

@@ -23,7 +23,6 @@ import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 public interface JavaClassFinder {
-    // TODO: scope
     @Nullable
     JavaClass findClass(@NotNull FqName fqName);
 

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/LazyJavaPackageFragmentProvider.kt

@@ -47,7 +47,8 @@ public class LazyJavaPackageFragmentProvider(
             outerContext.methodSignatureChecker,
             outerContext.javaResolverCache,
             outerContext.javaPropertyInitializerEvaluator,
-            outerContext.sourceElementFactory
+            outerContext.sourceElementFactory,
+            outerContext.moduleClassResolver
     )
 
     override fun getModule() = _module
@@ -105,13 +106,8 @@ public class LazyJavaPackageFragmentProvider(
 
     private inner class FragmentClassResolver : LazyJavaClassResolver {
         override fun resolveClass(javaClass: JavaClass): ClassDescriptor? {
-            // TODO: there's no notion of module separation here. We must refuse to resolve classes from other modules
             val fqName = javaClass.getFqName()
             if (fqName != null) {
-                // TODO: this should be handled by module separation logic
-                val builtinClass = DescriptorResolverUtils.getKotlinBuiltinClassDescriptor(fqName)
-                if (builtinClass != null) return builtinClass
-
                 if (javaClass.getOriginKind() == JavaClass.OriginKind.KOTLIN_LIGHT_CLASS) {
                     return c.javaResolverCache.getClassResolvedFromSource(fqName)
                 }
@@ -121,8 +117,7 @@ public class LazyJavaPackageFragmentProvider(
                 return c.lookupBinaryClass(javaClass) ?: topLevelClasses(javaClass)
             }
             val outerClassScope = resolveClass(outerClass)?.getUnsubstitutedInnerClassesScope()
-            val nestedClass = outerClassScope?.getClassifier(javaClass.getName()) as? ClassDescriptor
-            return nestedClass ?: c.javaResolverCache.getClass(javaClass)
+            return outerClassScope?.getClassifier(javaClass.getName()) as? ClassDescriptor
         }
     }
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/ModuleClassResolver.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.java.lazy
+
+import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor
+import kotlin.properties.Delegates
+import javax.inject.Inject
+
+trait ModuleClassResolver {
+    fun resolveClass(javaClass: JavaClass): ClassDescriptor?
+}
+
+public class SingleModuleClassResolver() : ModuleClassResolver {
+    override fun resolveClass(javaClass: JavaClass): ClassDescriptor? {
+        return resolver!!.resolveClass(javaClass)
+    }
+
+    var resolver: JavaDescriptorResolver? = null
+        [Inject] set
+}
+
+public class ModuleClassResolverImpl(private val descriptorResolverByJavaClass: (JavaClass) -> JavaDescriptorResolver): ModuleClassResolver {
+    override fun resolveClass(javaClass: JavaClass): ClassDescriptor? = descriptorResolverByJavaClass(javaClass).resolveClass(javaClass)
+}

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/context.kt

@@ -42,7 +42,8 @@ open class GlobalJavaResolverContext(
         val methodSignatureChecker: MethodSignatureChecker,
         val javaResolverCache: JavaResolverCache,
         val javaPropertyInitializerEvaluator: JavaPropertyInitializerEvaluator,
-        val sourceElementFactory: JavaSourceElementFactory
+        val sourceElementFactory: JavaSourceElementFactory,
+        val moduleClassResolver: ModuleClassResolver
 )
 
 open class LazyJavaResolverContext(
@@ -58,11 +59,12 @@ open class LazyJavaResolverContext(
         methodSignatureChecker: MethodSignatureChecker,
         javaResolverCache: JavaResolverCache,
         javaPropertyInitializerEvaluator: JavaPropertyInitializerEvaluator,
-        sourceElementFactory: JavaSourceElementFactory
+        sourceElementFactory: JavaSourceElementFactory,
+        moduleClassResolver: ModuleClassResolver
 ) : GlobalJavaResolverContext(storageManager, finder, kotlinClassFinder, deserializedDescriptorResolver,
                               externalAnnotationResolver, externalSignatureResolver,
                               errorReporter, methodSignatureChecker, javaResolverCache, javaPropertyInitializerEvaluator,
-                              sourceElementFactory)
+                              sourceElementFactory, moduleClassResolver)
 
 fun LazyJavaResolverContext.withTypes(
         typeParameterResolver: TypeParameterResolver = TypeParameterResolver.EMPTY
@@ -80,6 +82,7 @@ fun LazyJavaResolverContext.withTypes(
         javaResolverCache,
         javaPropertyInitializerEvaluator,
         sourceElementFactory,
+        moduleClassResolver,
         LazyJavaTypeResolver(this, typeParameterResolver),
         typeParameterResolver)
 
@@ -97,12 +100,13 @@ class LazyJavaResolverContextWithTypes(
         javaResolverCache: JavaResolverCache,
         javaPropertyInitializerEvaluator: JavaPropertyInitializerEvaluator,
         sourceElementFactory: JavaSourceElementFactory,
+        moduleClassResolver: ModuleClassResolver,
         val typeResolver: LazyJavaTypeResolver,
         val typeParameterResolver: TypeParameterResolver
 ) : LazyJavaResolverContext(packageFragmentProvider, javaClassResolver, storageManager, finder,
                             kotlinClassFinder, deserializedDescriptorResolver,
                             externalAnnotationResolver, externalSignatureResolver, errorReporter, methodSignatureChecker,
-                            javaResolverCache, javaPropertyInitializerEvaluator, sourceElementFactory)
+                            javaResolverCache, javaPropertyInitializerEvaluator, sourceElementFactory, moduleClassResolver)
 
 fun LazyJavaResolverContextWithTypes.child(
         containingDeclaration: DeclarationDescriptor,

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt

@@ -65,7 +65,7 @@ class LazyJavaAnnotationDescriptor(
         val fqName = _fqName()
         if (fqName == null) return@createLazyValue ErrorUtils.createErrorType("No fqName: $javaAnnotation")
         val annotationClass = JavaToKotlinClassMap.getInstance().mapKotlinClass(fqName, TypeUsage.MEMBER_SIGNATURE_INVARIANT)
-                ?: javaAnnotation.resolve()?.let { javaClass -> c.javaClassResolver.resolveClass(javaClass) }
+                ?: javaAnnotation.resolve()?.let { javaClass -> c.moduleClassResolver.resolveClass(javaClass) }
         annotationClass?.getDefaultType() ?: ErrorUtils.createErrorType(fqName.asString())
     }
 
@@ -148,6 +148,7 @@ class LazyJavaAnnotationDescriptor(
 
         val containingJavaClass = element.getContainingClass()
 
+        //TODO: (module refactoring) moduleClassResolver should be used here
         val enumClass = c.javaClassResolver.resolveClass(containingJavaClass)
         if (enumClass == null) return null
 

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassMemberScope.kt

@@ -232,6 +232,7 @@ public class LazyJavaClassMemberScope(
         }
         else {
             // TODO: this caching is a temporary workaround, should be replaced with properly caching the whole LazyJavaPackageFragmentProvider
+            //TODO_R: remove this logic?
             val alreadyResolved = c.javaResolverCache.getClass(jNestedClass)
             if (alreadyResolved != null)
                 alreadyResolved

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/resolvers.kt

@@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass
 import org.jetbrains.jet.lang.resolve.resolveTopLevelClass
 
+//TODO: (module refactoring) usages of this interface should be replaced by ModuleClassResolver
 trait LazyJavaClassResolver {
     fun resolveClass(javaClass: JavaClass): ClassDescriptor?
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/types/LazyJavaTypeResolver.kt

@@ -113,7 +113,7 @@ class LazyJavaTypeResolver(
                     }
 
                     val classData = javaToKotlinClassMap.mapKotlinClass(fqName, howThisTypeIsUsedEffectively)
-                                    ?: c.javaClassResolver.resolveClass(classifier)
+                                    ?: c.moduleClassResolver.resolveClass(classifier)
 
                     classData?.getTypeConstructor()
                         ?: ErrorUtils.createErrorTypeConstructor("Unresolved java classifier: " + javaType.getPresentableText())