check for access to internal elements from another module in jps-plugin

hack for access from tests to internal declarations in production code

fix AbstractCompileKotlinAgainstKotinTest: add information about output directory in order to correct check for internal visibility.

compiler/cli/src/org/jetbrains/kotlin/cli/common/moduleVisibilityImpl.kt

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2010-2015 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.kotlin.cli.common
+
+import com.intellij.openapi.Disposable
+import org.jetbrains.kotlin.cli.common.modules.ModuleXmlParser
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityManager
+import org.jetbrains.kotlin.load.kotlin.getSourceElement
+import org.jetbrains.kotlin.load.kotlin.isContainedByCompiledPartOfOurModule
+import org.jetbrains.kotlin.modules.Module
+import org.jetbrains.kotlin.resolve.source.KotlinSourceElement
+import org.jetbrains.kotlin.util.ModuleVisibilityHelper
+import java.io.File
+
+class ModuleVisibilityHelperImpl : ModuleVisibilityHelper {
+
+    override fun isInFriendModule(what: DeclarationDescriptor, from: DeclarationDescriptor): Boolean {
+        val fromSource = getSourceElement(from)
+        // We only interested in case when fromSource is KotlinSourceElement,
+        // because at this point
+        // We should check accessibility of 'from' in current module (some set of source files, which are compiled together),
+        // so we can assume that 'from' should have sources.
+        if (fromSource !is KotlinSourceElement) return true
+
+        val project = fromSource.psi.project
+        val moduleVisibilityManager = ModuleVisibilityManager.SERVICE.getInstance(project)
+
+        val whatSource = getSourceElement(what)
+        if (whatSource is KotlinSourceElement) return true
+
+        val modules = moduleVisibilityManager.chunk.toList()
+        val outputDirectories = modules.map { File(it.getOutputDirectory()) }
+        if (outputDirectories.isEmpty()) return isContainedByCompiledPartOfOurModule(what, null)
+
+        outputDirectories.forEach {
+            if (isContainedByCompiledPartOfOurModule(what, it)) return true
+        }
+
+        // Hack in order to allow access to internal elements in production code from tests
+        if (modules.size() == 1 && modules[0].getModuleType() == ModuleXmlParser.TYPE_TEST) return true
+
+        return false
+    }
+}
+
+/*
+   At the moment, there is no proper support for module infrastructure in the compiler.
+   So we add try to remember given list of interdependent modules and use it for checking visibility.
+ */
+class CliModuleVisibilityManagerImpl() : ModuleVisibilityManager, Disposable {
+    override val chunk: MutableList<Module> = arrayListOf()
+
+    override fun addModule(module: Module) {
+        chunk.add(module)
+    }
+
+    override fun dispose() {
+        chunk.clear()
+    }
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt

@@ -56,6 +56,7 @@ import org.jetbrains.kotlin.asJava.JavaElementFinder
 import org.jetbrains.kotlin.asJava.KotlinLightClassForFacade
 import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
+import org.jetbrains.kotlin.cli.common.CliModuleVisibilityManagerImpl
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.ERROR
@@ -75,6 +76,7 @@ import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor
 import org.jetbrains.kotlin.idea.JetFileType
 import org.jetbrains.kotlin.load.kotlin.JvmVirtualFileFinderFactory
 import org.jetbrains.kotlin.load.kotlin.KotlinBinaryClassCache
+import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityManager
 import org.jetbrains.kotlin.parsing.JetParserDefinition
 import org.jetbrains.kotlin.parsing.JetScriptDefinitionProvider
 import org.jetbrains.kotlin.psi.JetFile
@@ -85,8 +87,7 @@ import org.jetbrains.kotlin.resolve.lazy.declarations.CliDeclarationProviderFact
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
 import org.jetbrains.kotlin.utils.PathUtil
 import java.io.File
-import java.util.ArrayList
-import java.util.Comparator
+import java.util.*
 
 public class KotlinCoreEnvironment private constructor(
         parentDisposable: Disposable, 
@@ -114,6 +115,7 @@ public class KotlinCoreEnvironment private constructor(
         annotationsManager = CoreExternalAnnotationsManager(project.getComponent(javaClass<PsiManager>())!!)
         project.registerService(javaClass<ExternalAnnotationsManager>(), annotationsManager)
         project.registerService(javaClass<DeclarationProviderFactoryService>(), CliDeclarationProviderFactoryService(sourceFiles))
+        project.registerService(ModuleVisibilityManager::class.java, CliModuleVisibilityManagerImpl())
 
         registerProjectServicesForCLI(projectEnvironment)
         registerProjectServices(projectEnvironment)

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

@@ -42,6 +42,7 @@ import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.idea.MainFunctionDetector;
+import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityManager;
 import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache;
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents;
@@ -119,6 +120,10 @@ public class KotlinToJVMBytecodeCompiler {
 
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
 
+        for (Module module: chunk) {
+            ModuleVisibilityManager.SERVICE.getInstance(environment.getProject()).addModule(module);
+        }
+
         String targetDescription = "in targets [" + Joiner.on(", ").join(Collections2.transform(chunk, new Function<Module, String>() {
             @Override
             public String apply(@Nullable Module input) {
@@ -144,8 +149,9 @@ public class KotlinToJVMBytecodeCompiler {
                         }
                     }
             );
+            File moduleOutputDirectory = new File(module.getOutputDirectory());
             GenerationState generationState =
-                    generate(environment, result, jetFiles, module, new File(module.getOutputDirectory()),
+                    generate(environment, result, jetFiles, module, moduleOutputDirectory,
                              module.getModuleName());
             outputFiles.put(module, generationState.getFactory());
         }