Switch to 181 platform

2018-04-27 18:25:17 +03:00
parent df59af8ee8
commit bc403ce744
673 changed files with 25853 additions and 922 deletions
@@ -395,7 +395,7 @@ class KotlinCoreEnvironment private constructor(
    }

    companion object {
-        private val ideaCompatibleBuildNumber = "173.1"
+        private val ideaCompatibleBuildNumber = "181.1"

        init {
            setCompatibleBuild()
@@ -0,0 +1,629 @@
+/*
+ * Copyright 2010-2017 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.jvm.compiler
+
+import com.intellij.codeInsight.ContainerProvider
+import com.intellij.codeInsight.ExternalAnnotationsManager
+import com.intellij.codeInsight.InferredAnnotationsManager
+import com.intellij.codeInsight.runner.JavaMainMethodProvider
+import com.intellij.core.CoreApplicationEnvironment
+import com.intellij.core.CoreJavaFileManager
+import com.intellij.core.JavaCoreApplicationEnvironment
+import com.intellij.core.JavaCoreProjectEnvironment
+import com.intellij.ide.highlighter.JavaFileType
+import com.intellij.ide.plugins.PluginManagerCore
+import com.intellij.lang.MetaLanguage
+import com.intellij.lang.java.JavaParserDefinition
+import com.intellij.lang.jvm.facade.JvmElementProvider
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.application.TransactionGuard
+import com.intellij.openapi.application.TransactionGuardImpl
+import com.intellij.openapi.components.ServiceManager
+import com.intellij.openapi.extensions.Extensions
+import com.intellij.openapi.extensions.ExtensionsArea
+import com.intellij.openapi.fileTypes.FileTypeExtensionPoint
+import com.intellij.openapi.fileTypes.PlainTextFileType
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.Disposer
+import com.intellij.openapi.util.io.FileUtilRt
+import com.intellij.openapi.util.text.StringUtil
+import com.intellij.openapi.vfs.*
+import com.intellij.openapi.vfs.impl.ZipHandler
+import com.intellij.psi.FileContextProvider
+import com.intellij.psi.JavaModuleSystem
+import com.intellij.psi.PsiElementFinder
+import com.intellij.psi.PsiManager
+import com.intellij.psi.augment.PsiAugmentProvider
+import com.intellij.psi.augment.TypeAnnotationModifier
+import com.intellij.psi.compiled.ClassFileDecompilers
+import com.intellij.psi.impl.JavaClassSupersImpl
+import com.intellij.psi.impl.PsiElementFinderImpl
+import com.intellij.psi.impl.PsiTreeChangePreprocessor
+import com.intellij.psi.impl.compiled.ClsCustomNavigationPolicy
+import com.intellij.psi.impl.file.impl.JavaFileManager
+import com.intellij.psi.meta.MetaDataContributor
+import com.intellij.psi.search.GlobalSearchScope
+import com.intellij.psi.stubs.BinaryFileStubBuilders
+import com.intellij.psi.util.JavaClassSupers
+import com.intellij.util.io.URLUtil
+import com.intellij.util.lang.UrlClassLoader
+import org.jetbrains.annotations.TestOnly
+import org.jetbrains.kotlin.asJava.KotlinAsJavaSupport
+import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
+import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
+import org.jetbrains.kotlin.cli.common.CliModuleVisibilityManagerImpl
+import org.jetbrains.kotlin.cli.common.KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.ERROR
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.STRONG_WARNING
+import org.jetbrains.kotlin.cli.common.messages.MessageCollector
+import org.jetbrains.kotlin.cli.common.script.CliScriptDefinitionProvider
+import org.jetbrains.kotlin.cli.common.script.CliScriptDependenciesProvider
+import org.jetbrains.kotlin.cli.common.script.CliScriptReportSink
+import org.jetbrains.kotlin.cli.common.toBooleanLenient
+import org.jetbrains.kotlin.cli.jvm.JvmRuntimeVersionsConsistencyChecker
+import org.jetbrains.kotlin.cli.jvm.config.*
+import org.jetbrains.kotlin.cli.jvm.index.*
+import org.jetbrains.kotlin.cli.jvm.javac.JavacWrapperRegistrar
+import org.jetbrains.kotlin.cli.jvm.modules.CliJavaModuleFinder
+import org.jetbrains.kotlin.cli.jvm.modules.CliJavaModuleResolver
+import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem
+import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension
+import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension
+import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
+import org.jetbrains.kotlin.config.*
+import org.jetbrains.kotlin.extensions.CompilerConfigurationExtension
+import org.jetbrains.kotlin.extensions.DeclarationAttributeAltererExtension
+import org.jetbrains.kotlin.extensions.PreprocessedVirtualFileFactoryExtension
+import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor
+import org.jetbrains.kotlin.idea.KotlinFileType
+import org.jetbrains.kotlin.js.translate.extensions.JsSyntheticTranslateExtension
+import org.jetbrains.kotlin.load.kotlin.KotlinBinaryClassCache
+import org.jetbrains.kotlin.load.kotlin.MetadataFinderFactory
+import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityManager
+import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory
+import org.jetbrains.kotlin.parsing.KotlinParserDefinition
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
+import org.jetbrains.kotlin.resolve.ModuleAnnotationsResolver
+import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension
+import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
+import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtension
+import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver
+import org.jetbrains.kotlin.resolve.lazy.declarations.CliDeclarationProviderFactoryService
+import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
+import org.jetbrains.kotlin.script.ScriptDefinitionProvider
+import org.jetbrains.kotlin.script.ScriptDependenciesProvider
+import org.jetbrains.kotlin.script.ScriptReportSink
+import org.jetbrains.kotlin.script.StandardScriptDefinition
+import org.jetbrains.kotlin.utils.PathUtil
+import java.io.File
+import java.util.zip.ZipFile
+
+class KotlinCoreEnvironment private constructor(
+        parentDisposable: Disposable,
+        applicationEnvironment: JavaCoreApplicationEnvironment,
+        initialConfiguration: CompilerConfiguration,
+        configFiles: EnvironmentConfigFiles
+) {
+    private val projectEnvironment: JavaCoreProjectEnvironment = object : KotlinCoreProjectEnvironment(parentDisposable, applicationEnvironment) {
+        override fun preregisterServices() {
+            registerProjectExtensionPoints(Extensions.getArea(project))
+        }
+
+        override fun registerJavaPsiFacade() {
+            with (project) {
+                registerService(CoreJavaFileManager::class.java, ServiceManager.getService(this, JavaFileManager::class.java) as CoreJavaFileManager)
+
+                val traceHolder = CliTraceHolder()
+                val cliLightClassGenerationSupport = CliLightClassGenerationSupport(traceHolder)
+                val kotlinAsJavaSupport = CliKotlinAsJavaSupport(this, traceHolder)
+                registerService(LightClassGenerationSupport::class.java, cliLightClassGenerationSupport)
+                registerService(CliLightClassGenerationSupport::class.java, cliLightClassGenerationSupport)
+                registerService(KotlinAsJavaSupport::class.java, kotlinAsJavaSupport)
+                registerService(CodeAnalyzerInitializer::class.java, traceHolder)
+
+                registerService(ExternalAnnotationsManager::class.java, MockExternalAnnotationsManager())
+                registerService(InferredAnnotationsManager::class.java, MockInferredAnnotationsManager())
+
+                val area = Extensions.getArea(this)
+
+                area.getExtensionPoint(PsiElementFinder.EP_NAME).registerExtension(JavaElementFinder(this, kotlinAsJavaSupport))
+                area.getExtensionPoint(PsiElementFinder.EP_NAME).registerExtension(
+                        PsiElementFinderImpl(this, ServiceManager.getService(this, JavaFileManager::class.java)))
+            }
+
+            super.registerJavaPsiFacade()
+        }
+    }
+
+    private val sourceFiles = mutableListOf<KtFile>()
+    private val rootsIndex: JvmDependenciesDynamicCompoundIndex
+    private val packagePartProviders = mutableListOf<JvmPackagePartProvider>()
+
+    private val classpathRootsResolver: ClasspathRootsResolver
+    private val initialRoots: List<JavaRoot>
+
+    val configuration: CompilerConfiguration = initialConfiguration.apply { setupJdkClasspathRoots(configFiles) }.copy()
+
+    init {
+        PersistentFSConstants::class.java.getDeclaredField("ourMaxIntellisenseFileSize")
+                .apply { isAccessible = true }
+                .setInt(null, FileUtilRt.LARGE_FOR_CONTENT_LOADING)
+
+        val project = projectEnvironment.project
+
+        ExpressionCodegenExtension.registerExtensionPoint(project)
+        SyntheticResolveExtension.registerExtensionPoint(project)
+        ClassBuilderInterceptorExtension.registerExtensionPoint(project)
+        AnalysisHandlerExtension.registerExtensionPoint(project)
+        PackageFragmentProviderExtension.registerExtensionPoint(project)
+        StorageComponentContainerContributor.registerExtensionPoint(project)
+        DeclarationAttributeAltererExtension.registerExtensionPoint(project)
+        PreprocessedVirtualFileFactoryExtension.registerExtensionPoint(project)
+        JsSyntheticTranslateExtension.registerExtensionPoint(project)
+        CompilerConfigurationExtension.registerExtensionPoint(project)
+
+        for (registrar in configuration.getList(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS)) {
+            try {
+                registrar.registerProjectComponents(project, configuration)
+            } catch (e: AbstractMethodError) {
+                throw IllegalStateException("The provided plugin ${registrar.javaClass.name} is not compatible with this version of compiler", e)
+            }
+        }
+
+        project.registerService(DeclarationProviderFactoryService::class.java, CliDeclarationProviderFactoryService(sourceFiles))
+        project.registerService(ModuleVisibilityManager::class.java, CliModuleVisibilityManagerImpl(configFiles == EnvironmentConfigFiles.JVM_CONFIG_FILES))
+
+        registerProjectServicesForCLI(projectEnvironment)
+
+        val messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
+        registerProjectServices(projectEnvironment, messageCollector)
+
+        CompilerConfigurationExtension.getInstances(project).forEach {
+            it.updateConfiguration(configuration)
+        }
+
+        sourceFiles += CompileEnvironmentUtil.getKtFiles(project, getSourceRootsCheckingForDuplicates(), this.configuration, {
+            message ->
+            report(ERROR, message)
+        })
+        sourceFiles.sortBy { it.virtualFile.path }
+
+        // We should always support at least the standard script definition
+        configuration.add(JVMConfigurationKeys.SCRIPT_DEFINITIONS, StandardScriptDefinition)
+
+        val scriptDefinitionProvider = ScriptDefinitionProvider.getInstance(project) as? CliScriptDefinitionProvider
+        if (scriptDefinitionProvider != null) {
+            scriptDefinitionProvider.setScriptDefinitions(
+                    configuration.getList(JVMConfigurationKeys.SCRIPT_DEFINITIONS))
+
+            ScriptDependenciesProvider.getInstance(project).let { importsProvider ->
+                configuration.addJvmClasspathRoots(
+                        sourceFiles.mapNotNull(importsProvider::getScriptDependencies)
+                                .flatMap { it.classpath }
+                                .distinctBy { it.absolutePath })
+            }
+        }
+
+        val jdkHome = configuration.get(JVMConfigurationKeys.JDK_HOME)
+        val jrtFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.JRT_PROTOCOL)
+        val javaModuleFinder = CliJavaModuleFinder(jdkHome?.path?.let { path ->
+            jrtFileSystem?.findFileByPath(path + URLUtil.JAR_SEPARATOR)
+        })
+
+        val outputDirectory =
+                configuration.get(JVMConfigurationKeys.MODULES)?.singleOrNull()?.getOutputDirectory()
+                ?: configuration.get(JVMConfigurationKeys.OUTPUT_DIRECTORY)?.absolutePath
+
+        classpathRootsResolver = ClasspathRootsResolver(
+                PsiManager.getInstance(project),
+                messageCollector,
+                configuration.getList(JVMConfigurationKeys.ADDITIONAL_JAVA_MODULES),
+                this::contentRootToVirtualFile,
+                javaModuleFinder,
+                !configuration.getBoolean(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE),
+                outputDirectory?.let(this::findLocalFile)
+        )
+
+        val (initialRoots, javaModules) =
+                classpathRootsResolver.convertClasspathRoots(configuration.getList(JVMConfigurationKeys.CONTENT_ROOTS))
+        this.initialRoots = initialRoots
+
+        if (!configuration.getBoolean(JVMConfigurationKeys.SKIP_RUNTIME_VERSION_CHECK) && messageCollector != null) {
+            JvmRuntimeVersionsConsistencyChecker.checkCompilerClasspathConsistency(
+                    messageCollector,
+                    configuration,
+                    initialRoots.mapNotNull { (file, type) -> if (type == JavaRoot.RootType.BINARY) file else null }
+            )
+        }
+
+        val (roots, singleJavaFileRoots) =
+                initialRoots.partition { (file) -> file.isDirectory || file.extension != JavaFileType.DEFAULT_EXTENSION }
+
+        // REPL and kapt2 update classpath dynamically
+        rootsIndex = JvmDependenciesDynamicCompoundIndex().apply {
+            addIndex(JvmDependenciesIndexImpl(roots))
+            updateClasspathFromRootsIndex(this)
+        }
+
+        (ServiceManager.getService(project, CoreJavaFileManager::class.java) as KotlinCliJavaFileManagerImpl).initialize(
+                rootsIndex,
+                packagePartProviders,
+                SingleJavaFileRootsIndex(singleJavaFileRoots),
+                configuration.getBoolean(JVMConfigurationKeys.USE_FAST_CLASS_FILES_READING)
+        )
+
+        project.registerService(
+                JavaModuleResolver::class.java,
+                CliJavaModuleResolver(classpathRootsResolver.javaModuleGraph, javaModules, javaModuleFinder.systemModules.toList())
+        )
+
+        val finderFactory = CliVirtualFileFinderFactory(rootsIndex)
+        project.registerService(MetadataFinderFactory::class.java, finderFactory)
+        project.registerService(VirtualFileFinderFactory::class.java, finderFactory)
+
+        project.putUserData(APPEND_JAVA_SOURCE_ROOTS_HANDLER_KEY, fun(roots: List<File>) {
+            updateClasspath(roots.map { JavaSourceRoot(it, null) })
+        })
+    }
+
+    fun createPackagePartProvider(scope: GlobalSearchScope): JvmPackagePartProvider {
+        return JvmPackagePartProvider(configuration.languageVersionSettings, scope).apply {
+            addRoots(initialRoots)
+            packagePartProviders += this
+            (ModuleAnnotationsResolver.getInstance(project) as CliModuleAnnotationsResolver).addPackagePartProvider(this)
+        }
+    }
+
+    private val VirtualFile.javaFiles: List<VirtualFile>
+        get() = mutableListOf<VirtualFile>().apply {
+            VfsUtilCore.processFilesRecursively(this@javaFiles) { file ->
+                if (file.fileType == JavaFileType.INSTANCE) {
+                    add(file)
+                }
+                true
+            }
+        }
+
+    private val allJavaFiles: List<File>
+        get() = configuration.javaSourceRoots
+                .mapNotNull(this::findLocalFile)
+                .flatMap { it.javaFiles }
+                .map { File(it.canonicalPath) }
+
+    fun registerJavac(
+            javaFiles: List<File> = allJavaFiles,
+            kotlinFiles: List<KtFile> = sourceFiles,
+            arguments: Array<String>? = null,
+            bootClasspath: List<File>? = null,
+            sourcePath: List<File>? = null
+    ): Boolean {
+        return JavacWrapperRegistrar.registerJavac(projectEnvironment.project, configuration, javaFiles, kotlinFiles, arguments, bootClasspath, sourcePath, LightClassGenerationSupport.getInstance(project))
+    }
+
+    private val applicationEnvironment: CoreApplicationEnvironment
+        get() = projectEnvironment.environment
+
+    val project: Project
+        get() = projectEnvironment.project
+
+    internal fun countLinesOfCode(sourceFiles: List<KtFile>): Int  =
+            sourceFiles.sumBy { sourceFile ->
+                val text = sourceFile.text
+                StringUtil.getLineBreakCount(text) + (if (StringUtil.endsWithLineBreak(text)) 0 else 1)
+            }
+
+    private fun updateClasspathFromRootsIndex(index: JvmDependenciesIndex) {
+        index.indexedRoots.forEach {
+            projectEnvironment.addSourcesToClasspath(it.file)
+        }
+    }
+
+    fun updateClasspath(contentRoots: List<ContentRoot>): List<File>? {
+        // TODO: add new Java modules to CliJavaModuleResolver
+        val newRoots = classpathRootsResolver.convertClasspathRoots(contentRoots).roots
+
+        for (packagePartProvider in packagePartProviders) {
+            packagePartProvider.addRoots(newRoots)
+        }
+
+        return rootsIndex.addNewIndexForRoots(newRoots)?.let { newIndex ->
+            updateClasspathFromRootsIndex(newIndex)
+            newIndex.indexedRoots.mapNotNull { (file) ->
+                VfsUtilCore.virtualToIoFile(VfsUtilCore.getVirtualFileForJar(file) ?: file)
+            }.toList()
+        }.orEmpty()
+    }
+
+    private fun contentRootToVirtualFile(root: JvmContentRoot): VirtualFile? {
+        return when (root) {
+            is JvmClasspathRoot -> if (root.file.isFile) findJarRoot(root.file) else findLocalFile(root)
+            is JvmModulePathRoot -> if (root.file.isFile) findJarRoot(root.file) else findLocalFile(root)
+            is JavaSourceRoot -> findLocalFile(root)
+            else -> throw IllegalStateException("Unexpected root: $root")
+        }
+    }
+
+    internal fun findLocalFile(path: String): VirtualFile? =
+            applicationEnvironment.localFileSystem.findFileByPath(path)
+
+    private fun findLocalFile(root: JvmContentRoot): VirtualFile? {
+        return findLocalFile(root.file.absolutePath).also {
+            if (it == null) {
+                report(STRONG_WARNING, "Classpath entry points to a non-existent location: ${root.file}")
+            }
+        }
+    }
+
+    private fun findJarRoot(file: File): VirtualFile? =
+            applicationEnvironment.jarFileSystem.findFileByPath("$file${URLUtil.JAR_SEPARATOR}")
+
+    private fun getSourceRootsCheckingForDuplicates(): Collection<String> {
+        val uniqueSourceRoots = linkedSetOf<String>()
+
+        configuration.kotlinSourceRoots.forEach { path ->
+            if (!uniqueSourceRoots.add(path)) {
+                report(STRONG_WARNING, "Duplicate source root: $path")
+            }
+        }
+
+        return uniqueSourceRoots
+    }
+
+    fun getSourceFiles(): List<KtFile> = sourceFiles
+
+    private fun report(severity: CompilerMessageSeverity, message: String) {
+        configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY).report(severity, message)
+    }
+
+    companion object {
+        private val ideaCompatibleBuildNumber = "173.1"
+
+        init {
+            setCompatibleBuild()
+        }
+
+        private val APPLICATION_LOCK = Object()
+        private var ourApplicationEnvironment: JavaCoreApplicationEnvironment? = null
+        private var ourProjectCount = 0
+
+        @JvmStatic
+        fun createForProduction(
+                parentDisposable: Disposable, configuration: CompilerConfiguration, configFiles: EnvironmentConfigFiles
+        ): KotlinCoreEnvironment {
+            setCompatibleBuild()
+            val appEnv = getOrCreateApplicationEnvironmentForProduction(configuration)
+            // Disposing of the environment is unsafe in production then parallel builds are enabled, but turning it off universally
+            // breaks a lot of tests, therefore it is disabled for production and enabled for tests
+            if (System.getProperty(KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY).toBooleanLenient() != true) {
+                // JPS may run many instances of the compiler in parallel (there's an option for compiling independent modules in parallel in IntelliJ)
+                // All projects share the same ApplicationEnvironment, and when the last project is disposed, the ApplicationEnvironment is disposed as well
+                Disposer.register(parentDisposable, Disposable {
+                    synchronized (APPLICATION_LOCK) {
+                        if (--ourProjectCount <= 0) {
+                            disposeApplicationEnvironment()
+                        }
+                    }
+                })
+            }
+            val environment = KotlinCoreEnvironment(parentDisposable, appEnv, configuration, configFiles)
+
+            synchronized (APPLICATION_LOCK) {
+                ourProjectCount++
+            }
+            return environment
+        }
+
+        @JvmStatic
+        private fun setCompatibleBuild() {
+            PluginManagerCore.BUILD_NUMBER = ideaCompatibleBuildNumber
+            System.getProperties().setProperty("idea.plugins.compatible.build", ideaCompatibleBuildNumber)
+        }
+
+        @TestOnly
+        @JvmStatic
+        fun createForTests(
+                parentDisposable: Disposable, initialConfiguration: CompilerConfiguration, extensionConfigs: EnvironmentConfigFiles
+        ): KotlinCoreEnvironment {
+            val configuration = initialConfiguration.copy()
+            if (configuration.getList(JVMConfigurationKeys.SCRIPT_DEFINITIONS).isEmpty()) {
+                configuration.add(JVMConfigurationKeys.SCRIPT_DEFINITIONS, StandardScriptDefinition)
+            }
+            // Tests are supposed to create a single project and dispose it right after use
+            return KotlinCoreEnvironment(
+                    parentDisposable,
+                    createApplicationEnvironment(parentDisposable, configuration, unitTestMode = true),
+                    configuration,
+                    extensionConfigs
+            )
+        }
+
+        // used in the daemon for jar cache cleanup
+        val applicationEnvironment: JavaCoreApplicationEnvironment? get() = ourApplicationEnvironment
+
+        private fun getOrCreateApplicationEnvironmentForProduction(configuration: CompilerConfiguration): JavaCoreApplicationEnvironment {
+            synchronized (APPLICATION_LOCK) {
+                if (ourApplicationEnvironment != null)
+                    return ourApplicationEnvironment!!
+
+                val parentDisposable = Disposer.newDisposable()
+                ourApplicationEnvironment = createApplicationEnvironment(parentDisposable, configuration, unitTestMode = false)
+                ourProjectCount = 0
+                Disposer.register(parentDisposable, Disposable {
+                    synchronized (APPLICATION_LOCK) {
+                        ourApplicationEnvironment = null
+                    }
+                })
+                return ourApplicationEnvironment!!
+            }
+        }
+
+        private fun disposeApplicationEnvironment() {
+            synchronized (APPLICATION_LOCK) {
+                val environment = ourApplicationEnvironment ?: return
+                ourApplicationEnvironment = null
+                Disposer.dispose(environment.parentDisposable)
+                ZipHandler.clearFileAccessorCache()
+            }
+        }
+
+        private fun createApplicationEnvironment(
+                parentDisposable: Disposable,
+                configuration: CompilerConfiguration,
+                unitTestMode: Boolean
+        ): JavaCoreApplicationEnvironment {
+            Extensions.cleanRootArea(parentDisposable)
+            registerAppExtensionPoints()
+            val applicationEnvironment = object : JavaCoreApplicationEnvironment(parentDisposable, unitTestMode) {
+                override fun createJrtFileSystem(): VirtualFileSystem? = CoreJrtFileSystem()
+            }
+
+            registerApplicationExtensionPointsAndExtensionsFrom(configuration, "extensions/compiler.xml")
+
+            registerApplicationServicesForCLI(applicationEnvironment)
+            registerApplicationServices(applicationEnvironment)
+
+            return applicationEnvironment
+        }
+
+        private fun registerAppExtensionPoints() {
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), BinaryFileStubBuilders.EP_NAME, FileTypeExtensionPoint::class.java)
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), FileContextProvider.EP_NAME, FileContextProvider::class.java)
+            //
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), MetaDataContributor.EP_NAME, MetaDataContributor::class.java)
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), PsiAugmentProvider.EP_NAME, PsiAugmentProvider::class.java)
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider::class.java)
+            //
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ContainerProvider.EP_NAME, ContainerProvider::class.java)
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ClsCustomNavigationPolicy.EP_NAME, ClsCustomNavigationPolicy::class.java)
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ClassFileDecompilers.EP_NAME, ClassFileDecompilers.Decompiler::class.java)
+            //
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), TypeAnnotationModifier.EP_NAME, TypeAnnotationModifier::class.java)
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), MetaLanguage.EP_NAME, MetaLanguage::class.java)
+            //
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), JavaModuleSystem.EP_NAME, JavaModuleSystem::class.java)
+        }
+
+        private fun registerApplicationExtensionPointsAndExtensionsFrom(configuration: CompilerConfiguration, configFilePath: String) {
+            fun File.hasConfigFile(configFile: String): Boolean =
+                    if (isDirectory) File(this, "META-INF" + File.separator + configFile).exists()
+                    else try {
+                        ZipFile(this).use {
+                            it.getEntry("META-INF/" + configFile) != null
+                        }
+                    }
+                    catch (e: Throwable) {
+                        false
+                    }
+
+            val pluginRoot =
+                    configuration.get(CLIConfigurationKeys.INTELLIJ_PLUGIN_ROOT)?.let(::File)
+                    ?: configuration.get(CLIConfigurationKeys.COMPILER_JAR_LOCATOR)?.compilerJar
+                    ?: PathUtil.getResourcePathForClass(this::class.java).takeIf { it.hasConfigFile(configFilePath) }
+                    // hack for load extensions when compiler run directly from project directory (e.g. in tests)
+                    ?: File("idea/src").takeIf { it.hasConfigFile(configFilePath) }
+                    ?: throw IllegalStateException(
+                                "Unable to find extension point configuration $configFilePath " +
+                                "(cp:\n  ${(Thread.currentThread().contextClassLoader as? UrlClassLoader)?.urls?.joinToString("\n  ") { it.file }})")
+
+            CoreApplicationEnvironment.registerExtensionPointAndExtensions(pluginRoot, configFilePath, Extensions.getRootArea())
+        }
+
+        private fun registerApplicationServicesForCLI(applicationEnvironment: JavaCoreApplicationEnvironment) {
+            // ability to get text from annotations xml files
+            applicationEnvironment.registerFileType(PlainTextFileType.INSTANCE, "xml")
+            applicationEnvironment.registerParserDefinition(JavaParserDefinition())
+        }
+
+        // made public for Upsource
+        @Suppress("MemberVisibilityCanPrivate")
+        @JvmStatic
+        fun registerApplicationServices(applicationEnvironment: JavaCoreApplicationEnvironment) {
+            with(applicationEnvironment) {
+                registerFileType(KotlinFileType.INSTANCE, "kt")
+                registerFileType(KotlinFileType.INSTANCE, KotlinParserDefinition.STD_SCRIPT_SUFFIX)
+                registerParserDefinition(KotlinParserDefinition())
+                application.registerService(KotlinBinaryClassCache::class.java, KotlinBinaryClassCache())
+                application.registerService(JavaClassSupers::class.java, JavaClassSupersImpl::class.java)
+                application.registerService(TransactionGuard::class.java, TransactionGuardImpl::class.java)
+            }
+        }
+
+        private fun registerProjectExtensionPoints(area: ExtensionsArea) {
+            CoreApplicationEnvironment.registerExtensionPoint(area, PsiTreeChangePreprocessor.EP_NAME, PsiTreeChangePreprocessor::class.java)
+            CoreApplicationEnvironment.registerExtensionPoint(area, PsiElementFinder.EP_NAME, PsiElementFinder::class.java)
+            CoreApplicationEnvironment.registerExtensionPoint(area, JvmElementProvider.EP_NAME, JvmElementProvider::class.java)
+        }
+
+        // made public for Upsource
+        @JvmStatic
+        fun registerProjectServices(projectEnvironment: JavaCoreProjectEnvironment, messageCollector: MessageCollector?) {
+            with (projectEnvironment.project) {
+                val scriptDefinitionProvider = CliScriptDefinitionProvider()
+                registerService(ScriptDefinitionProvider::class.java, scriptDefinitionProvider)
+                registerService(ScriptDependenciesProvider::class.java, CliScriptDependenciesProvider(projectEnvironment.project, scriptDefinitionProvider))
+                registerService(KotlinJavaPsiFacade::class.java, KotlinJavaPsiFacade(this))
+                registerService(KtLightClassForFacade.FacadeStubCache::class.java, KtLightClassForFacade.FacadeStubCache(this))
+                registerService(ModuleAnnotationsResolver::class.java, CliModuleAnnotationsResolver())
+                if (messageCollector != null) {
+                    registerService(ScriptReportSink::class.java, CliScriptReportSink(messageCollector))
+                }
+            }
+        }
+
+        private fun registerProjectServicesForCLI(@Suppress("UNUSED_PARAMETER") projectEnvironment: JavaCoreProjectEnvironment) {
+            /**
+             * Note that Kapt may restart code analysis process, and CLI services should be aware of that.
+             * Use PsiManager.getModificationTracker() to ensure that all the data you cached is still valid.
+             */
+
+        }
+
+        private fun CompilerConfiguration.setupJdkClasspathRoots(configFiles: EnvironmentConfigFiles) {
+            if (getBoolean(JVMConfigurationKeys.NO_JDK)) return
+
+            val jvmTarget = configFiles == EnvironmentConfigFiles.JVM_CONFIG_FILES
+            if (!jvmTarget) return
+
+            val jdkHome = get(JVMConfigurationKeys.JDK_HOME)
+            val (javaRoot, classesRoots) = if (jdkHome == null) {
+                val javaHome = File(System.getProperty("java.home"))
+                put(JVMConfigurationKeys.JDK_HOME, javaHome)
+
+                javaHome to PathUtil.getJdkClassesRootsFromCurrentJre()
+            }
+            else {
+                jdkHome to PathUtil.getJdkClassesRoots(jdkHome)
+            }
+
+            if (!CoreJrtFileSystem.isModularJdk(javaRoot)) {
+                if (classesRoots.isEmpty()) {
+                    val messageCollector = get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
+                    messageCollector?.report(ERROR, "No class roots are found in the JDK path: $javaRoot")
+                }
+                else {
+                    addJvmSdkRoots(classesRoots)
+                }
+            }
+        }
+
+    }
+}
@@ -17,6 +17,7 @@ dependencies {
    compileOnly(project(":compiler:daemon-common"))
    compileOnly(project(":kotlin-reflect-api"))
    compileOnly(commonDep("net.rubygrapefruit", "native-platform"))
+    compileOnly(intellijDep()) { includeIntellijCoreJarDependencies(project) }

    embeddedComponents(project(":compiler:daemon-common")) { isTransitive = false }
    embeddedComponents(commonDep("net.rubygrapefruit", "native-platform"))
@@ -0,0 +1,47 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+
+description = "Kotlin Daemon Client"
+
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+jvmTarget = "1.6"
+
+val nativePlatformVariants: List<String> by rootProject.extra
+
+dependencies {
+    compileOnly(project(":compiler:util"))
+    compileOnly(project(":compiler:cli-common"))
+    compileOnly(project(":compiler:daemon-common"))
+    compileOnly(project(":kotlin-reflect-api"))
+    compileOnly(commonDep("net.rubygrapefruit", "native-platform"))
+
+    embeddedComponents(project(":compiler:daemon-common")) { isTransitive = false }
+    embeddedComponents(commonDep("net.rubygrapefruit", "native-platform"))
+    nativePlatformVariants.forEach {
+        embeddedComponents(commonDep("net.rubygrapefruit", "native-platform", "-$it"))
+    }
+}
+
+sourceSets {
+    "main" { projectDefault() }
+    "test" {}
+}
+
+noDefaultJar()
+
+runtimeJar(task<ShadowJar>("shadowJar")) {
+    from(the<JavaPluginConvention>().sourceSets.getByName("main").output)
+    fromEmbeddedComponents()
+}
+
+sourcesJar()
+javadocJar()
+
+dist()
+
+ideaPlugin()
+
+publish()
@@ -22,9 +22,7 @@ import com.intellij.openapi.progress.ProcessCanceledException
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.SystemInfo
 import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.psi.ClassFileViewProvider
 import com.intellij.psi.PsiElement
-import com.intellij.psi.PsiManager
 import com.intellij.psi.impl.compiled.ClsFileImpl
 import com.intellij.psi.impl.java.stubs.PsiJavaFileStub
 import com.intellij.psi.impl.java.stubs.impl.PsiJavaFileStubImpl
@@ -80,10 +78,7 @@ private fun createJavaFileStub(project: Project, packageFqName: FqName, files: C
    val javaFileStub = PsiJavaFileStubImpl(packageFqName.asString(), /*compiled = */true)
    javaFileStub.psiFactory = ClsWrapperStubPsiFactory.INSTANCE

-    val manager = PsiManager.getInstance(project)
-
-    val virtualFile = getRepresentativeVirtualFile(files)
-    val fakeFile = object : ClsFileImpl(ClassFileViewProvider(manager, virtualFile)) {
+    val fakeFile = object : ClsFileImpl(files.first().viewProvider) {
        override fun getStub() = javaFileStub

        override fun getPackageName() = packageFqName.asString()
@@ -121,10 +116,6 @@ private fun createJavaFileStub(project: Project, packageFqName: FqName, files: C
    return javaFileStub
 }

-private fun getRepresentativeVirtualFile(files: Collection<KtFile>): VirtualFile {
-    return files.first().viewProvider.virtualFile
-}
-
 private fun logErrorWithOSInfo(cause: Throwable?, fqName: FqName, virtualFile: VirtualFile?) {
    val path = if (virtualFile == null) "<null>" else virtualFile.path
    LOG.error(
@@ -0,0 +1,137 @@
+/*
+ * Copyright 2010-2017 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.asJava.builder
+
+import com.intellij.openapi.components.ServiceManager
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.progress.ProcessCanceledException
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.SystemInfo
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.psi.ClassFileViewProvider
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiManager
+import com.intellij.psi.impl.compiled.ClsFileImpl
+import com.intellij.psi.impl.java.stubs.PsiJavaFileStub
+import com.intellij.psi.impl.java.stubs.impl.PsiJavaFileStubImpl
+import com.intellij.psi.impl.source.tree.TreeElement
+import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
+import java.lang.StringBuilder
+
+data class LightClassBuilderResult(val stub: PsiJavaFileStub, val bindingContext: BindingContext, val diagnostics: Diagnostics)
+
+fun buildLightClass(
+        packageFqName: FqName,
+        files: Collection<KtFile>,
+        generateClassFilter: GenerationState.GenerateClassFilter,
+        context: LightClassConstructionContext,
+        generate: (state: GenerationState, files: Collection<KtFile>) -> Unit
+): LightClassBuilderResult {
+    val project = files.first().project
+
+    try {
+        val classBuilderFactory = KotlinLightClassBuilderFactory(createJavaFileStub(project, packageFqName, files))
+        val state = GenerationState.Builder(
+                project,
+                classBuilderFactory,
+                context.module,
+                context.bindingContext,
+                files.toList(),
+                CompilerConfiguration.EMPTY
+        ).generateDeclaredClassFilter(generateClassFilter).wantsDiagnostics(false).build()
+        state.beforeCompile()
+
+        generate(state, files)
+
+        val javaFileStub = classBuilderFactory.result()
+
+        ServiceManager.getService(project, StubComputationTracker::class.java)?.onStubComputed(javaFileStub, context)
+        return LightClassBuilderResult(javaFileStub, context.bindingContext, state.collectedExtraJvmDiagnostics)
+    }
+    catch (e: ProcessCanceledException) {
+        throw e
+    }
+    catch (e: RuntimeException) {
+        logErrorWithOSInfo(e, packageFqName, null)
+        throw e
+    }
+}
+
+private fun createJavaFileStub(project: Project, packageFqName: FqName, files: Collection<KtFile>): PsiJavaFileStub {
+    val javaFileStub = PsiJavaFileStubImpl(packageFqName.asString(), /*compiled = */true)
+    javaFileStub.psiFactory = ClsWrapperStubPsiFactory.INSTANCE
+
+    val manager = PsiManager.getInstance(project)
+
+    val virtualFile = getRepresentativeVirtualFile(files)
+    val fakeFile = object : ClsFileImpl(ClassFileViewProvider(manager, virtualFile)) {
+        override fun getStub() = javaFileStub
+
+        override fun getPackageName() = packageFqName.asString()
+
+        override fun isPhysical() = false
+
+        override fun appendMirrorText(indentLevel: Int, buffer: StringBuilder) {
+            if (files.size == 1) {
+                LOG.error("Mirror text should never be calculated for light classes generated from a single file")
+            }
+            super.appendMirrorText(indentLevel, buffer)
+        }
+
+
+        override fun setMirror(element: TreeElement) {
+            if (files.size == 1) {
+                LOG.error("Mirror element should never be set for light classes generated from a single file")
+            }
+            super.setMirror(element)
+        }
+
+        override fun getMirror(): PsiElement {
+            if (files.size == 1) {
+                LOG.error("Mirror element should never be calculated for light classes generated from a single file")
+            }
+            return super.getMirror()
+        }
+
+        override fun getText(): String {
+            return files.singleOrNull()?.text ?: super.getText()
+        }
+    }
+
+    javaFileStub.psi = fakeFile
+    return javaFileStub
+}
+
+private fun getRepresentativeVirtualFile(files: Collection<KtFile>): VirtualFile {
+    return files.first().viewProvider.virtualFile
+}
+
+private fun logErrorWithOSInfo(cause: Throwable?, fqName: FqName, virtualFile: VirtualFile?) {
+    val path = if (virtualFile == null) "<null>" else virtualFile.path
+    LOG.error(
+            "Could not generate LightClass for $fqName declared in $path\n" +
+            "System: ${SystemInfo.OS_NAME} ${SystemInfo.OS_VERSION} Java Runtime: ${SystemInfo.JAVA_RUNTIME_VERSION}",
+            cause
+    )
+}
+
+private val LOG = Logger.getInstance(LightClassBuilderResult::class.java)
@@ -16,8 +16,8 @@

 package org.jetbrains.kotlin.asJava.elements

+import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.pom.java.LanguageLevel
-import com.intellij.psi.ClassFileViewProvider
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.impl.compiled.ClsFileImpl
@@ -33,9 +33,11 @@ open class FakeFileForLightClass(
        private val lightClass: () -> KtLightClass,
        private val stub: () -> PsiClassHolderFileStub<*>,
        private val packageFqName: FqName = ktFile.packageFqName
-) : ClsFileImpl(ClassFileViewProvider(ktFile.manager, ktFile.virtualFile ?:
-                                                      ktFile.originalFile.virtualFile ?:
-                                                      ktFile.viewProvider.virtualFile)) {
+) : ClsFileImpl(ktFile.viewProvider) {
+
+    override fun getVirtualFile(): VirtualFile =
+        ktFile.virtualFile ?: ktFile.originalFile.virtualFile ?: super.getVirtualFile()
+
    override fun getPackageName() = packageFqName.asString()

    override fun getStub() = stub()
@@ -83,4 +85,4 @@ open class FakeFileForLightClass(
    }

    override fun isPhysical() = false
-}
+}
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2010-2016 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.asJava.elements
+
+import com.intellij.pom.java.LanguageLevel
+import com.intellij.psi.ClassFileViewProvider
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiElementVisitor
+import com.intellij.psi.impl.compiled.ClsFileImpl
+import com.intellij.psi.stubs.PsiClassHolderFileStub
+import org.jetbrains.kotlin.asJava.classes.KtLightClass
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
+import org.jetbrains.kotlin.asJava.classes.KtLightClassForSourceDeclaration
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.KtFile
+
+open class FakeFileForLightClass(
+        val ktFile: KtFile,
+        private val lightClass: () -> KtLightClass,
+        private val stub: () -> PsiClassHolderFileStub<*>,
+        private val packageFqName: FqName = ktFile.packageFqName
+) : ClsFileImpl(ClassFileViewProvider(ktFile.manager, ktFile.virtualFile ?:
+                                                      ktFile.originalFile.virtualFile ?:
+                                                      ktFile.viewProvider.virtualFile)) {
+    override fun getPackageName() = packageFqName.asString()
+
+    override fun getStub() = stub()
+
+    override fun getClasses() = arrayOf(lightClass())
+
+    override fun getNavigationElement() = ktFile
+
+    override fun accept(visitor: PsiElementVisitor) {
+        // Prevent access to compiled PSI
+        // TODO: More complex traversal logic may be implemented when necessary
+    }
+
+    // this should be equal to current compiler target language level
+    override fun getLanguageLevel() = LanguageLevel.JDK_1_6
+
+    override fun hashCode(): Int {
+        val thisClass = lightClass()
+        if (thisClass is KtLightClassForSourceDeclaration) return ktFile.hashCode()
+        return thisClass.hashCode()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is FakeFileForLightClass) return false
+        val thisClass = lightClass()
+        val anotherClass = other.lightClass()
+
+        if (thisClass is KtLightClassForSourceDeclaration) {
+            return anotherClass is KtLightClassForSourceDeclaration && ktFile == other.ktFile
+        }
+
+        return thisClass == anotherClass
+    }
+
+    override fun isEquivalentTo(another: PsiElement?) = this == another
+
+    override fun setPackageName(packageName: String) {
+        if (lightClass() is KtLightClassForFacade) {
+            ktFile.packageDirective?.fqName = FqName(packageName)
+        }
+        else {
+            super.setPackageName(packageName)
+        }
+    }
+
+    override fun isPhysical() = false
+}
@@ -95,12 +95,13 @@ class KtLightAnnotationForSourceEntry(
        override fun getReferences() = originalExpression?.references.orEmpty()
        override fun getLanguage() = KotlinLanguage.INSTANCE
        override fun getNavigationElement() = originalExpression
-        override fun isPhysical(): Boolean = originalExpression?.containingFile == kotlinOrigin.containingFile
+        override fun isPhysical(): Boolean = false
        override fun getTextRange() = originalExpression?.textRange ?: TextRange.EMPTY_RANGE
        override fun getStartOffsetInParent() = originalExpression?.startOffsetInParent ?: 0
        override fun getParent() = parent
        override fun getText() = originalExpression?.text.orEmpty()
-        override fun getContainingFile(): PsiFile? = if (isPhysical) kotlinOrigin.containingFile else delegate.containingFile
+        override fun getContainingFile(): PsiFile? = if (originalExpression?.containingFile == kotlinOrigin.containingFile)
+            kotlinOrigin.containingFile else delegate.containingFile

        override fun replace(newElement: PsiElement): PsiElement {
            val value = (newElement as? PsiLiteral)?.value as? String ?: return this
@@ -250,8 +251,6 @@ class KtLightAnnotationForSourceEntry(
                else -> LightElementValue(value, parent, ktOrigin)
            }

-    override fun isPhysical() = true
-
    override fun getName() = null

    private fun wrapAnnotationValue(value: PsiAnnotationMemberValue): PsiAnnotationMemberValue = wrapAnnotationValue(value, this, {
@@ -0,0 +1,380 @@
+/*
+ * Copyright 2010-2016 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.asJava.elements
+
+import com.intellij.openapi.diagnostic.Attachment
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.util.TextRange
+import com.intellij.openapi.util.text.StringUtil
+import com.intellij.psi.*
+import org.jetbrains.annotations.NotNull
+import org.jetbrains.annotations.Nullable
+import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
+import org.jetbrains.kotlin.asJava.classes.cannotModify
+import org.jetbrains.kotlin.asJava.classes.lazyPub
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor
+import org.jetbrains.kotlin.idea.KotlinLanguage
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
+import org.jetbrains.kotlin.resolve.calls.model.DefaultValueArgument
+import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.resolve.calls.model.VarargValueArgument
+import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
+import org.jetbrains.kotlin.resolve.source.getPsi
+import org.jetbrains.kotlin.types.TypeUtils
+
+private val LOG = Logger.getInstance("#org.jetbrains.kotlin.asJava.elements.lightAnnotations")
+
+abstract class KtLightAbstractAnnotation(parent: PsiElement, computeDelegate: () -> PsiAnnotation) :
+        KtLightElementBase(parent), PsiAnnotation, KtLightElement<KtCallElement, PsiAnnotation> {
+    override val clsDelegate by lazyPub(computeDelegate)
+
+    override fun getNameReferenceElement() = clsDelegate.nameReferenceElement
+
+    override fun getOwner() = parent as? PsiAnnotationOwner
+
+    override fun getMetaData() = clsDelegate.metaData
+
+    override fun getParameterList() = clsDelegate.parameterList
+
+    override fun canNavigate(): Boolean = super<KtLightElementBase>.canNavigate()
+
+    override fun canNavigateToSource(): Boolean = super<KtLightElementBase>.canNavigateToSource()
+
+    override fun navigate(requestFocus: Boolean) = super<KtLightElementBase>.navigate(requestFocus)
+
+    open fun fqNameMatches(fqName: String): Boolean = qualifiedName == fqName
+}
+
+private typealias AnnotationValueOrigin = () -> PsiElement?
+
+class KtLightAnnotationForSourceEntry(
+        private val qualifiedName: String,
+        override val kotlinOrigin: KtCallElement,
+        parent: PsiElement,
+        computeDelegate: () -> PsiAnnotation
+) : KtLightAbstractAnnotation(parent, computeDelegate) {
+
+    override fun getQualifiedName() = qualifiedName
+
+    open inner class LightElementValue<out D : PsiElement>(
+            val delegate: D,
+            private val parent: PsiElement,
+            valueOrigin: AnnotationValueOrigin
+    ) : PsiAnnotationMemberValue, PsiCompiledElement, PsiElement by delegate {
+        override fun getMirror(): PsiElement = delegate
+
+        val originalExpression: PsiElement? by lazyPub(valueOrigin)
+
+        fun getConstantValue(): Any? {
+            val expression = originalExpression as? KtExpression ?: return null
+            val annotationEntry = this@KtLightAnnotationForSourceEntry.kotlinOrigin
+            val context = LightClassGenerationSupport.getInstance(project).analyze(annotationEntry)
+            return context[BindingContext.COMPILE_TIME_VALUE, expression]?.getValue(TypeUtils.NO_EXPECTED_TYPE)
+        }
+
+        override fun getReference() = references.singleOrNull()
+        override fun getReferences() = originalExpression?.references.orEmpty()
+        override fun getLanguage() = KotlinLanguage.INSTANCE
+        override fun getNavigationElement() = originalExpression
+        override fun isPhysical(): Boolean = originalExpression?.containingFile == kotlinOrigin.containingFile
+        override fun getTextRange() = originalExpression?.textRange ?: TextRange.EMPTY_RANGE
+        override fun getStartOffsetInParent() = originalExpression?.startOffsetInParent ?: 0
+        override fun getParent() = parent
+        override fun getText() = originalExpression?.text.orEmpty()
+        override fun getContainingFile(): PsiFile? = if (isPhysical) kotlinOrigin.containingFile else delegate.containingFile
+
+        override fun replace(newElement: PsiElement): PsiElement {
+            val value = (newElement as? PsiLiteral)?.value as? String ?: return this
+            val origin = originalExpression
+
+            val exprToReplace =
+                    if (origin is KtCallExpression /*arrayOf*/) {
+                        unwrapArray(origin.valueArguments)
+                    }
+                    else {
+                        origin as? KtExpression
+                    } ?: return this
+            exprToReplace.replace(KtPsiFactory(this).createExpression("\"${StringUtil.escapeStringCharacters(value)}\""))
+
+            return this
+        }
+    }
+
+    private fun getMemberValueAsCallArgument(memberValue: PsiElement, callHolder: KtCallElement): PsiElement? {
+        val resolvedCall = callHolder.getResolvedCall() ?: return null
+        val annotationConstructor = resolvedCall.resultingDescriptor
+        val parameterName =
+                memberValue.getNonStrictParentOfType<PsiNameValuePair>()?.name ?:
+                memberValue.getNonStrictParentOfType<PsiAnnotationMethod>()?.takeIf { it.containingClass?.isAnnotationType == true }?.name ?:
+                "value"
+
+        val parameter = annotationConstructor.valueParameters.singleOrNull { it.name.asString() == parameterName } ?: return null
+        val resolvedArgument = resolvedCall.valueArguments[parameter] ?: return null
+        return when (resolvedArgument) {
+            is DefaultValueArgument -> {
+                val psi = parameter.source.getPsi()
+                when (psi) {
+                    is KtParameter -> psi.defaultValue
+                    is PsiAnnotationMethod -> psi.defaultValue
+                    else -> error("$psi of type ${psi?.javaClass}")
+                }
+            }
+
+            is ExpressionValueArgument -> {
+                val argExpression = resolvedArgument.valueArgument?.getArgumentExpression()
+                argExpression?.asKtCall()
+                ?: argExpression
+                ?: error("resolvedArgument ($resolvedArgument) has no arg expression")
+            }
+
+            is VarargValueArgument ->
+                memberValue.unwrapArray(resolvedArgument.arguments)
+                ?: resolvedArgument.arguments.first().asElement().let {
+                    (it as? KtValueArgument)
+                            ?.takeIf {
+                                it.getSpreadElement() != null ||
+                                it.getArgumentName() != null ||
+                                it.getArgumentExpression() is KtCollectionLiteralExpression
+                            }
+                            ?.getArgumentExpression() ?: it.parent
+                }
+
+            else -> error("resolvedArgument: ${resolvedArgument.javaClass} cant be processed")
+        }
+    }
+
+    private fun PsiElement.unwrapArray(arguments: List<ValueArgument>): PsiElement? {
+        val arrayInitializer = parent as? PsiArrayInitializerMemberValue ?: return null
+        val exprIndex = arrayInitializer.initializers.indexOf(this)
+        if (exprIndex < 0 || exprIndex >= arguments.size) return null
+        return arguments[exprIndex].getArgumentExpression()
+    }
+
+    open inner class LightExpressionValue<out D : PsiExpression>(
+            delegate: D,
+            parent: PsiElement,
+            valueOrigin: AnnotationValueOrigin
+    ) : LightElementValue<D>(delegate, parent, valueOrigin), PsiExpression {
+        override fun getType(): PsiType? = delegate.type
+    }
+
+    inner class LightPsiLiteral(
+            delegate: PsiLiteralExpression,
+            parent: PsiElement,
+            valueOrigin: AnnotationValueOrigin
+    ) : LightExpressionValue<PsiLiteralExpression>(delegate, parent, valueOrigin), PsiLiteralExpression {
+        override fun getValue() = delegate.value
+    }
+
+    inner class LightClassLiteral(
+            delegate: PsiClassObjectAccessExpression,
+            parent: PsiElement,
+            valueOrigin: AnnotationValueOrigin
+    ) : LightExpressionValue<PsiClassObjectAccessExpression>(delegate, parent, valueOrigin), PsiClassObjectAccessExpression {
+        override fun getType() = delegate.type
+        override fun getOperand(): PsiTypeElement = delegate.operand
+    }
+
+    inner class LightArrayInitializerValue(
+            delegate: PsiArrayInitializerMemberValue,
+            parent: PsiElement,
+            valueOrigin: AnnotationValueOrigin
+    ) : LightElementValue<PsiArrayInitializerMemberValue>(delegate, parent, valueOrigin), PsiArrayInitializerMemberValue {
+        private val _initializers by lazyPub {
+            delegate.initializers.mapIndexed { i, memberValue ->
+                wrapAnnotationValue(memberValue, this, {
+                    originalExpression.let { ktOrigin ->
+                        when {
+                            ktOrigin is KtCallExpression
+                                    && memberValue is PsiAnnotation
+                                    && isAnnotationConstructorCall(ktOrigin, memberValue) -> ktOrigin
+                            ktOrigin is KtValueArgumentList -> ktOrigin.arguments.getOrNull(i)?.getArgumentExpression()
+                            ktOrigin is KtCallElement -> ktOrigin.valueArguments.getOrNull(i)?.getArgumentExpression()
+                            ktOrigin is KtCollectionLiteralExpression -> ktOrigin.getInnerExpressions().getOrNull(i)
+                            delegate.initializers.size == 1 -> ktOrigin
+                            else -> null
+                        }.also {
+                            if (it == null)
+                                LOG.error("error wrapping ${memberValue.javaClass} for ${ktOrigin?.javaClass} in ${ktOrigin?.containingFile}",
+                                          Attachment(
+                                              "source_fragments.txt",
+                                              "origin: '${psiReport(ktOrigin)}', delegate: ${psiReport(delegate)}, parent: ${psiReport(parent)}"
+                                          )
+                                )
+                        }
+                    }
+                })
+            }.toTypedArray()
+        }
+
+        override fun getInitializers() = _initializers
+    }
+
+    private fun wrapAnnotationValue(value: PsiAnnotationMemberValue, parent: PsiElement, ktOrigin: AnnotationValueOrigin): PsiAnnotationMemberValue =
+            when {
+                value is PsiLiteralExpression -> LightPsiLiteral(value, parent, ktOrigin)
+                value is PsiClassObjectAccessExpression -> LightClassLiteral(value, parent, ktOrigin)
+                value is PsiExpression -> LightExpressionValue(value, parent, ktOrigin)
+                value is PsiArrayInitializerMemberValue -> LightArrayInitializerValue(value, parent, ktOrigin)
+                value is PsiAnnotation -> {
+                    val origin = ktOrigin()
+                    val ktCallElement = origin?.asKtCall()
+                    val qualifiedName = value.qualifiedName
+                    if (qualifiedName != null && ktCallElement != null)
+                        KtLightAnnotationForSourceEntry(qualifiedName, ktCallElement, parent, { value })
+                    else {
+                        LOG.error("can't convert ${origin?.javaClass} to KtCallElement in ${origin?.containingFile} (value = ${value.javaClass})",
+                                  Attachment("source_fragments.txt", "origin: '${psiReport(origin)}', value: '${psiReport(value)}'"))
+                        LightElementValue(value, parent, ktOrigin) // or maybe create a LightErrorAnnotationMemberValue instead?
+                    }
+                }
+                else -> LightElementValue(value, parent, ktOrigin)
+            }
+
+    override fun isPhysical() = true
+
+    override fun getName() = null
+
+    private fun wrapAnnotationValue(value: PsiAnnotationMemberValue): PsiAnnotationMemberValue = wrapAnnotationValue(value, this, {
+        getMemberValueAsCallArgument(value, kotlinOrigin)
+    })
+
+    override fun findAttributeValue(name: String?) = clsDelegate.findAttributeValue(name)?.let { wrapAnnotationValue(it) }
+
+    override fun findDeclaredAttributeValue(name: String?) = clsDelegate.findDeclaredAttributeValue(name)?.let { wrapAnnotationValue(it) }
+
+    override fun getParameterList(): PsiAnnotationParameterList = KtLightAnnotationParameterList(super.getParameterList())
+
+    inner class KtLightAnnotationParameterList(private val list: PsiAnnotationParameterList) : KtLightElementBase(this),
+        PsiAnnotationParameterList {
+        override val kotlinOrigin get() = null
+        override fun getAttributes(): Array<PsiNameValuePair> = list.attributes.map { KtLightPsiNameValuePair(it) }.toTypedArray()
+
+        inner class KtLightPsiNameValuePair(private val psiNameValuePair: PsiNameValuePair) : KtLightElementBase(this),
+            PsiNameValuePair {
+            override fun setValue(newValue: PsiAnnotationMemberValue): PsiAnnotationMemberValue = psiNameValuePair.setValue(newValue)
+            override fun getNameIdentifier(): PsiIdentifier? = psiNameValuePair.nameIdentifier
+            override fun getLiteralValue(): String? = (value as? PsiLiteralValue)?.value?.toString()
+            override val kotlinOrigin: KtElement? = null
+
+            override fun getValue(): PsiAnnotationMemberValue? = psiNameValuePair.value?.let { wrapAnnotationValue(it) }
+        }
+    }
+
+
+    override fun delete() = kotlinOrigin.delete()
+
+    override fun toString() = "@$qualifiedName"
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || other::class.java != this::class.java) return false
+        return kotlinOrigin == (other as KtLightAnnotationForSourceEntry).kotlinOrigin
+    }
+
+    override fun hashCode() = kotlinOrigin.hashCode()
+
+    override fun <T : PsiAnnotationMemberValue?> setDeclaredAttributeValue(attributeName: String?, value: T?) = cannotModify()
+}
+
+class KtLightNonSourceAnnotation(
+        parent: PsiElement, clsDelegate: PsiAnnotation
+) : KtLightAbstractAnnotation(parent, { clsDelegate }) {
+    override val kotlinOrigin: KtAnnotationEntry? get() = null
+    override fun getQualifiedName() = clsDelegate.qualifiedName
+    override fun <T : PsiAnnotationMemberValue?> setDeclaredAttributeValue(attributeName: String?, value: T?) = cannotModify()
+    override fun findAttributeValue(attributeName: String?) = clsDelegate.findAttributeValue(attributeName)
+    override fun findDeclaredAttributeValue(attributeName: String?) = clsDelegate.findDeclaredAttributeValue(attributeName)
+}
+
+class KtLightNonExistentAnnotation(parent: KtLightElement<*, *>) : KtLightElementBase(parent), PsiAnnotation {
+    override val kotlinOrigin get() = null
+    override fun toString() = this.javaClass.name
+
+    override fun <T : PsiAnnotationMemberValue?> setDeclaredAttributeValue(attributeName: String?, value: T?) = cannotModify()
+
+    override fun getNameReferenceElement() = null
+    override fun findAttributeValue(attributeName: String?) = null
+    override fun getQualifiedName() = null
+    override fun getOwner() = parent as? PsiAnnotationOwner
+    override fun findDeclaredAttributeValue(attributeName: String?) = null
+    override fun getMetaData() = null
+    override fun getParameterList() = KtLightEmptyAnnotationParameterList(this)
+
+    override fun canNavigate(): Boolean = super<KtLightElementBase>.canNavigate()
+
+    override fun canNavigateToSource(): Boolean = super<KtLightElementBase>.canNavigateToSource()
+
+    override fun navigate(requestFocus: Boolean) = super<KtLightElementBase>.navigate(requestFocus)
+}
+
+class KtLightEmptyAnnotationParameterList(parent: PsiElement) : KtLightElementBase(parent), PsiAnnotationParameterList {
+    override val kotlinOrigin get() = null
+    override fun getAttributes(): Array<PsiNameValuePair> = emptyArray()
+}
+
+class KtLightNullabilityAnnotation(member: KtLightElement<*, PsiModifierListOwner>, parent: PsiElement) : KtLightAbstractAnnotation(parent, {
+    // searching for last because nullability annotations are generated after backend generates source annotations
+    member.clsDelegate.modifierList?.annotations?.findLast {
+        isNullabilityAnnotation(it.qualifiedName)
+    } ?: KtLightNonExistentAnnotation(member)
+}) {
+    override fun fqNameMatches(fqName: String): Boolean {
+        if (!isNullabilityAnnotation(fqName)) return false
+
+        return super.fqNameMatches(fqName)
+    }
+
+    override val kotlinOrigin get() = null
+    override fun <T : PsiAnnotationMemberValue?> setDeclaredAttributeValue(attributeName: String?, value: T?) = cannotModify()
+
+    override fun findAttributeValue(attributeName: String?) = null
+
+    override fun getQualifiedName(): String? = clsDelegate.qualifiedName
+
+    override fun findDeclaredAttributeValue(attributeName: String?) = null
+}
+
+internal fun isNullabilityAnnotation(qualifiedName: String?) = qualifiedName in backendNullabilityAnnotations
+
+private val backendNullabilityAnnotations = arrayOf(Nullable::class.java.name, NotNull::class.java.name)
+
+private fun KtElement.getResolvedCall(): ResolvedCall<out CallableDescriptor>? {
+    val context = LightClassGenerationSupport.getInstance(this.project).analyze(this)
+    return this.getResolvedCall(context)
+}
+
+private fun isAnnotationConstructorCall(callExpression: KtCallExpression, psiAnnotation: PsiAnnotation) =
+    (callExpression.getResolvedCall()?.resultingDescriptor as? ClassConstructorDescriptor)?.constructedClass?.fqNameUnsafe?.toString() == psiAnnotation.qualifiedName
+
+private fun PsiElement.asKtCall(): KtCallElement? = (this as? KtElement)?.getResolvedCall()?.call?.callElement as? KtCallElement
+
+private fun psiReport(psiElement: PsiElement?): String {
+    if (psiElement == null) return "null"
+    val text = try {
+        psiElement.text
+    }
+    catch (e: Exception) {
+        "${e.javaClass.simpleName}:${e.message}"
+    }
+    return "${psiElement.javaClass.canonicalName}[$text]"
+}
@@ -137,3 +137,6 @@ fun KtClassOrObject.getOrCreateBody(): KtClassBody {
    if (this is KtEnumEntry) return addAfter(newBody, initializerList ?: nameIdentifier) as KtClassBody
    return add(newBody) as KtClassBody
 }
+
+val KtClassOrObject.allConstructors
+    get() = listOfNotNull(primaryConstructor) + secondaryConstructors
@@ -0,0 +1,139 @@
+/*
+ * 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.psi
+
+import com.intellij.lang.ASTNode
+import com.intellij.navigation.ItemPresentation
+import com.intellij.navigation.ItemPresentationProviders
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiWhiteSpace
+import com.intellij.psi.impl.CheckUtil
+import com.intellij.psi.stubs.IStubElementType
+import com.intellij.psi.tree.TokenSet
+import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.stubs.KotlinClassOrObjectStub
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
+
+abstract class KtClassOrObject :
+    KtTypeParameterListOwnerStub<KotlinClassOrObjectStub<out KtClassOrObject>>, KtDeclarationContainer, KtNamedDeclaration,
+    KtPureClassOrObject {
+    constructor(node: ASTNode) : super(node)
+    constructor(stub: KotlinClassOrObjectStub<out KtClassOrObject>, nodeType: IStubElementType<*, *>) : super(stub, nodeType)
+
+    fun getSuperTypeList(): KtSuperTypeList? = getStubOrPsiChild(KtStubElementTypes.SUPER_TYPE_LIST)
+
+    override fun getSuperTypeListEntries(): List<KtSuperTypeListEntry> = getSuperTypeList()?.entries.orEmpty()
+
+    fun addSuperTypeListEntry(superTypeListEntry: KtSuperTypeListEntry): KtSuperTypeListEntry {
+        getSuperTypeList()?.let {
+            val single = it.entries.singleOrNull()
+            if (single != null && single.typeReference?.typeElement == null) {
+                return single.replace(superTypeListEntry) as KtSuperTypeListEntry
+            }
+            return EditCommaSeparatedListHelper.addItem(it, superTypeListEntries, superTypeListEntry)
+        }
+
+        val psiFactory = KtPsiFactory(this)
+        val specifierListToAdd = psiFactory.createSuperTypeCallEntry("A()").replace(superTypeListEntry).parent
+        val colon = addBefore(psiFactory.createColon(), getBody())
+        return (addAfter(specifierListToAdd, colon) as KtSuperTypeList).entries.first()
+    }
+
+    fun removeSuperTypeListEntry(superTypeListEntry: KtSuperTypeListEntry) {
+        val specifierList = getSuperTypeList() ?: return
+        assert(superTypeListEntry.parent === specifierList)
+
+        if (specifierList.entries.size > 1) {
+            EditCommaSeparatedListHelper.removeItem<KtElement>(superTypeListEntry)
+        } else {
+            deleteChildRange(findChildByType<PsiElement>(KtTokens.COLON) ?: specifierList, specifierList)
+        }
+    }
+
+    fun getAnonymousInitializers(): List<KtAnonymousInitializer> = getBody()?.anonymousInitializers.orEmpty()
+
+    fun getBody(): KtClassBody? = getStubOrPsiChild(KtStubElementTypes.CLASS_BODY)
+
+    inline fun <reified T : KtDeclaration> addDeclaration(declaration: T): T {
+        val body = getOrCreateBody()
+        val anchor = PsiTreeUtil.skipSiblingsBackward(body.rBrace ?: body.lastChild!!, PsiWhiteSpace::class.java)
+        return body.addAfter(declaration, anchor) as T
+    }
+
+    inline fun <reified T : KtDeclaration> addDeclarationAfter(declaration: T, anchor: PsiElement?): T {
+        val anchorBefore = anchor ?: declarations.lastOrNull() ?: return addDeclaration(declaration)
+        return getOrCreateBody().addAfter(declaration, anchorBefore) as T
+    }
+
+    inline fun <reified T : KtDeclaration> addDeclarationBefore(declaration: T, anchor: PsiElement?): T {
+        val anchorAfter = anchor ?: declarations.firstOrNull() ?: return addDeclaration(declaration)
+        return getOrCreateBody().addBefore(declaration, anchorAfter) as T
+    }
+
+    fun isTopLevel(): Boolean = stub?.isTopLevel() ?: (parent is KtFile)
+
+    override fun isLocal(): Boolean = stub?.isLocal() ?: KtPsiUtil.isLocal(this)
+
+    override fun getDeclarations(): List<KtDeclaration> = getBody()?.declarations.orEmpty()
+
+    override fun getPresentation(): ItemPresentation? = ItemPresentationProviders.getItemPresentation(this)
+
+    override fun getPrimaryConstructor(): KtPrimaryConstructor? = getStubOrPsiChild(KtStubElementTypes.PRIMARY_CONSTRUCTOR)
+
+    override fun getPrimaryConstructorModifierList(): KtModifierList? = primaryConstructor?.modifierList
+
+    fun getPrimaryConstructorParameterList(): KtParameterList? = primaryConstructor?.valueParameterList
+
+    override fun getPrimaryConstructorParameters(): List<KtParameter> = getPrimaryConstructorParameterList()?.parameters.orEmpty()
+
+    override fun hasExplicitPrimaryConstructor(): Boolean = primaryConstructor != null
+
+    override fun hasPrimaryConstructor(): Boolean = hasExplicitPrimaryConstructor() || !hasSecondaryConstructors()
+
+    private fun hasSecondaryConstructors(): Boolean = !secondaryConstructors.isEmpty()
+
+    override fun getSecondaryConstructors(): List<KtSecondaryConstructor> = getBody()?.secondaryConstructors.orEmpty()
+
+    fun isAnnotation(): Boolean = hasModifier(KtTokens.ANNOTATION_KEYWORD)
+
+    fun getDeclarationKeyword(): PsiElement? =
+        findChildByType(
+            TokenSet.create(
+                KtTokens.CLASS_KEYWORD, KtTokens.INTERFACE_KEYWORD, KtTokens.OBJECT_KEYWORD
+            )
+        )
+
+    override fun delete() {
+        CheckUtil.checkWritable(this)
+
+        val file = containingKtFile
+        if (!isTopLevel() || file.declarations.size > 1) {
+            super.delete()
+        } else {
+            file.delete()
+        }
+    }
+}
+
+fun KtClassOrObject.getOrCreateBody(): KtClassBody {
+    getBody()?.let { return it }
+
+    val newBody = KtPsiFactory(this).createEmptyClassBody()
+    if (this is KtEnumEntry) return addAfter(newBody, initializerList ?: nameIdentifier) as KtClassBody
+    return add(newBody) as KtClassBody
+}
@@ -31,7 +31,7 @@ dependencies {
    testCompile(androidDxJar()) { isTransitive = false }
    testCompile(intellijCoreDep()) { includeJars("intellij-core"); isTransitive = false }
    testCompile(intellijDep()) {
-        includeJars("openapi", "idea", "idea_rt", "guava", "trove4j", "picocontainer", "asm-all", "log4j", "jdom", "annotations", rootProject = rootProject)
+        includeJars("openapi", "platform-api", "platform-impl", "idea", "idea_rt", "guava", "trove4j", "picocontainer", "asm-all", "log4j", "jdom", "bootstrap", "annotations", rootProject = rootProject)
        isTransitive = false
    }
 }
@@ -0,0 +1,44 @@
+
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+dependencies {
+    testCompile(project(":core:descriptors"))
+    testCompile(project(":core:descriptors.jvm"))
+    testCompile(project(":core:deserialization"))
+    testCompile(project(":compiler:util"))
+    testCompile(project(":compiler:backend"))
+    testCompile(project(":compiler:ir.ir2cfg"))
+    testCompile(project(":compiler:frontend"))
+    testCompile(project(":compiler:frontend.java"))
+    testCompile(project(":compiler:util"))
+    testCompile(project(":compiler:cli-common"))
+    testCompile(project(":compiler:cli"))
+    testCompile(project(":compiler:light-classes"))
+    testCompile(project(":compiler:serialization"))
+    testCompile(project(":kotlin-preloader"))
+    testCompile(project(":compiler:daemon-common"))
+    testCompile(project(":js:js.serializer"))
+    testCompile(project(":js:js.frontend"))
+    testCompile(project(":js:js.translator"))
+    testCompileOnly(project(":plugins:android-extensions-compiler"))
+    testCompile(projectDist(":kotlin-test:kotlin-test-jvm"))
+    testCompile(projectTests(":compiler:tests-common-jvm6"))
+    testCompileOnly(project(":kotlin-reflect-api"))
+    testCompile(commonDep("junit:junit"))
+    testCompile(androidDxJar()) { isTransitive = false }
+    testCompile(intellijCoreDep()) { includeJars("intellij-core"); isTransitive = false }
+    testCompile(intellijDep()) {
+        includeJars("openapi", "idea", "idea_rt", "guava", "trove4j", "picocontainer", "asm-all", "log4j", "jdom", "annotations", rootProject = rootProject)
+        isTransitive = false
+    }
+}
+
+sourceSets {
+    "main" { }
+    "test" { projectDefault() }
+}
+
+testsJar {}
@@ -429,11 +429,11 @@ public class KotlinTestUtils {

    private static void deleteOnShutdown(File file) {
        if (filesToDelete.isEmpty()) {
-            ShutDownTracker.getInstance().registerShutdownTask(() -> ShutDownTracker.invokeAndWait(true, true, () -> {
+            ShutDownTracker.getInstance().registerShutdownTask(() -> {
                for (File victim : filesToDelete) {
                    FileUtil.delete(victim);
                }
-            }));
+            });
        }

        filesToDelete.add(file);