Update changelog for Kotlin 1.2.41

Skip @JvmDefault in UnimplementedKotlinInterfaceMemberAnnotator
#KT-23967 Fixed (cherry picked from commit ec0b9aa)
2026-03-30 00:21:27 +00:00 · 2018-04-28 04:08:27 +03:00 · 2018-04-26 15:39:16 +02:00 · 2018-04-26 15:39:10 +02:00 · 2018-04-25 17:44:49 +03:00 · 2018-04-24 16:59:53 +03:00
9506 changed files with 279935 additions and 164239 deletions
--- a/.gitattributes
+++ b/.gitattributes
@@ -1 +1,4 @@
 **/testData/** linguist-vendored
+*Generated.java linguist-generated=true
+compiler/cli/bin/* eol=lf
+compiler/cli/bin/*.bat eol=crlf
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,7 @@
 /confluence/target
 /dependencies
 /dist
+/local
 /gh-pages
 /ideaSDK
 /clionSDK
@@ -18,15 +19,20 @@ workspace.xml
 /ultimate/ideaSDK
 /ultimate/out
 /ultimate/tmp
-/js/js.translator/testData/**/out/
+/js/js.translator/testData/out/
+/js/js.translator/testData/out-min/
 .gradle/
 build/
 !**/src/**/build
-*.iml
 !**/test/**/build
-.idea/modules.xml
+*.iml
+!**/testData/**/*.iml
 .idea/libraries/Gradle*.xml
+.idea/libraries/Maven*.xml
+.idea/artifacts
 .idea/modules
+.idea/runConfigurations/JPS_*.xml
+.idea/libraries
 .idea/modules.xml
 .idea/gradle.xml
 .idea/compiler.xml
--- a/.idea/ant.xml
+++ b/.idea/ant.xml
@@ -2,10 +2,6 @@
 <project version="4">
  <component name="AntConfiguration">
    <buildFile url="file://$PROJECT_DIR$/compiler/frontend/buildLexer.xml" />
-    <buildFile url="file://$PROJECT_DIR$/build.xml">
-      <antCommandLine value="-J-ea" />
-      <maximumHeapSize value="1024" />
-    </buildFile>
    <buildFile url="file://$PROJECT_DIR$/update_dependencies.xml" />
    <buildFile url="file://$PROJECT_DIR$/TeamCityBuild.xml">
      <maximumHeapSize value="512" />
@@ -18,6 +14,5 @@
      </properties>
    </buildFile>
    <buildFile url="file://$PROJECT_DIR$/TeamCityRelay.xml" />
-    <buildFile url="file://$PROJECT_DIR$/node_utils.xml" />
  </component>
 </project>
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -55,6 +55,16 @@
        </value>
      </option>
    </JavaCodeStyleSettings>
+    <JetCodeStyleSettings>
+      <option name="CONTINUATION_INDENT_IN_PARAMETER_LISTS" value="false" />
+      <option name="CONTINUATION_INDENT_IN_ARGUMENT_LISTS" value="false" />
+      <option name="CONTINUATION_INDENT_FOR_EXPRESSION_BODIES" value="false" />
+      <option name="CONTINUATION_INDENT_FOR_CHAINED_CALLS" value="false" />
+      <option name="CONTINUATION_INDENT_IN_SUPERTYPE_LISTS" value="false" />
+      <option name="CONTINUATION_INDENT_IN_IF_CONDITIONS" value="false" />
+      <option name="WRAP_EXPRESSION_BODY_FUNCTIONS" value="1" />
+      <option name="IF_RPAREN_ON_NEW_LINE" value="true" />
+    </JetCodeStyleSettings>
    <MarkdownNavigatorCodeStyleSettings>
      <option name="RIGHT_MARGIN" value="72" />
    </MarkdownNavigatorCodeStyleSettings>
@@ -207,6 +217,13 @@
      <option name="WHILE_BRACE_FORCE" value="1" />
      <option name="FOR_BRACE_FORCE" value="1" />
    </codeStyleSettings>
+    <codeStyleSettings language="PROTO">
+      <indentOptions>
+        <option name="INDENT_SIZE" value="2" />
+        <option name="CONTINUATION_INDENT_SIZE" value="4" />
+        <option name="TAB_SIZE" value="2" />
+      </indentOptions>
+    </codeStyleSettings>
    <codeStyleSettings language="Scala">
      <option name="KEEP_BLANK_LINES_BEFORE_RBRACE" value="0" />
      <option name="ELSE_ON_NEW_LINE" value="true" />
@@ -228,7 +245,6 @@
      <option name="WHILE_BRACE_FORCE" value="1" />
      <option name="FOR_BRACE_FORCE" value="1" />
      <option name="FIELD_ANNOTATION_WRAP" value="0" />
-      <option name="PARENT_SETTINGS_INSTALLED" value="true" />
    </codeStyleSettings>
    <codeStyleSettings language="TypeScript">
      <option name="ELSE_ON_NEW_LINE" value="true" />
@@ -261,12 +277,16 @@
      </indentOptions>
    </codeStyleSettings>
    <codeStyleSettings language="kotlin">
-      <option name="ELSE_ON_NEW_LINE" value="true" />
-      <option name="WHILE_ON_NEW_LINE" value="true" />
-      <option name="CATCH_ON_NEW_LINE" value="true" />
-      <option name="FINALLY_ON_NEW_LINE" value="true" />
      <option name="ALIGN_MULTILINE_PARAMETERS_IN_CALLS" value="true" />
-      <option name="ALIGN_MULTILINE_BINARY_OPERATION" value="true" />
+      <option name="CALL_PARAMETERS_WRAP" value="5" />
+      <option name="CALL_PARAMETERS_LPAREN_ON_NEXT_LINE" value="true" />
+      <option name="CALL_PARAMETERS_RPAREN_ON_NEXT_LINE" value="true" />
+      <option name="METHOD_PARAMETERS_WRAP" value="5" />
+      <option name="METHOD_PARAMETERS_LPAREN_ON_NEXT_LINE" value="true" />
+      <option name="METHOD_PARAMETERS_RPAREN_ON_NEXT_LINE" value="true" />
+      <option name="EXTENDS_LIST_WRAP" value="1" />
+      <option name="METHOD_CALL_CHAIN_WRAP" value="1" />
+      <option name="ASSIGNMENT_WRAP" value="1" />
    </codeStyleSettings>
  </code_scheme>
 </component>
--- a/.idea/copyright/apache.xml
+++ b/.idea/copyright/apache.xml
@@ -1,9 +1,7 @@
 <component name="CopyrightManager">
  <copyright>
-    <option name="notice" value="Copyright 2010-&amp;#36;today.year JetBrains s.r.o.&#10;&#10;Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);&#10;you may not use this file except in compliance with the License.&#10;You may obtain a copy of the License at&#10;&#10;http://www.apache.org/licenses/LICENSE-2.0&#10;&#10;Unless required by applicable law or agreed to in writing, software&#10;distributed under the License is distributed on an &quot;AS IS&quot; BASIS,&#10;WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.&#10;See the License for the specific language governing permissions and&#10;limitations under the License." />
-    <option name="keyword" value="Copyright" />
-    <option name="allowReplaceKeyword" value="JetBrains" />
+    <option name="allowReplaceRegexp" value="JetBrains" />
+    <option name="notice" value="Copyright 2010-&amp;#36;today.year JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license &#10;that can be found in the license/LICENSE.txt file." />
    <option name="myName" value="apache" />
-    <option name="myLocal" value="true" />
  </copyright>
 </component>
--- a/.idea/copyright/profiles_settings.xml
+++ b/.idea/copyright/profiles_settings.xml
@@ -1,7 +1,7 @@
 <component name="CopyrightManager">
-  <settings default="">
+  <settings>
    <module2copyright>
-      <element module="all except testData" copyright="apache" />
+      <element module="Apply copyright" copyright="apache" />
    </module2copyright>
    <LanguageOptions name="Groovy">
      <option name="fileTypeOverride" value="1" />
--- a/.idea/dictionaries/Nikolay_Krasko.xml
+++ b/.idea/dictionaries/Nikolay_Krasko.xml
@@ -2,6 +2,7 @@
  <dictionary name="Nikolay.Krasko">
    <words>
      <w>accessors</w>
+      <w>coroutines</w>
      <w>crossinline</w>
      <w>fqname</w>
      <w>goto</w>
@@ -12,6 +13,7 @@
      <w>memoize</w>
      <w>memoized</w>
      <w>multiline</w>
+      <w>navigatable</w>
      <w>preload</w>
      <w>preloader</w>
      <w>preloading</w>
--- a/.idea/dictionaries/bashor.xml
+++ b/.idea/dictionaries/bashor.xml
@@ -2,9 +2,13 @@
  <dictionary name="bashor">
    <words>
      <w>ctor</w>
+      <w>inlining</w>
      <w>interner</w>
      <w>kclass</w>
      <w>lookups</w>
+      <w>minification</w>
+      <w>minifier</w>
+      <w>minify</w>
      <w>unescape</w>
    </words>
  </dictionary>
--- a/.idea/dictionaries/dzharkov.xml
+++ b/.idea/dictionaries/dzharkov.xml
@@ -3,6 +3,8 @@
    <words>
      <w>checkcast</w>
      <w>coroutine</w>
+      <w>experimentalities</w>
+      <w>experimentality</w>
      <w>insn</w>
      <w>liveness</w>
    </words>
--- a/.idea/dictionaries/yan.xml
+++ b/.idea/dictionaries/yan.xml
@@ -5,6 +5,7 @@
      <w>impls</w>
      <w>kapt</w>
      <w>parceler</w>
+      <w>repl</w>
      <w>uast</w>
    </words>
  </dictionary>
--- a/.idea/encodings.xml
+++ b/.idea/encodings.xml
@@ -1,6 +1,23 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="Encoding" useUTFGuessing="true" native2AsciiForPropertiesFiles="false">
+    <file url="file://$PROJECT_DIR$/libraries" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/examples/browser-example" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/examples/browser-example-with-library" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/examples/js-example" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/examples/kotlin-java-example" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/examples/kotlin-js-library-example" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/idl2k" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-annotation-processing-maven" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-allopen" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-noarg" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-plugin" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-plugin-test" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-sam-with-receiver" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-osgi-bundle" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/maven-archetypes" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/maven-archetypes/kotlin-archetype-js" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/maven-archetypes/kotlin-archetype-jvm" charset="UTF-8" />
    <file url="PROJECT" charset="UTF-8" />
  </component>
 </project>
--- a/.idea/inspectionProfiles/idea_default.xml
+++ b/.idea/inspectionProfiles/idea_default.xml
@@ -56,7 +56,7 @@
      <option name="ignoreOnVolatileVariables" value="true" />
    </inspection_tool>
    <inspection_tool class="DuplicateCondition" enabled="true" level="WARNING" enabled_by_default="true">
-      <option name="ignoreMethodCalls" value="false" />
+      <option name="ignoreSideEffectConditions" value="true" />
    </inspection_tool>
    <inspection_tool class="EmptyStatementBody" enabled="true" level="WARNING" enabled_by_default="true">
      <option name="m_reportEmptyBlocks" value="false" />
@@ -281,6 +281,7 @@
      <option name="fromVersion" value="2.4" />
      <option name="toVersion" value="3.1" />
    </inspection_tool>
+    <inspection_tool class="Reformat" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
    <inspection_tool class="ReplaceAssignmentWithOperatorAssignment" enabled="true" level="WARNING" enabled_by_default="true">
      <option name="ignoreLazyOperators" value="true" />
      <option name="ignoreObscureOperators" value="true" />
@@ -402,8 +403,10 @@
    <inspection_tool class="UnnecessaryFullyQualifiedName" enabled="true" level="WARNING" enabled_by_default="true">
      <scope name="IDEA Test Sources" level="WARNING" enabled="false">
        <option name="m_ignoreJavadoc" value="true" />
+        <option name="ignoreInModuleStatements" value="true" />
      </scope>
      <option name="m_ignoreJavadoc" value="true" />
+      <option name="ignoreInModuleStatements" value="true" />
    </inspection_tool>
    <inspection_tool class="UnnecessaryLabelOnBreakStatement" enabled="false" level="WARNING" enabled_by_default="false" />
    <inspection_tool class="UnnecessaryLabelOnContinueStatement" enabled="false" level="WARNING" enabled_by_default="false" />
--- a/.idea/kotlinc.xml
+++ b/.idea/kotlinc.xml
@@ -13,6 +13,6 @@
    </option>
  </component>
  <component name="KotlinCompilerSettings">
-    <option name="additionalArguments" value="-version -Xallow-kotlin-package -Xskip-metadata-version-check" />
+    <option name="additionalArguments" value="-version -Xallow-kotlin-package -Xskip-metadata-version-check -Xread-deserialized-contracts" />
  </component>
 </project>
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -40,8 +40,7 @@
  <component name="MavenProjectsManager">
    <option name="originalFiles">
      <list>
-        <option value="$PROJECT_DIR$/confluence-highlighting/pom.xml" />
-        <option value="$PROJECT_DIR$/confluence/pom.xml" />
+        <option value="$PROJECT_DIR$/libraries/pom.xml" />
      </list>
    </option>
  </component>
@@ -54,6 +53,7 @@
  <component name="SuppressABINotification">
    <option name="modulesWithSuppressedNotConfigured">
      <set>
+        <option value="backend.src" />
        <option value="kotlin-stdlib-common" />
        <option value="kotlin-stdlib-js" />
        <option value="kotlin-test-common" />
--- a/.idea/runConfigurations/Generate_All_Tests.xml
+++ b/.idea/runConfigurations/Generate_All_Tests.xml
@@ -4,7 +4,7 @@
      <option name="executionName" />
      <option name="externalProjectPath" value="$PROJECT_DIR$" />
      <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="-x :ultimate:generateTests" />
+      <option name="scriptParameters" value="" />
      <option name="taskDescriptions">
        <list />
      </option>
--- a/.idea/runConfigurations/IDEA_Ultimate.xml
+++ b/.idea/runConfigurations/IDEA_Ultimate.xml
@@ -4,7 +4,7 @@
      <option name="executionName" />
      <option name="externalProjectPath" value="$PROJECT_DIR$" />
      <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="" />
+      <option name="scriptParameters" value="-P intellijUltimateEnabled" />
      <option name="taskDescriptions">
        <list />
      </option>
--- a/.idea/scopes/Apply_copyright.xml
+++ b/.idea/scopes/Apply_copyright.xml
@@ -0,0 +1,3 @@
+<component name="DependencyValidationManager">
+  <scope name="Apply copyright" pattern="!file[*]:*//testData//*&amp;&amp;!file[*]:testData//*&amp;&amp;!file[*]:*.gradle.kts&amp;&amp;!file[*]:*.gradle" />
+</component>
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@@ -15,6 +15,10 @@
          <option name="issueRegexp" value="KEEP\-(\d+)" />
          <option name="linkRegexp" value="https://github.com/Kotlin/KEEP/issues/$1" />
        </IssueNavigationLink>
+        <IssueNavigationLink>
+          <option name="issueRegexp" value="KOTLIN-CR\-\d+" />
+          <option name="linkRegexp" value="https://upsource.jetbrains.com/kotlin/review/$0" />
+        </IssueNavigationLink>
      </list>
    </option>
  </component>
--- a/ChangeLog.md
+++ b/ChangeLog.md
--- a/ReadMe.md
+++ b/ReadMe.md
@@ -29,16 +29,16 @@ Welcome to [Kotlin](https://kotlinlang.org/)! Some handy links:

 In order to build Kotlin distribution you need to have:

- Apache Ant 1.9.4 and higher
- JDK 1.6, 1.7 and 1.8
+- JDK 1.6, 1.7, 1.8 and 9
 - Setup environment variables as following:

        JAVA_HOME="path to JDK 1.8"
        JDK_16="path to JDK 1.6"
        JDK_17="path to JDK 1.7"
        JDK_18="path to JDK 1.8"
+        JDK_9="path to JDK 9"

-For local development, if you're not working on bytecode generation or the standard library, it's OK to have only JDK 8 installed, and to point all of the environment variables mentioned above to your JDK 8 installation.
+For local development, if you're not working on bytecode generation or the standard library, it's OK to have only JDK 1.8 and JDK 9 installed, and to point JDK_16 and JDK_17 environment variables to your JDK 1.8 installation.

 You also can use [Gradle properties](https://docs.gradle.org/current/userguide/build_environment.html#sec:gradle_properties_and_system_properties) to setup JDK_* variables.

@@ -46,24 +46,25 @@ You also can use [Gradle properties](https://docs.gradle.org/current/userguide/b

 ## Building

-To build this project, first time you try to build you need to run this:
+The project is built with Gradle. Run Gradle to build the project and to run the tests 
+using the following command on Unix/macOS:

-    ant -f update_dependencies.xml
+    ./gradlew <tasks-and-options>
+    
+or the following command on Windows:

-which will setup the dependencies on
+    gradlew <tasks-and-options>
+
+On the first project configuration gradle will download and setup the dependencies on

 * `intellij-core` is a part of command line compiler and contains only necessary APIs.
 * `idea-full` is a full blown IntelliJ IDEA Community Edition to be used in the plugin module.

-Then, you may run Gradle to build the project and run tests, using:
-
-    ./gradlew <tasks-and-options>
+These dependencies are quite large, so depending on the quality of your internet connection 
+you might face timeouts getting them. In this case you can increase timeout by specifying the following 
+command line parameters on the first run: 
    
-command on Unix/macOS, or
-
-    gradlew <tasks-and-options>
-    
-on Windows.
+    ./gradlew -Dhttp.socketTimeout=60000 -Dhttp.connectionTimeout=60000

 ## Important gradle tasks

@@ -77,15 +78,12 @@ on Windows.
 - `compilerTest` - build and run all compiler tests
 - `ideaPluginTest` - build and run all IDEA plugin tests

-**OPTIONAL:** Some artifacts, mainly Maven plugin ones, are built separately by Maven: go into `libraries` directory after building the compiler and run:
-
-    mvn install
-
+**OPTIONAL:** Some artifacts, mainly Maven plugin ones, are built separately with Maven.
 Refer to [libraries/ReadMe.md](libraries/ReadMe.md) for details.

-## Working with the project in IntelliJ IDEA
+## <a name="working-in-idea"></a> Working with the project in IntelliJ IDEA

-Working with the Kotlin project requires IntelliJ IDEA 2017.3. You can download an Early Access Preview version of IntelliJ IDEA 2017.3 [here](https://www.jetbrains.com/idea/nextversion/).
+Working with the Kotlin project requires IntelliJ IDEA 2017.3. You can download IntelliJ IDEA 2017.3 [here](https://www.jetbrains.com/idea/download).

 To import the project in Intellij choose project directory in Open project dialog. Then, after project opened, Select 
 `File` -> `New...` -> `Module from Existing Sources` in the menu, and select `build.gradle.kts` file in the project's root folder.
@@ -94,7 +92,7 @@ In the import dialog, select `use default gradle wrapper`.

 To be able to run tests from IntelliJ easily, check `Delegate IDE build/run actions to Gradle` in the Gradle runner settings.

-At this time, you can use the latest released 1.1.x version of the Kotlin plugin for working with the code. To make sure you have the latest version installed, use Tools | Kotlin | Configure Kotlin Plugin Updates and press "Check for updates now".
+At this time, you can use the latest released 1.2.x version of the Kotlin plugin for working with the code. To make sure you have the latest version installed, use Tools | Kotlin | Configure Kotlin Plugin Updates and press "Check for updates now".

 ### Compiling and running

@@ -104,6 +102,18 @@ From this root project there are Run/Debug Configurations for running IDEA or th
 * Run the "IDEA" run configuration in the project
 * a child IntelliJ IDEA with the Kotlin plugin will then startup

+### Including into composite build
+
+To include kotlin compiler into [composite build](https://docs.gradle.org/current/userguide/composite_builds.html) you need to define `dependencySubstitution` for `kotlin-compiler` module in `settings.gradle`
+
+```
+includeBuild('/path/to/kotlin') {
+    dependencySubstitution {
+        substitute module('org.jetbrains.kotlin:kotlin-compiler') with project(':include:kotlin-compiler')
+    }
+}
+```
+
 # Contributing

 We love contributions! There's [lots to do on Kotlin](https://youtrack.jetbrains.com/issues/KT) and on the
@@ -125,7 +135,7 @@ macro to include code from a test function. The benefits of this approach are tw

 Also the [JavaScript translation](https://github.com/JetBrains/kotlin/blob/master/js/ReadMe.md) could really use your help. See the [JavaScript contribution section](https://github.com/JetBrains/kotlin/blob/master/js/ReadMe.md) for more details.

-Some of the code in the standard library is created by generating code from templates. See the [README](libraries/stdlib/ReadMe.md) in the stdlib section for how run the code generator. The existing templates can be used as examples for creating new ones.
+Some of the code in the standard library is created by generating code from templates. See the [README](libraries/stdlib/ReadMe.md) in the stdlib section for how to run the code generator. The existing templates can be used as examples for creating new ones.

 ## Submitting patches

--- a/TeamCityBuild.xml
+++ b/TeamCityBuild.xml
@@ -1,12 +1,13 @@
 <project name="Kotlin CI Steps" default="none">
-    <import file="build.xml" optional="false"/>
+    <import file="common.xml" optional="false"/>
+    <property name="kotlin-home" value="${output}/kotlinc"/>

    <property name="build.number" value="snapshot"/>
    <property name="fail.on.plugin.verifier.error" value="true"/>

    <property name="version_substitute_dir" value="${basedir}/versions_temp/"/>

-    <property name="artifact.output.path" value="${basedir}/dist/artifacts"/>
+    <property name="artifact.output.path" value="${basedir}/dist/artifacts/ideaPlugin"/>
    <property name="plugin.xml" value="idea/src/META-INF/plugin.xml"/>
    <property name="plugin.xml.bk" value="${version_substitute_dir}/plugin.xml.bk"/>
    <property name="plugin.xml.versioned" value="${plugin.xml}.versioned"/>
@@ -38,84 +39,49 @@
    <echoprop prop="user.home"/>
    <echoprop prop="user.dir"/>

-    <target name="cleanupArtifacts">
-        <delete dir="${artifact.output.path}" includes="*"/>
-    </target>
-
-    <macrodef name="substituteVersionInFile">
-        <attribute name="target.file"/>
-        <attribute name="test.string"/>
-        <attribute name="target.file.bk" default="@{target.file}.bk"/>
-        <attribute name="target.file.versioned" default="@{target.file}.versioned"/>
-        <attribute name="token.key" default="snapshot"/>
-        <attribute name="version" default="${build.number}"/>
+    <macrodef name="run-gradle">
+        <attribute name="tasks" />
+        <attribute name="args" default="" />
        <sequential>
-            <!-- Create backup. Backup will be restored after build end. This will allow to rebuild project without renew
-                 plugin.xml from repository. -->
-            <copy file="@{target.file}" tofile="@{target.file.bk}"/>
-
-            <!-- Check that version has correct pattern for substitution -->
-            <copy todir="">
-                <fileset file="@{target.file.bk}">
-                    <contains text="@{test.string}"/>
-                </fileset>
-                <filterchain>
-                    <replacetokens>
-                        <token key="@{token.key}" value="@{version}"/>
-                    </replacetokens>
-                </filterchain>
-                <mergemapper to="@{target.file.versioned}"/>
-            </copy>
-
-            <!-- If file doesn't exist - there's a problem with original plugin.xml. Probably there's a bad pattern used for version -->
-            <copy file="@{target.file.versioned}" tofile="@{target.file}" overwrite="true"/>
-
-            <delete file="@{target.file.versioned}" quiet="true"/>
+            <java classname="org.gradle.wrapper.GradleWrapperMain"
+                  fork="true"
+                  dir="${basedir}"
+                  failonerror="true"
+                  timeout="4000000"
+                  maxmemory="400m"
+                  taskname="gradle">
+                <classpath>
+                    <pathelement location="${basedir}/gradle/wrapper/gradle-wrapper.jar"/>
+                </classpath>
+                <arg line="--no-daemon" />
+                <arg line="@{tasks}" />
+                <arg line="@{args}" />
+            </java>
        </sequential>
    </macrodef>

+    <target name="cleanupArtifacts">
+        <run-gradle tasks="cleanupArtifacts" />
+    </target>
+
+    <target name="zip-compiler">
+        <run-gradle tasks="zipCompiler" args="-PdeployVersion=${build.number}" />
+    </target>
+
+    <target name="zip-test-data">
+        <run-gradle tasks="zipTestData" />
+    </target>
+
    <target name="writeCompilerVersionToTemplateFile">
        <!-- empty, version is written in gradle build -->
    </target>

    <target name="writePluginVersionToTemplateFile">
-        <mkdir dir="${version_substitute_dir}"/>
-
-        <substituteVersionInFile
-            target.file="${plugin.xml}"
-            target.file.bk="${plugin.xml.bk}"
-            target.file.versioned="${plugin.xml.versioned}"
-            test.string="&lt;version&gt;@snapshot@&lt;/version&gt;"
-            version="${plugin.xml.version.number}"/>
+        <run-gradle tasks="writePluginVersion" args="-PpluginVersion=${plugin.xml.version.number}" />
    </target>

-    <target name="revertTemplateFiles">
-        <copy file="${plugin.xml.bk}" tofile="${plugin.xml}" overwrite="true"/>
-        <copy file="${compiler.version.java.bk}" tofile="${compiler.version.java}" overwrite="true"/>
-
-        <delete dir="${version_substitute_dir}" quiet="true"/>
-    </target>
-
-    <target name="pre_build" depends="writeCompilerVersionToTemplateFile, writePluginVersionToTemplateFile, cleanupArtifacts"/>
-
    <target name="zipArtifacts">
-        <macrodef name="zipPlugin">
-            <attribute name="filename"/>
-            <attribute name="prefix" />
-            <attribute name="dir"/>
-
-            <sequential>
-                <zip destfile="@{filename}">
-                    <zipfileset prefix="@{prefix}" dir="@{dir}" excludes="kotlinc/bin/*"/>
-                    <zipfileset prefix="@{prefix}/kotlinc/bin" dir="@{dir}/kotlinc/bin" includes="*.bat"
-                                filemode="644"/>
-                    <zipfileset prefix="@{prefix}/kotlinc/bin" dir="@{dir}/kotlinc/bin" excludes="*.bat"
-                                filemode="755"/>
-                </zip>
-            </sequential>
-        </macrodef>
-
-        <zipPlugin filename="${plugin.zip}" prefix="Kotlin" dir="${artifact.output.path}/${pluginArtifactDir}"/>
+        <run-gradle tasks="zipPlugin" args="-PpluginArtifactDir=${pluginArtifactDir} -PpluginZipPath=${plugin.zip}"/>
    </target>

    <macrodef name="print-statistic">
@@ -148,42 +114,8 @@
        <print-file-size-statistic path="${basedir}/libraries/stdlib/js/build/classes/main" file-name="kotlin.meta.js"/>
    </target>

-    <target name="post_build" depends="zipArtifacts, revertTemplateFiles, printStatistics, remove_internal_artifacts, dont_remove_internal_artifacts"/>
-
    <target name="none">
        <fail message="Either specify pre_build or post_build"/>
    </target>

-    <property name="teamcity.build.branch" value=""/>
-
-    <condition property="need.remove.artifacts" value="true">
-        <and>
-            <matches pattern="rri?/.*" string="${teamcity.build.branch}"/>
-            <not>
-                <matches pattern="rri?/internal/.*" string="${teamcity.build.branch}"/>
-            </not>
-        </and>
-    </condition>
-
-    <target name="remove_internal_artifacts"
-            description="Remove internal artifacts for rri?/* branches, but store them for rri?/internal/*"
-            if="need.remove.artifacts">
-        <echo message="Remove internal artifacts" />
-
-        <delete failonerror="false" verbose="true">
-            <fileset dir="dist">
-                <include name="kotlin-compiler-before-shrink.jar"/>
-                <include name="kotlin-for-upsource.jar"/>
-                <include name="kotlin-for-upsource-sources.jar"/>
-                <include name="kotlin-test-data.zip"/>
-            </fileset>
-            <fileset dir="out/artifacts/internal">
-                <include name="kotlin-ide-common.jar"/>
-            </fileset>
-        </delete>
-    </target>
-
-    <target name="dont_remove_internal_artifacts" unless="need.remove.artifacts">
-        <echo message="Internal artifacts left untouched"/>
-    </target>
 </project>
--- a/build-common/build.gradle.kts
+++ b/build-common/build.gradle.kts
@@ -2,6 +2,7 @@
 description = "Kotlin Build Common"

 apply { plugin("kotlin") }
+apply { plugin("jps-compatible") }

 dependencies {
    compileOnly(project(":core:util.runtime"))
@@ -10,15 +11,18 @@ dependencies {
    compileOnly(project(":compiler:frontend.java"))
    compileOnly(project(":js:js.serializer"))
    compileOnly(project(":js:js.frontend"))
-    compileOnly(ideaSdkDeps("util"))
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
+    compileOnly(intellijDep()) { includeJars("annotations", "asm-all", "trove4j", "util") }
+    compileOnly(project(":kotlin-reflect-api"))
+
    testCompileOnly(project(":compiler:cli-common"))
    testCompile(projectTests(":compiler:tests-common"))
    testCompile(commonDep("junit:junit"))
    testCompile(protobufFull())
    testCompile(projectDist(":kotlin-stdlib"))
-    testCompile(projectDist(":kotlin-reflect"))
-    testCompileOnly(ideaSdkDeps("openapi"))
-    testRuntime(projectDist(":kotlin-compiler"))
+    testCompileOnly(intellijDep()) { includeJars("openapi") }
+
+    testRuntime(projectDist(":kotlin-reflect"))
 }

 sourceSets {
--- a/build-common/src/java_descriptors.proto
+++ b/build-common/src/java_descriptors.proto
@@ -0,0 +1,40 @@
+/*
+ * 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.metadata.java;
+
+import "core/metadata/src/metadata.proto";
+
+option java_outer_classname = "JavaClassProtoBuf";
+option optimize_for = LITE_RUNTIME;
+
+extend Function {
+  optional bool is_static_method = 1000;
+  optional bool is_package_private_method = 1001;
+}
+
+extend Property {
+  optional bool is_static_field = 1000;
+  optional bool is_package_private_field = 1001;
+}
+
+extend Class {
+  optional bool is_package_private_class = 1000;
+}
+
+extend Constructor {
+  optional bool is_package_private_constructor = 1000;
+}
--- a/build-common/src/org/jetbrains/kotlin/build/JvmBuildMetaInfo.kt
+++ b/build-common/src/org/jetbrains/kotlin/build/JvmBuildMetaInfo.kt
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
 import org.jetbrains.kotlin.config.ApiVersion
 import org.jetbrains.kotlin.config.KotlinCompilerVersion
 import org.jetbrains.kotlin.config.LanguageVersion
-import org.jetbrains.kotlin.config.shouldWritePreReleaseFlag
+import org.jetbrains.kotlin.config.isPreRelease
 import org.jetbrains.kotlin.load.java.JvmBytecodeBinaryVersion
 import org.jetbrains.kotlin.load.kotlin.JvmMetadataVersion

@@ -63,10 +63,10 @@ fun JvmBuildMetaInfo(args: CommonCompilerArguments): JvmBuildMetaInfo {
    val languageVersion = args.languageVersion?.let((LanguageVersion)::fromVersionString) ?: LanguageVersion.LATEST_STABLE

    return JvmBuildMetaInfo(
-            isEAP = languageVersion.shouldWritePreReleaseFlag(),
+            isEAP = languageVersion.isPreRelease(),
            compilerBuildVersion = KotlinCompilerVersion.VERSION,
            languageVersionString = languageVersion.versionString,
-            apiVersionString = args.apiVersion ?: ApiVersion.LATEST_STABLE.versionString,
+            apiVersionString = args.apiVersion ?: languageVersion.versionString,
            coroutinesEnable = args.coroutinesState == CommonCompilerArguments.ENABLE,
            coroutinesWarn = args.coroutinesState == CommonCompilerArguments.WARN,
            coroutinesError = args.coroutinesState == CommonCompilerArguments.ERROR,
--- a/build-common/src/org/jetbrains/kotlin/incremental/ChangesCollector.kt
+++ b/build-common/src/org/jetbrains/kotlin/incremental/ChangesCollector.kt
@@ -16,11 +16,12 @@

 package org.jetbrains.kotlin.incremental

+import org.jetbrains.kotlin.metadata.ProtoBuf
+import org.jetbrains.kotlin.metadata.deserialization.Flags
+import org.jetbrains.kotlin.metadata.deserialization.NameResolver
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.protobuf.MessageLite
-import org.jetbrains.kotlin.serialization.Flags
-import org.jetbrains.kotlin.serialization.ProtoBuf
-import org.jetbrains.kotlin.serialization.deserialization.NameResolver
+import org.jetbrains.kotlin.serialization.deserialization.getClassId

 class ChangesCollector {
    private val removedMembers = hashMapOf<FqName, MutableSet<String>>()
@@ -72,13 +73,13 @@ class ChangesCollector {
        }
    }

-    fun collectProtoChanges(oldData: ProtoData?, newData: ProtoData?) {
+    fun collectProtoChanges(oldData: ProtoData?, newData: ProtoData?, collectAllMembersForNewClass: Boolean = false) {
        if (oldData == null && newData == null) {
            throw IllegalStateException("Old and new value are null")
        }

        if (oldData == null) {
-            newData!!.collectAll(isRemoved = false)
+            newData!!.collectAll(isRemoved = false, collectAllMembersForNewClass = collectAllMembersForNewClass)
            return
        }

@@ -120,10 +121,10 @@ class ChangesCollector {
    private fun <T> T.getNonPrivateNames(nameResolver: NameResolver, vararg members: T.() -> List<MessageLite>): Set<String> =
            members.flatMap { this.it().filterNot { it.isPrivate }.names(nameResolver) }.toSet()

-    private fun ProtoData.collectAll(isRemoved: Boolean) =
+    private fun ProtoData.collectAll(isRemoved: Boolean, collectAllMembersForNewClass: Boolean = false) =
        when (this) {
            is PackagePartProtoData -> collectAllFromPackage(isRemoved)
-            is ClassProtoData -> collectAllFromClass(isRemoved)
+            is ClassProtoData -> collectAllFromClass(isRemoved, collectAllMembersForNewClass)
        }

    private fun PackagePartProtoData.collectAllFromPackage(isRemoved: Boolean) {
@@ -142,28 +143,36 @@ class ChangesCollector {
        }
    }

-    private fun ClassProtoData.collectAllFromClass(isRemoved: Boolean) {
+    private fun ClassProtoData.collectAllFromClass(isRemoved: Boolean, collectAllMembersForNewClass: Boolean = false) {
        val classFqName = nameResolver.getClassId(proto.fqName).asSingleFqName()
        val kind = Flags.CLASS_KIND.get(proto.flags)

        if (kind == ProtoBuf.Class.Kind.COMPANION_OBJECT) {
-            val memberNames =
-                    proto.getNonPrivateNames(
-                            nameResolver,
-                            ProtoBuf.Class::getConstructorList,
-                            ProtoBuf.Class::getFunctionList,
-                            ProtoBuf.Class::getPropertyList
-                    ) + proto.enumEntryList.map { nameResolver.getString(it.name) }
+            val memberNames = getNonPrivateMemberNames()

            val collectMember = if (isRemoved) this@ChangesCollector::collectRemovedMember else this@ChangesCollector::collectChangedMember
            collectMember(classFqName.parent(), classFqName.shortName().asString())
            memberNames.forEach { collectMember(classFqName, it) }
        }
        else {
+            if (!isRemoved && collectAllMembersForNewClass) {
+                val memberNames = getNonPrivateMemberNames()
+                memberNames.forEach { this@ChangesCollector.collectChangedMember(classFqName, it) }
+            }
+
            collectSignature(classFqName, areSubclassesAffected = true)
        }
    }

+    private fun ClassProtoData.getNonPrivateMemberNames(): Set<String> {
+        return proto.getNonPrivateNames(
+                nameResolver,
+                ProtoBuf.Class::getConstructorList,
+                ProtoBuf.Class::getFunctionList,
+                ProtoBuf.Class::getPropertyList
+        ) + proto.enumEntryList.map { nameResolver.getString(it.name) }
+    }
+
    fun collectMemberIfValueWasChanged(scope: FqName, name: String, oldValue: Any?, newValue: Any?) {
        if (oldValue == null && newValue == null) {
            throw IllegalStateException("Old and new value are null for $scope#$name")
@@ -186,4 +195,4 @@ class ChangesCollector {
        val prevValue = this.areSubclassesAffected[fqName] ?: false
        this.areSubclassesAffected[fqName] = prevValue || areSubclassesAffected
    }
-}
+}
--- a/build-common/src/org/jetbrains/kotlin/incremental/ICReporter.kt
+++ b/build-common/src/org/jetbrains/kotlin/incremental/ICReporter.kt
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.cli.common.ExitCode
 import java.io.File

 interface ICReporter {
-    fun report(message: ()->String)
+    fun report(message: () -> String)

    // used in Gradle plugin
    @Suppress("unused")
--- a/build-common/src/org/jetbrains/kotlin/incremental/IncrementalCacheCommon.kt
+++ b/build-common/src/org/jetbrains/kotlin/incremental/IncrementalCacheCommon.kt
@@ -18,28 +18,31 @@ package org.jetbrains.kotlin.incremental

 import com.intellij.util.io.EnumeratorStringDescriptor
 import org.jetbrains.kotlin.incremental.storage.*
+import org.jetbrains.kotlin.metadata.ProtoBuf
+import org.jetbrains.kotlin.metadata.deserialization.NameResolver
+import org.jetbrains.kotlin.metadata.deserialization.TypeTable
+import org.jetbrains.kotlin.metadata.deserialization.supertypes
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.serialization.ProtoBuf
-import org.jetbrains.kotlin.serialization.deserialization.NameResolver
-import org.jetbrains.kotlin.serialization.deserialization.TypeTable
-import org.jetbrains.kotlin.serialization.deserialization.supertypes
+import org.jetbrains.kotlin.serialization.deserialization.getClassId
 import java.io.File

 /**
 * Incremental cache common for JVM and JS
 */
-abstract class IncrementalCacheCommon(workingDir: File) : BasicMapsOwner(workingDir) {
+abstract class IncrementalCacheCommon<ClassName>(workingDir: File) : BasicMapsOwner(workingDir) {
    companion object {
        private val SUBTYPES = "subtypes"
        private val SUPERTYPES = "supertypes"
        private val CLASS_FQ_NAME_TO_SOURCE = "class-fq-name-to-source"
+        @JvmStatic protected val SOURCE_TO_CLASSES = "source-to-classes"
+        @JvmStatic protected val DIRTY_OUTPUT_CLASSES = "dirty-output-classes"
    }

-    private val dependents = arrayListOf<IncrementalCacheCommon>()
-    fun addDependentCache(cache: IncrementalCacheCommon) {
+    private val dependents = arrayListOf<IncrementalCacheCommon<ClassName>>()
+    fun addDependentCache(cache: IncrementalCacheCommon<ClassName>) {
        dependents.add(cache)
    }
-    val thisWithDependentCaches: Iterable<IncrementalCacheCommon> by lazy {
+    val thisWithDependentCaches: Iterable<IncrementalCacheCommon<ClassName>> by lazy {
        val result = arrayListOf(this)
        result.addAll(dependents)
        result
@@ -48,6 +51,11 @@ abstract class IncrementalCacheCommon(workingDir: File) : BasicMapsOwner(working
    private val subtypesMap = registerMap(SubtypesMap(SUBTYPES.storageFile))
    private val supertypesMap = registerMap(SupertypesMap(SUPERTYPES.storageFile))
    protected val classFqNameToSourceMap = registerMap(ClassFqNameToSourceMap(CLASS_FQ_NAME_TO_SOURCE.storageFile))
+    internal abstract val sourceToClassesMap: AbstractSourceToOutputMap<ClassName>
+    internal abstract val dirtyOutputClassesMap: AbstractDirtyClassesMap<ClassName>
+
+    fun classesFqNamesBySources(files: Iterable<File>): Collection<FqName> =
+        files.flatMapTo(HashSet()) { sourceToClassesMap.getFqNames(it) }

    fun getSubtypesOf(className: FqName): Sequence<FqName> =
            subtypesMap[className].asSequence()
@@ -55,7 +63,16 @@ abstract class IncrementalCacheCommon(workingDir: File) : BasicMapsOwner(working
    fun getSourceFileIfClass(fqName: FqName): File? =
            classFqNameToSourceMap[fqName]

-    abstract fun markDirty(removedAndCompiledSources: List<File>)
+    open fun markDirty(removedAndCompiledSources: Collection<File>) {
+        for (sourceFile in removedAndCompiledSources) {
+            val classes = sourceToClassesMap[sourceFile]
+            classes.forEach {
+                dirtyOutputClassesMap.markDirty(it)
+            }
+
+            sourceToClassesMap.clearOutputsForSource(sourceFile)
+        }
+    }

    protected fun addToClassStorage(proto: ProtoBuf.Class, nameResolver: NameResolver, srcFile: File) {
        val supertypes = proto.supertypes(TypeTable(proto.typeTable))
@@ -73,11 +90,19 @@ abstract class IncrementalCacheCommon(workingDir: File) : BasicMapsOwner(working
        classFqNameToSourceMap[child] = srcFile
    }

-    protected fun removeAllFromClassStorage(removedClasses: Collection<FqName>) {
+    abstract fun clearCacheForRemovedClasses(changesCollector: ChangesCollector)
+
+    protected fun removeAllFromClassStorage(removedClasses: Collection<FqName>, changesCollector: ChangesCollector) {
        if (removedClasses.isEmpty()) return

        val removedFqNames = removedClasses.toSet()

+        for (removedClass in removedFqNames) {
+            for (affectedClass in withSubtypes(removedClass, thisWithDependentCaches)) {
+                changesCollector.collectSignature(affectedClass, areSubclassesAffected = false)
+            }
+        }
+
        for (cache in thisWithDependentCaches) {
            val parentsFqNames = hashSetOf<FqName>()
            val childrenFqNames = hashSetOf<FqName>()
--- a/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJsCache.kt
+++ b/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJsCache.kt
@@ -19,31 +19,37 @@ package org.jetbrains.kotlin.incremental
 import com.intellij.util.io.DataExternalizer
 import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumerImpl
 import org.jetbrains.kotlin.incremental.js.TranslationResultValue
-import org.jetbrains.kotlin.incremental.storage.*
+import org.jetbrains.kotlin.incremental.storage.BasicStringMap
+import org.jetbrains.kotlin.incremental.storage.DirtyClassesFqNameMap
+import org.jetbrains.kotlin.incremental.storage.SourceToFqNameMap
+import org.jetbrains.kotlin.incremental.storage.StringToLongMapExternalizer
+import org.jetbrains.kotlin.metadata.ProtoBuf
+import org.jetbrains.kotlin.metadata.deserialization.NameResolverImpl
+import org.jetbrains.kotlin.metadata.deserialization.getExtensionOrNull
+import org.jetbrains.kotlin.metadata.js.JsProtoBuf
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.serialization.ProtoBuf
-import org.jetbrains.kotlin.serialization.deserialization.NameResolverImpl
-import org.jetbrains.kotlin.serialization.js.JsProtoBuf
+import org.jetbrains.kotlin.serialization.deserialization.getClassId
 import org.jetbrains.kotlin.serialization.js.JsSerializerProtocol
 import java.io.DataInput
 import java.io.DataOutput
 import java.io.File

-open class IncrementalJsCache(cachesDir: File) : IncrementalCacheCommon(cachesDir) {
+open class IncrementalJsCache(cachesDir: File) : IncrementalCacheCommon<FqName>(cachesDir) {
    companion object {
        private val TRANSLATION_RESULT_MAP = "translation-result"
-        private val SOURCES_TO_CLASSES_FQNS = "sources-to-classes"
        private val INLINE_FUNCTIONS = "inline-functions"
        private val HEADER_FILE_NAME = "header.meta"
    }

-    private val dirtySources = arrayListOf<File>()
+    override val sourceToClassesMap = registerMap(SourceToFqNameMap(SOURCE_TO_CLASSES.storageFile))
+    override val dirtyOutputClassesMap = registerMap(DirtyClassesFqNameMap(DIRTY_OUTPUT_CLASSES.storageFile))
    private val translationResults = registerMap(TranslationResultMap(TRANSLATION_RESULT_MAP.storageFile))
-    private val sourcesToClasses = registerMap(SourceToClassesMap(SOURCES_TO_CLASSES_FQNS.storageFile))
    private val inlineFunctions = registerMap(InlineFunctionsMap(INLINE_FUNCTIONS.storageFile))

+    private val dirtySources = hashSetOf<File>()
+
    private val headerFile: File
        get() = File(cachesDir, HEADER_FILE_NAME)

@@ -54,31 +60,24 @@ open class IncrementalJsCache(cachesDir: File) : IncrementalCacheCommon(cachesDi
            headerFile.writeBytes(value)
        }

-    override fun markDirty(removedAndCompiledSources: List<File>) {
+    override fun markDirty(removedAndCompiledSources: Collection<File>) {
+        super.markDirty(removedAndCompiledSources)
        dirtySources.addAll(removedAndCompiledSources)
    }

    fun compareAndUpdate(incrementalResults: IncrementalResultsConsumerImpl, changesCollector: ChangesCollector) {
        val translatedFiles = incrementalResults.packageParts

-        dirtySources.forEach {
-            if (it !in translatedFiles) {
-                translationResults.remove(it, changesCollector)
-                inlineFunctions.remove(it)
-            }
-
-            removeAllFromClassStorage(sourcesToClasses[it])
-            sourcesToClasses.clearOutputsForSource(it)
-        }
-        dirtySources.clear()
-
        for ((srcFile, data) in translatedFiles) {
+            dirtySources.remove(srcFile)
            val (binaryMetadata, binaryAst) = data

            val oldProtoMap = translationResults[srcFile]?.metadata?.let { getProtoData(srcFile, it) } ?: emptyMap()
            val newProtoMap = getProtoData(srcFile, binaryMetadata)

-            for (protoData in newProtoMap.values) {
+            for ((classId, protoData) in newProtoMap) {
+                registerOutputForFile(srcFile, classId.asSingleFqName())
+
                if (protoData is ClassProtoData) {
                    addToClassStorage(protoData.proto, protoData.nameResolver, srcFile)
                }
@@ -96,6 +95,21 @@ open class IncrementalJsCache(cachesDir: File) : IncrementalCacheCommon(cachesDi
        }
    }

+    private fun registerOutputForFile(srcFile: File, name: FqName) {
+        sourceToClassesMap.add(srcFile, name)
+        dirtyOutputClassesMap.notDirty(name)
+    }
+
+    override fun clearCacheForRemovedClasses(changesCollector: ChangesCollector) {
+        dirtySources.forEach {
+            translationResults.remove(it, changesCollector)
+            inlineFunctions.remove(it)
+        }
+        removeAllFromClassStorage(dirtyOutputClassesMap.getDirtyOutputClasses(), changesCollector)
+        dirtySources.clear()
+        dirtyOutputClassesMap.clean()
+    }
+
    fun nonDirtyPackageParts(): Map<File, TranslationResultValue> =
            hashMapOf<File, TranslationResultValue>().apply {
                for (path in translationResults.keys()) {
@@ -107,25 +121,6 @@ open class IncrementalJsCache(cachesDir: File) : IncrementalCacheCommon(cachesDi
            }
 }

-private class SourceToClassesMap(storageFile: File) : BasicStringMap<Collection<String>>(storageFile, PathStringDescriptor, StringCollectionExternalizer) {
-    fun clearOutputsForSource(sourceFile: File) {
-        remove(sourceFile.canonicalPath)
-    }
-
-    fun add(sourceFile: File, className: FqName) {
-        storage.append(sourceFile.canonicalPath, className.asString())
-    }
-
-    operator fun get(sourceFile: File): Collection<FqName> =
-            storage[sourceFile.canonicalPath].orEmpty().map { FqName(it) }
-
-    override fun dumpValue(value: Collection<String>) = value.dumpCollection()
-
-    private fun remove(path: String) {
-        storage.remove(path)
-    }
-}
-
 private object TranslationResultValueExternalizer : DataExternalizer<TranslationResultValue> {
    override fun save(output: DataOutput, value: TranslationResultValue) {
        output.writeInt(value.metadata.size)
@@ -187,14 +182,11 @@ fun getProtoData(sourceFile: File, metadata: ByteArray): Map<ClassId, ProtoData>
    }

    proto.`package`.apply {
-        val packageFqName = if (hasExtension(JsProtoBuf.packageFqName)) {
-            nameResolver.getPackageFqName(getExtension(JsProtoBuf.packageFqName))
-        }
-        else FqName.ROOT
-
+        val packageFqName = getExtensionOrNull(JsProtoBuf.packageFqName)?.let(nameResolver::getPackageFqName)?.let(::FqName) ?: FqName.ROOT
        val packagePartClassId = ClassId(packageFqName, Name.identifier(sourceFile.nameWithoutExtension.capitalize() + "Kt"))
        classes[packagePartClassId] = PackagePartProtoData(this, nameResolver, packageFqName)
    }
+
    return classes
 }

--- a/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt
+++ b/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt
@@ -29,10 +29,11 @@ import org.jetbrains.kotlin.load.kotlin.ModuleMapping
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
 import org.jetbrains.kotlin.load.kotlin.incremental.components.JvmPackagePartProto
+import org.jetbrains.kotlin.metadata.jvm.deserialization.BitEncoding
+import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil
+import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
-import org.jetbrains.kotlin.serialization.jvm.BitEncoding
-import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil
 import org.jetbrains.org.objectweb.asm.*
 import java.io.File
 import java.security.MessageDigest
@@ -43,57 +44,52 @@ val KOTLIN_CACHE_DIRECTORY_NAME = "kotlin"
 open class IncrementalJvmCache(
        private val targetDataRoot: File,
        targetOutputDir: File?
-) : IncrementalCacheCommon(File(targetDataRoot, KOTLIN_CACHE_DIRECTORY_NAME)), IncrementalCache {
+) : IncrementalCacheCommon<JvmClassName>(File(targetDataRoot, KOTLIN_CACHE_DIRECTORY_NAME)), IncrementalCache {
    companion object {
        private val PROTO_MAP = "proto"
        private val CONSTANTS_MAP = "constants"
        private val PACKAGE_PARTS = "package-parts"
        private val MULTIFILE_CLASS_FACADES = "multifile-class-facades"
        private val MULTIFILE_CLASS_PARTS = "multifile-class-parts"
-        private val SOURCE_TO_CLASSES = "source-to-classes"
-        private val DIRTY_OUTPUT_CLASSES = "dirty-output-classes"
        private val INLINE_FUNCTIONS = "inline-functions"
        private val INTERNAL_NAME_TO_SOURCE = "internal-name-to-source"
+        private val JAVA_SOURCES_PROTO_MAP = "java-sources-proto-map"

        private val MODULE_MAPPING_FILE_NAME = "." + ModuleMapping.MAPPING_FILE_EXT
    }

+    override val sourceToClassesMap = registerMap(SourceToJvmNameMap(SOURCE_TO_CLASSES.storageFile))
+    override val dirtyOutputClassesMap = registerMap(DirtyClassesJvmNameMap(DIRTY_OUTPUT_CLASSES.storageFile))
+
    private val protoMap = registerMap(ProtoMap(PROTO_MAP.storageFile))
    private val constantsMap = registerMap(ConstantsMap(CONSTANTS_MAP.storageFile))
    private val packagePartMap = registerMap(PackagePartMap(PACKAGE_PARTS.storageFile))
    private val multifileFacadeToParts = registerMap(MultifileClassFacadeMap(MULTIFILE_CLASS_FACADES.storageFile))
    private val partToMultifileFacade = registerMap(MultifileClassPartMap(MULTIFILE_CLASS_PARTS.storageFile))
-    private val sourceToClassesMap = registerMap(SourceToClassesMap(SOURCE_TO_CLASSES.storageFile))
-    private val dirtyOutputClassesMap = registerMap(DirtyOutputClassesMap(DIRTY_OUTPUT_CLASSES.storageFile))
    private val inlineFunctionsMap = registerMap(InlineFunctionsMap(INLINE_FUNCTIONS.storageFile))
    // todo: try to use internal names only?
    private val internalNameToSource = registerMap(InternalNameToSourcesMap(INTERNAL_NAME_TO_SOURCE.storageFile))
+    private val javaSourcesProtoMap = registerMap(JavaSourcesProtoMap(JAVA_SOURCES_PROTO_MAP.storageFile))

    private val outputDir by lazy(LazyThreadSafetyMode.NONE) { requireNotNull(targetOutputDir) { "Target is expected to have output directory" } }

    protected open fun debugLog(message: String) {}

-    override fun markDirty(removedAndCompiledSources: List<File>) {
-        for (sourceFile in removedAndCompiledSources) {
-            val classes = sourceToClassesMap[sourceFile]
-            classes.forEach {
-                dirtyOutputClassesMap.markDirty(it.internalName)
-            }
-
-            sourceToClassesMap.clearOutputsForSource(sourceFile)
-        }
-    }
+    fun isTrackedFile(file: File) = sourceToClassesMap.contains(file)

    // used in gradle
    @Suppress("unused")
    fun classesBySources(sources: Iterable<File>): Iterable<JvmClassName> =
            sources.flatMap { sourceToClassesMap[it] }

+    fun sourceInCache(file: File): Boolean =
+        sourceToClassesMap.contains(file)
+
    fun sourcesByInternalName(internalName: String): Collection<File> =
            internalNameToSource[internalName]

    fun isMultifileFacade(className: JvmClassName): Boolean =
-            className.internalName in multifileFacadeToParts
+            className in multifileFacadeToParts

    override fun getClassFilePath(internalClassName: String): String {
        return toSystemIndependentName(File(outputDir, "$internalClassName.class").canonicalPath)
@@ -102,7 +98,7 @@ open class IncrementalJvmCache(
    fun saveModuleMappingToCache(sourceFiles: Collection<File>, file: File) {
        val jvmClassName = JvmClassName.byInternalName(MODULE_MAPPING_FILE_NAME)
        protoMap.storeModuleMapping(jvmClassName, file.readBytes())
-        dirtyOutputClassesMap.notDirty(MODULE_MAPPING_FILE_NAME)
+        dirtyOutputClassesMap.notDirty(jvmClassName)
        sourceFiles.forEach { sourceToClassesMap.add(it, jvmClassName) }
    }

@@ -111,7 +107,7 @@ open class IncrementalJvmCache(
        val kotlinClass: LocalFileKotlinClass = generatedClass.outputClass
        val className = kotlinClass.className

-        dirtyOutputClassesMap.notDirty(className.internalName)
+        dirtyOutputClassesMap.notDirty(className)
        sourceFiles.forEach {
            sourceToClassesMap.add(it, className)
        }
@@ -169,22 +165,46 @@ open class IncrementalJvmCache(
        }
    }

-    fun clearCacheForRemovedClasses(changesCollector: ChangesCollector) {
-        val dirtyClasses = dirtyOutputClassesMap
-                                .getDirtyOutputClasses()
-                                .map(JvmClassName::byInternalName)
-                                .toList()
+    fun saveJavaClassProto(source: File, serializedJavaClass: SerializedJavaClass, collector: ChangesCollector) {
+        val jvmClassName = JvmClassName.byClassId(serializedJavaClass.classId)
+        javaSourcesProtoMap.process(jvmClassName, serializedJavaClass, collector)
+        sourceToClassesMap.add(source, jvmClassName)
+        val (proto, nameResolver) = serializedJavaClass.toProtoData()
+        addToClassStorage(proto, nameResolver, source)
+
+        dirtyOutputClassesMap.notDirty(jvmClassName)
+    }
+
+    fun getObsoleteJavaClasses(): Collection<ClassId> =
+            dirtyOutputClassesMap.getDirtyOutputClasses()
+                    .mapNotNull {
+                        javaSourcesProtoMap[it]?.classId
+                    }
+
+    fun isJavaClassToTrack(classId: ClassId): Boolean {
+        val jvmClassName = JvmClassName.byClassId(classId)
+        return dirtyOutputClassesMap.isDirty(jvmClassName) ||
+               jvmClassName !in javaSourcesProtoMap
+    }
+
+    fun isJavaClassAlreadyInCache(classId: ClassId): Boolean {
+        val jvmClassName = JvmClassName.byClassId(classId)
+        return jvmClassName in javaSourcesProtoMap
+    }
+
+    override fun clearCacheForRemovedClasses(changesCollector: ChangesCollector) {
+        val dirtyClasses = dirtyOutputClassesMap.getDirtyOutputClasses()

        val facadesWithRemovedParts = hashMapOf<JvmClassName, MutableSet<String>>()
        for (dirtyClass in dirtyClasses) {
-            val facade = partToMultifileFacade.get(dirtyClass.internalName) ?: continue
+            val facade = partToMultifileFacade.get(dirtyClass) ?: continue
            val facadeClassName = JvmClassName.byInternalName(facade)
            val removedParts = facadesWithRemovedParts.getOrPut(facadeClassName) { hashSetOf() }
            removedParts.add(dirtyClass.internalName)
        }

        for ((facade, removedParts) in facadesWithRemovedParts.entries) {
-            val allParts = multifileFacadeToParts[facade.internalName] ?: continue
+            val allParts = multifileFacadeToParts[facade] ?: continue
            val notRemovedParts = allParts.filter { it !in removedParts }

            if (notRemovedParts.isEmpty()) {
@@ -203,18 +223,17 @@ open class IncrementalJvmCache(
            constantsMap.remove(it)
            inlineFunctionsMap.remove(it)
            internalNameToSource.remove(it.internalName)
+            javaSourcesProtoMap.remove(it, changesCollector)
        }

-        removeAllFromClassStorage(dirtyClasses.map { it.fqNameForClassNameWithoutDollars })
-
+        removeAllFromClassStorage(dirtyClasses.map { it.fqNameForClassNameWithoutDollars }, changesCollector)
        dirtyOutputClassesMap.clean()
    }

    override fun getObsoletePackageParts(): Collection<String> {
-        val obsoletePackageParts =
-                dirtyOutputClassesMap.getDirtyOutputClasses().filter { packagePartMap.isPackagePart(JvmClassName.byInternalName(it)) }
+        val obsoletePackageParts = dirtyOutputClassesMap.getDirtyOutputClasses().filter(packagePartMap::isPackagePart)
        debugLog("Obsolete package parts: $obsoletePackageParts")
-        return obsoletePackageParts
+        return obsoletePackageParts.map { it.internalName }
    }

    override fun getPackagePartData(partInternalName: String): JvmPackagePartProto? {
@@ -234,8 +253,9 @@ open class IncrementalJvmCache(
    }

    override fun getStableMultifileFacadeParts(facadeInternalName: String): Collection<String>? {
-        val partNames = multifileFacadeToParts.get(facadeInternalName) ?: return null
-        return partNames.filter { !dirtyOutputClassesMap.isDirty(it) }
+        val jvmClassName = JvmClassName.byInternalName(facadeInternalName)
+        val partNames = multifileFacadeToParts[jvmClassName] ?: return null
+        return partNames.filter { !dirtyOutputClassesMap.isDirty(JvmClassName.byInternalName(it)) }
    }

    override fun getModuleMappingData(): ByteArray? {
@@ -287,7 +307,9 @@ open class IncrementalJvmCache(
        fun remove(className: JvmClassName, changesCollector: ChangesCollector) {
            val key = className.internalName
            val oldValue = storage[key] ?: return
-            changesCollector.collectProtoChanges(oldData = oldValue.toProtoData(className.packageFqName), newData = null)
+            if (key != MODULE_MAPPING_FILE_NAME) {
+                changesCollector.collectProtoChanges(oldData = oldValue.toProtoData(className.packageFqName), newData = null)
+            }
            storage.remove(key)
        }

@@ -296,6 +318,36 @@ open class IncrementalJvmCache(
        }
    }

+    private inner class JavaSourcesProtoMap(storageFile: File) : BasicStringMap<SerializedJavaClass>(storageFile, JavaClassProtoMapValueExternalizer) {
+        fun process(jvmClassName: JvmClassName, newData: SerializedJavaClass, changesCollector: ChangesCollector) {
+            val key = jvmClassName.internalName
+            val oldData = storage[key]
+            storage[key] = newData
+
+            changesCollector.collectProtoChanges(
+                    oldData?.toProtoData(), newData.toProtoData(),
+                    collectAllMembersForNewClass = true
+            )
+        }
+
+        fun remove(className: JvmClassName, changesCollector: ChangesCollector) {
+            val key = className.internalName
+            val oldValue = storage[key] ?: return
+            storage.remove(key)
+
+            changesCollector.collectProtoChanges(oldValue.toProtoData(), newData = null)
+        }
+
+        operator fun get(className: JvmClassName): SerializedJavaClass? =
+                storage[className.internalName]
+
+        operator fun contains(className: JvmClassName): Boolean =
+                className.internalName in storage
+
+        override fun dumpValue(value: SerializedJavaClass): String =
+                java.lang.Long.toHexString(value.proto.toByteArray().md5())
+    }
+
    // todo: reuse code with InlineFunctionsMap?
    private inner class ConstantsMap(storageFile: File) : BasicStringMap<Map<String, Any>>(storageFile, ConstantsMapExternalizer) {
        private fun getConstantsMap(bytes: ByteArray): Map<String, Any> {
@@ -358,13 +410,15 @@ open class IncrementalJvmCache(
    }

    private inner class MultifileClassFacadeMap(storageFile: File) : BasicStringMap<Collection<String>>(storageFile, StringCollectionExternalizer) {
-        operator fun set(facadeName: JvmClassName, partNames: Collection<String>) {
-            storage[facadeName.internalName] = partNames
+        operator fun set(className: JvmClassName, partNames: Collection<String>) {
+            storage[className.internalName] = partNames
        }

-        operator fun get(internalName: String): Collection<String>? = storage[internalName]
+        operator fun get(className: JvmClassName): Collection<String>? =
+                storage[className.internalName]

-        operator fun contains(internalName: String): Boolean = internalName in storage
+        operator fun contains(className: JvmClassName): Boolean =
+                className.internalName in storage

        fun remove(className: JvmClassName) {
            storage.remove(className.internalName)
@@ -378,9 +432,8 @@ open class IncrementalJvmCache(
            storage[partName] = facadeName
        }

-        fun get(partName: String): String? {
-            return storage.get(partName)
-        }
+        fun get(partName: JvmClassName): String? =
+                storage[partName.internalName]

        fun remove(className: JvmClassName) {
            storage.remove(className.internalName)
@@ -389,25 +442,6 @@ open class IncrementalJvmCache(
        override fun dumpValue(value: String): String = value
    }

-    inner class SourceToClassesMap(storageFile: File) : BasicStringMap<Collection<String>>(storageFile, PathStringDescriptor, StringCollectionExternalizer) {
-        fun clearOutputsForSource(sourceFile: File) {
-            remove(sourceFile.absolutePath)
-        }
-
-        fun add(sourceFile: File, className: JvmClassName) {
-            storage.append(sourceFile.absolutePath, className.internalName)
-        }
-
-        operator fun get(sourceFile: File): Collection<JvmClassName> =
-                storage[sourceFile.absolutePath].orEmpty().map { JvmClassName.byInternalName(it) }
-
-        override fun dumpValue(value: Collection<String>) = value.dumpCollection()
-
-        private fun remove(path: String) {
-            storage.remove(path)
-        }
-    }
-
    inner class InternalNameToSourcesMap(storageFile: File) : BasicStringMap<Collection<String>>(storageFile, EnumeratorStringDescriptor(), PathCollectionExternalizer) {
        operator fun set(internalName: String, sourceFiles: Iterable<File>) {
            storage[internalName] = sourceFiles.map { it.canonicalPath }
@@ -429,24 +463,6 @@ open class IncrementalJvmCache(
        addToClassStorage(proto, nameResolver, srcFile)
    }

-    private inner class DirtyOutputClassesMap(storageFile: File) : BasicStringMap<Boolean>(storageFile, BooleanDataDescriptor.INSTANCE) {
-        fun markDirty(className: String) {
-            storage[className] = true
-        }
-
-        fun notDirty(className: String) {
-            storage.remove(className)
-        }
-
-        fun getDirtyOutputClasses(): Collection<String> =
-                storage.keys
-
-        fun isDirty(className: String): Boolean =
-                storage.contains(className)
-
-        override fun dumpValue(value: Boolean) = ""
-    }
-
    private inner class InlineFunctionsMap(storageFile: File) : BasicStringMap<Map<String, Long>>(storageFile, StringToLongMapExternalizer) {
        private fun getInlineFunctionsMap(header: KotlinClassHeader, bytes: ByteArray): Map<String, Long> {
            val inlineFunctions = inlineFunctionsJvmNames(header)
--- a/build-common/src/org/jetbrains/kotlin/incremental/JavaClassesSerializerExtension.kt
+++ b/build-common/src/org/jetbrains/kotlin/incremental/JavaClassesSerializerExtension.kt
@@ -0,0 +1,81 @@
+/*
+ * 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.incremental
+
+import org.jetbrains.kotlin.builtins.BuiltInSerializerProtocol
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.load.java.JavaVisibilities
+import org.jetbrains.kotlin.metadata.ProtoBuf
+import org.jetbrains.kotlin.metadata.java.JavaClassProtoBuf
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
+import org.jetbrains.kotlin.serialization.DescriptorSerializer
+import org.jetbrains.kotlin.serialization.KotlinSerializerExtensionBase
+
+// It uses BuiltInSerializerProtocol for annotations serialization
+class JavaClassesSerializerExtension : KotlinSerializerExtensionBase(BuiltInSerializerProtocol) {
+    override fun serializeClass(descriptor: ClassDescriptor, proto: ProtoBuf.Class.Builder) {
+        super.serializeClass(descriptor, proto)
+        if (descriptor.visibility == JavaVisibilities.PACKAGE_VISIBILITY) {
+            proto.setExtension(JavaClassProtoBuf.isPackagePrivateClass, true)
+        }
+    }
+
+    override fun serializeConstructor(descriptor: ConstructorDescriptor, proto: ProtoBuf.Constructor.Builder) {
+        super.serializeConstructor(descriptor, proto)
+        if (descriptor.visibility == JavaVisibilities.PACKAGE_VISIBILITY) {
+            proto.setExtension(JavaClassProtoBuf.isPackagePrivateConstructor, true)
+        }
+    }
+
+    override fun serializeFunction(descriptor: FunctionDescriptor, proto: ProtoBuf.Function.Builder) {
+        super.serializeFunction(descriptor, proto)
+        if (descriptor.visibility == JavaVisibilities.PACKAGE_VISIBILITY) {
+            proto.setExtension(JavaClassProtoBuf.isPackagePrivateMethod, true)
+        }
+
+        if (descriptor.dispatchReceiverParameter == null) {
+            proto.setExtension(JavaClassProtoBuf.isStaticMethod, true)
+        }
+    }
+
+    override fun serializeProperty(descriptor: PropertyDescriptor, proto: ProtoBuf.Property.Builder) {
+        super.serializeProperty(descriptor, proto)
+        if (descriptor.visibility == JavaVisibilities.PACKAGE_VISIBILITY) {
+            proto.setExtension(JavaClassProtoBuf.isPackagePrivateField, true)
+        }
+
+        if (descriptor.dispatchReceiverParameter == null) {
+            proto.setExtension(JavaClassProtoBuf.isStaticField, true)
+        }
+    }
+
+    override fun shouldUseNormalizedVisibility() = true
+
+    override val customClassMembersProducer =
+            object : ClassMembersProducer {
+                override fun getCallableMembers(classDescriptor: ClassDescriptor) =
+                        arrayListOf<CallableMemberDescriptor>().apply {
+                            addAll(classDescriptor.unsubstitutedMemberScope.getSortedCallableDescriptors())
+                            addAll(classDescriptor.staticScope.getSortedCallableDescriptors())
+                        }
+            }
+
+    private fun MemberScope.getSortedCallableDescriptors(): Collection<CallableMemberDescriptor> =
+            DescriptorUtils.getAllDescriptors(this).filterIsInstance<CallableMemberDescriptor>()
+                    .let { DescriptorSerializer.sort(it) }
+}
--- a/build-common/src/org/jetbrains/kotlin/incremental/JavaClassesTrackerImpl.kt
+++ b/build-common/src/org/jetbrains/kotlin/incremental/JavaClassesTrackerImpl.kt
@@ -0,0 +1,153 @@
+/*
+ * 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.incremental
+
+import com.intellij.psi.PsiJavaFile
+import com.intellij.util.io.DataExternalizer
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies
+import org.jetbrains.kotlin.load.java.JavaClassesTracker
+import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
+import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaClassDescriptor
+import org.jetbrains.kotlin.metadata.ProtoBuf
+import org.jetbrains.kotlin.metadata.builtins.BuiltInsProtoBuf
+import org.jetbrains.kotlin.metadata.deserialization.NameResolverImpl
+import org.jetbrains.kotlin.metadata.java.JavaClassProtoBuf
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.protobuf.ExtensionRegistryLite
+import org.jetbrains.kotlin.resolve.descriptorUtil.classId
+import org.jetbrains.kotlin.resolve.source.PsiSourceElement
+import org.jetbrains.kotlin.serialization.DescriptorSerializer
+import org.jetbrains.kotlin.serialization.deserialization.getClassId
+import org.jetbrains.kotlin.util.PerformanceCounter
+import org.jetbrains.kotlin.utils.addToStdlib.safeAs
+import org.jetbrains.kotlin.utils.sure
+import java.io.DataInput
+import java.io.DataOutput
+import java.io.File
+
+val CONVERTING_JAVA_CLASSES_TO_PROTO = PerformanceCounter.create("Converting Java sources to proto")
+
+class JavaClassesTrackerImpl(
+        private val cache: IncrementalJvmCache,
+        private val untrackedJavaClasses: Set<ClassId>
+) : JavaClassesTracker {
+    private val classToSourceSerialized: MutableMap<ClassId, SerializedJavaClassWithSource> = hashMapOf()
+
+    val javaClassesUpdates: Collection<SerializedJavaClassWithSource>
+        get() = classToSourceSerialized.values
+
+    private val classDescriptors: MutableList<JavaClassDescriptor> = mutableListOf()
+
+    override fun reportClass(classDescriptor: JavaClassDescriptor) {
+        val classId = classDescriptor.classId!!
+        if (!cache.isJavaClassToTrack(classId) || classDescriptor.javaSourceFile == null) return
+
+        classDescriptors.add(classDescriptor)
+    }
+
+    override fun onCompletedAnalysis(module: ModuleDescriptor) {
+        for (classId in cache.getObsoleteJavaClasses() + untrackedJavaClasses) {
+            // Just force the loading obsolete classes
+            // We assume here that whenever an LazyJavaClassDescriptor instances is created
+            // it's being passed to JavaClassesTracker::reportClass
+            module.findClassAcrossModuleDependencies(classId)
+        }
+
+        for (classDescriptor in classDescriptors.toList()) {
+            val classId = classDescriptor.classId!!
+            if (cache.isJavaClassAlreadyInCache(classId) || classId in untrackedJavaClasses || classDescriptor.wasContentRequested()) {
+                assert(classId !in classToSourceSerialized) {
+                    "Duplicated JavaClassDescriptor $classId reported to IC"
+                }
+                classToSourceSerialized[classId] = CONVERTING_JAVA_CLASSES_TO_PROTO.time {
+                    classDescriptor.convertToProto()
+                }
+            }
+        }
+    }
+
+    private fun JavaClassDescriptor.wasContentRequested() =
+            this.safeAs<LazyJavaClassDescriptor>()?.wasScopeContentRequested() != false
+}
+
+private val JavaClassDescriptor.javaSourceFile: File?
+    get() = source.safeAs<PsiSourceElement>()
+            ?.psi?.containingFile?.takeIf { it is PsiJavaFile }
+            ?.virtualFile?.path?.let(::File)
+
+fun JavaClassDescriptor.convertToProto(): SerializedJavaClassWithSource {
+    val file = javaSourceFile.sure { "convertToProto should only be called for source based classes" }
+
+    val extension = JavaClassesSerializerExtension()
+    val serializer = DescriptorSerializer.createTopLevel(extension)
+    val classProto = serializer.classProto(this).build()
+
+    val (stringTable, qualifiedNameTable) = extension.stringTable.buildProto()
+
+    return SerializedJavaClassWithSource(file, SerializedJavaClass(classProto, stringTable, qualifiedNameTable))
+}
+
+class SerializedJavaClass(
+        val proto: ProtoBuf.Class,
+        val stringTable: ProtoBuf.StringTable,
+        val qualifiedNameTable: ProtoBuf.QualifiedNameTable
+) {
+    val classId: ClassId
+        get() = NameResolverImpl(stringTable, qualifiedNameTable).getClassId(proto.fqName)
+}
+
+data class SerializedJavaClassWithSource(
+        val source: File,
+        val proto: SerializedJavaClass
+)
+
+fun SerializedJavaClass.toProtoData() = ClassProtoData(proto, NameResolverImpl(stringTable, qualifiedNameTable))
+
+val JAVA_CLASS_PROTOBUF_REGISTRY =
+        ExtensionRegistryLite.newInstance()
+                .also(JavaClassProtoBuf::registerAllExtensions)
+                // Built-ins extensions are used for annotations' serialization
+                .also(BuiltInsProtoBuf::registerAllExtensions)
+
+object JavaClassProtoMapValueExternalizer : DataExternalizer<SerializedJavaClass> {
+    override fun save(output: DataOutput, value: SerializedJavaClass) {
+        output.writeBytesWithSize(value.proto.toByteArray())
+        output.writeBytesWithSize(value.stringTable.toByteArray())
+        output.writeBytesWithSize(value.qualifiedNameTable.toByteArray())
+    }
+
+    private fun DataOutput.writeBytesWithSize(bytes: ByteArray) {
+        writeInt(bytes.size)
+        write(bytes)
+    }
+
+    private fun DataInput.readBytesWithSize(): ByteArray {
+        val bytesLength = readInt()
+        return ByteArray(bytesLength).also {
+            readFully(it, 0, bytesLength)
+        }
+    }
+
+    override fun read(input: DataInput): SerializedJavaClass {
+        val proto = ProtoBuf.Class.parseFrom(input.readBytesWithSize(), JAVA_CLASS_PROTOBUF_REGISTRY)
+        val stringTable = ProtoBuf.StringTable.parseFrom(input.readBytesWithSize(), JAVA_CLASS_PROTOBUF_REGISTRY)
+        val qualifiedNameTable = ProtoBuf.QualifiedNameTable.parseFrom(input.readBytesWithSize(), JAVA_CLASS_PROTOBUF_REGISTRY)
+
+        return SerializedJavaClass(proto, stringTable, qualifiedNameTable)
+    }
+}
--- a/build-common/src/org/jetbrains/kotlin/incremental/LookupStorage.kt
+++ b/build-common/src/org/jetbrains/kotlin/incremental/LookupStorage.kt
@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.incremental.storage.*
 import org.jetbrains.kotlin.utils.Printer
 import org.jetbrains.kotlin.utils.keysToMap
 import java.io.File
+import java.io.IOException
 import java.util.*


@@ -47,11 +48,16 @@ open class LookupStorage(targetDataDir: File) : BasicMapsOwner(targetDataDir) {
    private var deletedCount: Int = 0

    init {
-        if (countersFile.exists()) {
-            val lines = countersFile.readLines()
-            size = lines[0].toInt()
-            deletedCount = lines[1].toInt()
+        try {
+            if (countersFile.exists()) {
+                val lines = countersFile.readLines()
+                size = lines[0].toInt()
+                deletedCount = lines[1].toInt()
+            }
+        } catch (e: Exception) {
+            throw IOException("Could not read $countersFile", e)
        }
+
    }

    @Synchronized
--- a/build-common/src/org/jetbrains/kotlin/incremental/ProtoCompareGenerated.kt
+++ b/build-common/src/org/jetbrains/kotlin/incremental/ProtoCompareGenerated.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2017 JetBrains s.r.o.
+ * Copyright 2010-2018 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.
@@ -16,12 +16,15 @@

 package org.jetbrains.kotlin.incremental

+import org.jetbrains.kotlin.metadata.ProtoBuf
+import org.jetbrains.kotlin.metadata.builtins.BuiltInsProtoBuf
+import org.jetbrains.kotlin.metadata.deserialization.NameResolver
+import org.jetbrains.kotlin.metadata.java.JavaClassProtoBuf
+import org.jetbrains.kotlin.metadata.js.JsProtoBuf
+import org.jetbrains.kotlin.metadata.jvm.JvmProtoBuf
+import org.jetbrains.kotlin.metadata.serialization.Interner
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.serialization.ProtoBuf
-import org.jetbrains.kotlin.serialization.deserialization.NameResolver
-import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf
-import org.jetbrains.kotlin.serialization.js.JsProtoBuf
-import org.jetbrains.kotlin.utils.Interner
+import org.jetbrains.kotlin.serialization.deserialization.getClassId
 import java.util.*

 /** This file is generated by org.jetbrains.kotlin.generators.protobuf.GenerateProtoBufCompare. DO NOT MODIFY MANUALLY */
@@ -71,6 +74,11 @@ open class ProtoCompareGenerated(val oldNameResolver: NameResolver, val newNameR
            if (old.getExtension(JsProtoBuf.packageFqName) != new.getExtension(JsProtoBuf.packageFqName)) return false
        }

+        if (old.hasExtension(BuiltInsProtoBuf.packageFqName) != new.hasExtension(BuiltInsProtoBuf.packageFqName)) return false
+        if (old.hasExtension(BuiltInsProtoBuf.packageFqName)) {
+            if (old.getExtension(BuiltInsProtoBuf.packageFqName) != new.getExtension(BuiltInsProtoBuf.packageFqName)) return false
+        }
+
        return true
    }
    enum class ProtoBufPackageKind {
@@ -81,7 +89,8 @@ open class ProtoCompareGenerated(val oldNameResolver: NameResolver, val newNameR
        VERSION_REQUIREMENT_TABLE,
        JVM_EXT_PACKAGE_MODULE_NAME,
        JVM_EXT_PACKAGE_LOCAL_VARIABLE_LIST,
-        JS_EXT_PACKAGE_FQ_NAME
+        JS_EXT_PACKAGE_FQ_NAME,
+        BUILT_INS_EXT_PACKAGE_FQ_NAME
    }

    fun difference(old: ProtoBuf.Package, new: ProtoBuf.Package): EnumSet<ProtoBufPackageKind> {
@@ -122,6 +131,11 @@ open class ProtoCompareGenerated(val oldNameResolver: NameResolver, val newNameR
            if (old.getExtension(JsProtoBuf.packageFqName) != new.getExtension(JsProtoBuf.packageFqName)) result.add(ProtoBufPackageKind.JS_EXT_PACKAGE_FQ_NAME)
        }

+        if (old.hasExtension(BuiltInsProtoBuf.packageFqName) != new.hasExtension(BuiltInsProtoBuf.packageFqName)) result.add(ProtoBufPackageKind.BUILT_INS_EXT_PACKAGE_FQ_NAME)
+        if (old.hasExtension(BuiltInsProtoBuf.packageFqName)) {
+            if (old.getExtension(BuiltInsProtoBuf.packageFqName) != new.getExtension(BuiltInsProtoBuf.packageFqName)) result.add(ProtoBufPackageKind.BUILT_INS_EXT_PACKAGE_FQ_NAME)
+        }
+
        return result
    }

@@ -187,6 +201,11 @@ open class ProtoCompareGenerated(val oldNameResolver: NameResolver, val newNameR
            }
        }

+        if (old.hasExtension(JvmProtoBuf.anonymousObjectOriginName) != new.hasExtension(JvmProtoBuf.anonymousObjectOriginName)) return false
+        if (old.hasExtension(JvmProtoBuf.anonymousObjectOriginName)) {
+            if (!checkStringEquals(old.getExtension(JvmProtoBuf.anonymousObjectOriginName), new.getExtension(JvmProtoBuf.anonymousObjectOriginName))) return false
+        }
+
        if (old.getExtensionCount(JsProtoBuf.classAnnotation) != new.getExtensionCount(JsProtoBuf.classAnnotation)) {
            return false
        }
@@ -201,6 +220,20 @@ open class ProtoCompareGenerated(val oldNameResolver: NameResolver, val newNameR
            if (old.getExtension(JsProtoBuf.classContainingFileId) != new.getExtension(JsProtoBuf.classContainingFileId)) return false
        }

+        if (old.hasExtension(JavaClassProtoBuf.isPackagePrivateClass) != new.hasExtension(JavaClassProtoBuf.isPackagePrivateClass)) return false
+        if (old.hasExtension(JavaClassProtoBuf.isPackagePrivateClass)) {
+            if (old.getExtension(JavaClassProtoBuf.isPackagePrivateClass) != new.getExtension(JavaClassProtoBuf.isPackagePrivateClass)) return false
+        }
+
+        if (old.getExtensionCount(BuiltInsProtoBuf.classAnnotation) != new.getExtensionCount(BuiltInsProtoBuf.classAnnotation)) {
+            return false
+        }
+        else {
+            for(i in 0..old.getExtensionCount(BuiltInsProtoBuf.classAnnotation) - 1) {
+                if (!checkEquals(old.getExtension(BuiltInsProtoBuf.classAnnotation, i), new.getExtension(BuiltInsProtoBuf.classAnnotation, i))) return false
+            }
+        }
+
        return true
    }
    enum class ProtoBufClassKind {
@@ -222,8 +255,11 @@ open class ProtoCompareGenerated(val oldNameResolver: NameResolver, val newNameR
        VERSION_REQUIREMENT_TABLE,
        JVM_EXT_CLASS_MODULE_NAME,
        JVM_EXT_CLASS_LOCAL_VARIABLE_LIST,
+        JVM_EXT_ANONYMOUS_OBJECT_ORIGIN_NAME,
        JS_EXT_CLASS_ANNOTATION_LIST,
-        JS_EXT_CLASS_CONTAINING_FILE_ID
+        JS_EXT_CLASS_CONTAINING_FILE_ID,
+        JAVA_EXT_IS_PACKAGE_PRIVATE_CLASS,
+        BUILT_INS_EXT_CLASS_ANNOTATION_LIST
    }

    fun difference(old: ProtoBuf.Class, new: ProtoBuf.Class): EnumSet<ProtoBufClassKind> {
@@ -290,6 +326,11 @@ open class ProtoCompareGenerated(val oldNameResolver: NameResolver, val newNameR
            }
        }

+        if (old.hasExtension(JvmProtoBuf.anonymousObjectOriginName) != new.hasExtension(JvmProtoBuf.anonymousObjectOriginName)) result.add(ProtoBufClassKind.JVM_EXT_ANONYMOUS_OBJECT_ORIGIN_NAME)
+        if (old.hasExtension(JvmProtoBuf.anonymousObjectOriginName)) {
+            if (!checkStringEquals(old.getExtension(JvmProtoBuf.anonymousObjectOriginName), new.getExtension(JvmProtoBuf.anonymousObjectOriginName))) result.add(ProtoBufClassKind.JVM_EXT_ANONYMOUS_OBJECT_ORIGIN_NAME)
+        }
+
        if (old.getExtensionCount(JsProtoBuf.classAnnotation) != new.getExtensionCount(JsProtoBuf.classAnnotation)) {
            result.add(ProtoBufClassKind.JS_EXT_CLASS_ANNOTATION_LIST)
        }
@@ -304,6 +345,20 @@ open class ProtoCompareGenerated(val oldNameResolver: NameResolver, val newNameR
            if (old.getExtension(JsProtoBuf.classContainingFileId) != new.getExtension(JsProtoBuf.classContainingFileId)) result.add(ProtoBufClassKind.JS_EXT_CLASS_CONTAINING_FILE_ID)
        }

+        if (old.hasExtension(JavaClassProtoBuf.isPackagePrivateClass) != new.hasExtension(JavaClassProtoBuf.isPackagePrivateClass)) result.add(ProtoBufClassKind.JAVA_EXT_IS_PACKAGE_PRIVATE_CLASS)
+        if (old.hasExtension(JavaClassProtoBuf.isPackagePrivateClass)) {
+            if (old.getExtension(JavaClassProtoBuf.isPackagePrivateClass) != new.getExtension(JavaClassProtoBuf.isPackagePrivateClass)) result.add(ProtoBufClassKind.JAVA_EXT_IS_PACKAGE_PRIVATE_CLASS)
+        }
+
+        if (old.getExtensionCount(BuiltInsProtoBuf.classAnnotation) != new.getExtensionCount(BuiltInsProtoBuf.classAnnotation)) {
+            result.add(ProtoBufClassKind.BUILT_INS_EXT_CLASS_ANNOTATION_LIST)
+        }
+        else {
+            for(i in 0..old.getExtensionCount(BuiltInsProtoBuf.classAnnotation) - 1) {
+                if (!checkEquals(old.getExtension(BuiltInsProtoBuf.classAnnotation, i), new.getExtension(BuiltInsProtoBuf.classAnnotation, i))) result.add(ProtoBufClassKind.BUILT_INS_EXT_CLASS_ANNOTATION_LIST)
+            }
+        }
+
        return result
    }

@@ -364,6 +419,11 @@ open class ProtoCompareGenerated(val oldNameResolver: NameResolver, val newNameR
            if (!checkEquals(old.getExtension(JvmProtoBuf.methodSignature), new.getExtension(JvmProtoBuf.methodSignature))) return false
        }

+        if (old.hasExtension(JvmProtoBuf.lambdaClassOriginName) != new.hasExtension(JvmProtoBuf.lambdaClassOriginName)) return false
+        if (old.hasExtension(JvmProtoBuf.lambdaClassOriginName)) {
+            if (!checkStringEquals(old.getExtension(JvmProtoBuf.lambdaClassOriginName), new.getExtension(JvmProtoBuf.lambdaClassOriginName))) return false
+        }
+
        if (old.getExtensionCount(JsProtoBuf.functionAnnotation) != new.getExtensionCount(JsProtoBuf.functionAnnotation)) {
            return false
        }
@@ -378,6 +438,25 @@ open class ProtoCompareGenerated(val oldNameResolver: NameResolver, val newNameR
            if (old.getExtension(JsProtoBuf.functionContainingFileId) != new.getExtension(JsProtoBuf.functionContainingFileId)) return false
        }

+        if (old.hasExtension(JavaClassProtoBuf.isStaticMethod) != new.hasExtension(JavaClassProtoBuf.isStaticMethod)) return false
+        if (old.hasExtension(JavaClassProtoBuf.isStaticMethod)) {
+            if (old.getExtension(JavaClassProtoBuf.isStaticMethod) != new.getExtension(JavaClassProtoBuf.isStaticMethod)) return false
+        }
+
+        if (old.hasExtension(JavaClassProtoBuf.isPackagePrivateMethod) != new.hasExtension(JavaClassProtoBuf.isPackagePrivateMethod)) return false
+        if (old.hasExtension(JavaClassProtoBuf.isPackagePrivateMethod)) {
+            if (old.getExtension(JavaClassProtoBuf.isPackagePrivateMethod) != new.getExtension(JavaClassProtoBuf.isPackagePrivateMethod)) return false
+        }
+
+        if (old.getExtensionCount(BuiltInsProtoBuf.functionAnnotation) != new.getExtensionCount(BuiltInsProtoBuf.functionAnnotation)) {
+            return false
+        }
+        else {
+            for(i in 0..old.getExtensionCount(BuiltInsProtoBuf.functionAnnotation) - 1) {
+                if (!checkEquals(old.getExtension(BuiltInsProtoBuf.functionAnnotation, i), new.getExtension(BuiltInsProtoBuf.functionAnnotation, i))) return false
+            }
+        }
+
        return true
    }

@@ -460,6 +539,30 @@ open class ProtoCompareGenerated(val oldNameResolver: NameResolver, val newNameR
            if (old.getExtension(JsProtoBuf.propertyContainingFileId) != new.getExtension(JsProtoBuf.propertyContainingFileId)) return false
        }

+        if (old.hasExtension(JavaClassProtoBuf.isStaticField) != new.hasExtension(JavaClassProtoBuf.isStaticField)) return false
+        if (old.hasExtension(JavaClassProtoBuf.isStaticField)) {
+            if (old.getExtension(JavaClassProtoBuf.isStaticField) != new.getExtension(JavaClassProtoBuf.isStaticField)) return false
+        }
+
+        if (old.hasExtension(JavaClassProtoBuf.isPackagePrivateField) != new.hasExtension(JavaClassProtoBuf.isPackagePrivateField)) return false
+        if (old.hasExtension(JavaClassProtoBuf.isPackagePrivateField)) {
+            if (old.getExtension(JavaClassProtoBuf.isPackagePrivateField) != new.getExtension(JavaClassProtoBuf.isPackagePrivateField)) return false
+        }
+
+        if (old.getExtensionCount(BuiltInsProtoBuf.propertyAnnotation) != new.getExtensionCount(BuiltInsProtoBuf.propertyAnnotation)) {
+            return false
+        }
+        else {
+            for(i in 0..old.getExtensionCount(BuiltInsProtoBuf.propertyAnnotation) - 1) {
+                if (!checkEquals(old.getExtension(BuiltInsProtoBuf.propertyAnnotation, i), new.getExtension(BuiltInsProtoBuf.propertyAnnotation, i))) return false
+            }
+        }
+
+        if (old.hasExtension(BuiltInsProtoBuf.compileTimeValue) != new.hasExtension(BuiltInsProtoBuf.compileTimeValue)) return false
+        if (old.hasExtension(BuiltInsProtoBuf.compileTimeValue)) {
+            if (!checkEquals(old.getExtension(BuiltInsProtoBuf.compileTimeValue), new.getExtension(BuiltInsProtoBuf.compileTimeValue))) return false
+        }
+
        return true
    }

@@ -557,6 +660,15 @@ open class ProtoCompareGenerated(val oldNameResolver: NameResolver, val newNameR
            }
        }

+        if (old.getExtensionCount(BuiltInsProtoBuf.typeParameterAnnotation) != new.getExtensionCount(BuiltInsProtoBuf.typeParameterAnnotation)) {
+            return false
+        }
+        else {
+            for(i in 0..old.getExtensionCount(BuiltInsProtoBuf.typeParameterAnnotation) - 1) {
+                if (!checkEquals(old.getExtension(BuiltInsProtoBuf.typeParameterAnnotation, i), new.getExtension(BuiltInsProtoBuf.typeParameterAnnotation, i))) return false
+            }
+        }
+
        return true
    }

@@ -651,6 +763,15 @@ open class ProtoCompareGenerated(val oldNameResolver: NameResolver, val newNameR
            }
        }

+        if (old.getExtensionCount(BuiltInsProtoBuf.typeAnnotation) != new.getExtensionCount(BuiltInsProtoBuf.typeAnnotation)) {
+            return false
+        }
+        else {
+            for(i in 0..old.getExtensionCount(BuiltInsProtoBuf.typeAnnotation) - 1) {
+                if (!checkEquals(old.getExtension(BuiltInsProtoBuf.typeAnnotation, i), new.getExtension(BuiltInsProtoBuf.typeAnnotation, i))) return false
+            }
+        }
+
        return true
    }

@@ -681,6 +802,20 @@ open class ProtoCompareGenerated(val oldNameResolver: NameResolver, val newNameR
            }
        }

+        if (old.hasExtension(JavaClassProtoBuf.isPackagePrivateConstructor) != new.hasExtension(JavaClassProtoBuf.isPackagePrivateConstructor)) return false
+        if (old.hasExtension(JavaClassProtoBuf.isPackagePrivateConstructor)) {
+            if (old.getExtension(JavaClassProtoBuf.isPackagePrivateConstructor) != new.getExtension(JavaClassProtoBuf.isPackagePrivateConstructor)) return false
+        }
+
+        if (old.getExtensionCount(BuiltInsProtoBuf.constructorAnnotation) != new.getExtensionCount(BuiltInsProtoBuf.constructorAnnotation)) {
+            return false
+        }
+        else {
+            for(i in 0..old.getExtensionCount(BuiltInsProtoBuf.constructorAnnotation) - 1) {
+                if (!checkEquals(old.getExtension(BuiltInsProtoBuf.constructorAnnotation, i), new.getExtension(BuiltInsProtoBuf.constructorAnnotation, i))) return false
+            }
+        }
+
        return true
    }

@@ -699,6 +834,15 @@ open class ProtoCompareGenerated(val oldNameResolver: NameResolver, val newNameR
            }
        }

+        if (old.getExtensionCount(BuiltInsProtoBuf.enumEntryAnnotation) != new.getExtensionCount(BuiltInsProtoBuf.enumEntryAnnotation)) {
+            return false
+        }
+        else {
+            for(i in 0..old.getExtensionCount(BuiltInsProtoBuf.enumEntryAnnotation) - 1) {
+                if (!checkEquals(old.getExtension(BuiltInsProtoBuf.enumEntryAnnotation, i), new.getExtension(BuiltInsProtoBuf.enumEntryAnnotation, i))) return false
+            }
+        }
+
        return true
    }

@@ -747,6 +891,15 @@ open class ProtoCompareGenerated(val oldNameResolver: NameResolver, val newNameR
            }
        }

+        if (old.getExtensionCount(BuiltInsProtoBuf.parameterAnnotation) != new.getExtensionCount(BuiltInsProtoBuf.parameterAnnotation)) {
+            return false
+        }
+        else {
+            for(i in 0..old.getExtensionCount(BuiltInsProtoBuf.parameterAnnotation) - 1) {
+                if (!checkEquals(old.getExtension(BuiltInsProtoBuf.parameterAnnotation, i), new.getExtension(BuiltInsProtoBuf.parameterAnnotation, i))) return false
+            }
+        }
+
        return true
    }

@@ -1335,6 +1488,10 @@ fun ProtoBuf.Package.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int)
        hashCode = 31 * hashCode + getExtension(JsProtoBuf.packageFqName)
    }

+    if (hasExtension(BuiltInsProtoBuf.packageFqName)) {
+        hashCode = 31 * hashCode + getExtension(BuiltInsProtoBuf.packageFqName)
+    }
+
    return hashCode
 }

@@ -1411,6 +1568,10 @@ fun ProtoBuf.Class.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int) ->
        hashCode = 31 * hashCode + getExtension(JvmProtoBuf.classLocalVariable, i).hashCode(stringIndexes, fqNameIndexes)
    }

+    if (hasExtension(JvmProtoBuf.anonymousObjectOriginName)) {
+        hashCode = 31 * hashCode + stringIndexes(getExtension(JvmProtoBuf.anonymousObjectOriginName))
+    }
+
    for(i in 0..getExtensionCount(JsProtoBuf.classAnnotation) - 1) {
        hashCode = 31 * hashCode + getExtension(JsProtoBuf.classAnnotation, i).hashCode(stringIndexes, fqNameIndexes)
    }
@@ -1419,6 +1580,14 @@ fun ProtoBuf.Class.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int) ->
        hashCode = 31 * hashCode + getExtension(JsProtoBuf.classContainingFileId)
    }

+    if (hasExtension(JavaClassProtoBuf.isPackagePrivateClass)) {
+        hashCode = 31 * hashCode + getExtension(JavaClassProtoBuf.isPackagePrivateClass).hashCode()
+    }
+
+    for(i in 0..getExtensionCount(BuiltInsProtoBuf.classAnnotation) - 1) {
+        hashCode = 31 * hashCode + getExtension(BuiltInsProtoBuf.classAnnotation, i).hashCode(stringIndexes, fqNameIndexes)
+    }
+
    return hashCode
 }

@@ -1475,6 +1644,10 @@ fun ProtoBuf.Function.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int)
        hashCode = 31 * hashCode + getExtension(JvmProtoBuf.methodSignature).hashCode(stringIndexes, fqNameIndexes)
    }

+    if (hasExtension(JvmProtoBuf.lambdaClassOriginName)) {
+        hashCode = 31 * hashCode + stringIndexes(getExtension(JvmProtoBuf.lambdaClassOriginName))
+    }
+
    for(i in 0..getExtensionCount(JsProtoBuf.functionAnnotation) - 1) {
        hashCode = 31 * hashCode + getExtension(JsProtoBuf.functionAnnotation, i).hashCode(stringIndexes, fqNameIndexes)
    }
@@ -1483,6 +1656,18 @@ fun ProtoBuf.Function.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int)
        hashCode = 31 * hashCode + getExtension(JsProtoBuf.functionContainingFileId)
    }

+    if (hasExtension(JavaClassProtoBuf.isStaticMethod)) {
+        hashCode = 31 * hashCode + getExtension(JavaClassProtoBuf.isStaticMethod).hashCode()
+    }
+
+    if (hasExtension(JavaClassProtoBuf.isPackagePrivateMethod)) {
+        hashCode = 31 * hashCode + getExtension(JavaClassProtoBuf.isPackagePrivateMethod).hashCode()
+    }
+
+    for(i in 0..getExtensionCount(BuiltInsProtoBuf.functionAnnotation) - 1) {
+        hashCode = 31 * hashCode + getExtension(BuiltInsProtoBuf.functionAnnotation, i).hashCode(stringIndexes, fqNameIndexes)
+    }
+
    return hashCode
 }

@@ -1551,6 +1736,22 @@ fun ProtoBuf.Property.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int)
        hashCode = 31 * hashCode + getExtension(JsProtoBuf.propertyContainingFileId)
    }

+    if (hasExtension(JavaClassProtoBuf.isStaticField)) {
+        hashCode = 31 * hashCode + getExtension(JavaClassProtoBuf.isStaticField).hashCode()
+    }
+
+    if (hasExtension(JavaClassProtoBuf.isPackagePrivateField)) {
+        hashCode = 31 * hashCode + getExtension(JavaClassProtoBuf.isPackagePrivateField).hashCode()
+    }
+
+    for(i in 0..getExtensionCount(BuiltInsProtoBuf.propertyAnnotation) - 1) {
+        hashCode = 31 * hashCode + getExtension(BuiltInsProtoBuf.propertyAnnotation, i).hashCode(stringIndexes, fqNameIndexes)
+    }
+
+    if (hasExtension(BuiltInsProtoBuf.compileTimeValue)) {
+        hashCode = 31 * hashCode + getExtension(BuiltInsProtoBuf.compileTimeValue).hashCode(stringIndexes, fqNameIndexes)
+    }
+
    return hashCode
 }

@@ -1649,6 +1850,10 @@ fun ProtoBuf.TypeParameter.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes:
        hashCode = 31 * hashCode + getExtension(JsProtoBuf.typeParameterAnnotation, i).hashCode(stringIndexes, fqNameIndexes)
    }

+    for(i in 0..getExtensionCount(BuiltInsProtoBuf.typeParameterAnnotation) - 1) {
+        hashCode = 31 * hashCode + getExtension(BuiltInsProtoBuf.typeParameterAnnotation, i).hashCode(stringIndexes, fqNameIndexes)
+    }
+
    return hashCode
 }

@@ -1723,6 +1928,10 @@ fun ProtoBuf.Type.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int) ->
        hashCode = 31 * hashCode + getExtension(JsProtoBuf.typeAnnotation, i).hashCode(stringIndexes, fqNameIndexes)
    }

+    for(i in 0..getExtensionCount(BuiltInsProtoBuf.typeAnnotation) - 1) {
+        hashCode = 31 * hashCode + getExtension(BuiltInsProtoBuf.typeAnnotation, i).hashCode(stringIndexes, fqNameIndexes)
+    }
+
    return hashCode
 }

@@ -1749,6 +1958,14 @@ fun ProtoBuf.Constructor.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (I
        hashCode = 31 * hashCode + getExtension(JsProtoBuf.constructorAnnotation, i).hashCode(stringIndexes, fqNameIndexes)
    }

+    if (hasExtension(JavaClassProtoBuf.isPackagePrivateConstructor)) {
+        hashCode = 31 * hashCode + getExtension(JavaClassProtoBuf.isPackagePrivateConstructor).hashCode()
+    }
+
+    for(i in 0..getExtensionCount(BuiltInsProtoBuf.constructorAnnotation) - 1) {
+        hashCode = 31 * hashCode + getExtension(BuiltInsProtoBuf.constructorAnnotation, i).hashCode(stringIndexes, fqNameIndexes)
+    }
+
    return hashCode
 }

@@ -1763,6 +1980,10 @@ fun ProtoBuf.EnumEntry.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int
        hashCode = 31 * hashCode + getExtension(JsProtoBuf.enumEntryAnnotation, i).hashCode(stringIndexes, fqNameIndexes)
    }

+    for(i in 0..getExtensionCount(BuiltInsProtoBuf.enumEntryAnnotation) - 1) {
+        hashCode = 31 * hashCode + getExtension(BuiltInsProtoBuf.enumEntryAnnotation, i).hashCode(stringIndexes, fqNameIndexes)
+    }
+
    return hashCode
 }

@@ -1807,6 +2028,10 @@ fun ProtoBuf.ValueParameter.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes:
        hashCode = 31 * hashCode + getExtension(JsProtoBuf.parameterAnnotation, i).hashCode(stringIndexes, fqNameIndexes)
    }

+    for(i in 0..getExtensionCount(BuiltInsProtoBuf.parameterAnnotation) - 1) {
+        hashCode = 31 * hashCode + getExtension(BuiltInsProtoBuf.parameterAnnotation, i).hashCode(stringIndexes, fqNameIndexes)
+    }
+
    return hashCode
 }

--- a/build-common/src/org/jetbrains/kotlin/incremental/buildUtil.kt
+++ b/build-common/src/org/jetbrains/kotlin/incremental/buildUtil.kt
@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.modules.KotlinModuleXmlBuilder
 import org.jetbrains.kotlin.modules.TargetId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.progress.CompilationCanceledStatus
+import org.jetbrains.kotlin.synthetic.SAM_LOOKUP_NAME
 import java.io.File
 import java.util.*

@@ -46,7 +47,10 @@ fun makeModuleFile(
    builder.addModule(
            name,
            outputDir.absolutePath,
-            sourcesToCompile,
+            // important to transform file to absolute paths,
+            // otherwise compiler will use module file's parent as base path (a temporary file; see below)
+            // (see org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler.getAbsolutePaths)
+            sourcesToCompile.map { it.absoluteFile },
            javaSourceRoots,
            classpath,
            null,
@@ -79,7 +83,8 @@ fun makeCompileServices(
 fun updateIncrementalCache(
        generatedFiles: Iterable<GeneratedFile>,
        cache: IncrementalJvmCache,
-        changesCollector: ChangesCollector
+        changesCollector: ChangesCollector,
+        javaChangesTracker: JavaClassesTrackerImpl?
 ) {
    for (generatedFile in generatedFiles) {
        when {
@@ -88,6 +93,11 @@ fun updateIncrementalCache(
        }
    }

+    javaChangesTracker?.javaClassesUpdates?.forEach {
+        (source, serializedJavaClass) ->
+        cache.saveJavaClassProto(source, serializedJavaClass, changesCollector)
+    }
+
    cache.clearCacheForRemovedClasses(changesCollector)
 }

@@ -109,7 +119,7 @@ data class DirtyData(
 )

 fun ChangesCollector.getDirtyData(
-        caches: Iterable<IncrementalCacheCommon>,
+        caches: Iterable<IncrementalCacheCommon<*>>,
        reporter: ICReporter
 ): DirtyData {
    val dirtyLookupSymbols = HashSet<LookupSymbol>()
@@ -135,10 +145,10 @@ fun ChangesCollector.getDirtyData(
            dirtyClassesFqNames.addAll(fqNames)

            for (name in change.names) {
-                for (fqName in fqNames) {
-                    dirtyLookupSymbols.add(LookupSymbol(name, fqName.asString()))
-                }
+                fqNames.mapTo(dirtyLookupSymbols) { LookupSymbol(name, it.asString()) }
            }
+
+            fqNames.mapTo(dirtyLookupSymbols) { LookupSymbol(SAM_LOOKUP_NAME.asString(), it.asString()) }
        }
    }

@@ -163,7 +173,7 @@ fun mapLookupSymbolsToFiles(
 }

 fun mapClassesFqNamesToFiles(
-        caches: Iterable<IncrementalCacheCommon>,
+        caches: Iterable<IncrementalCacheCommon<*>>,
        classesFqNames: Iterable<FqName>,
        reporter: ICReporter,
        excludes: Set<File> = emptySet()
@@ -173,7 +183,7 @@ fun mapClassesFqNamesToFiles(
    for (cache in caches) {
        for (dirtyClassFqName in classesFqNames) {
            val srcFile = cache.getSourceFileIfClass(dirtyClassFqName)
-            if (srcFile == null || srcFile in excludes) continue
+            if (srcFile == null || srcFile in excludes || srcFile.isJavaFile()) continue

            reporter.report { ("Class $dirtyClassFqName caused recompilation of: ${reporter.pathsAsString(srcFile)}") }
            dirtyFiles.add(srcFile)
@@ -185,7 +195,7 @@ fun mapClassesFqNamesToFiles(

 fun withSubtypes(
        typeFqName: FqName,
-        caches: Iterable<IncrementalCacheCommon>
+        caches: Iterable<IncrementalCacheCommon<*>>
 ): Set<FqName> {
    val types = LinkedList(listOf(typeFqName))
    val subtypes = hashSetOf<FqName>()
--- a/build-common/src/org/jetbrains/kotlin/incremental/protoDifferenceUtils.kt
+++ b/build-common/src/org/jetbrains/kotlin/incremental/protoDifferenceUtils.kt
@@ -20,13 +20,13 @@ import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.incremental.ProtoCompareGenerated.ProtoBufClassKind
 import org.jetbrains.kotlin.incremental.ProtoCompareGenerated.ProtoBufPackageKind
 import org.jetbrains.kotlin.incremental.storage.ProtoMapValue
+import org.jetbrains.kotlin.metadata.ProtoBuf
+import org.jetbrains.kotlin.metadata.deserialization.Flags
+import org.jetbrains.kotlin.metadata.deserialization.NameResolver
+import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.protobuf.MessageLite
-import org.jetbrains.kotlin.serialization.Flags
-import org.jetbrains.kotlin.serialization.ProtoBuf
-import org.jetbrains.kotlin.serialization.deserialization.Deserialization
-import org.jetbrains.kotlin.serialization.deserialization.NameResolver
-import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil
+import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
 import java.util.*

 data class Difference(
@@ -41,16 +41,15 @@ data class PackagePartProtoData(val proto: ProtoBuf.Package, val nameResolver: N

 fun ProtoMapValue.toProtoData(packageFqName: FqName): ProtoData =
    if (isPackageFacade) {
-        val packageData = JvmProtoBufUtil.readPackageDataFrom(bytes, strings)
-        PackagePartProtoData(packageData.packageProto, packageData.nameResolver, packageFqName)
-    }
-    else {
-        val classData = JvmProtoBufUtil.readClassDataFrom(bytes, strings)
-        ClassProtoData(classData.classProto, classData.nameResolver)
+        val (nameResolver, packageProto) = JvmProtoBufUtil.readPackageDataFrom(bytes, strings)
+        PackagePartProtoData(packageProto, nameResolver, packageFqName)
+    } else {
+        val (nameResolver, classProto) = JvmProtoBufUtil.readClassDataFrom(bytes, strings)
+        ClassProtoData(classProto, nameResolver)
    }

 internal val MessageLite.isPrivate: Boolean
-    get() = Visibilities.isPrivate(Deserialization.visibility(
+    get() = Visibilities.isPrivate(ProtoEnumFlags.visibility(
            when (this) {
                is ProtoBuf.Constructor -> Flags.VISIBILITY.get(flags)
                is ProtoBuf.Function -> Flags.VISIBILITY.get(flags)
@@ -244,6 +243,16 @@ class DifferenceCalculatorForClass(
                ProtoBufClassKind.JVM_EXT_CLASS_LOCAL_VARIABLE_LIST -> {
                    // Not affected, local variables are not accessible outside of a file
                }
+                ProtoBufClassKind.JAVA_EXT_IS_PACKAGE_PRIVATE_CLASS -> {
+                    isClassAffected = true
+                    areSubclassesAffected = true
+                }
+                ProtoBufClassKind.BUILT_INS_EXT_CLASS_ANNOTATION_LIST -> {
+                    isClassAffected = true
+                }
+                ProtoCompareGenerated.ProtoBufClassKind.JVM_EXT_ANONYMOUS_OBJECT_ORIGIN_NAME -> {
+                    // Not affected, this extension is not used in the compiler
+                }
            }
        }

@@ -289,6 +298,9 @@ class DifferenceCalculatorForPackageFacade(
                ProtoBufPackageKind.JVM_EXT_PACKAGE_LOCAL_VARIABLE_LIST -> {
                    // Not affected, local variables are not accessible outside of a file
                }
+                ProtoBufPackageKind.BUILT_INS_EXT_PACKAGE_FQ_NAME -> {
+                    // Not affected
+                }
            }
        }

--- a/build-common/src/org/jetbrains/kotlin/incremental/storage/DirtyClassesMaps.kt
+++ b/build-common/src/org/jetbrains/kotlin/incremental/storage/DirtyClassesMaps.kt
@@ -0,0 +1,46 @@
+/*
+ * 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.incremental.storage
+
+import com.intellij.util.io.BooleanDataDescriptor
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.jvm.JvmClassName
+import java.io.File
+
+internal class DirtyClassesJvmNameMap(storageFile: File) : AbstractDirtyClassesMap<JvmClassName>(JvmClassNameTransformer, storageFile)
+internal class DirtyClassesFqNameMap(storageFile: File) : AbstractDirtyClassesMap<FqName>(FqNameTransformer, storageFile)
+
+internal abstract class AbstractDirtyClassesMap<Name>(
+        private val nameTransformer: NameTransformer<Name>,
+        storageFile: File
+) : BasicStringMap<Boolean>(storageFile, BooleanDataDescriptor.INSTANCE) {
+    fun markDirty(className: Name) {
+        storage[nameTransformer.asString(className)] = true
+    }
+
+    fun notDirty(className: Name) {
+        storage.remove(nameTransformer.asString(className))
+    }
+
+    fun getDirtyOutputClasses(): Collection<Name> =
+            storage.keys.map { nameTransformer.asName(it) }
+
+    fun isDirty(className: Name): Boolean =
+            storage.contains(nameTransformer.asString(className))
+
+    override fun dumpValue(value: Boolean) = ""
+}
--- a/build-common/src/org/jetbrains/kotlin/incremental/storage/NameTransformers.kt
+++ b/build-common/src/org/jetbrains/kotlin/incremental/storage/NameTransformers.kt
@@ -0,0 +1,48 @@
+/*
+ * 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.incremental.storage
+
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.jvm.JvmClassName
+
+internal interface NameTransformer<Name> {
+    fun asString(name: Name): String
+    fun asName(string: String): Name
+    fun asFqName(string: String): FqName
+}
+
+internal object FqNameTransformer : NameTransformer<FqName> {
+    override fun asString(name: FqName): String =
+        name.asString()
+
+    override fun asName(string: String): FqName =
+        FqName(string)
+
+    override fun asFqName(string: String): FqName =
+        asName(string)
+}
+
+internal object JvmClassNameTransformer : NameTransformer<JvmClassName> {
+    override fun asString(name: JvmClassName): String =
+        name.internalName
+
+    override fun asName(string: String): JvmClassName =
+        JvmClassName.byInternalName(string)
+
+    override fun asFqName(string: String): FqName =
+        asName(string).fqNameForClassNameWithoutDollars
+}
--- a/build-common/src/org/jetbrains/kotlin/incremental/storage/SourceToOutputMaps.kt
+++ b/build-common/src/org/jetbrains/kotlin/incremental/storage/SourceToOutputMaps.kt
@@ -0,0 +1,54 @@
+/*
+ * 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.incremental.storage
+
+import org.jetbrains.kotlin.incremental.dumpCollection
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.jvm.JvmClassName
+import java.io.File
+
+internal class SourceToJvmNameMap(storageFile: File) : AbstractSourceToOutputMap<JvmClassName>(JvmClassNameTransformer, storageFile)
+internal class SourceToFqNameMap(storageFile: File) : AbstractSourceToOutputMap<FqName>(FqNameTransformer, storageFile)
+
+internal abstract class AbstractSourceToOutputMap<Name>(
+        private val nameTransformer: NameTransformer<Name>,
+        storageFile: File
+) : BasicStringMap<Collection<String>>(storageFile, PathStringDescriptor, StringCollectionExternalizer) {
+    fun clearOutputsForSource(sourceFile: File) {
+        remove(sourceFile.absolutePath)
+    }
+
+    fun add(sourceFile: File, className: Name) {
+        storage.append(sourceFile.absolutePath, nameTransformer.asString(className))
+    }
+
+    fun contains(sourceFile: File): Boolean =
+            sourceFile.absolutePath in storage
+
+    operator fun get(sourceFile: File): Collection<Name> =
+            storage[sourceFile.absolutePath].orEmpty().map(nameTransformer::asName)
+
+    fun getFqNames(sourceFile: File): Collection<FqName> =
+        storage[sourceFile.absolutePath].orEmpty().map(nameTransformer::asFqName)
+
+    override fun dumpValue(value: Collection<String>) =
+            value.dumpCollection()
+
+    private fun remove(path: String) {
+        storage.remove(path)
+    }
+}
--- a/build-common/src/org/jetbrains/kotlin/metadata/java/JavaClassProtoBuf.java
+++ b/build-common/src/org/jetbrains/kotlin/metadata/java/JavaClassProtoBuf.java
@@ -0,0 +1,118 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: build-common/src/java_descriptors.proto
+
+package org.jetbrains.kotlin.metadata.java;
+
+public final class JavaClassProtoBuf {
+  private JavaClassProtoBuf() {}
+  public static void registerAllExtensions(
+      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite registry) {
+    registry.add(org.jetbrains.kotlin.metadata.java.JavaClassProtoBuf.isStaticMethod);
+    registry.add(org.jetbrains.kotlin.metadata.java.JavaClassProtoBuf.isPackagePrivateMethod);
+    registry.add(org.jetbrains.kotlin.metadata.java.JavaClassProtoBuf.isStaticField);
+    registry.add(org.jetbrains.kotlin.metadata.java.JavaClassProtoBuf.isPackagePrivateField);
+    registry.add(org.jetbrains.kotlin.metadata.java.JavaClassProtoBuf.isPackagePrivateClass);
+    registry.add(org.jetbrains.kotlin.metadata.java.JavaClassProtoBuf.isPackagePrivateConstructor);
+  }
+  public static final int IS_STATIC_METHOD_FIELD_NUMBER = 1000;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Function { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessageLite.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.ProtoBuf.Function,
+      java.lang.Boolean> isStaticMethod = org.jetbrains.kotlin.protobuf.GeneratedMessageLite
+          .newSingularGeneratedExtension(
+        org.jetbrains.kotlin.metadata.ProtoBuf.Function.getDefaultInstance(),
+        false,
+        null,
+        null,
+        1000,
+        org.jetbrains.kotlin.protobuf.WireFormat.FieldType.BOOL,
+        java.lang.Boolean.class);
+  public static final int IS_PACKAGE_PRIVATE_METHOD_FIELD_NUMBER = 1001;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Function { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessageLite.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.ProtoBuf.Function,
+      java.lang.Boolean> isPackagePrivateMethod = org.jetbrains.kotlin.protobuf.GeneratedMessageLite
+          .newSingularGeneratedExtension(
+        org.jetbrains.kotlin.metadata.ProtoBuf.Function.getDefaultInstance(),
+        false,
+        null,
+        null,
+        1001,
+        org.jetbrains.kotlin.protobuf.WireFormat.FieldType.BOOL,
+        java.lang.Boolean.class);
+  public static final int IS_STATIC_FIELD_FIELD_NUMBER = 1000;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Property { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessageLite.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.ProtoBuf.Property,
+      java.lang.Boolean> isStaticField = org.jetbrains.kotlin.protobuf.GeneratedMessageLite
+          .newSingularGeneratedExtension(
+        org.jetbrains.kotlin.metadata.ProtoBuf.Property.getDefaultInstance(),
+        false,
+        null,
+        null,
+        1000,
+        org.jetbrains.kotlin.protobuf.WireFormat.FieldType.BOOL,
+        java.lang.Boolean.class);
+  public static final int IS_PACKAGE_PRIVATE_FIELD_FIELD_NUMBER = 1001;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Property { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessageLite.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.ProtoBuf.Property,
+      java.lang.Boolean> isPackagePrivateField = org.jetbrains.kotlin.protobuf.GeneratedMessageLite
+          .newSingularGeneratedExtension(
+        org.jetbrains.kotlin.metadata.ProtoBuf.Property.getDefaultInstance(),
+        false,
+        null,
+        null,
+        1001,
+        org.jetbrains.kotlin.protobuf.WireFormat.FieldType.BOOL,
+        java.lang.Boolean.class);
+  public static final int IS_PACKAGE_PRIVATE_CLASS_FIELD_NUMBER = 1000;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Class { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessageLite.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.ProtoBuf.Class,
+      java.lang.Boolean> isPackagePrivateClass = org.jetbrains.kotlin.protobuf.GeneratedMessageLite
+          .newSingularGeneratedExtension(
+        org.jetbrains.kotlin.metadata.ProtoBuf.Class.getDefaultInstance(),
+        false,
+        null,
+        null,
+        1000,
+        org.jetbrains.kotlin.protobuf.WireFormat.FieldType.BOOL,
+        java.lang.Boolean.class);
+  public static final int IS_PACKAGE_PRIVATE_CONSTRUCTOR_FIELD_NUMBER = 1000;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Constructor { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessageLite.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.ProtoBuf.Constructor,
+      java.lang.Boolean> isPackagePrivateConstructor = org.jetbrains.kotlin.protobuf.GeneratedMessageLite
+          .newSingularGeneratedExtension(
+        org.jetbrains.kotlin.metadata.ProtoBuf.Constructor.getDefaultInstance(),
+        false,
+        null,
+        null,
+        1000,
+        org.jetbrains.kotlin.protobuf.WireFormat.FieldType.BOOL,
+        java.lang.Boolean.class);
+
+  static {
+  }
+
+  // @@protoc_insertion_point(outer_class_scope)
+}
--- a/build-common/test/org/jetbrains/kotlin/incremental/testingUtils/BuildLogFinder.kt
+++ b/build-common/test/org/jetbrains/kotlin/incremental/testingUtils/BuildLogFinder.kt
@@ -28,6 +28,9 @@ data class BuildLogFinder(
        private const val GRADLE_LOG = "gradle-build.log"
        private const val DATA_CONTAINER_LOG = "data-container-version-build.log"
        private const val SIMPLE_LOG = "build.log"
+
+        fun isJpsLogFile(file: File): Boolean =
+                file.name.let { it == SIMPLE_LOG || it == DATA_CONTAINER_LOG }
    }

    fun findBuildLog(dir: File): File? {
--- a/build-common/test/org/jetbrains/kotlin/incremental/testingUtils/classFilesComparison.kt
+++ b/build-common/test/org/jetbrains/kotlin/incremental/testingUtils/classFilesComparison.kt
@@ -19,10 +19,14 @@ package org.jetbrains.kotlin.incremental.testingUtils
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.incremental.LocalFileKotlinClass
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
+import org.jetbrains.kotlin.metadata.DebugProtoBuf
+import org.jetbrains.kotlin.metadata.js.DebugJsProtoBuf
+import org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf
+import org.jetbrains.kotlin.metadata.jvm.deserialization.BitEncoding
 import org.jetbrains.kotlin.protobuf.ExtensionRegistry
-import org.jetbrains.kotlin.serialization.DebugProtoBuf
-import org.jetbrains.kotlin.serialization.jvm.BitEncoding
-import org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf
+import org.jetbrains.kotlin.serialization.js.JsSerializerProtocol
+import org.jetbrains.kotlin.utils.KotlinJavascriptMetadata
+import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils
 import org.jetbrains.kotlin.utils.Printer
 import org.jetbrains.org.objectweb.asm.ClassReader
 import org.jetbrains.org.objectweb.asm.util.TraceClassVisitor
@@ -34,6 +38,7 @@ import java.io.PrintWriter
 import java.io.StringWriter
 import java.util.*
 import java.util.zip.CRC32
+import java.util.zip.GZIPInputStream
 import kotlin.comparisons.compareBy

 // Set this to true if you want to dump all bytecode (test will fail in this case)
@@ -163,6 +168,24 @@ private fun classFileToString(classFile: File): String {
    return out.toString()
 }

+private fun metaJsToString(metaJsFile: File): String {
+    val out = StringWriter()
+
+    val metadataList = arrayListOf<KotlinJavascriptMetadata>()
+    KotlinJavascriptMetadataUtils.parseMetadata(metaJsFile.readText(), metadataList)
+
+    for (metadata in metadataList) {
+        val (header, content) = GZIPInputStream(ByteArrayInputStream(metadata.body)).use { stream ->
+            DebugJsProtoBuf.Header.parseDelimitedFrom(stream, JsSerializerProtocol.extensionRegistry) to
+                    DebugJsProtoBuf.Library.parseFrom(stream, JsSerializerProtocol.extensionRegistry)
+        }
+        out.write("\n------ header -----\n$header")
+        out.write("\n------ library -----\n$content")
+    }
+
+    return out.toString()
+}
+
 private fun getExtensionRegistry(): ExtensionRegistry {
    val registry = ExtensionRegistry.newInstance()!!
    DebugJvmProtoBuf.registerAllExtensions(registry)
@@ -174,6 +197,9 @@ private fun fileToStringRepresentation(file: File): String {
        file.name.endsWith(".class") -> {
            classFileToString(file)
        }
+        file.name.endsWith(KotlinJavascriptMetadataUtils.META_JS_SUFFIX) -> {
+            metaJsToString(file)
+        }
        else -> {
            file.readText()
        }
--- a/build-common/test/org/jetbrains/kotlin/serialization/DebugExtOptionsProtoBuf.java
+++ b/build-common/test/org/jetbrains/kotlin/serialization/DebugExtOptionsProtoBuf.java
@@ -1,16 +1,16 @@
 // Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: core/deserialization/src/ext_options.debug.proto
+// source: core/metadata/src/ext_options.debug.proto

-package org.jetbrains.kotlin.serialization;
+package org.jetbrains.kotlin.metadata;

 public final class DebugExtOptionsProtoBuf {
  private DebugExtOptionsProtoBuf() {}
  public static void registerAllExtensions(
      org.jetbrains.kotlin.protobuf.ExtensionRegistry registry) {
-    registry.add(org.jetbrains.kotlin.serialization.DebugExtOptionsProtoBuf.skipInComparison);
-    registry.add(org.jetbrains.kotlin.serialization.DebugExtOptionsProtoBuf.nameIdInTable);
-    registry.add(org.jetbrains.kotlin.serialization.DebugExtOptionsProtoBuf.fqNameIdInTable);
-    registry.add(org.jetbrains.kotlin.serialization.DebugExtOptionsProtoBuf.stringIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.skipInComparison);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.nameIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.fqNameIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.stringIdInTable);
  }
  public static final int SKIP_IN_COMPARISON_FIELD_NUMBER = 50000;
  /**
@@ -65,16 +65,16 @@ public final class DebugExtOptionsProtoBuf {
      descriptor;
  static {
    java.lang.String[] descriptorData = {
-      "\n0core/deserialization/src/ext_options.d" +
-      "ebug.proto\022\"org.jetbrains.kotlin.seriali" +
-      "zation\032 google/protobuf/descriptor.proto" +
-      ":;\n\022skip_in_comparison\022\035.google.protobuf" +
-      ".FieldOptions\030\320\206\003 \001(\010:9\n\020name_id_in_tabl" +
-      "e\022\035.google.protobuf.FieldOptions\030\321\206\003 \001(\010" +
-      ":<\n\023fq_name_id_in_table\022\035.google.protobu" +
-      "f.FieldOptions\030\322\206\003 \001(\010:;\n\022string_id_in_t" +
-      "able\022\035.google.protobuf.FieldOptions\030\323\206\003 " +
-      "\001(\010B\031B\027DebugExtOptionsProtoBuf"
+      "\n)core/metadata/src/ext_options.debug.pr" +
+      "oto\022\035org.jetbrains.kotlin.metadata\032 goog" +
+      "le/protobuf/descriptor.proto:;\n\022skip_in_" +
+      "comparison\022\035.google.protobuf.FieldOption" +
+      "s\030\320\206\003 \001(\010:9\n\020name_id_in_table\022\035.google.p" +
+      "rotobuf.FieldOptions\030\321\206\003 \001(\010:<\n\023fq_name_" +
+      "id_in_table\022\035.google.protobuf.FieldOptio" +
+      "ns\030\322\206\003 \001(\010:;\n\022string_id_in_table\022\035.googl" +
+      "e.protobuf.FieldOptions\030\323\206\003 \001(\010B\031B\027Debug" +
+      "ExtOptionsProtoBuf"
    };
    org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
        new org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
--- a/build-common/test/org/jetbrains/kotlin/metadata/DebugProtoBuf.java
+++ b/build-common/test/org/jetbrains/kotlin/metadata/DebugProtoBuf.java
--- a/build-common/test/org/jetbrains/kotlin/metadata/builtins/DebugBuiltInsProtoBuf.java
+++ b/build-common/test/org/jetbrains/kotlin/metadata/builtins/DebugBuiltInsProtoBuf.java
@@ -0,0 +1,200 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: core/metadata/src/builtins.debug.proto
+
+package org.jetbrains.kotlin.metadata.builtins;
+
+public final class DebugBuiltInsProtoBuf {
+  private DebugBuiltInsProtoBuf() {}
+  public static void registerAllExtensions(
+      org.jetbrains.kotlin.protobuf.ExtensionRegistry registry) {
+    registry.add(org.jetbrains.kotlin.metadata.builtins.DebugBuiltInsProtoBuf.packageFqName);
+    registry.add(org.jetbrains.kotlin.metadata.builtins.DebugBuiltInsProtoBuf.classAnnotation);
+    registry.add(org.jetbrains.kotlin.metadata.builtins.DebugBuiltInsProtoBuf.constructorAnnotation);
+    registry.add(org.jetbrains.kotlin.metadata.builtins.DebugBuiltInsProtoBuf.functionAnnotation);
+    registry.add(org.jetbrains.kotlin.metadata.builtins.DebugBuiltInsProtoBuf.propertyAnnotation);
+    registry.add(org.jetbrains.kotlin.metadata.builtins.DebugBuiltInsProtoBuf.compileTimeValue);
+    registry.add(org.jetbrains.kotlin.metadata.builtins.DebugBuiltInsProtoBuf.enumEntryAnnotation);
+    registry.add(org.jetbrains.kotlin.metadata.builtins.DebugBuiltInsProtoBuf.parameterAnnotation);
+    registry.add(org.jetbrains.kotlin.metadata.builtins.DebugBuiltInsProtoBuf.typeAnnotation);
+    registry.add(org.jetbrains.kotlin.metadata.builtins.DebugBuiltInsProtoBuf.typeParameterAnnotation);
+  }
+  public static final int PACKAGE_FQ_NAME_FIELD_NUMBER = 151;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Package { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.Package,
+      java.lang.Integer> packageFqName = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        java.lang.Integer.class,
+        null);
+  public static final int CLASS_ANNOTATION_FIELD_NUMBER = 150;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Class { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.Class,
+      java.util.List<org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation>> classAnnotation = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.class,
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.getDefaultInstance());
+  public static final int CONSTRUCTOR_ANNOTATION_FIELD_NUMBER = 150;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Constructor { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.Constructor,
+      java.util.List<org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation>> constructorAnnotation = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.class,
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.getDefaultInstance());
+  public static final int FUNCTION_ANNOTATION_FIELD_NUMBER = 150;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Function { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.Function,
+      java.util.List<org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation>> functionAnnotation = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.class,
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.getDefaultInstance());
+  public static final int PROPERTY_ANNOTATION_FIELD_NUMBER = 150;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Property { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.Property,
+      java.util.List<org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation>> propertyAnnotation = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.class,
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.getDefaultInstance());
+  public static final int COMPILE_TIME_VALUE_FIELD_NUMBER = 151;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Property { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.Property,
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.Argument.Value> compileTimeValue = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.Argument.Value.class,
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.Argument.Value.getDefaultInstance());
+  public static final int ENUM_ENTRY_ANNOTATION_FIELD_NUMBER = 150;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.EnumEntry { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.EnumEntry,
+      java.util.List<org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation>> enumEntryAnnotation = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.class,
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.getDefaultInstance());
+  public static final int PARAMETER_ANNOTATION_FIELD_NUMBER = 150;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.ValueParameter { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.ValueParameter,
+      java.util.List<org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation>> parameterAnnotation = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.class,
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.getDefaultInstance());
+  public static final int TYPE_ANNOTATION_FIELD_NUMBER = 150;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Type { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.Type,
+      java.util.List<org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation>> typeAnnotation = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.class,
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.getDefaultInstance());
+  public static final int TYPE_PARAMETER_ANNOTATION_FIELD_NUMBER = 150;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.TypeParameter { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.TypeParameter,
+      java.util.List<org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation>> typeParameterAnnotation = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.class,
+        org.jetbrains.kotlin.metadata.DebugProtoBuf.Annotation.getDefaultInstance());
+
+  public static org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor
+      getDescriptor() {
+    return descriptor;
+  }
+  private static org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor
+      descriptor;
+  static {
+    java.lang.String[] descriptorData = {
+      "\n&core/metadata/src/builtins.debug.proto" +
+      "\022&org.jetbrains.kotlin.metadata.builtins" +
+      "\032&core/metadata/src/metadata.debug.proto" +
+      ":@\n\017package_fq_name\022&.org.jetbrains.kotl" +
+      "in.metadata.Package\030\227\001 \001(\005:j\n\020class_anno" +
+      "tation\022$.org.jetbrains.kotlin.metadata.C" +
+      "lass\030\226\001 \003(\0132).org.jetbrains.kotlin.metad" +
+      "ata.Annotation:v\n\026constructor_annotation" +
+      "\022*.org.jetbrains.kotlin.metadata.Constru" +
+      "ctor\030\226\001 \003(\0132).org.jetbrains.kotlin.metad",
+      "ata.Annotation:p\n\023function_annotation\022\'." +
+      "org.jetbrains.kotlin.metadata.Function\030\226" +
+      "\001 \003(\0132).org.jetbrains.kotlin.metadata.An" +
+      "notation:p\n\023property_annotation\022\'.org.je" +
+      "tbrains.kotlin.metadata.Property\030\226\001 \003(\0132" +
+      ").org.jetbrains.kotlin.metadata.Annotati" +
+      "on:~\n\022compile_time_value\022\'.org.jetbrains" +
+      ".kotlin.metadata.Property\030\227\001 \001(\01328.org.j" +
+      "etbrains.kotlin.metadata.Annotation.Argu" +
+      "ment.Value:s\n\025enum_entry_annotation\022(.or",
+      "g.jetbrains.kotlin.metadata.EnumEntry\030\226\001" +
+      " \003(\0132).org.jetbrains.kotlin.metadata.Ann" +
+      "otation:w\n\024parameter_annotation\022-.org.je" +
+      "tbrains.kotlin.metadata.ValueParameter\030\226" +
+      "\001 \003(\0132).org.jetbrains.kotlin.metadata.An" +
+      "notation:h\n\017type_annotation\022#.org.jetbra" +
+      "ins.kotlin.metadata.Type\030\226\001 \003(\0132).org.je" +
+      "tbrains.kotlin.metadata.Annotation:{\n\031ty" +
+      "pe_parameter_annotation\022,.org.jetbrains." +
+      "kotlin.metadata.TypeParameter\030\226\001 \003(\0132).o",
+      "rg.jetbrains.kotlin.metadata.AnnotationB" +
+      "\027B\025DebugBuiltInsProtoBuf"
+    };
+    org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
+        new org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
+          public org.jetbrains.kotlin.protobuf.ExtensionRegistry assignDescriptors(
+              org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor root) {
+            descriptor = root;
+            return null;
+          }
+        };
+    org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor
+      .internalBuildGeneratedFileFrom(descriptorData,
+        new org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor[] {
+          org.jetbrains.kotlin.metadata.DebugProtoBuf.getDescriptor(),
+        }, assigner);
+    packageFqName.internalInit(descriptor.getExtensions().get(0));
+    classAnnotation.internalInit(descriptor.getExtensions().get(1));
+    constructorAnnotation.internalInit(descriptor.getExtensions().get(2));
+    functionAnnotation.internalInit(descriptor.getExtensions().get(3));
+    propertyAnnotation.internalInit(descriptor.getExtensions().get(4));
+    compileTimeValue.internalInit(descriptor.getExtensions().get(5));
+    enumEntryAnnotation.internalInit(descriptor.getExtensions().get(6));
+    parameterAnnotation.internalInit(descriptor.getExtensions().get(7));
+    typeAnnotation.internalInit(descriptor.getExtensions().get(8));
+    typeParameterAnnotation.internalInit(descriptor.getExtensions().get(9));
+    org.jetbrains.kotlin.metadata.DebugProtoBuf.getDescriptor();
+  }
+
+  // @@protoc_insertion_point(outer_class_scope)
+}
--- a/build-common/test/org/jetbrains/kotlin/metadata/java/DebugJavaClassProtoBuf.java
+++ b/build-common/test/org/jetbrains/kotlin/metadata/java/DebugJavaClassProtoBuf.java
@@ -0,0 +1,131 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: build-common/src/java_descriptors.debug.proto
+
+package org.jetbrains.kotlin.metadata.java;
+
+public final class DebugJavaClassProtoBuf {
+  private DebugJavaClassProtoBuf() {}
+  public static void registerAllExtensions(
+      org.jetbrains.kotlin.protobuf.ExtensionRegistry registry) {
+    registry.add(org.jetbrains.kotlin.metadata.java.DebugJavaClassProtoBuf.isStaticMethod);
+    registry.add(org.jetbrains.kotlin.metadata.java.DebugJavaClassProtoBuf.isPackagePrivateMethod);
+    registry.add(org.jetbrains.kotlin.metadata.java.DebugJavaClassProtoBuf.isStaticField);
+    registry.add(org.jetbrains.kotlin.metadata.java.DebugJavaClassProtoBuf.isPackagePrivateField);
+    registry.add(org.jetbrains.kotlin.metadata.java.DebugJavaClassProtoBuf.isPackagePrivateClass);
+    registry.add(org.jetbrains.kotlin.metadata.java.DebugJavaClassProtoBuf.isPackagePrivateConstructor);
+  }
+  public static final int IS_STATIC_METHOD_FIELD_NUMBER = 1000;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Function { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.Function,
+      java.lang.Boolean> isStaticMethod = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        java.lang.Boolean.class,
+        null);
+  public static final int IS_PACKAGE_PRIVATE_METHOD_FIELD_NUMBER = 1001;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Function { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.Function,
+      java.lang.Boolean> isPackagePrivateMethod = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        java.lang.Boolean.class,
+        null);
+  public static final int IS_STATIC_FIELD_FIELD_NUMBER = 1000;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Property { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.Property,
+      java.lang.Boolean> isStaticField = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        java.lang.Boolean.class,
+        null);
+  public static final int IS_PACKAGE_PRIVATE_FIELD_FIELD_NUMBER = 1001;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Property { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.Property,
+      java.lang.Boolean> isPackagePrivateField = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        java.lang.Boolean.class,
+        null);
+  public static final int IS_PACKAGE_PRIVATE_CLASS_FIELD_NUMBER = 1000;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Class { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.Class,
+      java.lang.Boolean> isPackagePrivateClass = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        java.lang.Boolean.class,
+        null);
+  public static final int IS_PACKAGE_PRIVATE_CONSTRUCTOR_FIELD_NUMBER = 1000;
+  /**
+   * <code>extend .org.jetbrains.kotlin.metadata.Constructor { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.metadata.DebugProtoBuf.Constructor,
+      java.lang.Boolean> isPackagePrivateConstructor = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        java.lang.Boolean.class,
+        null);
+
+  public static org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor
+      getDescriptor() {
+    return descriptor;
+  }
+  private static org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor
+      descriptor;
+  static {
+    java.lang.String[] descriptorData = {
+      "\n-build-common/src/java_descriptors.debu" +
+      "g.proto\022\"org.jetbrains.kotlin.metadata.j" +
+      "ava\032&core/metadata/src/metadata.debug.pr" +
+      "oto:B\n\020is_static_method\022\'.org.jetbrains." +
+      "kotlin.metadata.Function\030\350\007 \001(\010:K\n\031is_pa" +
+      "ckage_private_method\022\'.org.jetbrains.kot" +
+      "lin.metadata.Function\030\351\007 \001(\010:A\n\017is_stati" +
+      "c_field\022\'.org.jetbrains.kotlin.metadata." +
+      "Property\030\350\007 \001(\010:J\n\030is_package_private_fi" +
+      "eld\022\'.org.jetbrains.kotlin.metadata.Prop",
+      "erty\030\351\007 \001(\010:G\n\030is_package_private_class\022" +
+      "$.org.jetbrains.kotlin.metadata.Class\030\350\007" +
+      " \001(\010:S\n\036is_package_private_constructor\022*" +
+      ".org.jetbrains.kotlin.metadata.Construct" +
+      "or\030\350\007 \001(\010B\030B\026DebugJavaClassProtoBuf"
+    };
+    org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
+        new org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
+          public org.jetbrains.kotlin.protobuf.ExtensionRegistry assignDescriptors(
+              org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor root) {
+            descriptor = root;
+            return null;
+          }
+        };
+    org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor
+      .internalBuildGeneratedFileFrom(descriptorData,
+        new org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor[] {
+          org.jetbrains.kotlin.metadata.DebugProtoBuf.getDescriptor(),
+        }, assigner);
+    isStaticMethod.internalInit(descriptor.getExtensions().get(0));
+    isPackagePrivateMethod.internalInit(descriptor.getExtensions().get(1));
+    isStaticField.internalInit(descriptor.getExtensions().get(2));
+    isPackagePrivateField.internalInit(descriptor.getExtensions().get(3));
+    isPackagePrivateClass.internalInit(descriptor.getExtensions().get(4));
+    isPackagePrivateConstructor.internalInit(descriptor.getExtensions().get(5));
+    org.jetbrains.kotlin.metadata.DebugProtoBuf.getDescriptor();
+  }
+
+  // @@protoc_insertion_point(outer_class_scope)
+}
--- a/build-common/test/org/jetbrains/kotlin/metadata/js/DebugJsProtoBuf.java
+++ b/build-common/test/org/jetbrains/kotlin/metadata/js/DebugJsProtoBuf.java
--- a/build-common/test/org/jetbrains/kotlin/metadata/jvm/DebugJvmModuleProtoBuf.java
+++ b/build-common/test/org/jetbrains/kotlin/metadata/jvm/DebugJvmModuleProtoBuf.java
--- a/build-common/test/org/jetbrains/kotlin/metadata/jvm/DebugJvmProtoBuf.java
+++ b/build-common/test/org/jetbrains/kotlin/metadata/jvm/DebugJvmProtoBuf.java
--- a/build-common/test/org/jetbrains/kotlin/serialization/DebugProtoBuf.java
+++ b/build-common/test/org/jetbrains/kotlin/serialization/DebugProtoBuf.java
--- a/build-common/test/org/jetbrains/kotlin/serialization/builtins/DebugBuiltInsProtoBuf.java
+++ b/build-common/test/org/jetbrains/kotlin/serialization/builtins/DebugBuiltInsProtoBuf.java
@@ -1,203 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: core/deserialization/src/builtins.debug.proto
-
-package org.jetbrains.kotlin.serialization.builtins;
-
-public final class DebugBuiltInsProtoBuf {
-  private DebugBuiltInsProtoBuf() {}
-  public static void registerAllExtensions(
-      org.jetbrains.kotlin.protobuf.ExtensionRegistry registry) {
-    registry.add(org.jetbrains.kotlin.serialization.builtins.DebugBuiltInsProtoBuf.packageFqName);
-    registry.add(org.jetbrains.kotlin.serialization.builtins.DebugBuiltInsProtoBuf.classAnnotation);
-    registry.add(org.jetbrains.kotlin.serialization.builtins.DebugBuiltInsProtoBuf.constructorAnnotation);
-    registry.add(org.jetbrains.kotlin.serialization.builtins.DebugBuiltInsProtoBuf.functionAnnotation);
-    registry.add(org.jetbrains.kotlin.serialization.builtins.DebugBuiltInsProtoBuf.propertyAnnotation);
-    registry.add(org.jetbrains.kotlin.serialization.builtins.DebugBuiltInsProtoBuf.compileTimeValue);
-    registry.add(org.jetbrains.kotlin.serialization.builtins.DebugBuiltInsProtoBuf.enumEntryAnnotation);
-    registry.add(org.jetbrains.kotlin.serialization.builtins.DebugBuiltInsProtoBuf.parameterAnnotation);
-    registry.add(org.jetbrains.kotlin.serialization.builtins.DebugBuiltInsProtoBuf.typeAnnotation);
-    registry.add(org.jetbrains.kotlin.serialization.builtins.DebugBuiltInsProtoBuf.typeParameterAnnotation);
-  }
-  public static final int PACKAGE_FQ_NAME_FIELD_NUMBER = 151;
-  /**
-   * <code>extend .org.jetbrains.kotlin.serialization.Package { ... }</code>
-   */
-  public static final
-    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
-      org.jetbrains.kotlin.serialization.DebugProtoBuf.Package,
-      java.lang.Integer> packageFqName = org.jetbrains.kotlin.protobuf.GeneratedMessage
-          .newFileScopedGeneratedExtension(
-        java.lang.Integer.class,
-        null);
-  public static final int CLASS_ANNOTATION_FIELD_NUMBER = 150;
-  /**
-   * <code>extend .org.jetbrains.kotlin.serialization.Class { ... }</code>
-   */
-  public static final
-    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
-      org.jetbrains.kotlin.serialization.DebugProtoBuf.Class,
-      java.util.List<org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation>> classAnnotation = org.jetbrains.kotlin.protobuf.GeneratedMessage
-          .newFileScopedGeneratedExtension(
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.class,
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.getDefaultInstance());
-  public static final int CONSTRUCTOR_ANNOTATION_FIELD_NUMBER = 150;
-  /**
-   * <code>extend .org.jetbrains.kotlin.serialization.Constructor { ... }</code>
-   */
-  public static final
-    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
-      org.jetbrains.kotlin.serialization.DebugProtoBuf.Constructor,
-      java.util.List<org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation>> constructorAnnotation = org.jetbrains.kotlin.protobuf.GeneratedMessage
-          .newFileScopedGeneratedExtension(
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.class,
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.getDefaultInstance());
-  public static final int FUNCTION_ANNOTATION_FIELD_NUMBER = 150;
-  /**
-   * <code>extend .org.jetbrains.kotlin.serialization.Function { ... }</code>
-   */
-  public static final
-    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
-      org.jetbrains.kotlin.serialization.DebugProtoBuf.Function,
-      java.util.List<org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation>> functionAnnotation = org.jetbrains.kotlin.protobuf.GeneratedMessage
-          .newFileScopedGeneratedExtension(
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.class,
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.getDefaultInstance());
-  public static final int PROPERTY_ANNOTATION_FIELD_NUMBER = 150;
-  /**
-   * <code>extend .org.jetbrains.kotlin.serialization.Property { ... }</code>
-   */
-  public static final
-    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
-      org.jetbrains.kotlin.serialization.DebugProtoBuf.Property,
-      java.util.List<org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation>> propertyAnnotation = org.jetbrains.kotlin.protobuf.GeneratedMessage
-          .newFileScopedGeneratedExtension(
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.class,
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.getDefaultInstance());
-  public static final int COMPILE_TIME_VALUE_FIELD_NUMBER = 151;
-  /**
-   * <code>extend .org.jetbrains.kotlin.serialization.Property { ... }</code>
-   */
-  public static final
-    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
-      org.jetbrains.kotlin.serialization.DebugProtoBuf.Property,
-      org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.Argument.Value> compileTimeValue = org.jetbrains.kotlin.protobuf.GeneratedMessage
-          .newFileScopedGeneratedExtension(
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.Argument.Value.class,
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.Argument.Value.getDefaultInstance());
-  public static final int ENUM_ENTRY_ANNOTATION_FIELD_NUMBER = 150;
-  /**
-   * <code>extend .org.jetbrains.kotlin.serialization.EnumEntry { ... }</code>
-   */
-  public static final
-    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
-      org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry,
-      java.util.List<org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation>> enumEntryAnnotation = org.jetbrains.kotlin.protobuf.GeneratedMessage
-          .newFileScopedGeneratedExtension(
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.class,
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.getDefaultInstance());
-  public static final int PARAMETER_ANNOTATION_FIELD_NUMBER = 150;
-  /**
-   * <code>extend .org.jetbrains.kotlin.serialization.ValueParameter { ... }</code>
-   */
-  public static final
-    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
-      org.jetbrains.kotlin.serialization.DebugProtoBuf.ValueParameter,
-      java.util.List<org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation>> parameterAnnotation = org.jetbrains.kotlin.protobuf.GeneratedMessage
-          .newFileScopedGeneratedExtension(
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.class,
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.getDefaultInstance());
-  public static final int TYPE_ANNOTATION_FIELD_NUMBER = 150;
-  /**
-   * <code>extend .org.jetbrains.kotlin.serialization.Type { ... }</code>
-   */
-  public static final
-    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
-      org.jetbrains.kotlin.serialization.DebugProtoBuf.Type,
-      java.util.List<org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation>> typeAnnotation = org.jetbrains.kotlin.protobuf.GeneratedMessage
-          .newFileScopedGeneratedExtension(
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.class,
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.getDefaultInstance());
-  public static final int TYPE_PARAMETER_ANNOTATION_FIELD_NUMBER = 150;
-  /**
-   * <code>extend .org.jetbrains.kotlin.serialization.TypeParameter { ... }</code>
-   */
-  public static final
-    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
-      org.jetbrains.kotlin.serialization.DebugProtoBuf.TypeParameter,
-      java.util.List<org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation>> typeParameterAnnotation = org.jetbrains.kotlin.protobuf.GeneratedMessage
-          .newFileScopedGeneratedExtension(
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.class,
-        org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.getDefaultInstance());
-
-  public static org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\n-core/deserialization/src/builtins.debu" +
-      "g.proto\022+org.jetbrains.kotlin.serializat" +
-      "ion.builtins\0320core/deserialization/src/d" +
-      "escriptors.debug.proto:E\n\017package_fq_nam" +
-      "e\022+.org.jetbrains.kotlin.serialization.P" +
-      "ackage\030\227\001 \001(\005:t\n\020class_annotation\022).org." +
-      "jetbrains.kotlin.serialization.Class\030\226\001 " +
-      "\003(\0132..org.jetbrains.kotlin.serialization" +
-      ".Annotation:\200\001\n\026constructor_annotation\022/" +
-      ".org.jetbrains.kotlin.serialization.Cons",
-      "tructor\030\226\001 \003(\0132..org.jetbrains.kotlin.se" +
-      "rialization.Annotation:z\n\023function_annot" +
-      "ation\022,.org.jetbrains.kotlin.serializati" +
-      "on.Function\030\226\001 \003(\0132..org.jetbrains.kotli" +
-      "n.serialization.Annotation:z\n\023property_a" +
-      "nnotation\022,.org.jetbrains.kotlin.seriali" +
-      "zation.Property\030\226\001 \003(\0132..org.jetbrains.k" +
-      "otlin.serialization.Annotation:\210\001\n\022compi" +
-      "le_time_value\022,.org.jetbrains.kotlin.ser" +
-      "ialization.Property\030\227\001 \001(\0132=.org.jetbrai",
-      "ns.kotlin.serialization.Annotation.Argum" +
-      "ent.Value:}\n\025enum_entry_annotation\022-.org" +
-      ".jetbrains.kotlin.serialization.EnumEntr" +
-      "y\030\226\001 \003(\0132..org.jetbrains.kotlin.serializ" +
-      "ation.Annotation:\201\001\n\024parameter_annotatio" +
-      "n\0222.org.jetbrains.kotlin.serialization.V" +
-      "alueParameter\030\226\001 \003(\0132..org.jetbrains.kot" +
-      "lin.serialization.Annotation:r\n\017type_ann" +
-      "otation\022(.org.jetbrains.kotlin.serializa" +
-      "tion.Type\030\226\001 \003(\0132..org.jetbrains.kotlin.",
-      "serialization.Annotation:\205\001\n\031type_parame" +
-      "ter_annotation\0221.org.jetbrains.kotlin.se" +
-      "rialization.TypeParameter\030\226\001 \003(\0132..org.j" +
-      "etbrains.kotlin.serialization.Annotation" +
-      "B\027B\025DebugBuiltInsProtoBuf"
-    };
-    org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public org.jetbrains.kotlin.protobuf.ExtensionRegistry assignDescriptors(
-              org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor[] {
-          org.jetbrains.kotlin.serialization.DebugProtoBuf.getDescriptor(),
-        }, assigner);
-    packageFqName.internalInit(descriptor.getExtensions().get(0));
-    classAnnotation.internalInit(descriptor.getExtensions().get(1));
-    constructorAnnotation.internalInit(descriptor.getExtensions().get(2));
-    functionAnnotation.internalInit(descriptor.getExtensions().get(3));
-    propertyAnnotation.internalInit(descriptor.getExtensions().get(4));
-    compileTimeValue.internalInit(descriptor.getExtensions().get(5));
-    enumEntryAnnotation.internalInit(descriptor.getExtensions().get(6));
-    parameterAnnotation.internalInit(descriptor.getExtensions().get(7));
-    typeAnnotation.internalInit(descriptor.getExtensions().get(8));
-    typeParameterAnnotation.internalInit(descriptor.getExtensions().get(9));
-    org.jetbrains.kotlin.serialization.DebugProtoBuf.getDescriptor();
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
--- a/build-common/test/org/jetbrains/kotlin/serialization/js/DebugJsProtoBuf.java
+++ b/build-common/test/org/jetbrains/kotlin/serialization/js/DebugJsProtoBuf.java
--- a/build-common/test/org/jetbrains/kotlin/serialization/js/ast/DebugJsAstProtoBuf.java
+++ b/build-common/test/org/jetbrains/kotlin/serialization/js/ast/DebugJsAstProtoBuf.java
@@ -227,6 +227,10 @@ public final class DebugJsAstProtoBuf {
     * <code>COROUTINE_RECEIVER = 8;</code>
     */
    COROUTINE_RECEIVER(7, 8),
+    /**
+     * <code>SET_COROUTINE_RESULT = 9;</code>
+     */
+    SET_COROUTINE_RESULT(8, 9),
    ;

    /**
@@ -261,6 +265,10 @@ public final class DebugJsAstProtoBuf {
     * <code>COROUTINE_RECEIVER = 8;</code>
     */
    public static final int COROUTINE_RECEIVER_VALUE = 8;
+    /**
+     * <code>SET_COROUTINE_RESULT = 9;</code>
+     */
+    public static final int SET_COROUTINE_RESULT_VALUE = 9;


    public final int getNumber() { return value; }
@@ -275,6 +283,7 @@ public final class DebugJsAstProtoBuf {
        case 6: return COROUTINE_RESULT;
        case 7: return COROUTINE_CONTROLLER;
        case 8: return COROUTINE_RECEIVER;
+        case 9: return SET_COROUTINE_RESULT;
        default: return null;
      }
    }
@@ -32573,6 +32582,28 @@ public final class DebugJsAstProtoBuf {
     */
    org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.StatementOrBuilder getStatementOrBuilder(
        int index);
+
+    /**
+     * <code>optional int32 fileId = 3;</code>
+     */
+    boolean hasFileId();
+    /**
+     * <code>optional int32 fileId = 3;</code>
+     */
+    int getFileId();
+
+    /**
+     * <code>optional .org.jetbrains.kotlin.serialization.js.ast.Location location = 4;</code>
+     */
+    boolean hasLocation();
+    /**
+     * <code>optional .org.jetbrains.kotlin.serialization.js.ast.Location location = 4;</code>
+     */
+    org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location getLocation();
+    /**
+     * <code>optional .org.jetbrains.kotlin.serialization.js.ast.Location location = 4;</code>
+     */
+    org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.LocationOrBuilder getLocationOrBuilder();
  }
  /**
   * Protobuf type {@code org.jetbrains.kotlin.serialization.js.ast.SwitchEntry}
@@ -32647,6 +32678,24 @@ public final class DebugJsAstProtoBuf {
              statement_.add(input.readMessage(org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Statement.PARSER, extensionRegistry));
              break;
            }
+            case 24: {
+              bitField0_ |= 0x00000002;
+              fileId_ = input.readInt32();
+              break;
+            }
+            case 34: {
+              org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000004) == 0x00000004)) {
+                subBuilder = location_.toBuilder();
+              }
+              location_ = input.readMessage(org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(location_);
+                location_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000004;
+              break;
+            }
          }
        }
      } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
@@ -32746,9 +32795,47 @@ public final class DebugJsAstProtoBuf {
      return statement_.get(index);
    }

+    public static final int FILEID_FIELD_NUMBER = 3;
+    private int fileId_;
+    /**
+     * <code>optional int32 fileId = 3;</code>
+     */
+    public boolean hasFileId() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>optional int32 fileId = 3;</code>
+     */
+    public int getFileId() {
+      return fileId_;
+    }
+
+    public static final int LOCATION_FIELD_NUMBER = 4;
+    private org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location location_;
+    /**
+     * <code>optional .org.jetbrains.kotlin.serialization.js.ast.Location location = 4;</code>
+     */
+    public boolean hasLocation() {
+      return ((bitField0_ & 0x00000004) == 0x00000004);
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.serialization.js.ast.Location location = 4;</code>
+     */
+    public org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location getLocation() {
+      return location_;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.serialization.js.ast.Location location = 4;</code>
+     */
+    public org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.LocationOrBuilder getLocationOrBuilder() {
+      return location_;
+    }
+
    private void initFields() {
      label_ = org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Expression.getDefaultInstance();
      statement_ = java.util.Collections.emptyList();
+      fileId_ = 0;
+      location_ = org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location.getDefaultInstance();
    }
    private byte memoizedIsInitialized = -1;
    public final boolean isInitialized() {
@@ -32768,6 +32855,12 @@ public final class DebugJsAstProtoBuf {
          return false;
        }
      }
+      if (hasLocation()) {
+        if (!getLocation().isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
      memoizedIsInitialized = 1;
      return true;
    }
@@ -32781,6 +32874,12 @@ public final class DebugJsAstProtoBuf {
      for (int i = 0; i < statement_.size(); i++) {
        output.writeMessage(2, statement_.get(i));
      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeInt32(3, fileId_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        output.writeMessage(4, location_);
+      }
      getUnknownFields().writeTo(output);
    }

@@ -32798,6 +32897,14 @@ public final class DebugJsAstProtoBuf {
        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
          .computeMessageSize(2, statement_.get(i));
      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeInt32Size(3, fileId_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeMessageSize(4, location_);
+      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
@@ -32909,6 +33016,7 @@ public final class DebugJsAstProtoBuf {
        if (org.jetbrains.kotlin.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
          getLabelFieldBuilder();
          getStatementFieldBuilder();
+          getLocationFieldBuilder();
        }
      }
      private static Builder create() {
@@ -32929,6 +33037,14 @@ public final class DebugJsAstProtoBuf {
        } else {
          statementBuilder_.clear();
        }
+        fileId_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000004);
+        if (locationBuilder_ == null) {
+          location_ = org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location.getDefaultInstance();
+        } else {
+          locationBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000008);
        return this;
      }

@@ -32974,6 +33090,18 @@ public final class DebugJsAstProtoBuf {
        } else {
          result.statement_ = statementBuilder_.build();
        }
+        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.fileId_ = fileId_;
+        if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+          to_bitField0_ |= 0x00000004;
+        }
+        if (locationBuilder_ == null) {
+          result.location_ = location_;
+        } else {
+          result.location_ = locationBuilder_.build();
+        }
        result.bitField0_ = to_bitField0_;
        onBuilt();
        return result;
@@ -33019,6 +33147,12 @@ public final class DebugJsAstProtoBuf {
            }
          }
        }
+        if (other.hasFileId()) {
+          setFileId(other.getFileId());
+        }
+        if (other.hasLocation()) {
+          mergeLocation(other.getLocation());
+        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
@@ -33036,6 +33170,12 @@ public final class DebugJsAstProtoBuf {
            return false;
          }
        }
+        if (hasLocation()) {
+          if (!getLocation().isInitialized()) {
+            
+            return false;
+          }
+        }
        return true;
      }

@@ -33414,6 +33554,154 @@ public final class DebugJsAstProtoBuf {
        return statementBuilder_;
      }

+      private int fileId_ ;
+      /**
+       * <code>optional int32 fileId = 3;</code>
+       */
+      public boolean hasFileId() {
+        return ((bitField0_ & 0x00000004) == 0x00000004);
+      }
+      /**
+       * <code>optional int32 fileId = 3;</code>
+       */
+      public int getFileId() {
+        return fileId_;
+      }
+      /**
+       * <code>optional int32 fileId = 3;</code>
+       */
+      public Builder setFileId(int value) {
+        bitField0_ |= 0x00000004;
+        fileId_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>optional int32 fileId = 3;</code>
+       */
+      public Builder clearFileId() {
+        bitField0_ = (bitField0_ & ~0x00000004);
+        fileId_ = 0;
+        onChanged();
+        return this;
+      }
+
+      private org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location location_ = org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location.getDefaultInstance();
+      private org.jetbrains.kotlin.protobuf.SingleFieldBuilder<
+          org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location, org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location.Builder, org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.LocationOrBuilder> locationBuilder_;
+      /**
+       * <code>optional .org.jetbrains.kotlin.serialization.js.ast.Location location = 4;</code>
+       */
+      public boolean hasLocation() {
+        return ((bitField0_ & 0x00000008) == 0x00000008);
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.serialization.js.ast.Location location = 4;</code>
+       */
+      public org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location getLocation() {
+        if (locationBuilder_ == null) {
+          return location_;
+        } else {
+          return locationBuilder_.getMessage();
+        }
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.serialization.js.ast.Location location = 4;</code>
+       */
+      public Builder setLocation(org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location value) {
+        if (locationBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          location_ = value;
+          onChanged();
+        } else {
+          locationBuilder_.setMessage(value);
+        }
+        bitField0_ |= 0x00000008;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.serialization.js.ast.Location location = 4;</code>
+       */
+      public Builder setLocation(
+          org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location.Builder builderForValue) {
+        if (locationBuilder_ == null) {
+          location_ = builderForValue.build();
+          onChanged();
+        } else {
+          locationBuilder_.setMessage(builderForValue.build());
+        }
+        bitField0_ |= 0x00000008;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.serialization.js.ast.Location location = 4;</code>
+       */
+      public Builder mergeLocation(org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location value) {
+        if (locationBuilder_ == null) {
+          if (((bitField0_ & 0x00000008) == 0x00000008) &&
+              location_ != org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location.getDefaultInstance()) {
+            location_ =
+              org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location.newBuilder(location_).mergeFrom(value).buildPartial();
+          } else {
+            location_ = value;
+          }
+          onChanged();
+        } else {
+          locationBuilder_.mergeFrom(value);
+        }
+        bitField0_ |= 0x00000008;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.serialization.js.ast.Location location = 4;</code>
+       */
+      public Builder clearLocation() {
+        if (locationBuilder_ == null) {
+          location_ = org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location.getDefaultInstance();
+          onChanged();
+        } else {
+          locationBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000008);
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.serialization.js.ast.Location location = 4;</code>
+       */
+      public org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location.Builder getLocationBuilder() {
+        bitField0_ |= 0x00000008;
+        onChanged();
+        return getLocationFieldBuilder().getBuilder();
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.serialization.js.ast.Location location = 4;</code>
+       */
+      public org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.LocationOrBuilder getLocationOrBuilder() {
+        if (locationBuilder_ != null) {
+          return locationBuilder_.getMessageOrBuilder();
+        } else {
+          return location_;
+        }
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.serialization.js.ast.Location location = 4;</code>
+       */
+      private org.jetbrains.kotlin.protobuf.SingleFieldBuilder<
+          org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location, org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location.Builder, org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.LocationOrBuilder> 
+          getLocationFieldBuilder() {
+        if (locationBuilder_ == null) {
+          locationBuilder_ = new org.jetbrains.kotlin.protobuf.SingleFieldBuilder<
+              org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location, org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.Location.Builder, org.jetbrains.kotlin.serialization.js.ast.DebugJsAstProtoBuf.LocationOrBuilder>(
+                  getLocation(),
+                  getParentForChildren(),
+                  isClean());
+          location_ = null;
+        }
+        return locationBuilder_;
+      }
+
      // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.serialization.js.ast.SwitchEntry)
    }

@@ -49465,100 +49753,103 @@ public final class DebugJsAstProtoBuf {
      "tch\022I\n\nexpression\030\001 \002(\01325.org.jetbrains." +
      "kotlin.serialization.js.ast.Expression\022E" +
      "\n\005entry\030\002 \003(\01326.org.jetbrains.kotlin.ser" +
-      "ialization.js.ast.SwitchEntry\"\234\001\n\013Switch" +
+      "ialization.js.ast.SwitchEntry\"\363\001\n\013Switch" +
      "Entry\022D\n\005label\030\001 \001(\01325.org.jetbrains.kot" +
      "lin.serialization.js.ast.Expression\022G\n\ts",
      "tatement\030\002 \003(\01324.org.jetbrains.kotlin.se" +
-      "rialization.js.ast.Statement\"\225\001\n\005While\022H" +
-      "\n\tcondition\030\001 \002(\01325.org.jetbrains.kotlin" +
-      ".serialization.js.ast.Expression\022B\n\004body" +
-      "\030\002 \002(\01324.org.jetbrains.kotlin.serializat" +
-      "ion.js.ast.Statement\"\227\001\n\007DoWhile\022H\n\tcond" +
-      "ition\030\001 \002(\01325.org.jetbrains.kotlin.seria" +
-      "lization.js.ast.Expression\022B\n\004body\030\002 \002(\013" +
-      "24.org.jetbrains.kotlin.serialization.js" +
-      ".ast.Statement\"\304\003\n\003For\022I\n\tvariables\030\001 \001(",
-      "\01324.org.jetbrains.kotlin.serialization.j" +
-      "s.ast.StatementH\000\022K\n\nexpression\030\002 \001(\01325." +
-      "org.jetbrains.kotlin.serialization.js.as" +
-      "t.ExpressionH\000\022E\n\005empty\030\003 \001(\01324.org.jetb" +
-      "rains.kotlin.serialization.js.ast.EmptyI" +
-      "nitH\000\022H\n\tcondition\030\004 \001(\01325.org.jetbrains" +
+      "rialization.js.ast.Statement\022\016\n\006fileId\030\003" +
+      " \001(\005\022E\n\010location\030\004 \001(\01323.org.jetbrains.k" +
+      "otlin.serialization.js.ast.Location\"\225\001\n\005" +
+      "While\022H\n\tcondition\030\001 \002(\01325.org.jetbrains" +
      ".kotlin.serialization.js.ast.Expression\022" +
-      "H\n\tincrement\030\005 \001(\01325.org.jetbrains.kotli" +
-      "n.serialization.js.ast.Expression\022B\n\004bod" +
-      "y\030\006 \002(\01324.org.jetbrains.kotlin.serializa",
-      "tion.js.ast.StatementB\006\n\004init\"\013\n\tEmptyIn" +
-      "it\"\374\001\n\005ForIn\022\020\n\006nameId\030\001 \001(\005H\000\022K\n\nexpres" +
-      "sion\030\002 \001(\01325.org.jetbrains.kotlin.serial" +
-      "ization.js.ast.ExpressionH\000\022G\n\010iterable\030" +
-      "\003 \002(\01325.org.jetbrains.kotlin.serializati" +
-      "on.js.ast.Expression\022B\n\004body\030\004 \002(\01324.org" +
-      ".jetbrains.kotlin.serialization.js.ast.S" +
-      "tatementB\007\n\005value\"\337\001\n\003Try\022F\n\010tryBlock\030\001 " +
-      "\002(\01324.org.jetbrains.kotlin.serialization" +
-      ".js.ast.Statement\022D\n\ncatchBlock\030\002 \001(\01320.",
-      "org.jetbrains.kotlin.serialization.js.as" +
-      "t.Catch\022J\n\014finallyBlock\030\003 \001(\01324.org.jetb" +
-      "rains.kotlin.serialization.js.ast.Statem" +
-      "ent\"\224\001\n\005Catch\022G\n\tparameter\030\001 \002(\01324.org.j" +
-      "etbrains.kotlin.serialization.js.ast.Par" +
-      "ameter\022B\n\004body\030\002 \002(\01324.org.jetbrains.kot" +
-      "lin.serialization.js.ast.Statement\"\007\n\005Em" +
-      "pty\"\327\005\n\010Fragment\022R\n\017imported_module\030\001 \003(" +
-      "\01329.org.jetbrains.kotlin.serialization.j" +
-      "s.ast.ImportedModule\022G\n\014import_entry\030\002 \003",
-      "(\01321.org.jetbrains.kotlin.serialization." +
-      "js.ast.Import\022Q\n\021declaration_block\030\003 \001(\013" +
-      "26.org.jetbrains.kotlin.serialization.js" +
-      ".ast.GlobalBlock\022L\n\014export_block\030\004 \001(\01326" +
-      ".org.jetbrains.kotlin.serialization.js.a" +
-      "st.GlobalBlock\022Q\n\021initializer_block\030\005 \001(" +
-      "\01326.org.jetbrains.kotlin.serialization.j" +
-      "s.ast.GlobalBlock\022L\n\014name_binding\030\006 \003(\0132" +
-      "6.org.jetbrains.kotlin.serialization.js." +
-      "ast.NameBinding\022J\n\013class_model\030\007 \003(\01325.o",
+      "B\n\004body\030\002 \002(\01324.org.jetbrains.kotlin.ser" +
+      "ialization.js.ast.Statement\"\227\001\n\007DoWhile\022" +
+      "H\n\tcondition\030\001 \002(\01325.org.jetbrains.kotli" +
+      "n.serialization.js.ast.Expression\022B\n\004bod",
+      "y\030\002 \002(\01324.org.jetbrains.kotlin.serializa" +
+      "tion.js.ast.Statement\"\304\003\n\003For\022I\n\tvariabl" +
+      "es\030\001 \001(\01324.org.jetbrains.kotlin.serializ" +
+      "ation.js.ast.StatementH\000\022K\n\nexpression\030\002" +
+      " \001(\01325.org.jetbrains.kotlin.serializatio" +
+      "n.js.ast.ExpressionH\000\022E\n\005empty\030\003 \001(\01324.o" +
      "rg.jetbrains.kotlin.serialization.js.ast" +
-      ".ClassModel\022P\n\021module_expression\030\010 \003(\01325" +
-      ".org.jetbrains.kotlin.serialization.js.a" +
-      "st.Expression\022N\n\rinline_module\030\t \003(\01327.o" +
+      ".EmptyInitH\000\022H\n\tcondition\030\004 \001(\01325.org.je" +
+      "tbrains.kotlin.serialization.js.ast.Expr" +
+      "ession\022H\n\tincrement\030\005 \001(\01325.org.jetbrain",
+      "s.kotlin.serialization.js.ast.Expression" +
+      "\022B\n\004body\030\006 \002(\01324.org.jetbrains.kotlin.se" +
+      "rialization.js.ast.StatementB\006\n\004init\"\013\n\t" +
+      "EmptyInit\"\374\001\n\005ForIn\022\020\n\006nameId\030\001 \001(\005H\000\022K\n" +
+      "\nexpression\030\002 \001(\01325.org.jetbrains.kotlin" +
+      ".serialization.js.ast.ExpressionH\000\022G\n\010it" +
+      "erable\030\003 \002(\01325.org.jetbrains.kotlin.seri" +
+      "alization.js.ast.Expression\022B\n\004body\030\004 \002(" +
+      "\01324.org.jetbrains.kotlin.serialization.j" +
+      "s.ast.StatementB\007\n\005value\"\337\001\n\003Try\022F\n\010tryB",
+      "lock\030\001 \002(\01324.org.jetbrains.kotlin.serial" +
+      "ization.js.ast.Statement\022D\n\ncatchBlock\030\002" +
+      " \001(\01320.org.jetbrains.kotlin.serializatio" +
+      "n.js.ast.Catch\022J\n\014finallyBlock\030\003 \001(\01324.o" +
      "rg.jetbrains.kotlin.serialization.js.ast" +
-      ".InlineModule\"\224\001\n\016ImportedModule\022\030\n\020exte" +
-      "rnal_name_id\030\001 \002(\005\022\030\n\020internal_name_id\030\002" +
-      " \002(\005\022N\n\017plain_reference\030\003 \001(\01325.org.jetb" +
-      "rains.kotlin.serialization.js.ast.Expres" +
-      "sion\"i\n\006Import\022\024\n\014signature_id\030\001 \002(\005\022I\n\n",
-      "expression\030\002 \002(\01325.org.jetbrains.kotlin." +
-      "serialization.js.ast.Expression\"3\n\013NameB" +
-      "inding\022\024\n\014signature_id\030\001 \002(\005\022\016\n\006nameId\030\002" +
-      " \002(\005\"\247\001\n\nClassModel\022\017\n\007name_id\030\001 \002(\005\022\025\n\r" +
-      "super_name_id\030\002 \001(\005\022\031\n\021interface_name_id" +
-      "\030\004 \003(\005\022V\n\026post_declaration_block\030\003 \001(\01326" +
-      ".org.jetbrains.kotlin.serialization.js.a" +
-      "st.GlobalBlock\";\n\014InlineModule\022\024\n\014signat" +
-      "ure_id\030\001 \002(\005\022\025\n\rexpression_id\030\002 \002(\005\"\034\n\013S" +
-      "tringTable\022\r\n\005entry\030\001 \003(\t\"K\n\tNameTable\022>",
-      "\n\005entry\030\001 \003(\0132/.org.jetbrains.kotlin.ser" +
-      "ialization.js.ast.Name\"\263\001\n\004Name\022\021\n\ttempo" +
-      "rary\030\001 \002(\010\022\022\n\nidentifier\030\002 \001(\005\022\025\n\rlocal_" +
-      "name_id\030\003 \001(\005\022\027\n\010imported\030\004 \001(\010:\005false\022T" +
-      "\n\020special_function\030\005 \001(\0162:.org.jetbrains" +
-      ".kotlin.serialization.js.ast.SpecialFunc" +
-      "tion\"\346\001\n\005Chunk\022L\n\014string_table\030\001 \002(\01326.o" +
+      ".Statement\"\224\001\n\005Catch\022G\n\tparameter\030\001 \002(\0132" +
+      "4.org.jetbrains.kotlin.serialization.js." +
+      "ast.Parameter\022B\n\004body\030\002 \002(\01324.org.jetbra" +
+      "ins.kotlin.serialization.js.ast.Statemen" +
+      "t\"\007\n\005Empty\"\327\005\n\010Fragment\022R\n\017imported_modu",
+      "le\030\001 \003(\01329.org.jetbrains.kotlin.serializ" +
+      "ation.js.ast.ImportedModule\022G\n\014import_en" +
+      "try\030\002 \003(\01321.org.jetbrains.kotlin.seriali" +
+      "zation.js.ast.Import\022Q\n\021declaration_bloc" +
+      "k\030\003 \001(\01326.org.jetbrains.kotlin.serializa" +
+      "tion.js.ast.GlobalBlock\022L\n\014export_block\030" +
+      "\004 \001(\01326.org.jetbrains.kotlin.serializati" +
+      "on.js.ast.GlobalBlock\022Q\n\021initializer_blo" +
+      "ck\030\005 \001(\01326.org.jetbrains.kotlin.serializ" +
+      "ation.js.ast.GlobalBlock\022L\n\014name_binding",
+      "\030\006 \003(\01326.org.jetbrains.kotlin.serializat" +
+      "ion.js.ast.NameBinding\022J\n\013class_model\030\007 " +
+      "\003(\01325.org.jetbrains.kotlin.serialization" +
+      ".js.ast.ClassModel\022P\n\021module_expression\030" +
+      "\010 \003(\01325.org.jetbrains.kotlin.serializati" +
+      "on.js.ast.Expression\022N\n\rinline_module\030\t " +
+      "\003(\01327.org.jetbrains.kotlin.serialization" +
+      ".js.ast.InlineModule\"\224\001\n\016ImportedModule\022" +
+      "\030\n\020external_name_id\030\001 \002(\005\022\030\n\020internal_na" +
+      "me_id\030\002 \002(\005\022N\n\017plain_reference\030\003 \001(\01325.o",
      "rg.jetbrains.kotlin.serialization.js.ast" +
-      ".StringTable\022H\n\nname_table\030\002 \002(\01324.org.j" +
-      "etbrains.kotlin.serialization.js.ast.Nam",
-      "eTable\022E\n\010fragment\030\003 \002(\01323.org.jetbrains" +
-      ".kotlin.serialization.js.ast.Fragment*@\n" +
-      "\013SideEffects\022\021\n\rAFFECTS_STATE\020\001\022\024\n\020DEPEN" +
-      "DS_ON_STATE\020\002\022\010\n\004PURE\020\003*?\n\016InlineStrateg" +
-      "y\022\017\n\013AS_FUNCTION\020\000\022\014\n\010IN_PLACE\020\001\022\016\n\nNOT_" +
-      "INLINE\020\002*\275\001\n\017SpecialFunction\022\032\n\026DEFINE_I" +
-      "NLINE_FUNCTION\020\001\022\021\n\rWRAP_FUNCTION\020\002\022\021\n\rT" +
-      "O_BOXED_CHAR\020\003\022\016\n\nUNBOX_CHAR\020\004\022\020\n\014SUSPEN" +
-      "D_CALL\020\005\022\024\n\020COROUTINE_RESULT\020\006\022\030\n\024COROUT" +
-      "INE_CONTROLLER\020\007\022\026\n\022COROUTINE_RECEIVER\020\010",
-      "B\024B\022DebugJsAstProtoBuf"
+      ".Expression\"i\n\006Import\022\024\n\014signature_id\030\001 " +
+      "\002(\005\022I\n\nexpression\030\002 \002(\01325.org.jetbrains." +
+      "kotlin.serialization.js.ast.Expression\"3" +
+      "\n\013NameBinding\022\024\n\014signature_id\030\001 \002(\005\022\016\n\006n" +
+      "ameId\030\002 \002(\005\"\247\001\n\nClassModel\022\017\n\007name_id\030\001 " +
+      "\002(\005\022\025\n\rsuper_name_id\030\002 \001(\005\022\031\n\021interface_" +
+      "name_id\030\004 \003(\005\022V\n\026post_declaration_block\030" +
+      "\003 \001(\01326.org.jetbrains.kotlin.serializati" +
+      "on.js.ast.GlobalBlock\";\n\014InlineModule\022\024\n",
+      "\014signature_id\030\001 \002(\005\022\025\n\rexpression_id\030\002 \002" +
+      "(\005\"\034\n\013StringTable\022\r\n\005entry\030\001 \003(\t\"K\n\tName" +
+      "Table\022>\n\005entry\030\001 \003(\0132/.org.jetbrains.kot" +
+      "lin.serialization.js.ast.Name\"\263\001\n\004Name\022\021" +
+      "\n\ttemporary\030\001 \002(\010\022\022\n\nidentifier\030\002 \001(\005\022\025\n" +
+      "\rlocal_name_id\030\003 \001(\005\022\027\n\010imported\030\004 \001(\010:\005" +
+      "false\022T\n\020special_function\030\005 \001(\0162:.org.je" +
+      "tbrains.kotlin.serialization.js.ast.Spec" +
+      "ialFunction\"\346\001\n\005Chunk\022L\n\014string_table\030\001 " +
+      "\002(\01326.org.jetbrains.kotlin.serialization",
+      ".js.ast.StringTable\022H\n\nname_table\030\002 \002(\0132" +
+      "4.org.jetbrains.kotlin.serialization.js." +
+      "ast.NameTable\022E\n\010fragment\030\003 \002(\01323.org.je" +
+      "tbrains.kotlin.serialization.js.ast.Frag" +
+      "ment*@\n\013SideEffects\022\021\n\rAFFECTS_STATE\020\001\022\024" +
+      "\n\020DEPENDS_ON_STATE\020\002\022\010\n\004PURE\020\003*?\n\016Inline" +
+      "Strategy\022\017\n\013AS_FUNCTION\020\000\022\014\n\010IN_PLACE\020\001\022" +
+      "\016\n\nNOT_INLINE\020\002*\327\001\n\017SpecialFunction\022\032\n\026D" +
+      "EFINE_INLINE_FUNCTION\020\001\022\021\n\rWRAP_FUNCTION" +
+      "\020\002\022\021\n\rTO_BOXED_CHAR\020\003\022\016\n\nUNBOX_CHAR\020\004\022\020\n",
+      "\014SUSPEND_CALL\020\005\022\024\n\020COROUTINE_RESULT\020\006\022\030\n" +
+      "\024COROUTINE_CONTROLLER\020\007\022\026\n\022COROUTINE_REC" +
+      "EIVER\020\010\022\030\n\024SET_COROUTINE_RESULT\020\tB\024B\022Deb" +
+      "ugJsAstProtoBuf"
    };
    org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
        new org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
@@ -49793,7 +50084,7 @@ public final class DebugJsAstProtoBuf {
    internal_static_org_jetbrains_kotlin_serialization_js_ast_SwitchEntry_fieldAccessorTable = new
      org.jetbrains.kotlin.protobuf.GeneratedMessage.FieldAccessorTable(
        internal_static_org_jetbrains_kotlin_serialization_js_ast_SwitchEntry_descriptor,
-        new java.lang.String[] { "Label", "Statement", });
+        new java.lang.String[] { "Label", "Statement", "FileId", "Location", });
    internal_static_org_jetbrains_kotlin_serialization_js_ast_While_descriptor =
      getDescriptor().getMessageTypes().get(37);
    internal_static_org_jetbrains_kotlin_serialization_js_ast_While_fieldAccessorTable = new
--- a/build-common/test/org/jetbrains/kotlin/serialization/jvm/DebugJvmPackageTable.java
+++ b/build-common/test/org/jetbrains/kotlin/serialization/jvm/DebugJvmPackageTable.java
--- a/build-common/test/org/jetbrains/kotlin/serialization/jvm/DebugJvmProtoBuf.java
+++ b/build-common/test/org/jetbrains/kotlin/serialization/jvm/DebugJvmProtoBuf.java
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,3 +1,5 @@
+
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import org.gradle.api.Project
 import java.util.*
 import java.io.File
@@ -5,22 +7,28 @@ import org.gradle.api.tasks.bundling.Jar
 import org.gradle.plugins.ide.idea.model.IdeaModel
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile
+import proguard.gradle.ProGuardTask

 buildscript {
    extra["defaultSnapshotVersion"] = "1.2-SNAPSHOT"

-    kotlinBootstrapFrom(BootstrapOption.TeamCity("1.2.0-dev-439", onlySuccessBootstrap = false))
+    kotlinBootstrapFrom(BootstrapOption.TeamCity("1.2.40-dev-967", onlySuccessBootstrap = false))
+
+    val mirrorRepo: String? = findProperty("maven.repository.mirror")?.toString()

    val repos = listOfNotNull(
+            mirrorRepo,
            bootstrapKotlinRepo,
            "https://jcenter.bintray.com/",
            "https://plugins.gradle.org/m2",
-            "http://repository.jetbrains.com/utils/")
+            "http://dl.bintray.com/kotlin/kotlinx",
+            "https://repo.gradle.org/gradle/libs-releases-local", // for native-platform
+            "https://jetbrains.bintray.com/intellij-third-party-dependencies", // for jflex
+            "https://dl.bintray.com/jetbrains/markdown" // for org.jetbrains:markdown
+    )

    extra["repos"] = repos

-    extra["versions.shadow"] = "2.0.1"
-
    repositories {
        for (repo in repos) {
            maven(url = repo)
@@ -30,6 +38,7 @@ buildscript {
    dependencies {
        classpath("com.gradle.publish:plugin-publish-plugin:0.9.7")
        classpath(kotlinDep("gradle-plugin", bootstrapKotlinVersion))
+        classpath("net.sf.proguard:proguard-gradle:5.3.3")
    }
 }

@@ -76,16 +85,21 @@ dependencies {
 }

 val commonBuildDir = File(rootDir, "build")
-val distDir = "$rootDir/dist"
-val distKotlinHomeDir = "$distDir/kotlinc"
+val distDir by extra("$rootDir/dist")
+val distKotlinHomeDir by extra("$distDir/kotlinc")
 val distLibDir = "$distKotlinHomeDir/lib"
-val ideaPluginDir = "$distDir/artifacts/Kotlin"
-val ideaUltimatePluginDir = "$distDir/artifacts/KotlinUltimate"
+val commonLocalDataDir = "$rootDir/local"
+val ideaSandboxDir = "$commonLocalDataDir/ideaSandbox"
+val ideaUltimateSandboxDir = "$commonLocalDataDir/ideaUltimateSandbox"
+val ideaPluginDir = "$distDir/artifacts/ideaPlugin/Kotlin"
+val ideaUltimatePluginDir = "$distDir/artifacts/ideaUltimatePlugin/Kotlin"

-extra["distDir"] = distDir
-extra["distKotlinHomeDir"] = distKotlinHomeDir
+// TODO: use "by extra()" syntax where possible
 extra["distLibDir"] = project.file(distLibDir)
 extra["libsDir"] = project.file(distLibDir)
+extra["commonLocalDataDir"] = project.file(commonLocalDataDir)
+extra["ideaSandboxDir"] = project.file(ideaSandboxDir)
+extra["ideaUltimateSandboxDir"] = project.file(ideaUltimateSandboxDir)
 extra["ideaPluginDir"] = project.file(ideaPluginDir)
 extra["ideaUltimatePluginDir"] = project.file(ideaUltimatePluginDir)
 extra["isSonatypeRelease"] = false
@@ -102,7 +116,12 @@ Properties().apply {
 extra["JDK_16"] = jdkPath("1.6")
 extra["JDK_17"] = jdkPath("1.7")
 extra["JDK_18"] = jdkPath("1.8")
-extra["JDK_9"] = jdkPathIfFound("9")
+extra["JDK_9"] = jdkPath("9")
+extra["JDK_10"] = jdkPathIfFound("10")
+
+rootProject.apply {
+    from(rootProject.file("versions.gradle.kts"))
+}

 extra["versions.protobuf-java"] = "2.6.1"
 extra["versions.javax.inject"] = "1"
@@ -113,9 +132,48 @@ extra["versions.junit"] = "4.12"
 extra["versions.javaslang"] = "2.0.6"
 extra["versions.ant"] = "1.8.2"
 extra["versions.android"] = "2.3.1"
+extra["versions.kotlinx-coroutines-core"] = "0.20"
+extra["versions.kotlinx-coroutines-jdk8"] = "0.20"
+extra["versions.json"] = "20160807"
+extra["versions.native-platform"] = "0.14"
+extra["versions.ant-launcher"] = "1.8.0"
+extra["versions.robolectric"] = "3.1"
+extra["versions.org.springframework"] = "4.2.0.RELEASE"
+extra["versions.jflex"] = "1.7.0"
+extra["versions.markdown"] = "0.1.25"

-extra["ideaCoreSdkJars"] = arrayOf("annotations", "asm-all", "guava", "intellij-core", "jdom", "jna", "log4j", "picocontainer",
-                                   "snappy-in-java", "streamex", "trove4j", "xpp3-1.1.4-min", "xstream")
+val isTeamcityBuild = project.hasProperty("teamcity") || System.getenv("TEAMCITY_VERSION") != null
+val intellijUltimateEnabled = project.getBooleanProperty("intellijUltimateEnabled") ?: isTeamcityBuild
+val effectSystemEnabled by extra(project.getBooleanProperty("kotlin.compiler.effectSystemEnabled") ?: false)
+
+val intellijSeparateSdks = project.getBooleanProperty("intellijSeparateSdks") ?: false
+
+extra["intellijUltimateEnabled"] = intellijUltimateEnabled
+extra["intellijSeparateSdks"] = intellijSeparateSdks
+
+extra["IntellijCoreDependencies"] =
+        listOf("annotations",
+               "asm-all",
+               "guava-21.0",
+               "jdom",
+               "jna",
+               "log4j",
+               "picocontainer",
+               "snappy-in-java-0.5.1",
+               "streamex",
+               "trove4j")
+
+extra["nativePlatformVariants"] =
+        listOf("windows-amd64",
+               "windows-i386",
+               "osx-amd64",
+               "osx-i386",
+               "linux-amd64",
+               "linux-i386",
+               "freebsd-amd64-libcpp",
+               "freebsd-amd64-libstdcpp",
+               "freebsd-i386-libcpp",
+               "freebsd-i386-libstdcpp")

 extra["compilerModules"] = arrayOf(
        ":compiler:util",
@@ -123,6 +181,7 @@ extra["compilerModules"] = arrayOf(
        ":compiler:conditional-preprocessor",
        ":compiler:resolution",
        ":compiler:serialization",
+        ":compiler:psi",
        ":compiler:frontend",
        ":compiler:frontend.java",
        ":compiler:frontend.script",
@@ -145,6 +204,8 @@ extra["compilerModules"] = arrayOf(
        ":js:js.dce",
        ":compiler",
        ":kotlin-build-common",
+        ":core:metadata",
+        ":core:metadata.jvm",
        ":core:descriptors",
        ":core:descriptors.jvm",
        ":core:deserialization",
@@ -162,6 +223,7 @@ val coreLibProjects = listOf(
        ":kotlin-test:kotlin-test-common",
        ":kotlin-test:kotlin-test-jvm",
        ":kotlin-test:kotlin-test-junit",
+        ":kotlin-test:kotlin-test-testng",
        ":kotlin-test:kotlin-test-js",
        ":kotlin-reflect"
 )
@@ -191,20 +253,7 @@ apply {
    }
 }

-val importedAntTasksPrefix = "imported-ant-update-"
-
-// TODO: check the reasons of import conflict with xerces
-//ant.importBuild("$rootDir/update_dependencies.xml") { antTaskName -> importedAntTasksPrefix + antTaskName }
-
-tasks.matching { task ->
-    task.name.startsWith(importedAntTasksPrefix)
-}.forEach {
-    it.group = "Imported ant"
-}
-
-//task("update-dependencies") {
-//    dependsOn(tasks.getByName(importedAntTasksPrefix + "update"))
-//}
+apply { plugin("jps-compatible") }

 fun Project.allprojectsRecursive(body: Project.() -> Unit) {
    this.body()
@@ -213,7 +262,9 @@ fun Project.allprojectsRecursive(body: Project.() -> Unit) {

 fun Task.listConfigurationContents(configName: String) {
    doFirst {
-        println("$configName configuration files:\n${project.configurations[configName].allArtifacts.files.files.joinToString("\n  ", "  ")}")
+        project.configurations.findByName(configName)?.let {
+            println("$configName configuration files:\n${it.allArtifacts.files.files.joinToString("\n  ", "  ")}")
+        }
    }
 }

@@ -230,17 +281,22 @@ allprojects {
    //  - some tests (in particular js and binary-compatibility-validator depend on the fixed (default) location
    //  - idea seems unable to exclude common builddir from indexing
    // therefore it is disabled by default
-//    buildDir = File(commonBuildDir, project.name)
+    // buildDir = File(commonBuildDir, project.name)

+    val repos: List<String> by rootProject.extra
    repositories {
-        for (repo in (rootProject.extra["repos"] as List<String>)) {
-            maven { setUrl(repo) }
+        for (repo in repos) {
+            maven(repo)
        }
+
+        intellijSdkRepo(project)
+        androidDxJarRepo(project)
    }
+
    configureJvmProject(javaHome!!, jvmTarget!!)

-    val commonCompilerArgs = listOf("-Xallow-kotlin-package")
-    
+    val commonCompilerArgs = listOf("-Xallow-kotlin-package", "-Xread-deserialized-contracts")
+
    tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinCompile<*>> {
        kotlinOptions {
            languageVersion = kotlinLanguageVersion
@@ -282,25 +338,40 @@ allprojects {
        if (javaHome != defaultJavaHome || jvmTarget != defaultJvmTarget) {
            configureJvmProject(javaHome!!, jvmTarget!!)
        }
+
+        fun File.toProjectRootRelativePathOrSelf() = (relativeToOrNull(rootDir)?.takeUnless { it.startsWith("..") } ?: this).path
+
+        fun FileCollection.printClassPath(role: String) =
+                println("${project.path} $role classpath:\n  ${joinToString("\n  ") { it.toProjectRootRelativePathOrSelf() } }")
+
+        try { the<JavaPluginConvention>() } catch (_: UnknownDomainObjectException) { null }?.let { javaConvention ->
+            task("printCompileClasspath") { doFirst { javaConvention.sourceSets["main"].compileClasspath.printClassPath("compile") } }
+            task("printRuntimeClasspath") { doFirst { javaConvention.sourceSets["main"].runtimeClasspath.printClassPath("runtime") } }
+            task("printTestCompileClasspath") { doFirst { javaConvention.sourceSets["test"].compileClasspath.printClassPath("test compile") } }
+            task("printTestRuntimeClasspath") { doFirst { javaConvention.sourceSets["test"].runtimeClasspath.printClassPath("test runtime") } }
+        }
    }
 }

-task<Copy>("dist") {
+val distTask = task<Copy>("dist") {
+    val childDistTasks = getTasksByName("dist", true) - this@task
+    dependsOn(childDistTasks)
+
    into(distDir)
    from(files("compiler/cli/bin")) { into("kotlinc/bin") }
    from(files("license")) { into("kotlinc/license") }
 }

 val compilerCopyTask = task<Copy>("idea-plugin-copy-compiler") {
-    dependsOnTaskIfExistsRec("dist")
+    dependsOn(distTask)
    into(ideaPluginDir)
    from(distDir) { include("kotlinc/**") }
 }

 task<Copy>("ideaPlugin") {
    dependsOn(compilerCopyTask)
-    dependsOnTaskIfExistsRec("idea-plugin")
-    shouldRunAfter(":prepare:idea-plugin:idea-plugin")
+    val childIdeaPluginTasks = getTasksByName("ideaPlugin", true) - this@task
+    dependsOn(childIdeaPluginTasks)
    into("$ideaPluginDir/lib")
 }

@@ -312,6 +383,13 @@ tasks {
        }
    }

+    // TODO: copied from TeamCityBuild.xml (with ultimate-related modification), consider removing after migrating from it
+    "cleanupArtifacts" {
+        doLast {
+            delete(ideaPluginDir)
+            delete(ideaUltimatePluginDir)
+        }
+    }

    "coreLibsTest" {
        (coreLibProjects + listOf(
@@ -342,6 +420,7 @@ tasks {

    "jsCompilerTest" {
        dependsOn(":js:js.tests:test")
+        dependsOn(":js:js.tests:runMocha")
    }

    "scriptingTest" {
@@ -355,6 +434,7 @@ tasks {

        dependsOn("scriptingTest")
        dependsOn(":kotlin-build-common:test")
+        dependsOn(":compiler:incremental-compilation-impl:test")
    }

    "examplesTest" {
@@ -407,9 +487,11 @@ tasks {

    "plugins-tests" {
        dependsOn("dist")
-        dependsOn(":plugins:plugins-tests:test",
-                  ":kotlin-annotation-processing:test",
+        dependsOn(":kotlin-annotation-processing:test",
                  ":kotlin-source-sections-compiler-plugin:test",
+                  ":kotlin-allopen-compiler-plugin:test",
+                  ":kotlin-noarg-compiler-plugin:test",
+                  ":kotlin-sam-with-receiver-compiler-plugin:test",
                  ":plugins:uast-kotlin:test",
                  ":kotlin-annotation-processing-gradle:test")
    }
@@ -434,19 +516,70 @@ tasks {
    "check" { dependsOn("test") }
 }

+fun CopySpec.compilerScriptPermissionsSpec() {
+    filesMatching("bin/*") { mode = 0b111101101 }
+    filesMatching("bin/*.bat") { mode = 0b110100100 }
+}
+
+val zipCompiler by task<Zip> {
+    destinationDir = file(distDir)
+    archiveName = "kotlin-compiler-$kotlinVersion.zip"
+    from(distKotlinHomeDir) {
+        into("kotlinc")
+        compilerScriptPermissionsSpec()
+    }
+    doLast {
+        logger.lifecycle("Compiler artifacts packed to $archivePath")
+    }
+}
+
+val zipTestData by task<Zip> {
+    destinationDir = file(distDir)
+    archiveName = "kotlin-test-data.zip"
+    from("compiler/testData") { into("compiler") }
+    from("idea/testData") { into("ide") }
+    from("idea/idea-completion/testData") { into("ide/completion") }
+    doLast {
+        logger.lifecycle("Test data packed to $archivePath")
+    }
+}
+
+val zipPlugin by task<Zip> {
+    val src = when (project.findProperty("pluginArtifactDir") as String?) {
+        "Kotlin" -> ideaPluginDir
+        "KotlinUltimate" -> ideaUltimatePluginDir
+        null -> if (project.hasProperty("ultimate")) ideaUltimatePluginDir else ideaPluginDir
+        else -> error("Unsupported plugin artifact dir")
+    }
+    val destPath = project.findProperty("pluginZipPath") as String?
+    val dest = File(destPath ?: "$buildDir/kotlin-plugin.zip")
+    destinationDir = dest.parentFile
+    archiveName = dest.name
+    doFirst {
+        if (destPath == null) throw GradleException("Specify target zip path with 'pluginZipPath' property")
+    }
+    into("Kotlin") {
+        from("$src/kotlinc") {
+            into("kotlinc")
+            compilerScriptPermissionsSpec()
+        }
+        from(src) {
+            exclude("kotlinc")
+        }
+    }
+    doLast {
+        logger.lifecycle("Plugin artifacts packed to $archivePath")
+    }
+}
+
 configure<IdeaModel> {
    module {
        excludeDirs = files(
                project.buildDir,
+                commonLocalDataDir,
                ".gradle",
                "dependencies",
-                "dist",
-                "ideaSDK/bin",
-                "ideaSDK/androidSDK",
-                "ideaSDK/config",
-                "ideaSDK/config-idea",
-                "ideaSDK/system",
-                "ideaSDK/system-idea"
+                "dist"
        ).toSet()
    }
 }
@@ -462,10 +595,12 @@ fun jdkPath(version: String): String = jdkPathIfFound(version)

 fun Project.configureJvmProject(javaHome: String, javaVersion: String) {
    tasks.withType<JavaCompile> {
-        options.isFork = true
-        options.forkOptions.javaHome = file(javaHome)
-        options.compilerArgs.add("-proc:none")
-        options.encoding = "UTF-8"
+        if (name != "compileJava9Java") {
+            options.isFork = true
+            options.forkOptions.javaHome = file(javaHome)
+            options.compilerArgs.add("-proc:none")
+            options.encoding = "UTF-8"
+        }
    }

    tasks.withType<KotlinCompile> {
@@ -477,3 +612,41 @@ fun Project.configureJvmProject(javaHome: String, javaVersion: String) {
        executable = File(javaHome, "bin/java").canonicalPath
    }
 }
+
+tasks.create("findShadowJarsInClasspath").doLast {
+    fun Collection<File>.printSorted(indent: String = "    ") {
+        sortedBy { it.path }.forEach { println(indent + it.relativeTo(rootProject.projectDir)) }
+    }
+
+    val shadowJars = hashSetOf<File>()
+    for (project in rootProject.allprojects) {
+        for (task in project.tasks) {
+            when (task) {
+                is ShadowJar -> {
+                    shadowJars.add(File(task.archivePath))
+                }
+                is ProGuardTask -> {
+                    shadowJars.addAll(task.outputs.files.toList())
+                }
+            }
+        }
+    }
+
+    println("Shadow jars:")
+    shadowJars.printSorted()
+
+    fun Project.checkConfig(configName: String) {
+        val config = configurations.findByName(configName) ?: return
+        val shadowJarsInConfig = config.resolvedConfiguration.files.filter { it in shadowJars }
+        if (shadowJarsInConfig.isNotEmpty()) {
+            println()
+            println("Project $project contains shadow jars in configuration '$configName':")
+            shadowJarsInConfig.printSorted()
+        }
+    }
+
+    for (project in rootProject.allprojects) {
+        project.checkConfig("compileClasspath")
+        project.checkConfig("testCompileClasspath")
+    }
+}
--- a/build.xml
+++ b/build.xml
--- a/buildSrc/build.gradle.kts
+++ b/buildSrc/build.gradle.kts
@@ -2,7 +2,9 @@
 buildscript {
    val buildSrcKotlinVersion: String by extra(findProperty("buildSrc.kotlin.version")?.toString() ?: embeddedKotlinVersion)
    val buildSrcKotlinRepo: String? by extra(findProperty("buildSrc.kotlin.repo") as String?)
-    extra["versions.shadow"] = "2.0.1"
+    extra["versions.shadow"] = "2.0.2"
+    extra["versions.intellij-plugin"] = "0.3.0-SNAPSHOT"
+    extra["versions.native-platform"] = "0.14"

    repositories {
        buildSrcKotlinRepo?.let {
@@ -29,21 +31,42 @@ plugins {
    `kotlin-dsl`
 }

+fun Project.getBooleanProperty(name: String): Boolean? = this.findProperty(name)?.let {
+    val v = it.toString()
+    if (v.isBlank()) true
+    else v.toBoolean()
+}
+
+rootProject.apply {
+    from(rootProject.file("../versions.gradle.kts"))
+}
+
+val isTeamcityBuild = project.hasProperty("teamcity") || System.getenv("TEAMCITY_VERSION") != null
+val intellijUltimateEnabled by extra(project.getBooleanProperty("intellijUltimateEnabled") ?: isTeamcityBuild)
+val intellijSeparateSdks by extra(project.getBooleanProperty("intellijSeparateSdks") ?: false)
+
+extra["intellijRepo"] = "https://www.jetbrains.com/intellij-repository"
+extra["intellijReleaseType"] = "releases" // or "snapshots"
+extra["versions.androidDxSources"] = "5.0.0_r2"
+
+extra["customDepsOrg"] = "kotlin.build.custom.deps"
+
 repositories {
    extra["buildSrcKotlinRepo"]?.let {
        maven(url = it)
    }
-    maven(url = "https://dl.bintray.com/kotlin/kotlin-dev") // for dex-method-list
-//    maven { setUrl("https://repo.gradle.org/gradle/libs-releases-local") }
+    maven(url = "https://repo.gradle.org/gradle/libs-releases-local") // for native-platform
    jcenter()
 }

 dependencies {
-    compile(files("../dependencies/native-platform-uberjar.jar"))
-    compile("com.jakewharton.dex:dex-method-list:2.0.0-alpha")
-//    compile("net.rubygrapefruit:native-platform:0.14")
+    compile("net.rubygrapefruit:native-platform:${property("versions.native-platform")}")
+    compile("net.rubygrapefruit:native-platform-windows-amd64:${property("versions.native-platform")}")
+    compile("net.rubygrapefruit:native-platform-windows-i386:${property("versions.native-platform")}")
+    compile("com.jakewharton.dex:dex-method-list:3.0.0")
    // TODO: adding the dep to the plugin breaks the build unexpectedly, resolve and uncomment
 //    compile("org.jetbrains.kotlin:kotlin-gradle-plugin:${rootProject.extra["bootstrap_kotlin_version"]}")
+    // Shadow plugin is used in many projects of the main build. Once it's no longer used in buildSrc, please move this dependency to the root project
    compile("com.github.jengelman.gradle.plugins:shadow:${property("versions.shadow")}")
    compile("org.ow2.asm:asm-all:6.0_BETA")
 }
@@ -54,3 +77,5 @@ samWithReceiver {

 fun Project.`samWithReceiver`(configure: org.jetbrains.kotlin.samWithReceiver.gradle.SamWithReceiverExtension.() -> Unit): Unit =
        extensions.configure("samWithReceiver", configure)
+
+tasks["build"].dependsOn(":prepare-deps:android-dx:build", ":prepare-deps:intellij-sdk:build")
--- a/buildSrc/gradle.properties
+++ b/buildSrc/gradle.properties
@@ -1,7 +1,7 @@
 org.gradle.daemon=true
 org.gradle.parallel=false
 org.gradle.configureondemand=false
-org.gradle.jvmargs=-Xmx1200m -XX:+CMSClassUnloadingEnabled -XX:+CMSPermGenSweepingEnabled
+org.gradle.jvmargs=-Duser.country=US -Dkotlin.daemon.jvm.options=-Xmx1600m

 #buildSrc.kotlin.repo=https://jcenter.bintray.com
 #buildSrc.kotlin.version=1.1.50
--- a/buildSrc/prepare-deps/android-dx/build.gradle.kts
+++ b/buildSrc/prepare-deps/android-dx/build.gradle.kts
@@ -0,0 +1,106 @@
+
+import org.gradle.api.publish.ivy.internal.artifact.DefaultIvyArtifact
+import org.gradle.api.publish.ivy.internal.publication.DefaultIvyConfiguration
+import org.gradle.api.publish.ivy.internal.publication.DefaultIvyPublicationIdentity
+import org.gradle.api.publish.ivy.internal.publisher.IvyDescriptorFileGenerator
+import java.io.File
+import org.gradle.internal.os.OperatingSystem
+import org.gradle.jvm.tasks.Jar
+
+val toolsOs by lazy {
+    when {
+        OperatingSystem.current().isWindows -> "windows"
+        OperatingSystem.current().isMacOsX -> "macosx"
+        OperatingSystem.current().isLinux -> "linux"
+        else -> {
+            logger.error("Unknown operating system for android tools: ${OperatingSystem.current().name}")
+            ""
+        }
+    }
+}
+
+val buildToolsVersion = rootProject.extra["versions.androidBuildTools"] as String
+val dxSourcesVersion = rootProject.extra["versions.androidDxSources"] as String
+
+repositories {
+    ivy {
+        artifactPattern("https://dl-ssl.google.com/android/repository/[artifact]_[revision](-[classifier]).[ext]")
+        artifactPattern("https://android.googlesource.com/platform/dalvik/+archive/android-$dxSourcesVersion/[artifact].[ext]")
+    }
+}
+
+val customDepsRepoDir = File(buildDir, "repo")
+val customDepsOrg: String by rootProject.extra
+val dxModuleName = "android-dx"
+val dxRevision = buildToolsVersion
+val dxRepoModuleDir = File(customDepsRepoDir, "$customDepsOrg/$dxModuleName/$dxRevision")
+
+val buildToolsZip by configurations.creating
+val dxSourcesTar by configurations.creating
+
+dependencies {
+    buildToolsZip("google:build-tools:$buildToolsVersion:$toolsOs@zip")
+    dxSourcesTar("google:dx:0@tar.gz")
+}
+
+val unzipDxJar by tasks.creating {
+    dependsOn(buildToolsZip)
+    inputs.files(buildToolsZip)
+    outputs.files(File(dxRepoModuleDir, "dx.jar"))
+    doFirst {
+        project.copy {
+            from(zipTree(buildToolsZip.singleFile).files)
+            include("**/dx.jar")
+            into(dxRepoModuleDir)
+        }
+    }
+}
+
+val dxSourcesTargetDir = File(buildDir, "dx_src")
+
+val untarDxSources by tasks.creating {
+    dependsOn(dxSourcesTar)
+    inputs.files(dxSourcesTar)
+    outputs.dir(dxSourcesTargetDir)
+    doFirst {
+        project.copy {
+            from(tarTree(dxSourcesTar.singleFile))
+            include("src/**")
+            includeEmptyDirs = false
+            into(dxSourcesTargetDir)
+        }
+    }
+}
+
+val prepareDxSourcesJar by tasks.creating(Jar::class) {
+    dependsOn(untarDxSources)
+    from("$dxSourcesTargetDir/src")
+    destinationDir = dxRepoModuleDir
+    baseName = "dx"
+    classifier = "sources"
+}
+
+val prepareIvyXml by tasks.creating {
+    dependsOn(unzipDxJar, prepareDxSourcesJar)
+    inputs.files(unzipDxJar, prepareDxSourcesJar)
+    val ivyFile = File(dxRepoModuleDir, "$dxModuleName.ivy.xml")
+    outputs.file(ivyFile)
+    doLast {
+        with(IvyDescriptorFileGenerator(DefaultIvyPublicationIdentity(customDepsOrg, dxModuleName, dxRevision))) {
+            addConfiguration(DefaultIvyConfiguration("default"))
+            addConfiguration(DefaultIvyConfiguration("sources"))
+            addArtifact(DefaultIvyArtifact(File(dxRepoModuleDir, "dx.jar"), "dx", "jar", "jar", null).also { it.conf = "default" })
+            addArtifact(DefaultIvyArtifact(File(dxRepoModuleDir, "dx-sources.jar"), "dx", "jar", "sources", "sources").also { it.conf = "sources" })
+            writeTo(ivyFile)
+        }
+    }
+}
+
+val build by tasks.creating {
+    dependsOn(unzipDxJar, prepareDxSourcesJar, prepareIvyXml)
+}
+
+val clean by tasks.creating(Delete::class) {
+    delete(dxRepoModuleDir)
+    delete(buildDir)
+}
--- a/buildSrc/prepare-deps/intellij-sdk/build.gradle.kts
+++ b/buildSrc/prepare-deps/intellij-sdk/build.gradle.kts
@@ -0,0 +1,256 @@
+
+@file:Suppress("PropertyName")
+
+import org.gradle.api.publish.ivy.internal.artifact.DefaultIvyArtifact
+import org.gradle.api.publish.ivy.internal.publication.DefaultIvyConfiguration
+import org.gradle.api.publish.ivy.internal.publication.DefaultIvyPublicationIdentity
+import org.gradle.api.publish.ivy.internal.publisher.IvyDescriptorFileGenerator
+import java.io.File
+import org.gradle.internal.os.OperatingSystem
+
+val intellijUltimateEnabled: Boolean by rootProject.extra
+val intellijRepo: String by rootProject.extra
+val intellijReleaseType: String by rootProject.extra
+val intellijVersion = rootProject.extra["versions.intellijSdk"] as String
+val androidStudioRelease = rootProject.findProperty("versions.androidStudioRelease") as String?
+val androidStudioBuild = rootProject.findProperty("versions.androidStudioBuild") as String?
+val intellijSeparateSdks: Boolean by rootProject.extra
+val installIntellijCommunity = !intellijUltimateEnabled || intellijSeparateSdks
+val installIntellijUltimate = intellijUltimateEnabled
+
+val platformBaseVersion = intellijVersion.substringBefore('.', "").takeIf { it.isNotEmpty() }
+        ?: error("Invalid IDEA version $intellijVersion")
+
+logger.info("intellijUltimateEnabled: $intellijUltimateEnabled")
+
+logger.info("intellijVersion: $intellijVersion")
+logger.info("androidStudioRelease: $androidStudioRelease")
+logger.info("androidStudioBuild: $androidStudioBuild")
+
+logger.info("intellijSeparateSdks: $intellijSeparateSdks")
+logger.info("installIntellijCommunity: $installIntellijCommunity")
+logger.info("installIntellijUltimate: $installIntellijUltimate")
+
+val studioOs by lazy {
+    when {
+        OperatingSystem.current().isWindows -> "windows"
+        OperatingSystem.current().isMacOsX -> "mac"
+        OperatingSystem.current().isLinux -> "linux"
+        else -> {
+            logger.error("Unknown operating system for android tools: ${OperatingSystem.current().name}")
+            ""
+        }
+    }
+}
+
+repositories {
+    if (androidStudioRelease != null) {
+        ivy {
+            artifactPattern("https://dl.google.com/dl/android/studio/ide-zips/$androidStudioRelease/[artifact]-[revision]-$studioOs.zip")
+        }
+    }
+    maven { setUrl("$intellijRepo/$intellijReleaseType") }
+    maven { setUrl("https://plugins.jetbrains.com/maven") }
+    ivy {
+        artifactPattern("https://raw.github.com/JetBrains/intellij-community/[revision]/lib/src/[artifact].zip")
+    }
+}
+
+val intellij by configurations.creating
+val intellijUltimate by configurations.creating
+val sources by configurations.creating
+val `asm-shaded-sources` by configurations.creating
+val `jps-standalone` by configurations.creating
+val `jps-build-test` by configurations.creating
+val `intellij-core` by configurations.creating
+val `plugins-NodeJS` by configurations.creating
+
+val customDepsRepoDir = File(buildDir, "repo")
+val customDepsOrg: String by rootProject.extra
+val customDepsRevision = intellijVersion
+val customDepsRepoModulesDir = File(customDepsRepoDir, "$customDepsOrg/$customDepsRevision")
+val repoDir = customDepsRepoModulesDir
+
+dependencies {
+    if (androidStudioRelease != null) {
+        intellij("google:android-studio-ide:$androidStudioBuild")
+    } else {
+        if (installIntellijCommunity) {
+            intellij("com.jetbrains.intellij.idea:ideaIC:$intellijVersion")
+        }
+        if (installIntellijUltimate) {
+            intellijUltimate("com.jetbrains.intellij.idea:ideaIU:$intellijVersion")
+        }
+    }
+    sources("com.jetbrains.intellij.idea:ideaIC:$intellijVersion:sources@jar")
+    `asm-shaded-sources`("asmsources:asm-src:$platformBaseVersion@zip")
+    `jps-standalone`("com.jetbrains.intellij.idea:jps-standalone:$intellijVersion")
+    `jps-build-test`("com.jetbrains.intellij.idea:jps-build-test:$intellijVersion")
+    `intellij-core`("com.jetbrains.intellij.idea:intellij-core:$intellijVersion")
+    if (intellijUltimateEnabled) {
+        `plugins-NodeJS`("com.jetbrains.plugins:NodeJS:${rootProject.extra["versions.idea.NodeJS"]}@zip")
+    }
+}
+
+fun Task.configureExtractFromConfigurationTask(sourceConfig: Configuration,
+                                               pathRemap: (String) -> String = { it },
+                                               extractor: (Configuration) -> Any) {
+    dependsOn(sourceConfig)
+    inputs.files(sourceConfig)
+    val targetDir = File(repoDir, sourceConfig.name)
+    outputs.dirs(targetDir)
+    doFirst {
+        project.copy {
+            from(extractor(sourceConfig))
+            into(targetDir)
+            eachFile {
+                path = pathRemap(path)
+            }
+        }
+    }
+}
+
+fun removePathPrefix(path: String): String {
+    if (androidStudioRelease == null) return path
+    val slashes = if (studioOs == "mac") 2 else 1
+    var result = path
+    repeat(slashes) {
+        result = result.substringAfter('/')
+    }
+    return result
+}
+
+val unzipIntellijSdk by tasks.creating {
+    configureExtractFromConfigurationTask(intellij, pathRemap = { removePathPrefix(it) }) {
+        zipTree(it.singleFile).matching {
+            if (OperatingSystem.current().isMacOsX && androidStudioRelease != null) {
+                exclude("Android Studio*.app/Contents/plugins/Kotlin/**")
+            }
+            exclude("plugins/Kotlin/**")
+        }
+    }
+}
+
+val unzipIntellijUltimateSdk by tasks.creating {
+    configureExtractFromConfigurationTask(intellijUltimate) {
+        zipTree(it.singleFile).matching {
+            exclude("plugins/Kotlin/**")
+        }
+    }
+}
+
+val unzipIntellijCore by tasks.creating { configureExtractFromConfigurationTask(`intellij-core`) { zipTree(it.singleFile) } }
+
+val unzipJpsStandalone by tasks.creating { configureExtractFromConfigurationTask(`jps-standalone`) { zipTree(it.singleFile) } }
+
+val copyIntellijSdkSources by tasks.creating {
+    configureExtractFromConfigurationTask(sources) { it.singleFile }
+}
+
+val copyJpsBuildTest by tasks.creating { configureExtractFromConfigurationTask(`jps-build-test`) { it.singleFile } }
+
+val copyAsmShadedSources by tasks.creating { configureExtractFromConfigurationTask(`asm-shaded-sources`) { it.singleFile } }
+
+val unzipNodeJSPlugin by tasks.creating { configureExtractFromConfigurationTask(`plugins-NodeJS`) { zipTree(it.singleFile) } }
+
+fun writeIvyXml(moduleName: String, fileName: String, jarFiles: FileCollection, baseDir: File, sourcesJar: File?) {
+    with(IvyDescriptorFileGenerator(DefaultIvyPublicationIdentity(customDepsOrg, moduleName, intellijVersion))) {
+        addConfiguration(DefaultIvyConfiguration("default"))
+        addConfiguration(DefaultIvyConfiguration("sources"))
+        jarFiles.asFileTree.files.forEach {
+            if (it.isFile && it.extension == "jar") {
+                val relativeName = it.toRelativeString(baseDir).removeSuffix(".jar")
+                addArtifact(DefaultIvyArtifact(it, relativeName, "jar", "jar", null).also { it.conf = "default" })
+            }
+        }
+        if (sourcesJar != null) {
+            val sourcesArtifactName = sourcesJar.name.removeSuffix(".jar").substringBefore("-")
+            addArtifact(DefaultIvyArtifact(sourcesJar, sourcesArtifactName, "jar", "sources", "sources").also { it.conf = "sources" })
+        }
+        writeTo(File(customDepsRepoModulesDir, "$fileName.ivy.xml"))
+    }
+}
+
+val prepareIvyXmls by tasks.creating {
+    dependsOn(unzipIntellijCore, unzipJpsStandalone, copyIntellijSdkSources, copyJpsBuildTest, copyAsmShadedSources)
+
+    val intellijSdkDir = File(repoDir, intellij.name)
+    val intellijUltimateSdkDir = File(repoDir, intellijUltimate.name)
+
+    if (installIntellijCommunity) {
+        dependsOn(unzipIntellijSdk)
+        inputs.dir(intellijSdkDir)
+        outputs.file(File(repoDir, "${intellij.name}.ivy.xml"))
+    }
+
+    if (installIntellijUltimate) {
+        dependsOn(unzipIntellijUltimateSdk)
+        inputs.dir(intellijUltimateSdkDir)
+        outputs.file(File(repoDir, "${intellijUltimate.name}.ivy.xml"))
+    }
+
+    val flatDeps = listOf(`intellij-core`, `jps-standalone`, `jps-build-test`, `asm-shaded-sources`)
+    flatDeps.forEach {
+        inputs.dir(File(repoDir, it.name))
+        outputs.file(File(repoDir, "${it.name}.ivy.xml"))
+    }
+    inputs.dir(File(repoDir, sources.name))
+
+    if (intellijUltimateEnabled) {
+        dependsOn(unzipNodeJSPlugin)
+        inputs.dir(File(repoDir, `plugins-NodeJS`.name))
+        outputs.file(File(repoDir, "${`plugins-NodeJS`.name}.ivy.xml"))
+    }
+
+    doFirst {
+        val sourcesFile = if (sources.isEmpty) null else File(repoDir, "${sources.name}/${sources.singleFile.name}")
+
+        if (installIntellijCommunity) {
+            val libDir = File(intellijSdkDir, "lib")
+            writeIvyXml(intellij.name,
+                        intellij.name,
+                        fileTree(libDir).filter {
+                            it.parentFile == libDir && !it.name.startsWith("kotlin-")
+                        },
+                        libDir,
+                        sourcesFile)
+
+            File(intellijSdkDir, "plugins").listFiles { it: File -> it.isDirectory }.forEach {
+                writeIvyXml(it.name, "intellij.plugin.${it.name}", files("$it/lib/"), File(it, "lib"), sourcesFile)
+            }
+        }
+
+        if (installIntellijUltimate) {
+            val libDir = File(intellijUltimateSdkDir, "lib")
+            writeIvyXml(intellij.name, // important! the module name should be "intellij"
+                        intellijUltimate.name,
+                        fileTree(libDir).filter {
+                            it.parentFile == libDir && !it.name.startsWith("kotlin-")
+                        },
+                        libDir,
+                        sourcesFile)
+
+            File(intellijUltimateSdkDir, "plugins").listFiles { it: File -> it.isDirectory }.forEach {
+                writeIvyXml(it.name, "intellijUltimate.plugin.${it.name}", files("$it/lib/"), File(it, "lib"), sourcesFile)
+            }
+        }
+
+        flatDeps.forEach {
+            writeIvyXml(it.name, it.name, files("$repoDir/${it.name}"), File(repoDir, it.name), sourcesFile)
+        }
+
+        if (intellijUltimateEnabled) {
+            val nodeJsBaseDir = "${`plugins-NodeJS`.name}/NodeJS/lib"
+            writeIvyXml("NodeJS", `plugins-NodeJS`.name, files("$repoDir/$nodeJsBaseDir"), File(repoDir, nodeJsBaseDir), sourcesFile)
+        }
+    }
+}
+
+val build by tasks.creating {
+    dependsOn(prepareIvyXmls)
+}
+
+val clean by tasks.creating(Delete::class) {
+    delete(customDepsRepoModulesDir)
+    delete(buildDir)
+}
--- a/buildSrc/settings.gradle
+++ b/buildSrc/settings.gradle
@@ -0,0 +1,3 @@
+
+include "prepare-deps:android-dx",
+        "prepare-deps:intellij-sdk"
--- a/buildSrc/src/main/kotlin/AndroidSdkDependencies.kt
+++ b/buildSrc/src/main/kotlin/AndroidSdkDependencies.kt
@@ -0,0 +1,14 @@
+@file:Suppress("unused") // usages in build scripts are not tracked properly
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.dsl.RepositoryHandler
+import org.gradle.api.artifacts.repositories.IvyArtifactRepository
+import org.gradle.kotlin.dsl.extra
+
+fun RepositoryHandler.androidDxJarRepo(project: Project): IvyArtifactRepository = ivy {
+    val baseDir = File("${project.rootDir}/buildSrc/prepare-deps/android-dx/build/repo")
+    ivyPattern("${baseDir.canonicalPath}/[organisation]/[module]/[revision]/[module].ivy.xml")
+    artifactPattern("${baseDir.canonicalPath}/[organisation]/[module]/[revision]/[artifact](-[classifier]).jar")
+}
+
+fun Project.androidDxJar() = "kotlin.build.custom.deps:android-dx:${rootProject.extra["versions.androidBuildTools"]}"
--- a/buildSrc/src/main/kotlin/CommonUtil.kt
+++ b/buildSrc/src/main/kotlin/CommonUtil.kt
@@ -1,35 +1,23 @@
@file:Suppress("unused") // usages in build scripts are not tracked properly

-import org.gradle.api.*
-import org.gradle.api.tasks.*
-import org.gradle.kotlin.dsl.*
-import org.gradle.api.plugins.JavaPluginConvention
+import groovy.lang.Closure
+import org.gradle.api.Project
+import org.gradle.api.Task
 import org.gradle.api.file.SourceDirectorySet
 import org.gradle.api.internal.AbstractTask
-import org.gradle.jvm.tasks.Jar
+import org.gradle.api.plugins.JavaPluginConvention
+import org.gradle.api.tasks.JavaExec
+import org.gradle.api.tasks.SourceSetOutput
+import org.gradle.kotlin.dsl.creating
+import org.gradle.kotlin.dsl.extra
+import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.the
 import java.io.File

 inline fun <reified T : Task> Project.task(noinline configuration: T.() -> Unit) = tasks.creating(T::class, configuration)

-
-fun AbstractTask.dependsOnTaskIfExists(task: String, project: Project?, parentProject: Project?) {
-    val thisTask = this
-    val p = project ?: this.project
-    p.afterEvaluate {
-        p.tasks.firstOrNull { it.name == task }?.also {
-            if (parentProject != null) {
-                parentProject.evaluationDependsOn(p.path)
-            }
-            thisTask.dependsOn(it)
-        }
-    }
-}
-
-fun AbstractTask.dependsOnTaskIfExistsRec(task: String, project: Project? = null, parentProject: Project? = null) {
-    dependsOnTaskIfExists(task, project, parentProject)
-    (project ?: this.project).subprojects.forEach {
-        dependsOnTaskIfExistsRec(task, it, this.project)
-    }
+fun Project.callGroovy(name: String, vararg args: Any?): Any? {
+    return (property(name) as Closure<*>).call(*args)
 }

 inline fun<T: Any> Project.withJavaPlugin(crossinline body: () -> T?): T? {
@@ -68,3 +56,9 @@ fun Project.generator(fqName: String) = task<JavaExec> {
    main = fqName
    workingDir = rootDir
 }
+
+fun Project.getBooleanProperty(name: String): Boolean? = this.findProperty(name)?.let {
+    val v = it.toString()
+    if (v.isBlank()) true
+    else v.toBoolean()
+}
--- a/buildSrc/src/main/kotlin/artifacts.kt
+++ b/buildSrc/src/main/kotlin/artifacts.kt
@@ -36,10 +36,12 @@ fun Project.classesDirsArtifact(): FileCollection {
    return classesDirs
 }

+private const val MAGIC_DO_NOT_CHANGE_TEST_JAR_TASK_NAME = "testJar"
+
 fun Project.testsJar(body: Jar.() -> Unit = {}): Jar {
    val testsJarCfg = configurations.getOrCreate("tests-jar").extendsFrom(configurations["testCompile"])

-    return task<Jar>("testsJar") {
+    return task<Jar>(MAGIC_DO_NOT_CHANGE_TEST_JAR_TASK_NAME) {
        dependsOn("testClasses")
        pluginManager.withPlugin("java") {
            from(project.the<JavaPluginConvention>().sourceSets.getByName("test").output)
@@ -51,7 +53,12 @@ fun Project.testsJar(body: Jar.() -> Unit = {}): Jar {
 }

 fun Project.noDefaultJar() {
-    tasks.findByName("jar")?.enabled = false
+    tasks.findByName("jar")?.let { defaultJarTask ->
+        defaultJarTask.enabled = false
+        configurations.findByName("archives")?.artifacts?.removeAll {
+            (it as? ArchivePublishArtifact)?.archiveTask?.let { it == defaultJarTask } ?: false
+        }
+    }
 }

 fun<T> Project.runtimeJarArtifactBy(task: Task, artifactRef: T, body: ConfigurablePublishArtifact.() -> Unit = {}) {
@@ -74,18 +81,19 @@ fun<T: Jar> Project.runtimeJar(task: T, body: T.() -> Unit = {}): T {

 fun Project.runtimeJar(taskName: String = "jar", body: Jar.() -> Unit = {}): Jar = runtimeJar(getOrCreateTask(taskName, body))

-fun Project.sourcesJar(body: Jar.() -> Unit = {}): Jar =
+fun Project.sourcesJar(sourceSet: String? = "main", body: Jar.() -> Unit = {}): Jar =
        getOrCreateTask("sourcesJar") {
            duplicatesStrategy = DuplicatesStrategy.EXCLUDE
            classifier = "sources"
            try {
-                project.pluginManager.withPlugin("java-base") {
-                    from(project.the<JavaPluginConvention>().sourceSets["main"].allSource)
+                if (sourceSet != null) {
+                    project.pluginManager.withPlugin("java-base") {
+                        from(project.the<JavaPluginConvention>().sourceSets[sourceSet].allSource)
+                    }
                }
            } catch (e: UnknownDomainObjectException) {
                // skip default sources location
            }
-            tasks.findByName("classes")?.let { dependsOn(it) }
            body()
            project.addArtifact("archives", this, this)
        }
--- a/buildSrc/src/main/kotlin/dependencies.kt
+++ b/buildSrc/src/main/kotlin/dependencies.kt
@@ -2,10 +2,11 @@

 import org.gradle.api.GradleException
 import org.gradle.api.Project
-import org.gradle.api.artifacts.Dependency
 import org.gradle.api.artifacts.ProjectDependency
 import org.gradle.api.artifacts.dsl.DependencyHandler
 import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.tasks.AbstractCopyTask
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import org.gradle.kotlin.dsl.extra
 import org.gradle.kotlin.dsl.project
 import java.io.File
@@ -14,14 +15,24 @@ import java.io.File
 fun Project.commonDep(coord: String): String {
    val parts = coord.split(':')
    return when (parts.size) {
-        1 -> "$coord:$coord:${rootProject.extra["versions.$coord"]}"
-        2 -> "${parts[0]}:${parts[1]}:${rootProject.extra["versions.${parts[1]}"]}"
+        1 -> "$coord:$coord:${commonVer(coord, coord)}"
+        2 -> "${parts[0]}:${parts[1]}:${commonVer(parts[0], parts[1])}"
        3 -> coord
        else -> throw IllegalArgumentException("Illegal maven coordinates: $coord")
    }
 }

-fun Project.commonDep(group: String, artifact: String): String = "$group:$artifact:${rootProject.extra["versions.$artifact"]}"
+fun Project.commonDep(group: String, artifact: String, vararg suffixesAndClassifiers: String): String {
+    val (classifiers, artifactSuffixes) = suffixesAndClassifiers.partition { it.startsWith(':') }
+    return "$group:$artifact${artifactSuffixes.joinToString("")}:${commonVer(group, artifact)}${classifiers.joinToString("")}"
+}
+
+fun Project.commonVer(group: String, artifact: String) =
+        when {
+            rootProject.extra.has("versions.$artifact") -> rootProject.extra["versions.$artifact"]
+            rootProject.extra.has("versions.$group") -> rootProject.extra["versions.$group"]
+            else -> throw GradleException("Neither versions.$artifact nor versions.$group is defined in the root project's extra")
+        }

 fun Project.preloadedDeps(vararg artifactBaseNames: String, baseDir: File = File(rootDir, "dependencies"), subdir: String? = null, optional: Boolean = false): ConfigurableFileCollection {
    val dir = if (subdir != null) File(baseDir, subdir) else baseDir
@@ -44,25 +55,6 @@ fun Project.ideaUltimatePreloadedDeps(vararg artifactBaseNames: String, subdir:
    else files()
 }

-fun Project.ideaSdkDeps(vararg artifactBaseNames: String, subdir: String = "lib", optional: Boolean = false): ConfigurableFileCollection =
-        preloadedDeps(*artifactBaseNames, baseDir = File(rootDir, "ideaSDK"), subdir = subdir, optional = optional)
-
-fun Project.ideaUltimateSdkDeps(vararg artifactBaseNames: String, subdir: String = "lib"): ConfigurableFileCollection {
-    val ultimateSdkDir = File(rootDir, "ultimate", "ideaSDK")
-    return if (ultimateSdkDir.isDirectory) preloadedDeps(*artifactBaseNames, baseDir = ultimateSdkDir, subdir = subdir)
-           else files()
-}
-
-fun Project.ideaSdkCoreDeps(vararg artifactBaseNames: String): ConfigurableFileCollection = ideaSdkDeps(*artifactBaseNames, subdir = "core")
-
-fun Project.ideaUltimateSdkCoreDeps(vararg artifactBaseNames: String): ConfigurableFileCollection = ideaUltimateSdkDeps(*artifactBaseNames, subdir = "core")
-
-fun Project.ideaPluginDeps(vararg artifactBaseNames: String, plugin: String, subdir: String = "lib", optional: Boolean = false): ConfigurableFileCollection =
-        ideaSdkDeps(*artifactBaseNames, subdir = "plugins/$plugin/$subdir", optional = optional)
-
-fun Project.ideaUltimatePluginDeps(vararg artifactBaseNames: String, plugin: String, subdir: String = "lib"): ConfigurableFileCollection =
-        ideaUltimateSdkDeps(*artifactBaseNames, subdir = "plugins/$plugin/$subdir")
-
 fun Project.kotlinDep(artifactBaseName: String, version: String): String = "org.jetbrains.kotlin:kotlin-$artifactBaseName:$version"

 fun DependencyHandler.projectDist(name: String): ProjectDependency = project(name, configuration = "distJar").apply { isTransitive = false }
@@ -72,15 +64,15 @@ fun DependencyHandler.projectArchives(name: String): ProjectDependency = project
 fun DependencyHandler.projectClasses(name: String): ProjectDependency = project(name, configuration = "classes-dirs")

 val protobufLiteProject = ":custom-dependencies:protobuf-lite"
+val protobufRelocatedProject = ":custom-dependencies:protobuf-relocated"
 fun DependencyHandler.protobufLite(): ProjectDependency =
        project(protobufLiteProject, configuration = "default").apply { isTransitive = false }
 val protobufLiteTask = "$protobufLiteProject:prepare"

 fun DependencyHandler.protobufFull(): ProjectDependency =
-        project(protobufLiteProject, configuration = "relocated").apply { isTransitive = false }
-val protobufFullTask = "$protobufLiteProject:prepare-relocated-protobuf"
+        project(protobufRelocatedProject, configuration = "default").apply { isTransitive = false }

-private fun File.matchMaybeVersionedArtifact(baseName: String) = name.matches(baseName.toMaybeVersionedJarRegex())
+fun File.matchMaybeVersionedArtifact(baseName: String) = name.matches(baseName.toMaybeVersionedJarRegex())

 private val wildcardsRe = """[^*?]+|(\*)|(\?)""".toRegex()

@@ -101,10 +93,29 @@ private fun String.toMaybeVersionedJarRegex(): Regex {
 }


-private val jreHome = System.getProperty("java.home")

-fun firstFromJavaHomeThatExists(vararg paths: String): File =
-        paths.mapNotNull { File(jreHome, it).takeIf { it.exists() } }.firstOrNull()
-                ?: throw GradleException("Cannot find under '$jreHome' neither of: ${paths.joinToString()}")
+fun Project.firstFromJavaHomeThatExists(vararg paths: String, jdkHome: File = File(this.property("JDK_18") as String)): File? =
+    paths.map { File(jdkHome, it) }.firstOrNull { it.exists() }.also {
+        if (it == null)
+            logger.warn("Cannot find file by paths: ${paths.toList()} in $jdkHome")
+    }

-fun toolsJar(): File = firstFromJavaHomeThatExists("../lib/tools.jar", "../Classes/tools.jar")
+fun Project.toolsJar(jdkHome: File = File(this.property("JDK_18") as String)): File? =
+    firstFromJavaHomeThatExists("lib/tools.jar", jdkHome = jdkHome)
+
+object EmbeddedComponents {
+    val CONFIGURATION_NAME = "embeddedComponents"
+}
+
+fun Project.containsEmbeddedComponents() {
+    configurations.create(EmbeddedComponents.CONFIGURATION_NAME)
+}
+
+fun AbstractCopyTask.fromEmbeddedComponents() {
+    val embeddedComponents = project.configurations.getByName(EmbeddedComponents.CONFIGURATION_NAME)
+    if (this is ShadowJar) {
+        from(embeddedComponents)
+    } else {
+        embeddedComponents.forEach { from(if (it.isDirectory) it else project.zipTree(it)) }
+    }
+}
--- a/buildSrc/src/main/kotlin/embeddable.kt
+++ b/buildSrc/src/main/kotlin/embeddable.kt
@@ -1,10 +1,8 @@
@file:Suppress("unused") // usages in build scripts are not tracked properly

 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
-import org.gradle.api.GradleException
 import org.gradle.api.Project
 import org.gradle.api.file.DuplicatesStrategy
-import org.gradle.api.tasks.bundling.Zip
 import org.gradle.jvm.tasks.Jar
 import org.gradle.kotlin.dsl.task
 import org.gradle.kotlin.dsl.*
@@ -18,9 +16,10 @@ val packagesToRelocate =
                "org.apache",
                "org.jdom",
                "org.picocontainer",
-                "jline",
+                "org.jline",
                "gnu",
-                "org.fusesource")
+                "org.fusesource",
+                "kotlinx.coroutines")

 // The shaded compiler "dummy" is used to rewrite dependencies in projects that are used with the embeddable compiler
 // on the runtime and use some shaded dependencies from the compiler
@@ -41,7 +40,6 @@ val packagesToExcludeFromDummy =
               "one/util/streamex/**",
               "org/iq80/snappy/**",
               "org/jline/**",
-               "org/json/**",
               "org/xmlpull/**",
               "*.txt")

@@ -105,23 +103,22 @@ fun Project.embeddableCompilerDummyForDependenciesRewriting(taskName: String = "
    }
 }

-fun Project.rewriteDepsToShadedJar(originalJarTask: Jar, shadowJarTask: Zip, body: Jar.() -> Unit = {}): Jar {
-    val originalFiles by lazy {
-        val jarContents = zipTree(originalJarTask.outputs.files.singleFile).files
-        val basePath = jarContents.find { it.name == "MANIFEST.MF" }?.parentFile?.parentFile ?: throw GradleException("cannot determine the jar root dir")
-        jarContents.map { it.relativeTo(basePath).path }.toSet()
+fun Project.rewriteDepsToShadedJar(originalJarTask: Jar, shadowJarTask: Jar, body: Jar.() -> Unit = {}): Jar {
+    originalJarTask.apply {
+        classifier = "original"
    }
-    return task<Jar>("rewrittenDepsJar") {
-        originalJarTask.apply {
-            classifier = "original"
-        }
-        shadowJarTask.apply {
-            dependsOn(originalJarTask)
-            from(originalJarTask)// { include("**") }
-            classifier = "shadow"
-        }
-        dependsOn(shadowJarTask)
-        from(project.zipTree(shadowJarTask.outputs.files.singleFile)) { include { originalFiles.any { originalFile -> it.file.canonicalPath.endsWith(originalFile) } } }
+
+    val compilerDummyJarFile by lazy { configurations.getAt("compilerDummyJar").singleFile }
+
+    return shadowJarTask.apply {
+        dependsOn(originalJarTask)
+        from(originalJarTask)// { include("**") }
+
+        // When Gradle traverses the inputs, reject the shaded compiler JAR,
+        // which leads to the content of that JAR being excluded as well:
+        exclude { it.file == compilerDummyJarFile }
+
+        classifier = null
        body()
    }
 }
--- a/buildSrc/src/main/kotlin/instrument.kt
+++ b/buildSrc/src/main/kotlin/instrument.kt
@@ -17,6 +17,7 @@
 */

 import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.ProjectDependency
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.FileCollection
@@ -51,6 +52,12 @@ fun Project.configureInstrumentation() {
        }
    }

+    val instrumentationClasspathCfg = configurations.create("instrumentationClasspath")
+
+    dependencies {
+        instrumentationClasspathCfg(intellijDep()) { includeJars("javac2", "jdom", "asm-all", "jgoodies-forms") }
+    }
+
    afterEvaluate {
        the<JavaPluginConvention>().sourceSets.all { sourceSetParam ->
            // This copy will ignore filters, but they are unlikely to be used.
@@ -66,6 +73,7 @@ fun Project.configureInstrumentation() {
            instrumentTask.apply {
                dependsOn(sourceSetParam.classesTaskName).onlyIf { !classesDirsCopy.isEmpty }
                sourceSet = sourceSetParam
+                instrumentationClasspath = instrumentationClasspathCfg
                originalClassesDirs = classesDirsCopy
                output = instrumentedClassesDir
            }
@@ -88,6 +96,8 @@ open class IntelliJInstrumentCodeTask : ConventionTask() {

    var sourceSet: SourceSet? = null

+    var instrumentationClasspath: Configuration? = null
+
    @Input
    var originalClassesDirs: FileCollection? = null

@@ -101,9 +111,10 @@ open class IntelliJInstrumentCodeTask : ConventionTask() {
    @TaskAction
    fun instrumentClasses() {
        logger.info("input files are: ${originalClassesDirs?.joinToString("; ", transform = { "'${it.name}'${if (it.exists()) "" else " (does not exists)" }"})}")
+        output?.deleteRecursively()
        copyOriginalClasses()

-        val classpath = project.ideaSdkDeps("javac2.jar", "jdom.jar", "asm-all.jar", "jgoodies-forms.jar")
+        val classpath = instrumentationClasspath!!

        ant.withGroovyBuilder {
            "taskdef"("name" to "instrumentIdeaExtensions",
@@ -113,7 +124,7 @@ open class IntelliJInstrumentCodeTask : ConventionTask() {
        }

        logger.info("Compiling forms and instrumenting code with nullability preconditions")
-        val instrumentNotNull = prepareNotNullInstrumenting(classpath)
+        val instrumentNotNull = prepareNotNullInstrumenting(classpath.asPath)
        instrumentCode(sourceDirs, instrumentNotNull)
    }

@@ -124,10 +135,10 @@ open class IntelliJInstrumentCodeTask : ConventionTask() {
        }
    }

-    private fun prepareNotNullInstrumenting(classpath: ConfigurableFileCollection): Boolean {
+    private fun prepareNotNullInstrumenting(classpath: String): Boolean {
        ant.withGroovyBuilder {
            "typedef"("name"  to "skip",
-                      "classpath" to classpath.asPath,
+                      "classpath" to classpath,
                      "loaderref" to LOADER_REF,
                      "classname" to FILTER_ANNOTATION_REGEXP_CLASS)
        }
--- a/buildSrc/src/main/kotlin/intellijDependencies.kt
+++ b/buildSrc/src/main/kotlin/intellijDependencies.kt
@@ -0,0 +1,167 @@
+/*
+ * 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.
+ */
+
+@file:Suppress("unused") // usages in build scripts are not tracked properly
+
+import org.gradle.api.GradleException
+import org.gradle.api.Project
+import org.gradle.api.artifacts.ModuleDependency
+import org.gradle.api.artifacts.dsl.RepositoryHandler
+import org.gradle.api.artifacts.repositories.IvyArtifactRepository
+import org.gradle.api.plugins.JavaPluginConvention
+import org.gradle.api.tasks.JavaExec
+import org.gradle.kotlin.dsl.*
+import java.io.File
+
+private fun Project.intellijRepoDir() = File("${project.rootDir.absoluteFile}/buildSrc/prepare-deps/intellij-sdk/build/repo")
+
+fun RepositoryHandler.intellijSdkRepo(project: Project): IvyArtifactRepository = ivy {
+    val baseDir = project.intellijRepoDir()
+    val intellijEnforceCommunitySdk = project.getBooleanProperty("intellijEnforceCommunitySdk") == true
+
+    setUrl(baseDir)
+
+    if (!intellijEnforceCommunitySdk) {
+        ivyPattern("${baseDir.canonicalPath}/[organisation]/[revision]/[module]Ultimate.ivy.xml")
+        ivyPattern("${baseDir.canonicalPath}/[organisation]/[revision]/intellijUltimate.plugin.[module].ivy.xml")
+        artifactPattern("${baseDir.canonicalPath}/[organisation]/[revision]/[module]Ultimate/lib/[artifact](-[classifier]).jar")
+        artifactPattern("${baseDir.canonicalPath}/[organisation]/[revision]/intellijUltimate/plugins/[module]/lib/[artifact](-[classifier]).jar")
+    }
+
+    ivyPattern("${baseDir.canonicalPath}/[organisation]/[revision]/[module].ivy.xml")
+    ivyPattern("${baseDir.canonicalPath}/[organisation]/[revision]/intellij.plugin.[module].ivy.xml")
+    artifactPattern("${baseDir.canonicalPath}/[organisation]/[revision]/[module]/lib/[artifact](-[classifier]).jar")
+    artifactPattern("${baseDir.canonicalPath}/[organisation]/[revision]/intellij/plugins/[module]/lib/[artifact](-[classifier]).jar")
+    artifactPattern("${baseDir.canonicalPath}/[organisation]/[revision]/plugins-[module]/[module]/lib/[artifact](-[classifier]).jar")
+    artifactPattern("${baseDir.canonicalPath}/[organisation]/[revision]/[module]/[artifact].jar")
+    artifactPattern("${baseDir.canonicalPath}/[organisation]/[revision]/[module]/[artifact](-[revision])(-[classifier]).jar")
+    artifactPattern("${baseDir.canonicalPath}/[organisation]/[revision]/sources/[artifact]-[revision]-[classifier].[ext]")
+}
+
+fun Project.intellijDep(module: String = "intellij") = "kotlin.build.custom.deps:$module:${rootProject.extra["versions.intellijSdk"]}"
+
+fun Project.intellijCoreDep() = intellijDep("intellij-core")
+
+fun Project.intellijPluginDep(plugin: String) = intellijDep(plugin)
+
+fun Project.intellijUltimateDep() = intellijDep("intellij")
+
+fun Project.intellijUltimatePluginDep(plugin: String) = intellijDep(plugin)
+
+fun ModuleDependency.includeJars(vararg names: String, rootProject: Project? = null) {
+    names.forEach {
+        var baseName = it.removeSuffix(".jar")
+        if (rootProject != null && rootProject.extra.has("ignore.jar.$baseName")) {
+            return@forEach
+        }
+        if (rootProject != null && rootProject.extra.has("versions.jar.$baseName")) {
+            baseName += "-${rootProject.extra["versions.jar.$baseName"]}"
+        }
+        artifact {
+            name = baseName
+            type = "jar"
+            extension = "jar"
+        }
+    }
+}
+
+// Workaround. Top-level Kotlin function in a default package can't be called from a non-default package
+object IntellijRootUtils {
+    fun getRepositoryRootDir(project: Project): File = with (project.rootProject) {
+        return File(intellijRepoDir(), "kotlin.build.custom.deps/${extra["versions.intellijSdk"]}")
+    }
+
+    fun getIntellijRootDir(project: Project): File = with (project.rootProject) {
+        return File(getRepositoryRootDir(this), "intellij${if (isIntellijCommunityAvailable()) "" else "Ultimate"}")
+    }
+}
+
+fun ModuleDependency.includeIntellijCoreJarDependencies(project: Project) =
+        includeJars(*(project.rootProject.extra["IntellijCoreDependencies"] as List<String>).toTypedArray(), rootProject = project.rootProject)
+
+fun ModuleDependency.includeIntellijCoreJarDependencies(project: Project, jarsFilterPredicate: (String) -> Boolean) =
+        includeJars(*(project.rootProject.extra["IntellijCoreDependencies"] as List<String>).filter { jarsFilterPredicate(it) }.toTypedArray(), rootProject = project.rootProject)
+
+fun Project.isIntellijCommunityAvailable() = !(rootProject.extra["intellijUltimateEnabled"] as Boolean) || rootProject.extra["intellijSeparateSdks"] as Boolean
+
+fun Project.isIntellijUltimateSdkAvailable() = (rootProject.extra["intellijUltimateEnabled"] as Boolean)
+
+fun Project.intellijRootDir() = IntellijRootUtils.getIntellijRootDir(project)
+
+fun Project.intellijUltimateRootDir() =
+        if (isIntellijUltimateSdkAvailable())
+            File(intellijRepoDir(), "kotlin.build.custom.deps/${rootProject.extra["versions.intellijSdk"]}/intellijUltimate")
+        else
+            throw GradleException("intellij ultimate SDK is not available")
+
+fun DependencyHandlerScope.excludeInAndroidStudio(rootProject: Project, block: DependencyHandlerScope.() -> Unit) {
+    if (!rootProject.extra.has("versions.androidStudioRelease")) {
+        block()
+    }
+}
+
+fun Project.runIdeTask(name: String, ideaPluginDir: File, ideaSandboxDir: File, body: JavaExec.() -> Unit): JavaExec {
+
+    return task<JavaExec>(name) {
+        val ideaSandboxConfigDir = File(ideaSandboxDir, "config")
+
+        classpath = the<JavaPluginConvention>().sourceSets["main"].runtimeClasspath
+
+        main = "com.intellij.idea.Main"
+
+        workingDir = File(intellijRootDir(), "bin")
+
+        jvmArgs(
+            "-Xmx1250m",
+            "-XX:ReservedCodeCacheSize=240m",
+            "-XX:+HeapDumpOnOutOfMemoryError",
+            "-ea",
+            "-Didea.is.internal=true",
+            "-Didea.debug.mode=true",
+            "-Didea.system.path=$ideaSandboxDir",
+            "-Didea.config.path=$ideaSandboxConfigDir",
+            "-Dapple.laf.useScreenMenuBar=true",
+            "-Dapple.awt.graphics.UseQuartz=true",
+            "-Dsun.io.useCanonCaches=false",
+            "-Dplugin.path=${ideaPluginDir.absolutePath}",
+            "-Dkotlin.internal.mode.enabled=true",
+            "-Didea.additional.classpath=../idea-kotlin-runtime/kotlin-runtime.jar,../idea-kotlin-runtime/kotlin-reflect.jar"
+        )
+
+        if (rootProject.findProperty("versions.androidStudioRelease") != null) {
+            jvmArgs("-Didea.platform.prefix=AndroidStudio")
+        }
+
+        if (project.hasProperty("noPCE")) {
+            jvmArgs("-Didea.ProcessCanceledException=disabled")
+        }
+
+        args()
+
+        doFirst {
+            val disabledPluginsFile = File(ideaSandboxConfigDir, "disabled_plugins.txt")
+            val disabledPluginsContents = disabledPluginsFile.takeIf { it.isFile }?.readLines()
+            val filteredContents = disabledPluginsContents?.filterNot { it.contains("org.jetbrains.kotlin") }
+            if (filteredContents != null && filteredContents.size != disabledPluginsContents.size) {
+                with(disabledPluginsFile.printWriter()) {
+                    filteredContents.forEach(this::println)
+                }
+            }
+        }
+
+        body()
+    }
+}
--- a/buildSrc/src/main/kotlin/jdksFinder.kt
+++ b/buildSrc/src/main/kotlin/jdksFinder.kt
@@ -9,7 +9,7 @@ import net.rubygrapefruit.platform.WindowsRegistry.Key.HKEY_LOCAL_MACHINE
 import org.gradle.internal.os.OperatingSystem

 enum class JdkMajorVersion {
-    JDK_16, JDK_17, JDK_18, JDK_9
+    JDK_16, JDK_17, JDK_18, JDK_9, JDK_10
 }

 val jdkAlternativeVarNames = mapOf(JdkMajorVersion.JDK_9 to listOf("JDK_19"))
@@ -149,7 +149,9 @@ fun MutableCollection<JdkId>.discoverJdksOnUnix(project: Project) {

 private val windowsConventionalJdkRegistryPaths = listOf(
        "SOFTWARE\\JavaSoft\\Java Development Kit",
-        "SOFTWARE\\Wow6432Node\\JavaSoft\\Java Development Kit")
+        "SOFTWARE\\Wow6432Node\\JavaSoft\\Java Development Kit",
+        "SOFTWARE\\JavaSoft\\JDK",
+        "SOFTWARE\\Wow6432Node\\JavaSoft\\JDK")

 fun MutableCollection<JdkId>.discoverJdksOnWindows(project: Project) {
    val registry = Native.get(WindowsRegistry::class.java)
--- a/buildSrc/src/main/kotlin/pill/context.kt
+++ b/buildSrc/src/main/kotlin/pill/context.kt
@@ -0,0 +1,15 @@
+@file:Suppress("PackageDirectoryMismatch")
+package org.jetbrains.kotlin.pill
+
+import org.gradle.api.artifacts.*
+
+class DependencyMapper(
+    val group: String,
+    val module: String,
+    vararg val configurations: String,
+    val mapping: (ResolvedDependency) -> MappedDependency?
+)
+
+class MappedDependency(val main: PDependency, val deferred: List<PDependency> = emptyList())
+
+class ParserContext(val dependencyMappers: List<DependencyMapper>)
--- a/buildSrc/src/main/kotlin/pill/kotlinPluginArtifact.kt
+++ b/buildSrc/src/main/kotlin/pill/kotlinPluginArtifact.kt
@@ -0,0 +1,186 @@
+@file:Suppress("PackageDirectoryMismatch")
+
+package org.jetbrains.kotlin.pill
+
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.internal.file.copy.SingleParentCopySpec
+import org.gradle.api.plugins.JavaPlugin
+import org.gradle.api.tasks.Copy
+import org.gradle.jvm.tasks.Jar
+import org.gradle.kotlin.dsl.extra
+import org.jetbrains.kotlin.pill.ArtifactElement.*
+import org.jetbrains.kotlin.pill.POrderRoot.*
+import java.io.File
+
+class PArtifact(val artifactName: String, val outputDir: File, private val contents: ArtifactElement.Root) {
+    fun render(context: PathContext) = xml("component", "name" to "ArtifactManager") {
+        xml("artifact", "name" to artifactName) {
+            xml("output-path") {
+                raw(context(outputDir))
+            }
+
+            add(contents.renderRecursively(context))
+        }
+    }
+}
+
+sealed class ArtifactElement {
+    private val myChildren = mutableListOf<ArtifactElement>()
+    val children get() = myChildren
+
+    fun add(child: ArtifactElement) {
+        myChildren += child
+    }
+
+    abstract fun render(context: PathContext): xml
+
+    fun renderRecursively(context: PathContext): xml {
+        return render(context).apply {
+            children.forEach { add(it.renderRecursively(context)) }
+        }
+    }
+
+    fun getDirectory(path: String): ArtifactElement {
+        if (path.isEmpty()) {
+            return this
+        }
+
+        var current: ArtifactElement = this
+        for (segment in path.split("/")) {
+            val existing = current.children.firstOrNull { it is Directory && it.name == segment }
+            if (existing != null) {
+                current = existing
+                continue
+            }
+
+            current = Directory(segment).also { current.add(it) }
+        }
+
+        return current
+    }
+
+    class Root : ArtifactElement() {
+        override fun render(context: PathContext) = xml("root", "id" to "root")
+    }
+
+    data class Directory(val name: String) : ArtifactElement() {
+        override fun render(context: PathContext) = xml("element", "id" to "directory", "name" to name)
+    }
+
+    data class Archive(val name: String) : ArtifactElement() {
+        override fun render(context: PathContext) = xml("element", "id" to "archive", "name" to name)
+    }
+
+    data class ModuleOutput(val moduleName: String) : ArtifactElement() {
+        override fun render(context: PathContext) = xml("element", "id" to "module-output", "name" to moduleName)
+    }
+
+    data class FileCopy(val source: File) : ArtifactElement() {
+        override fun render(context: PathContext) = xml("element", "id" to "file-copy", "path" to context(source))
+    }
+
+    data class DirectoryCopy(val source: File) : ArtifactElement() {
+        override fun render(context: PathContext) = xml("element", "id" to "dir-copy", "path" to context(source))
+    }
+
+    data class ProjectLibrary(val name: String) : ArtifactElement() {
+        override fun render(context: PathContext) = xml("element", "id" to "library", "level" to "project", "name" to name)
+    }
+
+    data class ExtractedDirectory(val archive: File, val pathInJar: String = "/") : ArtifactElement() {
+        override fun render(context: PathContext) =
+            xml("element", "id" to "extracted-dir", "path" to context(archive), "path-in-jar" to pathInJar)
+    }
+}
+
+fun generateKotlinPluginArtifactFile(rootProject: Project): PFile {
+    val mainIdeaPluginTask = rootProject.tasks.getByName("ideaPlugin") as Copy
+    val gradleArtifactDir = mainIdeaPluginTask.destinationDir
+
+    val ideaPluginTasks = mainIdeaPluginTask.taskDependencies
+        .getDependencies(mainIdeaPluginTask)
+        .filter { it.name == "ideaPlugin" }
+        .filterIsInstance<Copy>()
+
+    val root = Root()
+
+    // Copy kotlinc directory
+    root.add(Directory("kotlinc").apply {
+        val kotlincDirectory = rootProject.extra["distKotlinHomeDir"].toString()
+        add(DirectoryCopy(File(kotlincDirectory)))
+    })
+
+    for (task in ideaPluginTasks) {
+        val spec = task.rootSpec.children.filterIsInstance<SingleParentCopySpec>().singleOrNull()
+                ?: error("Copy spec is not unique in ${rootProject.name}. Available specs: ${task.rootSpec.children}")
+
+        val sourcePaths = spec.sourcePaths
+        for (sourcePath in sourcePaths) {
+            if (sourcePath is ShadowJar) {
+                if (sourcePath.project.path == ":prepare:idea-plugin") {
+                    val kotlinPluginJar = Archive(sourcePath.archiveName).also { root.getDirectory("lib").add(it) }
+
+                    kotlinPluginJar.add(FileCopy(File(rootProject.projectDir, "resources/kotlinManifest.properties")))
+
+                    for (jarFile in sourcePath.project.configurations.getByName("packedJars").resolve()) {
+                        kotlinPluginJar.add(ExtractedDirectory(jarFile))
+                    }
+
+                    @Suppress("UNCHECKED_CAST")
+                    for (projectPath in sourcePath.project.extra["projectsToShadow"] as List<String>) {
+                        val jpsModuleName = rootProject.findProject(projectPath)!!.name + ".src"
+                        kotlinPluginJar.add(ModuleOutput(jpsModuleName))
+                    }
+
+                    continue
+                }
+            }
+
+            when (sourcePath) {
+                is Jar -> {
+                    val targetDir = ("lib/" + task.destinationDir.toRelativeString(gradleArtifactDir)).withoutSlash()
+
+                    val archiveForJar = Archive(sourcePath.project.name + ".jar").apply {
+                        if (task.project.plugins.hasPlugin(JavaPlugin::class.java)) {
+                            add(ModuleOutput(sourcePath.project.name + ".src"))
+                        }
+                        root.getDirectory(targetDir).add(this)
+                    }
+
+                    val embeddedComponents = sourcePath.project.configurations
+                        .findByName(EmbeddedComponents.CONFIGURATION_NAME)?.resolvedConfiguration
+
+                    if (embeddedComponents != null) {
+                        for ((_, _, dependency) in listOf(embeddedComponents to Scope.COMPILE).collectDependencies()) {
+                            if (dependency.configuration == "runtimeElements") {
+                                archiveForJar.add(ModuleOutput(dependency.moduleName + ".src"))
+                            } else if (dependency.configuration == "tests-jar" || dependency.configuration == "jpsTest") {
+                                error("Test configurations are not allowed here")
+                            } else {
+                                for (file in dependency.moduleArtifacts.map { it.file }) {
+                                    archiveForJar.add(ExtractedDirectory(file))
+                                }
+                            }
+                        }
+                    }
+                }
+                is Configuration -> {
+                    require(sourcePath.name == "sideJars") { "Configurations other than 'sideJars' are not supported" }
+                    for (file in sourcePath.resolve()) {
+                        root.getDirectory("lib").add(FileCopy(file))
+                    }
+                }
+                else -> error("${task.name} Unexpected task type ${task.javaClass.name}")
+            }
+        }
+    }
+
+    val artifact = PArtifact("KotlinPlugin", File(rootProject.projectDir, "out/artifacts/Kotlin"), root)
+    return PFile(
+        File(rootProject.projectDir, ".idea/artifacts/${artifact.artifactName}.xml"),
+        artifact.render(ProjectContext(rootProject))
+    )
+}
+
--- a/buildSrc/src/main/kotlin/pill/parser.kt
+++ b/buildSrc/src/main/kotlin/pill/parser.kt
@@ -0,0 +1,379 @@
+@file:Suppress("PackageDirectoryMismatch")
+package org.jetbrains.kotlin.pill
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.*
+import org.gradle.api.plugins.JavaPlugin
+import org.gradle.api.plugins.JavaPluginConvention
+import org.gradle.kotlin.dsl.configure
+import org.gradle.plugins.ide.idea.IdeaPlugin
+import org.gradle.api.file.SourceDirectorySet
+import org.gradle.api.internal.HasConvention
+import org.jetbrains.kotlin.pill.POrderRoot.*
+import org.jetbrains.kotlin.pill.PSourceRoot.*
+import java.io.File
+import java.util.LinkedList
+
+data class PProject(
+    val name: String,
+    val rootDirectory: File,
+    val modules: List<PModule>,
+    val libraries: List<PLibrary>
+)
+
+data class PModule(
+    val name: String,
+    val bundleName: String,
+    val rootDirectory: File,
+    val moduleFile: File,
+    val contentRoots: List<PContentRoot>,
+    val orderRoots: List<POrderRoot>,
+    val moduleForProductionSources: PModule? = null,
+    val group: String? = null
+)
+
+data class PContentRoot(
+    val path: File,
+    val forTests: Boolean,
+    val sourceRoots: List<PSourceRoot>,
+    val excludedDirectories: List<File>
+)
+
+data class PSourceRoot(
+    val path: File,
+    val kind: Kind
+) {
+    enum class Kind {
+        PRODUCTION, TEST, RESOURCES, TEST_RESOURCES;
+
+        val isResources get() = this == RESOURCES || this == TEST_RESOURCES
+    }
+}
+
+data class POrderRoot(
+    val dependency: PDependency,
+    val scope: Scope,
+    val isExported: Boolean = false,
+    val isProductionOnTestDependency: Boolean = false
+) {
+    enum class Scope { COMPILE, TEST, RUNTIME, PROVIDED }
+}
+
+sealed class PDependency {
+    data class Module(val name: String) : PDependency()
+    data class Library(val name: String) : PDependency()
+    data class ModuleLibrary(val library: PLibrary) : PDependency()
+}
+
+data class PLibrary(
+    val name: String,
+    val classes: List<File>,
+    val javadoc: List<File> = emptyList(),
+    val sources: List<File> = emptyList(),
+    val annotations: List<File> = emptyList(),
+    val dependencies: List<PLibrary> = emptyList()
+) {
+    fun attachSource(file: File): PLibrary {
+        return this.copy(sources = this.sources + listOf(file))
+    }
+}
+
+fun parse(project: Project, libraries: List<PLibrary>, context: ParserContext): PProject = with (context) {
+    if (project != project.rootProject) {
+        error("$project is not a root project")
+    }
+
+    val modules = project.allprojects
+        .filter { it.plugins.hasPlugin(JpsCompatiblePlugin::class.java) }
+        .flatMap { parseModules(it) }
+
+    return PProject("Kotlin", project.projectDir, modules, libraries)
+}
+
+/*
+    Ordering here and below is significant.
+    Placing 'runtime' configuration dependencies on the top make 'idea' tests to run normally.
+    ('idea' module has 'intellij-core' as transitive dependency, and we really need to get rid of it.)
+ */
+private val CONFIGURATION_MAPPING = mapOf(
+    listOf("runtime") to Scope.RUNTIME,
+    listOf("compile") to Scope.COMPILE,
+    listOf("compileOnly") to Scope.PROVIDED
+)
+
+private val TEST_CONFIGURATION_MAPPING = mapOf(
+    listOf("runtime", "testRuntime") to Scope.RUNTIME,
+    listOf("compile", "testCompile") to Scope.COMPILE,
+    listOf("compileOnly", "testCompileOnly") to Scope.PROVIDED,
+    listOf("jpsTest") to Scope.TEST
+)
+
+private val SOURCE_SET_MAPPING = mapOf(
+    "main" to Kind.PRODUCTION,
+    "test" to Kind.TEST
+)
+
+private fun ParserContext.parseModules(project: Project): List<PModule> {
+    val (productionContentRoots, testContentRoots) = parseContentRoots(project).partition { !it.forTests }
+
+    val modules = mutableListOf<PModule>()
+
+    fun getJavaExcludedDirs() = project.plugins.findPlugin(IdeaPlugin::class.java)
+        ?.model?.module?.excludeDirs?.toList() ?: emptyList()
+
+    val allExcludedDirs = getJavaExcludedDirs() + project.buildDir
+
+    var productionSourcesModule: PModule? = null
+
+    fun getModuleFile(suffix: String = ""): File {
+        val relativePath = File(project.projectDir, project.name + suffix + ".iml")
+            .toRelativeString(project.rootProject.projectDir)
+
+        return File(project.rootProject.projectDir, ".idea/modules/$relativePath")
+    }
+
+    for ((nameSuffix, roots) in mapOf(".src" to productionContentRoots, ".test" to testContentRoots)) {
+        if (roots.isEmpty()) {
+            continue
+        }
+
+        val mainRoot = roots.first()
+
+        var dependencies = parseDependencies(project, mainRoot.forTests)
+        if (productionContentRoots.isNotEmpty() && mainRoot.forTests) {
+            val productionModuleDependency = PDependency.Module(project.name + ".src")
+            dependencies += POrderRoot(productionModuleDependency, Scope.COMPILE, true)
+        }
+
+        val module = PModule(
+            project.name + nameSuffix,
+            project.name,
+            mainRoot.path,
+            getModuleFile(nameSuffix),
+            roots,
+            dependencies,
+            productionSourcesModule
+        )
+
+        modules += module
+
+        if (!mainRoot.forTests) {
+            productionSourcesModule = module
+        }
+    }
+
+    val mainModuleFileRelativePath = when {
+        project == project.rootProject -> File(project.rootProject.projectDir, project.name + ".iml")
+        else -> getModuleFile()
+    }
+
+    modules += PModule(
+        project.name,
+        project.name,
+        project.projectDir,
+        mainModuleFileRelativePath,
+        listOf(PContentRoot(project.projectDir, false, emptyList(), allExcludedDirs)),
+        if (modules.isEmpty()) parseDependencies(project, false) else emptyList()
+    )
+
+    return modules
+}
+
+private fun parseContentRoots(project: Project): List<PContentRoot> {
+    val sourceRoots = parseSourceRoots(project).groupBy { it.kind }
+    fun getRoots(kind: PSourceRoot.Kind) = sourceRoots[kind] ?: emptyList()
+
+    val productionSourceRoots = getRoots(Kind.PRODUCTION) + getRoots(Kind.RESOURCES)
+    val testSourceRoots = getRoots(Kind.TEST) + getRoots(Kind.TEST_RESOURCES)
+
+    fun createContentRoots(sourceRoots: List<PSourceRoot>, forTests: Boolean): List<PContentRoot> {
+        return sourceRoots.map { PContentRoot(it.path, forTests, listOf(it), emptyList()) }
+    }
+
+    return createContentRoots(productionSourceRoots, forTests = false) +
+            createContentRoots(testSourceRoots, forTests = true)
+}
+
+private fun parseSourceRoots(project: Project): List<PSourceRoot> {
+    if (!project.plugins.hasPlugin(JavaPlugin::class.java)) {
+        return emptyList()
+    }
+
+    val sourceRoots = mutableListOf<PSourceRoot>()
+
+    project.configure<JavaPluginConvention> {
+        for ((sourceSetName, kind) in SOURCE_SET_MAPPING) {
+            val sourceSet = sourceSets.findByName(sourceSetName) ?: continue
+
+            fun Any.getKotlin(): SourceDirectorySet {
+                val kotlinMethod = javaClass.getMethod("getKotlin")
+                val oldIsAccessible = kotlinMethod.isAccessible
+                try {
+                    kotlinMethod.isAccessible = true
+                    return kotlinMethod(this) as SourceDirectorySet
+                } finally {
+                    kotlinMethod.isAccessible = oldIsAccessible
+                }
+            }
+
+            val kotlinSourceDirectories = (sourceSet as HasConvention).convention
+                .plugins["kotlin"]?.getKotlin()?.srcDirs
+                    ?: emptySet()
+
+            val directories = (sourceSet.java.sourceDirectories.files + kotlinSourceDirectories).toList()
+                .filter { it.exists() }
+                .takeIf { it.isNotEmpty() }
+                    ?: continue
+
+            for (resourceRoot in sourceSet.resources.sourceDirectories.files) {
+                if (!resourceRoot.exists() || resourceRoot in directories) {
+                    continue
+                }
+
+                val resourceRootKind = when (kind) {
+                    Kind.PRODUCTION -> Kind.RESOURCES
+                    Kind.TEST -> Kind.TEST_RESOURCES
+                    else -> error("Invalid source root kind $kind")
+                }
+
+                sourceRoots += PSourceRoot(resourceRoot, resourceRootKind)
+            }
+
+            for (directory in directories) {
+                sourceRoots += PSourceRoot(directory, kind)
+            }
+        }
+    }
+
+    return sourceRoots
+}
+
+private fun ParserContext.parseDependencies(project: Project, forTests: Boolean): List<POrderRoot> {
+    val configurationMapping = if (forTests) TEST_CONFIGURATION_MAPPING else CONFIGURATION_MAPPING
+
+    with(project.configurations) {
+        val mainRoots = mutableListOf<POrderRoot>()
+        val deferredRoots = mutableListOf<POrderRoot>()
+
+        fun collectConfigurations(): List<Pair<ResolvedConfiguration, Scope>> {
+            val configurations = mutableListOf<Pair<ResolvedConfiguration, Scope>>()
+
+            for ((configurationNames, scope) in configurationMapping) {
+                for (configurationName in configurationNames) {
+                    val configuration = findByName(configurationName)?.also { it.resolve() } ?: continue
+                    configurations += Pair(configuration.resolvedConfiguration, scope)
+                }
+            }
+
+            return configurations
+        }
+
+        nextDependency@ for ((configuration, scope, dependency) in collectConfigurations().collectDependencies()) {
+            for (mapper in dependencyMappers) {
+                if (dependency.moduleGroup == mapper.group
+                    && dependency.moduleName == mapper.module
+                    && dependency.configuration in mapper.configurations
+                ) {
+                    val mappedDependency = mapper.mapping(dependency)
+
+                    if (mappedDependency != null) {
+                        val orderRoot = POrderRoot(mappedDependency.main, scope)
+                        if (mappedDependency.main is PDependency.Module) {
+                            mainRoots += orderRoot
+                        } else {
+                            mainRoots += orderRoot
+                        }
+
+                        for (deferredDep in mappedDependency.deferred) {
+                            deferredRoots += POrderRoot(deferredDep, scope)
+                        }
+                    }
+
+                    continue@nextDependency
+                }
+            }
+
+            if (dependency.configuration == "runtimeElements" && scope != Scope.TEST) {
+                mainRoots += POrderRoot(PDependency.Module(dependency.moduleName + ".src"), scope)
+            } else if (dependency.configuration == "tests-jar" || dependency.configuration == "jpsTest") {
+                mainRoots += POrderRoot(
+                    PDependency.Module(dependency.moduleName + ".test"),
+                    scope,
+                    isProductionOnTestDependency = true
+                )
+            } else {
+                val classes = dependency.moduleArtifacts.map { it.file }
+                val library = PLibrary(dependency.moduleName, classes)
+                mainRoots += POrderRoot(PDependency.ModuleLibrary(library), scope)
+            }
+        }
+
+        return removeDuplicates(mainRoots + deferredRoots)
+    }
+}
+
+private fun removeDuplicates(roots: List<POrderRoot>): List<POrderRoot> {
+    val dependenciesByScope = roots.groupBy { it.scope }.mapValues { it.value.mapTo(mutableSetOf()) { it.dependency } }
+    fun depenciesFor(scope: Scope) = dependenciesByScope[scope] ?: emptySet<PDependency>()
+
+    val result = mutableSetOf<POrderRoot>()
+    for (root in roots.distinct()) {
+        val scope = root.scope
+        val dependency = root.dependency
+
+        if (root in result) {
+            continue
+        }
+
+        if ((scope == Scope.PROVIDED || scope == Scope.RUNTIME) && dependency in depenciesFor(Scope.COMPILE)) {
+            continue
+        }
+
+        if (scope == Scope.PROVIDED && dependency in depenciesFor(Scope.RUNTIME)) {
+            result += POrderRoot(dependency, Scope.COMPILE)
+            continue
+        }
+
+        if (scope == Scope.RUNTIME && dependency in depenciesFor(Scope.PROVIDED)) {
+            result += POrderRoot(dependency, Scope.COMPILE)
+            continue
+        }
+
+        result += root
+    }
+
+    return result.toList()
+}
+
+data class DependencyInfo(val configuration: ResolvedConfiguration, val scope: Scope, val dependency: ResolvedDependency)
+
+fun List<Pair<ResolvedConfiguration, Scope>>.collectDependencies(): List<DependencyInfo> {
+    val dependencies = mutableListOf<DependencyInfo>()
+
+    val unprocessed = LinkedList<DependencyInfo>()
+    val existing = mutableSetOf<Pair<Scope, ResolvedDependency>>()
+
+    for ((configuration, scope) in this) {
+        for (dependency in configuration.firstLevelModuleDependencies) {
+            unprocessed += DependencyInfo(configuration, scope, dependency)
+        }
+    }
+
+    while (unprocessed.isNotEmpty()) {
+        val info = unprocessed.removeAt(0)
+        dependencies += info
+
+        val data = Pair(info.scope, info.dependency)
+        existing += data
+
+        for (child in info.dependency.children) {
+            if (child.moduleGroup != "org.jetbrains.kotlin" && Pair(info.scope, child) in existing) {
+                continue
+            }
+
+            unprocessed += DependencyInfo(info.configuration, info.scope, child)
+        }
+    }
+
+    return dependencies
+}
--- a/buildSrc/src/main/kotlin/pill/pathContext.kt
+++ b/buildSrc/src/main/kotlin/pill/pathContext.kt
@@ -0,0 +1,43 @@
+@file:Suppress("PackageDirectoryMismatch")
+package org.jetbrains.kotlin.pill
+
+import org.gradle.api.Project
+import java.io.File
+
+interface PathContext {
+    operator fun invoke(file: File): String
+
+    fun url(file: File): Pair<String, String> {
+        val path = when {
+            file.isFile && file.extension.toLowerCase() == "jar" -> "jar://" + this(file) + "!/"
+            else -> "file://" + this(file)
+        }
+
+        return Pair("url", path)
+    }
+}
+
+class ProjectContext private constructor(val projectDir: File) : PathContext {
+    constructor(project: PProject) : this(project.rootDirectory)
+    constructor(project: Project) : this(project.projectDir)
+
+    override fun invoke(file: File): String {
+        return file.absolutePath.replace(projectDir.absolutePath, "\$PROJECT_DIR\$")
+    }
+}
+
+class ModuleContext(val project: PProject, val module: PModule) : PathContext {
+    override fun invoke(file: File): String {
+        if (!file.startsWith(project.rootDirectory)) {
+            return file.absolutePath
+        }
+
+        return "\$MODULE_DIR\$/" +
+            project.rootDirectory.toRelativeString(module.moduleFile.parentFile).withSlash() +
+            module.rootDirectory.toRelativeString(project.rootDirectory).withSlash() +
+            file.toRelativeString(module.rootDirectory)
+    }
+}
+
+fun String.withSlash() = if (this.endsWith("/")) this else (this + "/")
+fun String.withoutSlash() = this.trimEnd('/')
--- a/buildSrc/src/main/kotlin/pill/plugin.kt
+++ b/buildSrc/src/main/kotlin/pill/plugin.kt
@@ -0,0 +1,276 @@
+package org.jetbrains.kotlin.pill
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.plugins.BasePluginConvention
+import org.gradle.kotlin.dsl.extra
+import shadow.org.jdom2.input.SAXBuilder
+import shadow.org.jdom2.*
+import shadow.org.jdom2.output.Format
+import shadow.org.jdom2.output.XMLOutputter
+import java.io.File
+
+class JpsCompatiblePlugin : Plugin<Project> {
+    companion object {
+        private const val JPS_LIBRARY_PATH = "jpsLibraryPath"
+
+        private fun mapper(module: String, vararg configurations: String): DependencyMapper {
+            return DependencyMapper("org.jetbrains.kotlin", module, *configurations) { MappedDependency(PDependency.Library(module)) }
+        }
+
+        private fun getDependencyMappers(projectLibraries: List<PLibrary>): List<DependencyMapper> {
+            val mappersForKotlinLibrariesExeptStdlib = projectLibraries
+                .filter { it.name != "kotlin-stdlib" }
+                .mapTo(mutableListOf()) { mapper(it.name, "default", "distJar", "runtimeElements") }
+
+            return mappersForKotlinLibrariesExeptStdlib + listOf(
+                DependencyMapper("org.jetbrains.kotlin", "kotlin-stdlib", "distJar", "runtimeElements") {
+                    MappedDependency(
+                        PDependency.Library("kotlin-stdlib"),
+                        listOf(PDependency.Library("annotations-13.0"))
+                    )
+                },
+                DependencyMapper("org.jetbrains.kotlin", "kotlin-reflect-api", "runtimeElements") {
+                    MappedDependency(PDependency.Library("kotlin-reflect"))
+                },
+                DependencyMapper("org.jetbrains.kotlin", "kotlin-compiler-embeddable", "runtimeJar") { null },
+                DependencyMapper("org.jetbrains.kotlin", "kotlin-stdlib-js", "distJar") { null },
+                DependencyMapper("org.jetbrains.kotlin", "kotlin-compiler", "runtimeJar") { null },
+                DependencyMapper("org.jetbrains.kotlin", "compiler", "runtimeElements") { null }
+            )
+        }
+
+        fun getProjectLibraries(rootProject: Project): List<PLibrary> {
+            fun distJar(name: String) = File(rootProject.projectDir, "dist/kotlinc/lib/$name.jar")
+            fun projectFile(path: String) = File(rootProject.projectDir, path)
+
+            val libraries = rootProject.allprojects
+                .filter { it.extra.has(JPS_LIBRARY_PATH) }
+                .map { library ->
+                    val libraryPath = library.extra.get(JPS_LIBRARY_PATH).toString()
+                    val archivesBaseName = library.convention.findPlugin(BasePluginConvention::class.java)?.archivesBaseName ?: library.name
+
+                    fun List<File>.filterExisting() = filter { it.exists() }
+
+                    PLibrary(
+                        library.name,
+                        classes = listOf(File(libraryPath, archivesBaseName + ".jar")).filterExisting(),
+                        sources = listOf(File(libraryPath, archivesBaseName + "-sources.jar")).filterExisting()
+                    )
+                }
+
+            return libraries + PLibrary("annotations-13.0", classes = listOf(distJar("annotations-13.0")))
+        }
+    }
+
+    override fun apply(project: Project) {
+        // 'jpsTest' does not require the 'tests-jar' artifact
+        project.configurations.create("jpsTest")
+
+        if (project == project.rootProject) {
+            project.tasks.create("pill") {
+                doLast { pill(project) }
+                TaskUtils.useAndroidSdk(this)
+                TaskUtils.useAndroidJar(this)
+            }
+
+            project.tasks.create("unpill") {
+                doLast { unpill(project) }
+            }
+        }
+    }
+
+    private lateinit var projectDir: File
+    private lateinit var platformVersion: String
+    private lateinit var platformBaseNumber: String
+    private lateinit var platformDir: File
+
+    private fun initEnvironment(project: Project) {
+        projectDir = project.projectDir
+        platformVersion = project.extensions.extraProperties.get("versions.intellijSdk").toString()
+        platformBaseNumber = platformVersion.substringBefore(".", "").takeIf { it.isNotEmpty() }
+                ?: error("Invalid platform version: $platformVersion")
+        platformDir = IntellijRootUtils.getIntellijRootDir(project)
+    }
+
+    private fun pill(rootProject: Project) {
+        initEnvironment(rootProject)
+
+        val projectLibraries = getProjectLibraries(rootProject)
+        val parserContext = ParserContext(getDependencyMappers(projectLibraries))
+
+        val jpsProject = parse(rootProject, projectLibraries, parserContext)
+            .mapLibraries(this::attachPlatformSources, this::attachAsmSources)
+
+        generateKotlinPluginArtifactFile(rootProject).write()
+
+        val files = render(jpsProject)
+
+        removeExistingIdeaLibrariesAndModules()
+        removeJpsRunConfigurations()
+
+        copyRunConfigurations()
+        setOptionsForDefaultJunitRunConfiguration(rootProject)
+
+        files.forEach { it.write() }
+    }
+
+    private fun unpill(project: Project) {
+        initEnvironment(project)
+
+        removeExistingIdeaLibrariesAndModules()
+        removeJpsRunConfigurations()
+    }
+
+    private fun removeExistingIdeaLibrariesAndModules() {
+        File(projectDir, ".idea/libraries").deleteRecursively()
+        File(projectDir, ".idea/modules").deleteRecursively()
+    }
+
+    private fun removeJpsRunConfigurations() {
+        File(projectDir, ".idea/runConfigurations")
+            .walk()
+            .filter { it.name.startsWith("JPS_") && it.extension.toLowerCase() == "xml" }
+            .forEach { it.delete() }
+    }
+
+    private fun copyRunConfigurations() {
+        val runConfigurationsDir = File(projectDir, "buildSrc/src/main/resources/runConfigurations")
+        val targetDir = File(projectDir, ".idea/runConfigurations")
+        val platformDirProjectRelative = "\$PROJECT_DIR\$/" + platformDir.toRelativeString(projectDir)
+
+        targetDir.mkdirs()
+
+        runConfigurationsDir.listFiles()
+            .filter { it.extension == "xml" }
+            .map { it.name to it.readText().replace("\$IDEA_HOME_PATH\$", platformDirProjectRelative) }
+            .forEach { File(targetDir, it.first).writeText(it.second) }
+    }
+
+    /*
+        This sets a proper (project root) working directory and a "idea.home.path" property to the default JUnit configuration,
+        so one does not need to make these changes manually.
+     */
+    private fun setOptionsForDefaultJunitRunConfiguration(project: Project) {
+        val workspaceFile = File(projectDir, ".idea/workspace.xml")
+        if (!workspaceFile.exists()) {
+            project.logger.warn("${workspaceFile.name} does not exist, JUnit default run configuration was not modified")
+            return
+        }
+
+        val document = SAXBuilder().build(workspaceFile)
+        val rootElement = document.rootElement
+
+        fun Element.getOrCreateChild(name: String, vararg attributes: Pair<String, String>): Element {
+            for (child in getChildren(name)) {
+                if (attributes.all { (attribute, value) -> child.getAttributeValue(attribute) == value }) {
+                    return child
+                }
+            }
+
+            return Element(name).apply {
+                for ((attributeName, value) in attributes) {
+                    setAttribute(attributeName, value)
+                }
+
+                this@getOrCreateChild.addContent(this@apply)
+            }
+        }
+
+        val platformDirProjectRelative = "\$PROJECT_DIR\$/" + platformDir.toRelativeString(projectDir)
+
+        val runManagerComponent = rootElement.getOrCreateChild("component", "name" to "RunManager")
+        val junitConfiguration = runManagerComponent.getOrCreateChild(
+            "configuration",
+            "default" to "true",
+            "type" to "JUnit",
+            "factoryName" to "JUnit"
+        )
+
+        junitConfiguration.apply {
+            getOrCreateChild("option", "name" to "WORKING_DIRECTORY").setAttribute("value", "file://\$PROJECT_DIR\$")
+            getOrCreateChild("option", "name" to "VM_PARAMETERS").also { vmParams ->
+                var options = vmParams.getAttributeValue("value", "")
+                    .split(' ')
+                    .map { it.trim() }
+                    .filter { it.isNotEmpty() }
+
+                fun addOrReplaceOptionValue(name: String, value: Any) {
+                    options = options.filter { !it.startsWith("-D$name=") } + listOf("-D$name=$value")
+                }
+
+                val robolectricClasspath = project.rootProject
+                    .project(":plugins:android-extensions-compiler")
+                    .configurations.getByName("robolectricClasspath")
+                    .files.joinToString(File.pathSeparator)
+
+                val androidJarPath = project.configurations.getByName("androidJar").singleFile
+                val androidSdkPath = project.configurations.getByName("androidSdk").singleFile
+
+                addOrReplaceOptionValue("idea.home.path", platformDirProjectRelative)
+                addOrReplaceOptionValue("ideaSdk.androidPlugin.path", platformDirProjectRelative + "/plugins/android/lib")
+                addOrReplaceOptionValue("robolectric.classpath", robolectricClasspath)
+                addOrReplaceOptionValue("use.pill", "true")
+
+                addOrReplaceOptionValue("android.sdk", "\$PROJECT_DIR\$/" + androidSdkPath.toRelativeString(projectDir))
+                addOrReplaceOptionValue("android.jar", "\$PROJECT_DIR\$/" + androidJarPath.toRelativeString(projectDir))
+
+                vmParams.setAttribute("value", options.joinToString(" "))
+            }
+        }
+
+        val output = XMLOutputter().also {
+            it.format = Format.getPrettyFormat().apply {
+                setEscapeStrategy { Verifier.isHighSurrogate(it) || it == '"' }
+                setIndent("  ")
+                setTextMode(Format.TextMode.TRIM)
+                setOmitEncoding(false)
+                setOmitDeclaration(false)
+            }
+        }
+
+        val postProcessedXml = output.outputString(document)
+            .replace("&#x22;", "&quot;")
+            .replace("&#xA;", "&#10;")
+            .replace("&#xC;", "&#13;")
+
+        workspaceFile.writeText(postProcessedXml)
+    }
+
+    private fun attachPlatformSources(library: PLibrary): PLibrary {
+        val platformSourcesJar = File(platformDir, "../sources/ideaIC-$platformVersion-sources.jar")
+
+        if (library.classes.any { it.startsWith(platformDir) }) {
+            return library.attachSource(platformSourcesJar)
+        }
+
+        return library
+    }
+
+    private fun attachAsmSources(library: PLibrary): PLibrary {
+        val asmSourcesJar = File(platformDir, "../asm-shaded-sources/asm-src-$platformBaseNumber.jar")
+        val asmAllJar = File(platformDir, "lib/asm-all.jar")
+
+        if (library.classes.any { it == asmAllJar }) {
+            return library.attachSource(asmSourcesJar)
+        }
+
+        return library
+    }
+
+    private fun PProject.mapLibraries(vararg mappers: (PLibrary) -> PLibrary): PProject {
+        fun mapLibrary(root: POrderRoot): POrderRoot {
+            val dependency = root.dependency
+
+            if (dependency is PDependency.ModuleLibrary) {
+                val newLibrary = mappers.fold(dependency.library) { lib, mapper -> mapper(lib) }
+                return root.copy(dependency = dependency.copy(library = newLibrary))
+            }
+
+            return root
+        }
+
+        val modules = this.modules.map { it.copy(orderRoots = it.orderRoots.map(::mapLibrary)) }
+        return this.copy(modules = modules)
+    }
+}
--- a/buildSrc/src/main/kotlin/pill/render.kt
+++ b/buildSrc/src/main/kotlin/pill/render.kt
@@ -0,0 +1,155 @@
+@file:Suppress("PackageDirectoryMismatch")
+package org.jetbrains.kotlin.pill
+
+import java.io.File
+
+class PFile(val path: File, val text: String) {
+    fun write() {
+        path.parentFile.mkdirs()
+        path.writeText(text)
+    }
+}
+
+fun PFile(path: File, xml: xml) = PFile(path, xml.toString())
+
+fun render(project: PProject): List<PFile> {
+    val files = mutableListOf<PFile>()
+
+    files += renderModulesFile(project)
+    project.modules.forEach { files += renderModule(project, it) }
+    project.libraries.forEach { files += renderLibrary(project, it) }
+
+    return files
+}
+
+private fun renderModulesFile(project: PProject) = PFile(
+    File(project.rootDirectory, ".idea/modules.xml"),
+    xml("project", "version" to 4) {
+        xml("component", "name" to "ProjectModuleManager") {
+            xml("modules") {
+                val pathContext = ProjectContext(project)
+
+                for (module in project.modules) {
+                    val moduleFilePath = pathContext(module.moduleFile)
+
+                    if (module.group != null) {
+                        xml("module", "fileurl" to "file://$moduleFilePath", "filepath" to moduleFilePath, "group" to module.group)
+                    } else {
+                        xml("module", "fileurl" to "file://$moduleFilePath", "filepath" to moduleFilePath)
+                    }
+                }
+            }
+        }
+    }
+)
+
+private fun renderModule(project: PProject, module: PModule) = PFile(
+    module.moduleFile,
+    xml("module",
+        "type" to "JAVA_MODULE",
+        "version" to 4
+    ) {
+        val moduleForProductionSources = module.moduleForProductionSources
+        if (moduleForProductionSources != null) {
+            xml("component", "name" to "TestModuleProperties", "production-module" to moduleForProductionSources.name)
+        }
+
+        xml("component", "name" to "NewModuleRootManager", "inherit-compiler-output" to "true") {
+            xml("exclude-output")
+
+            val pathContext = ModuleContext(project, module)
+
+            for (contentRoot in module.contentRoots) {
+                xml("content", pathContext.url(contentRoot.path)) {
+                    for (sourceRoot in contentRoot.sourceRoots) {
+                        var args = arrayOf(pathContext.url(sourceRoot.path))
+
+                        args += when (sourceRoot.kind) {
+                            PSourceRoot.Kind.PRODUCTION -> ("isTestSource" to "false")
+                            PSourceRoot.Kind.TEST -> ("isTestSource" to "true")
+                            PSourceRoot.Kind.RESOURCES -> ("type" to "java-resource")
+                            PSourceRoot.Kind.TEST_RESOURCES -> ("type" to "java-test-resource")
+                        }
+
+                        xml("sourceFolder", *args)
+                    }
+
+                    for (excludedDir in contentRoot.excludedDirectories) {
+                        xml("excludeFolder", pathContext.url(excludedDir))
+                    }
+                }
+            }
+
+            xml("orderEntry", "type" to "inheritedJdk")
+
+            for (orderRoot in module.orderRoots) {
+                val dependency = orderRoot.dependency
+
+                var args = when (dependency) {
+                    is PDependency.ModuleLibrary -> arrayOf(
+                        "type" to "module-library"
+                    )
+                    is PDependency.Module -> arrayOf(
+                        "type" to "module",
+                        "module-name" to dependency.name
+                    )
+                    is PDependency.Library -> arrayOf(
+                        "type" to "library",
+                        "name" to dependency.name,
+                        "level" to "project"
+                    )
+                    else -> error("Unsupported dependency type: $dependency")
+                }
+
+                if (dependency is PDependency.Module && orderRoot.isProductionOnTestDependency) {
+                    args += ("production-on-test" to "")
+                }
+
+                args += ("scope" to orderRoot.scope.toString())
+                if (orderRoot.isExported) {
+                    args += ("exported" to "")
+                }
+
+                xml("orderEntry", *args) {
+                    if (dependency is PDependency.ModuleLibrary) {
+                        add(renderLibraryToXml(dependency.library, pathContext, named = false))
+                    }
+                }
+            }
+        }
+    }
+)
+
+private fun renderLibrary(project: PProject, library: PLibrary): PFile {
+    val pathContext = ProjectContext(project)
+
+    // TODO find how IDEA escapes library names
+    val escapedName = library.renderName().replace(" ", "_").replace(".", "_").replace("-", "_")
+
+    return PFile(
+        File(project.rootDirectory, ".idea/libraries/$escapedName.xml"),
+
+        xml("component", "name" to "libraryTable") {
+            add(renderLibraryToXml(library, pathContext))
+        })
+}
+
+private fun renderLibraryToXml(library: PLibrary, pathContext: PathContext, named: Boolean = true): xml {
+    val args = if (named) arrayOf("name" to library.renderName()) else emptyArray()
+
+    return xml("library", *args) {
+        xml("CLASSES") {
+            library.classes.forEach { xml("root", pathContext.url(it)) }
+        }
+
+        xml("JAVADOC") {
+            library.javadoc.forEach { xml("root", pathContext.url(it)) }
+        }
+
+        xml("SOURCES") {
+            library.sources.forEach { xml("root", pathContext.url(it)) }
+        }
+    }
+}
+
+fun PLibrary.renderName() = name?.takeIf { it != "unspecified" } ?: classes.first().nameWithoutExtension
--- a/buildSrc/src/main/kotlin/pill/xml.kt
+++ b/buildSrc/src/main/kotlin/pill/xml.kt
@@ -0,0 +1,61 @@
+@file:Suppress("PackageDirectoryMismatch")
+package org.jetbrains.kotlin.pill
+
+import shadow.org.jdom2.Document
+import shadow.org.jdom2.Element
+import shadow.org.jdom2.output.Format
+import shadow.org.jdom2.output.XMLOutputter
+
+class xml(val name: String, vararg val args: Pair<String, Any>, block: xml.() -> Unit = {}) {
+    private companion object {
+        fun makeXml(name: String, vararg args: Pair<String, Any>, block: xml.() -> Unit = {}): xml {
+            return xml(name, *args, block = block)
+        }
+    }
+
+    private val children = mutableListOf<xml>()
+    private var value: Any? = null
+
+    init {
+        @Suppress("UNUSED_EXPRESSION")
+        block()
+    }
+
+    fun xml(name: String, vararg args: Pair<String, Any>, block: xml.() -> Unit = {}) {
+        children += makeXml(name, *args, block = block)
+    }
+
+    fun add(xml: xml) {
+        children += xml
+    }
+
+    fun raw(text: String) {
+        value = text
+    }
+
+    private fun toElement(): Element {
+        val element = Element(name)
+
+        for (arg in args) {
+            element.setAttribute(arg.first, arg.second.toString())
+        }
+
+        require(value == null || children.isEmpty())
+
+        value?.let { value ->
+            element.addContent(value.toString())
+        }
+
+        for (child in children) {
+            element.addContent(child.toElement())
+        }
+
+        return element
+    }
+
+    override fun toString(): String {
+        val document = Document().also { it.rootElement = toElement() }
+        val output = XMLOutputter().also { it.format = Format.getPrettyFormat() }
+        return output.outputString(document)
+    }
+}
--- a/buildSrc/src/main/kotlin/plugins/DexMethodCount.kt
+++ b/buildSrc/src/main/kotlin/plugins/DexMethodCount.kt
@@ -23,11 +23,11 @@ import java.io.File
 open class DexMethodCount : DefaultTask() {

    data class Counts(
-            val total: Int,
-            val totalOwnPackages: Int?,
-            val totalOtherPackages: Int?,
-            val byPackage: Map<String, Int>,
-            val byClass: Map<String, Int>
+        val total: Int,
+        val totalOwnPackages: Int?,
+        val totalOtherPackages: Int?,
+        val byPackage: Map<String, Int>,
+        val byClass: Map<String, Int>
    )

    @InputFile
@@ -58,7 +58,7 @@ open class DexMethodCount : DefaultTask() {

    @TaskAction
    fun invoke() {
-        val methods = DexMethods.list(jarFile)
+        val methods = dexMethods(jarFile)

        val counts = methods.getCounts().also { this.counts = it }

@@ -73,16 +73,18 @@ open class DexMethodCount : DefaultTask() {

        val ownPackages = ownPackages?.map { it + '.' }
        val byOwnPackages = if (ownPackages != null) {
-            this.partition { method -> ownPackages.any { method.declaringType.startsWith(it) }}.let {
+            this.partition { method -> ownPackages.any { method.declaringType.startsWith(it) } }.let {
                it.first.size to it.second.size
            }
        } else (null to null)

-        return Counts(total = this.size,
-                      totalOwnPackages = byOwnPackages.first,
-                      totalOtherPackages = byOwnPackages.second,
-                      byPackage = byPackage,
-                      byClass = byClass)
+        return Counts(
+            total = this.size,
+            totalOwnPackages = byOwnPackages.first,
+            totalOtherPackages = byOwnPackages.second,
+            byPackage = byPackage,
+            byClass = byClass
+        )
    }

    private fun printTotals(counts: Counts) {
--- a/buildSrc/src/main/kotlin/tasks.kt
+++ b/buildSrc/src/main/kotlin/tasks.kt
@@ -24,6 +24,7 @@ import org.gradle.api.tasks.testing.Test
 import org.gradle.kotlin.dsl.extra
 import org.gradle.kotlin.dsl.task
 import org.gradle.kotlin.dsl.the
+import org.gradle.kotlin.dsl.*
 import java.lang.Character.isLowerCase
 import java.lang.Character.isUpperCase

@@ -81,3 +82,41 @@ private inline fun String.isFirstChar(f: (Char) -> Boolean) = isNotEmpty() && f(

 inline fun <reified T : Task> Project.getOrCreateTask(taskName: String, body: T.() -> Unit): T =
        (tasks.findByName(taskName)?.let { it as T } ?: task<T>(taskName)).apply { body() }
+
+object TaskUtils {
+    fun useAndroidSdk(task: Task) {
+        task.useAndroidConfiguration(systemPropertyName = "android.sdk", configName = "androidSdk")
+    }
+
+    fun useAndroidJar(task: Task) {
+        task.useAndroidConfiguration(systemPropertyName = "android.jar", configName = "androidJar")
+    }
+}
+
+private fun Task.useAndroidConfiguration(systemPropertyName: String, configName: String) {
+    val configuration = with(project) {
+        configurations.getOrCreate(configName)
+            .also {
+                dependencies.add(
+                    configName,
+                    dependencies.project(":custom-dependencies:android-sdk", configuration = configName)
+                )
+            }
+    }
+
+    dependsOn(configuration)
+
+    if (this is Test) {
+        doFirst {
+            systemProperty(systemPropertyName, configuration.singleFile.canonicalPath)
+        }
+    }
+}
+
+fun Task.useAndroidSdk() {
+    TaskUtils.useAndroidSdk(this)
+}
+
+fun Task.useAndroidJar() {
+    TaskUtils.useAndroidJar(this)
+}
--- a/buildSrc/src/main/resources/META-INF/gradle-plugins/jps-compatible.properties
+++ b/buildSrc/src/main/resources/META-INF/gradle-plugins/jps-compatible.properties
@@ -0,0 +1 @@
+implementation-class=org.jetbrains.kotlin.pill.JpsCompatiblePlugin
--- a/buildSrc/src/main/resources/runConfigurations/JPS_All_Compiler_Tests.xml
+++ b/buildSrc/src/main/resources/runConfigurations/JPS_All_Compiler_Tests.xml
@@ -0,0 +1,8 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="[JPS] All Compiler Tests" type="CompoundRunConfigurationType" factoryName="Compound Run Configuration">
+    <toRun type="JUnit" name="[JPS] Compiler Tests" />
+    <toRun type="JUnit" name="[JPS] JS Backend Tests" />
+    <toRun type="JUnit" name="[JPS] Java 8 Tests" />
+    <method />
+  </configuration>
+</component>
--- a/buildSrc/src/main/resources/runConfigurations/JPS_All_IDEA_Plugin_Tests.xml
+++ b/buildSrc/src/main/resources/runConfigurations/JPS_All_IDEA_Plugin_Tests.xml
@@ -0,0 +1,37 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="[JPS] All IDEA Plugin Tests" type="JUnit" factoryName="JUnit">
+    <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea">
+      <pattern>
+        <option name="PATTERN" value="org.jetbrains.kotlin.*" />
+        <option name="ENABLED" value="true" />
+      </pattern>
+    </extension>
+    <module name="idea.test" />
+    <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
+    <option name="ALTERNATIVE_JRE_PATH" />
+    <option name="PACKAGE_NAME" value="org.jetbrains.kotlin" />
+    <option name="MAIN_CLASS_NAME" value="" />
+    <option name="METHOD_NAME" value="" />
+    <option name="TEST_OBJECT" value="package" />
+    <option name="VM_PARAMETERS" value="-ea -XX:+HeapDumpOnOutOfMemoryError -Xmx1250m -XX:+UseCodeCacheFlushing -XX:ReservedCodeCacheSize=128m -Djna.nosys=true -Didea.home.path=$IDEA_HOME_PATH$" />
+    <option name="PARAMETERS" value="" />
+    <option name="WORKING_DIRECTORY" value="file://$PROJECT_DIR$" />
+    <option name="ENV_VARIABLES" />
+    <option name="PASS_PARENT_ENVS" value="true" />
+    <option name="TEST_SEARCH_SCOPE">
+      <value defaultName="singleModule" />
+    </option>
+    <envs />
+    <patterns />
+    <RunnerSettings RunnerId="Debug">
+      <option name="DEBUG_PORT" value="" />
+      <option name="TRANSPORT" value="0" />
+      <option name="LOCAL" value="true" />
+    </RunnerSettings>
+    <RunnerSettings RunnerId="Profile " />
+    <RunnerSettings RunnerId="Run" />
+    <ConfigurationWrapper RunnerId="Debug" />
+    <ConfigurationWrapper RunnerId="Run" />
+    <method />
+  </configuration>
+</component>
--- a/buildSrc/src/main/resources/runConfigurations/JPS_Compiler_Tests.xml
+++ b/buildSrc/src/main/resources/runConfigurations/JPS_Compiler_Tests.xml
@@ -0,0 +1,35 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="[JPS] Compiler Tests" type="JUnit" factoryName="JUnit">
+    <module name="compiler.test" />
+    <extension name="coverage">
+      <pattern>
+        <option name="PATTERN" value="org.jetbrains.kotlin.*" />
+        <option name="ENABLED" value="true" />
+      </pattern>
+    </extension>
+    <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
+    <option name="ALTERNATIVE_JRE_PATH" />
+    <option name="PACKAGE_NAME" value="org.jetbrains.kotlin.codegen" />
+    <option name="MAIN_CLASS_NAME" value="" />
+    <option name="METHOD_NAME" value="" />
+    <option name="TEST_OBJECT" value="package" />
+    <option name="VM_PARAMETERS" value="-ea -XX:+HeapDumpOnOutOfMemoryError -Xmx1024m -XX:+UseCodeCacheFlushing -XX:ReservedCodeCacheSize=128m -Djna.nosys=true -Didea.home.path=$IDEA_HOME_PATH$" />
+    <option name="PARAMETERS" value="" />
+    <option name="WORKING_DIRECTORY" value="file://$PROJECT_DIR$" />
+    <option name="PASS_PARENT_ENVS" value="true" />
+    <option name="TEST_SEARCH_SCOPE">
+      <value defaultName="moduleWithDependencies" />
+    </option>
+    <patterns />
+    <RunnerSettings RunnerId="Debug">
+      <option name="DEBUG_PORT" value="" />
+      <option name="TRANSPORT" value="0" />
+      <option name="LOCAL" value="true" />
+    </RunnerSettings>
+    <RunnerSettings RunnerId="Profile " />
+    <RunnerSettings RunnerId="Run" />
+    <ConfigurationWrapper RunnerId="Debug" />
+    <ConfigurationWrapper RunnerId="Run" />
+    <method />
+  </configuration>
+</component>
--- a/buildSrc/src/main/resources/runConfigurations/JPS_Generate_All_Tests.xml
+++ b/buildSrc/src/main/resources/runConfigurations/JPS_Generate_All_Tests.xml
@@ -0,0 +1,8 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="[JPS] Generate All Tests" type="Application" factoryName="Application">
+    <option name="MAIN_CLASS_NAME" value="org.jetbrains.kotlin.pill.generateAllTests.Main" />
+    <module name="generate-all-tests.test" />
+    <option name="WORKING_DIRECTORY" value="file://$PROJECT_DIR$" />
+    <method />
+  </configuration>
+</component>
--- a/buildSrc/src/main/resources/runConfigurations/JPS_IDEA.xml
+++ b/buildSrc/src/main/resources/runConfigurations/JPS_IDEA.xml
@@ -0,0 +1,41 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="[JPS] IDEA" type="Application" factoryName="Application" singleton="true">
+    <log_file alias="idea.log" path="$PROJECT_DIR$/ideaSDK/system-idea/log/idea.log" />
+    <option name="MAIN_CLASS_NAME" value="com.intellij.idea.Main" />
+    <module name="idea-runner" />
+    <option name="VM_PARAMETERS" value="-Xmx1250m -XX:ReservedCodeCacheSize=240m -XX:+HeapDumpOnOutOfMemoryError -ea -Didea.is.internal=true -Didea.debug.mode=true -Didea.system.path=$IDEA_HOME_PATH$/system -Didea.config.path=$IDEA_HOME_PATH$/config -Dapple.laf.useScreenMenuBar=true -Dapple.awt.graphics.UseQuartz=true -Dsun.io.useCanonCaches=false -Dplugin.path=$PROJECT_DIR$/out/artifacts/Kotlin -Dkotlin.internal.mode.enabled=true" />
+    <option name="WORKING_DIRECTORY" value="file://$IDEA_HOME_PATH$" />
+    <RunnerSettings RunnerId="Debug">
+      <option name="DEBUG_PORT" value="" />
+      <option name="TRANSPORT" value="0" />
+      <option name="LOCAL" value="true" />
+    </RunnerSettings>
+    <RunnerSettings RunnerId="JavaRebel">
+      <option name="bootstrapPath" />
+      <option name="jrebelArgs" value="" />
+      <option name="loggingEnabled" value="false" />
+      <option name="useBootstrapDefaults" value="true" />
+    </RunnerSettings>
+    <RunnerSettings RunnerId="JavaRebel Debug">
+      <option name="bootstrapPath" />
+      <option name="debugPort" value="" />
+      <option name="jrebelArgs" value="" />
+      <option name="loggingEnabled" value="false" />
+      <option name="transport" value="0" />
+      <option name="useBootstrapDefaults" value="true" />
+      <option name="DEBUG_PORT" value="" />
+      <option name="TRANSPORT" value="0" />
+      <option name="LOCAL" value="true" />
+    </RunnerSettings>
+    <RunnerSettings RunnerId="Profile " />
+    <RunnerSettings RunnerId="Run" />
+    <ConfigurationWrapper RunnerId="Debug" />
+    <ConfigurationWrapper RunnerId="Profile " />
+    <ConfigurationWrapper RunnerId="Run" />
+    <method>
+      <option name="BuildArtifacts" enabled="true">
+        <artifact name="KotlinPlugin" />
+      </option>
+    </method>
+  </configuration>
+</component>
--- a/buildSrc/src/main/resources/runConfigurations/JPS_IDEA_No_ProcessCancelledException.xml
+++ b/buildSrc/src/main/resources/runConfigurations/JPS_IDEA_No_ProcessCancelledException.xml
@@ -0,0 +1,41 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="[JPS] IDEA (No ProcessCanceledException)" type="Application" factoryName="Application" singleton="true">
+    <log_file alias="idea.log" path="$PROJECT_DIR$/ideaSDK/system-idea/log/idea.log" />
+    <option name="MAIN_CLASS_NAME" value="com.intellij.idea.Main" />
+    <module name="idea-runner" />
+    <option name="VM_PARAMETERS" value="-Xmx1250m -XX:ReservedCodeCacheSize=240m -XX:+HeapDumpOnOutOfMemoryError -ea -Didea.is.internal=true -Didea.debug.mode=true -Didea.system.path=$IDEA_HOME_PATH$/system -Didea.config.path=$IDEA_HOME_PATH$/config -Dapple.laf.useScreenMenuBar=true -Dapple.awt.graphics.UseQuartz=true -Dsun.io.useCanonCaches=false -Dplugin.path=$PROJECT_DIR$/out/artifacts/Kotlin -Dkotlin.internal.mode.enabled=true -Didea.ProcessCanceledException=disabled" />
+    <option name="WORKING_DIRECTORY" value="file://$IDEA_HOME_PATH$" />
+    <RunnerSettings RunnerId="Debug">
+      <option name="DEBUG_PORT" value="" />
+      <option name="TRANSPORT" value="0" />
+      <option name="LOCAL" value="true" />
+    </RunnerSettings>
+    <RunnerSettings RunnerId="JavaRebel">
+      <option name="bootstrapPath" />
+      <option name="jrebelArgs" value="" />
+      <option name="loggingEnabled" value="false" />
+      <option name="useBootstrapDefaults" value="true" />
+    </RunnerSettings>
+    <RunnerSettings RunnerId="JavaRebel Debug">
+      <option name="bootstrapPath" />
+      <option name="debugPort" value="" />
+      <option name="jrebelArgs" value="" />
+      <option name="loggingEnabled" value="false" />
+      <option name="transport" value="0" />
+      <option name="useBootstrapDefaults" value="true" />
+      <option name="DEBUG_PORT" value="" />
+      <option name="TRANSPORT" value="0" />
+      <option name="LOCAL" value="true" />
+    </RunnerSettings>
+    <RunnerSettings RunnerId="Profile " />
+    <RunnerSettings RunnerId="Run" />
+    <ConfigurationWrapper RunnerId="Debug" />
+    <ConfigurationWrapper RunnerId="Profile " />
+    <ConfigurationWrapper RunnerId="Run" />
+    <method>
+      <option name="BuildArtifacts" enabled="true">
+        <artifact name="KotlinPlugin" />
+      </option>
+    </method>
+  </configuration>
+</component>
--- a/buildSrc/src/main/resources/runConfigurations/JPS_JS_Backend_Tests.xml
+++ b/buildSrc/src/main/resources/runConfigurations/JPS_JS_Backend_Tests.xml
@@ -0,0 +1,28 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="[JPS] JS Backend Tests" type="JUnit" factoryName="JUnit">
+    <module name="js.tests.test" />
+    <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
+    <option name="ALTERNATIVE_JRE_PATH" />
+    <option name="PACKAGE_NAME" value="org.jetbrains.kotlin.js.test" />
+    <option name="MAIN_CLASS_NAME" value="" />
+    <option name="METHOD_NAME" value="" />
+    <option name="TEST_OBJECT" value="package" />
+    <option name="VM_PARAMETERS" value="-ea -XX:+HeapDumpOnOutOfMemoryError -Xmx1250m -XX:+UseCodeCacheFlushing -Djna.nosys=true -Dkotlin.js.skipMinificationTest=false" />
+    <option name="PARAMETERS" value="" />
+    <option name="WORKING_DIRECTORY" value="file://$PROJECT_DIR$" />
+    <option name="PASS_PARENT_ENVS" value="true" />
+    <option name="TEST_SEARCH_SCOPE">
+      <value defaultName="moduleWithDependencies" />
+    </option>
+    <patterns />
+    <RunnerSettings RunnerId="Debug">
+      <option name="DEBUG_PORT" value="" />
+      <option name="TRANSPORT" value="0" />
+      <option name="LOCAL" value="true" />
+    </RunnerSettings>
+    <RunnerSettings RunnerId="Run" />
+    <ConfigurationWrapper RunnerId="Debug" />
+    <ConfigurationWrapper RunnerId="Run" />
+    <method />
+  </configuration>
+</component>
--- a/buildSrc/src/main/resources/runConfigurations/JPS_Java_8_Tests.xml
+++ b/buildSrc/src/main/resources/runConfigurations/JPS_Java_8_Tests.xml
@@ -0,0 +1,26 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="[JPS] Java 8 Tests" type="JUnit" factoryName="JUnit">
+    <module name="tests-java8.test" />
+    <extension name="coverage">
+      <pattern>
+        <option name="PATTERN" value="org.jetbrains.kotlin.*" />
+        <option name="ENABLED" value="true" />
+      </pattern>
+    </extension>
+    <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="true" />
+    <option name="ALTERNATIVE_JRE_PATH" value="1.8" />
+    <option name="PACKAGE_NAME" value="org.jetbrains.kotlin" />
+    <option name="MAIN_CLASS_NAME" value="" />
+    <option name="METHOD_NAME" value="" />
+    <option name="TEST_OBJECT" value="package" />
+    <option name="VM_PARAMETERS" value="-ea -XX:+HeapDumpOnOutOfMemoryError -XX:+UseCodeCacheFlushing -XX:ReservedCodeCacheSize=128m -Djna.nosys=true -Dkotlin.colors.enabled=false -Didea.home.path=$IDEA_HOME_PATH$" />
+    <option name="PARAMETERS" value="" />
+    <option name="WORKING_DIRECTORY" value="file://$PROJECT_DIR$" />
+    <option name="PASS_PARENT_ENVS" value="true" />
+    <option name="TEST_SEARCH_SCOPE">
+      <value defaultName="singleModule" />
+    </option>
+    <patterns />
+    <method />
+  </configuration>
+</component>
--- a/buildSrc/src/main/resources/runConfigurations/JPS_Refresh_JPS_Model.xml
+++ b/buildSrc/src/main/resources/runConfigurations/JPS_Refresh_JPS_Model.xml
@@ -0,0 +1,21 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="[JPS] Refresh JPS Model" type="GradleRunConfiguration" factoryName="Gradle" singleton="true">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value="pill" />
+        </list>
+      </option>
+      <option name="vmOptions" value="" />
+    </ExternalSystemSettings>
+    <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
+    <method />
+  </configuration>
+</component>
--- a/compiler/android-tests/android-module/build.gradle
+++ b/compiler/android-tests/android-module/build.gradle
@@ -7,7 +7,7 @@ buildscript {

    }
    dependencies {
-        classpath 'com.android.tools.build:gradle:3.0.0'
+        classpath 'com.android.tools.build:gradle:3.0.1'

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
@@ -22,7 +22,7 @@ repositories {

 android {
    compileSdkVersion 19
-    buildToolsVersion "26.0.2"
+    buildToolsVersion "27.0.3"

    defaultConfig {
        applicationId "org.jetbrains.kotlin.android.tests"
@@ -32,6 +32,7 @@ android {
        versionName "1.0"
        testApplicationId "org.jetbrains.kotlin.android.tests.gradle"
        testInstrumentationRunner "android.test.InstrumentationTestRunner"
+        multiDexEnabled true
    }
    buildTypes {
        debug {
@@ -67,9 +68,8 @@ android {

    dexOptions {
        dexInProcess false
-        javaMaxHeapSize "600m"
-        //default is 4 and Total Memory = maxProcessCount * javaMaxHeapSize
-        maxProcessCount 1
+        javaMaxHeapSize "1200m"
+        maxProcessCount 4
        additionalParameters "--debug"
    }
 }
@@ -91,4 +91,5 @@ tasks.withType(JavaCompile) {
 dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    androidTestCompile 'junit:junit:4.12'
+    compile 'com.android.support:multidex:1.0.1'
 }
--- a/compiler/android-tests/build.gradle.kts
+++ b/compiler/android-tests/build.gradle.kts
@@ -1,5 +1,6 @@

 apply { plugin("kotlin") }
+apply { plugin("jps-compatible") }

 jvmTarget = "1.6"

@@ -10,18 +11,17 @@ dependencies {
    compile(project(":compiler:backend"))
    compile(projectTests(":compiler:tests-common"))
    compile(commonDep("junit:junit"))
-    compile(ideaSdkDeps("openapi"))
+    compileOnly(intellijDep()) { includeJars("openapi") }

    testCompile(project(":compiler:incremental-compilation-impl"))
    testCompile(project(":core:descriptors"))
    testCompile(project(":core:descriptors.jvm"))
    testCompile(project(":compiler:frontend.java"))
    testCompile(projectTests(":jps-plugin"))
-    testCompile(ideaSdkDeps("jps-model.jar", subdir = "jps"))
-    testCompile(ideaSdkDeps("groovy-all"))
-    testCompile(ideaSdkDeps("idea", "idea_rt"))
-    testCompile(ideaSdkDeps("jps-build-test", subdir = "jps/test"))
-    testCompile(ideaSdkDeps("jps-builders"))
+    testCompile(commonDep("junit:junit"))
+    testCompile(intellijDep()) { includeJars("openapi", "idea", "idea_rt", "groovy-all", "jps-builders", rootProject = rootProject) }
+    testCompile(intellijDep("jps-standalone")) { includeJars("jps-model") }
+    testCompile(intellijDep("jps-build-test"))
 }

 sourceSets {
@@ -30,5 +30,9 @@ sourceSets {
 }

 projectTest {
+    doFirst {
+        systemProperty("idea.home.path", intellijRootDir().canonicalPath)
+        environment("kotlin.tests.android.timeout", "45")
+    }
    workingDir = rootDir
 }
--- a/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidRunner.kt
+++ b/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidRunner.kt
@@ -152,7 +152,9 @@ class CodegenTestsOnAndroidRunner private constructor(private val pathManager: P
        private fun parseSingleReportInFolder(reportFolder: String): List<TestCase> {
            val folder = File(reportFolder)
            val files = folder.listFiles()!!
-            assert(files.size == 1)
+            assert(files.size == 1) {
+                "Expecting one file but ${files.size}: ${files.joinToString { it.name }}"
+            }
            val reportFile = files[0]

            val dbFactory = DocumentBuilderFactory.newInstance()
--- a/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/download/SDKDownloader.java
+++ b/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/download/SDKDownloader.java
@@ -38,12 +38,11 @@ public class SDKDownloader {

    private final PathManager pathManager;

-    //NOTE: PLATFORM_TOOLS 23.1.0 requires only 64 bit build agents
-    private static final String PLATFORM_TOOLS = "23.0.1";
-    private static final String SDK_TOOLS = "25.1.1";
-    public static final String BUILD_TOOLS = "26.0.2";
+    private static final String PLATFORM_TOOLS = "27.0.1";
+    private static final String SDK_TOOLS = "25.1.6";
+    public static final String BUILD_TOOLS = "27.0.3";
    private static final int ANDROID_VERSION = 19;
-    public static final String GRADLE_VERSION = "4.3";
+    public static final String GRADLE_VERSION = "4.5.1";


    public SDKDownloader(PathManager pathManager) {
--- a/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/emulator/Emulator.java
+++ b/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/emulator/Emulator.java
@@ -157,7 +157,7 @@ public class Emulator {
        bootCheckCommand.addParameter("sys.boot_completed");
        int counter = 0;
        RunResult execute = RunUtils.execute(bootCheckCommand);
-        while (counter < 12) {
+        while (counter < 20) {
            String output = execute.getOutput();
            if (output.trim().endsWith("1")) {
                System.out.println("Emulator fully booted!");
--- a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/AndroidTestGenerator.kt
+++ b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/AndroidTestGenerator.kt
@@ -31,11 +31,14 @@ private val packagePattern = Pattern.compile("(?m)^\\s*package[ |\t]+([\\w|\\.]*

 private val importPattern = Pattern.compile("import[ |\t]([\\w|]*\\.)")

-internal fun genFiles(file: File, fileContent: String, filesHolder: CodegenTestsOnAndroidGenerator.FilesWriter): FqName? {
-    val testFiles = createTestFiles(file, fileContent)
-    if (testFiles.filter { it.name.endsWith(".java") }.isNotEmpty()) {
+internal fun patchFiles(
+    file: File,
+    testFiles: List<CodegenTestCase.TestFile>,
+    filesHolder: CodegenTestsOnAndroidGenerator.FilesWriter
+): FqName? {
+    if (testFiles.any { it.name.endsWith(".java") }) {
        //TODO support java files
-        return null;
+        return null
    }
    val ktFiles = testFiles.filter { it.name.endsWith(".kt") }
    if (ktFiles.isEmpty()) return null
@@ -82,16 +85,6 @@ internal fun genFiles(file: File, fileContent: String, filesHolder: CodegenTests
    return boxFiles.last().newClassId
 }

-
-private fun createTestFiles(file: File, expectedText: String): List<CodegenTestCase.TestFile> {
-    val files = KotlinTestUtils.createTestFiles(file.name, expectedText, object : KotlinTestUtils.TestFileFactoryNoModules<CodegenTestCase.TestFile>() {
-        override fun create(fileName: String, text: String, directives: Map<String, String>): CodegenTestCase.TestFile {
-            return CodegenTestCase.TestFile(fileName, text)
-        }
-    })
-    return files
-}
-
 private fun hasBoxMethod(text: String): Boolean {
    return text.contains("fun box()")
 }
--- a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.java
+++ b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.java
@@ -1,319 +0,0 @@
-/*
- * 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.android.tests;
-
-import com.google.common.collect.Lists;
-import com.intellij.openapi.Disposable;
-import com.intellij.openapi.util.Disposer;
-import com.intellij.openapi.util.io.FileUtil;
-import com.intellij.openapi.util.io.FileUtilRt;
-import com.intellij.openapi.util.text.StringUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
-import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsKt;
-import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
-import org.jetbrains.kotlin.codegen.CodegenTestFiles;
-import org.jetbrains.kotlin.codegen.GenerationUtils;
-import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
-import org.jetbrains.kotlin.codegen.state.GenerationState;
-import org.jetbrains.kotlin.config.CommonConfigurationKeys;
-import org.jetbrains.kotlin.config.CompilerConfiguration;
-import org.jetbrains.kotlin.config.JVMConfigurationKeys;
-import org.jetbrains.kotlin.idea.KotlinFileType;
-import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.name.NameUtils;
-import org.jetbrains.kotlin.psi.KtFile;
-import org.jetbrains.kotlin.test.*;
-import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase;
-import org.jetbrains.kotlin.utils.Printer;
-import org.junit.Assert;
-import org.junit.Ignore;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-
-@Ignore
-public class CodegenTestsOnAndroidGenerator extends KtUsefulTestCase {
-
-    private final PathManager pathManager;
-    private static final String testClassPackage = "org.jetbrains.kotlin.android.tests";
-    private static final String testClassName = "CodegenTestCaseOnAndroid";
-    private static final String baseTestClassPackage = "org.jetbrains.kotlin.android.tests";
-    private static final String baseTestClassName = "AbstractCodegenTestCaseOnAndroid";
-    private static final String generatorName = "CodegenTestsOnAndroidGenerator";
-
-    private static int MODULE_INDEX = 1;
-    private int WRITED_FILES_COUNT = 0;
-
-    private final List<String> generatedTestNames = Lists.newArrayList();
-
-    public static void generate(PathManager pathManager) throws Throwable {
-        new CodegenTestsOnAndroidGenerator(pathManager).generateOutputFiles();
-    }
-
-    private CodegenTestsOnAndroidGenerator(PathManager pathManager) {
-        this.pathManager = pathManager;
-    }
-
-    private void generateOutputFiles() throws Throwable {
-        prepareAndroidModule();
-        generateAndSave();
-    }
-
-    private void prepareAndroidModule() throws IOException {
-        System.out.println("Copying kotlin-runtime.jar and kotlin-reflect.jar in android module...");
-        copyKotlinRuntimeJars();
-
-        System.out.println("Check \"libs\" folder in tested android module...");
-        File libsFolderInTestedModule = new File(pathManager.getLibsFolderInAndroidTestedModuleTmpFolder());
-        if (!libsFolderInTestedModule.exists()) {
-            libsFolderInTestedModule.mkdirs();
-        }
-    }
-
-    private void copyKotlinRuntimeJars() throws IOException {
-        FileUtil.copy(
-                ForTestCompileRuntime.runtimeJarForTests(),
-                new File(pathManager.getLibsFolderInAndroidTmpFolder() + "/kotlin-runtime.jar")
-        );
-        FileUtil.copy(
-                ForTestCompileRuntime.reflectJarForTests(),
-                new File(pathManager.getLibsFolderInAndroidTmpFolder() + "/kotlin-reflect.jar")
-        );
-
-        FileUtil.copy(
-                ForTestCompileRuntime.kotlinTestJarForTests(),
-                new File(pathManager.getLibsFolderInAndroidTmpFolder() + "/kotlin-test.jar")
-        );
-    }
-
-    private void generateAndSave() throws Throwable {
-        System.out.println("Generating test files...");
-        StringBuilder out = new StringBuilder();
-        Printer p = new Printer(out);
-
-        p.print(FileUtil.loadFile(new File("license/LICENSE.txt")));
-        p.println("package " + testClassPackage + ";");
-        p.println();
-        p.println("import ", baseTestClassPackage, ".", baseTestClassName, ";");
-        p.println();
-        p.println("/* This class is generated by " + generatorName + ". DO NOT MODIFY MANUALLY */");
-        p.println("public class ", testClassName, " extends ", baseTestClassName, " {");
-        p.pushIndent();
-
-        generateTestMethodsForDirectories(p, new File("compiler/testData/codegen/box"), new File("compiler/testData/codegen/boxInline"));
-
-        p.popIndent();
-        p.println("}");
-
-        String testSourceFilePath =
-                pathManager.getSrcFolderInAndroidTmpFolder() + "/" + testClassPackage.replace(".", "/") + "/" + testClassName + ".java";
-        FileUtil.writeToFile(new File(testSourceFilePath), out.toString());
-    }
-
-    private void generateTestMethodsForDirectories(Printer p, File... dirs) throws IOException {
-        FilesWriter holderMock = new FilesWriter(false, false);
-        FilesWriter holderFull = new FilesWriter(true, false);
-        FilesWriter holderInheritMFP = new FilesWriter(true, true);
-
-        for (File dir : dirs) {
-            File[] files = dir.listFiles();
-            Assert.assertNotNull("Folder with testData is empty: " + dir.getAbsolutePath(), files);
-            processFiles(p, files, holderFull, holderMock, holderInheritMFP);
-        }
-
-        holderFull.writeFilesOnDisk();
-        holderMock.writeFilesOnDisk();
-        holderInheritMFP.writeFilesOnDisk();
-    }
-
-    class FilesWriter {
-        private final boolean isFullJdkAndRuntime;
-        private final boolean inheritMultifileParts;
-
-        public List<KtFile> files = new ArrayList<>();
-        private KotlinCoreEnvironment environment;
-        private Disposable disposable;
-
-        private FilesWriter(boolean isFullJdkAndRuntime, boolean inheritMultifileParts) {
-            this.isFullJdkAndRuntime = isFullJdkAndRuntime;
-            this.inheritMultifileParts = inheritMultifileParts;
-            this.disposable = new TestDisposable();
-            this.environment = createEnvironment(isFullJdkAndRuntime, disposable);
-        }
-
-        private KotlinCoreEnvironment createEnvironment(boolean isFullJdkAndRuntime, @NotNull Disposable disposable) {
-            ConfigurationKind configurationKind = isFullJdkAndRuntime ? ConfigurationKind.ALL : ConfigurationKind.NO_KOTLIN_REFLECT;
-            TestJdkKind testJdkKind = isFullJdkAndRuntime ? TestJdkKind.FULL_JDK : TestJdkKind.MOCK_JDK;
-            CompilerConfiguration configuration =
-                    KotlinTestUtils.newConfiguration(configurationKind, testJdkKind, KotlinTestUtils.getAnnotationsJar());
-            configuration.put(CommonConfigurationKeys.MODULE_NAME, "android-module-" + MODULE_INDEX++);
-            if (inheritMultifileParts) {
-                configuration.put(JVMConfigurationKeys.INHERIT_MULTIFILE_PARTS, true);
-            }
-            return KotlinCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
-        }
-
-        public boolean shouldWriteFilesOnDisk() {
-            return files.size() > 300;
-        }
-
-        public void writeFilesOnDiskIfNeeded() {
-            if (shouldWriteFilesOnDisk()) {
-                writeFilesOnDisk();
-            }
-        }
-
-        public void writeFilesOnDisk() {
-            writeFiles(files);
-            files = new ArrayList<>();
-            if (disposable != null) {
-                Disposer.dispose(disposable);
-                disposable = new TestDisposable();
-            }
-            environment = createEnvironment(isFullJdkAndRuntime, disposable);
-        }
-
-        public void addFile(String name, String content) {
-            try {
-                files.add(CodegenTestFiles.create(name, content, environment.getProject()).getPsiFile());
-            }
-            catch (Throwable e) {
-                throw new RuntimeException("Problem during creating file " + name + ": \n" + content, e);
-            }
-        }
-
-        private void writeFiles(List<KtFile> filesToCompile) {
-            if (filesToCompile.isEmpty()) return;
-
-            //1000 files per folder, each folder would be jared by build.gradle script
-            // We can't create one big jar with all test cause dex has problem with memory on teamcity
-            WRITED_FILES_COUNT += filesToCompile.size();
-            File outputDir = new File(pathManager.getOutputForCompiledFiles(WRITED_FILES_COUNT / 1000));
-
-            System.out.println("Generating " + filesToCompile.size() + " files" +
-                               (inheritMultifileParts
-                                ? " (JVM.INHERIT_MULTIFILE_PARTS)"
-                                : isFullJdkAndRuntime ? " (full jdk and runtime)" : "") + " into " + outputDir.getName() + "...");
-            OutputFileCollection outputFiles;
-            GenerationState state = null;
-            try {
-                state = GenerationUtils.compileFiles(filesToCompile, environment);
-                outputFiles = state.getFactory();
-            }
-            catch (Throwable e) {
-                throw new RuntimeException(e);
-            }
-            finally {
-                if (state != null) {
-                    state.destroy();
-                }
-            }
-
-            if (!outputDir.exists()) {
-                outputDir.mkdirs();
-            }
-            Assert.assertTrue("Cannot create directory for compiled files", outputDir.exists());
-
-            OutputUtilsKt.writeAllTo(outputFiles, outputDir);
-        }
-    }
-
-    private void processFiles(
-            @NotNull Printer printer,
-            @NotNull File[] files,
-            @NotNull FilesWriter holderFull,
-            @NotNull FilesWriter holderMock,
-            @NotNull FilesWriter holderInheritMFP
-    ) throws IOException {
-        holderFull.writeFilesOnDiskIfNeeded();
-        holderMock.writeFilesOnDiskIfNeeded();
-        holderInheritMFP.writeFilesOnDiskIfNeeded();
-
-        for (File file : files) {
-            if (SpecialFiles.getExcludedFiles().contains(file.getName())) {
-                continue;
-            }
-            if (file.isDirectory()) {
-                File[] listFiles = file.listFiles();
-                if (listFiles != null) {
-                    processFiles(printer, listFiles, holderFull, holderMock, holderInheritMFP);
-                }
-            }
-            else if (!FileUtilRt.getExtension(file.getName()).equals(KotlinFileType.INSTANCE.getDefaultExtension())) {
-                // skip non kotlin files
-            }
-            else {
-                String fullFileText = FileUtil.loadFile(file, true);
-
-                if (!InTextDirectivesUtils.isPassingTarget(TargetBackend.JVM, file)) {
-                    continue;
-                }
-
-                //TODO: support LANGUAGE_VERSION
-                if (InTextDirectivesUtils.isDirectiveDefined(fullFileText, "LANGUAGE_VERSION:")) {
-                    continue;
-                }
-
-                //TODO: support multifile facades
-                //TODO: support multifile facades hierarchies
-                if (hasBoxMethod(fullFileText)) {
-                    FilesWriter filesHolder = InTextDirectivesUtils.isDirectiveDefined(fullFileText, "FULL_JDK") ||
-                                              InTextDirectivesUtils.isDirectiveDefined(fullFileText, "WITH_RUNTIME") ||
-                                              InTextDirectivesUtils.isDirectiveDefined(fullFileText, "WITH_REFLECT") ? holderFull : holderMock;
-                    filesHolder = fullFileText.contains("+JVM.INHERIT_MULTIFILE_PARTS") ? holderInheritMFP : filesHolder;
-
-                    FqName classWithBoxMethod = AndroidTestGeneratorKt.genFiles(file, fullFileText, filesHolder);
-                    if (classWithBoxMethod == null)
-                        continue;
-
-                    String generatedTestName = generateTestName(file.getName());
-                    generateTestMethod(printer, generatedTestName, classWithBoxMethod.asString(), StringUtil.escapeStringCharacters(file.getPath()));
-                }
-            }
-        }
-    }
-
-
-
-    private static boolean hasBoxMethod(String text) {
-        return text.contains("fun box()");
-    }
-
-    private static void generateTestMethod(Printer p, String testName, String className, String filePath) {
-        p.println("public void test" + testName + "() throws Exception {");
-        p.pushIndent();
-        p.println("invokeBoxMethod(" + className + ".class, \"" + filePath + "\", \"OK\");");
-        p.popIndent();
-        p.println("}");
-        p.println();
-    }
-
-    private String generateTestName(String fileName) {
-        String result = NameUtils.sanitizeAsJavaIdentifier(FileUtil.getNameWithoutExtension(StringUtil.capitalize(fileName)));
-
-        int i = 0;
-        while (generatedTestNames.contains(result)) {
-            result += "_" + i++;
-        }
-        generatedTestNames.add(result);
-        return result;
-    }
-}
--- a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.kt
+++ b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.kt
@@ -0,0 +1,294 @@
+/*
+ * 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.android.tests
+
+import com.google.common.collect.Lists
+import com.intellij.openapi.util.Disposer
+import com.intellij.openapi.util.io.FileUtil
+import com.intellij.openapi.util.io.FileUtilRt
+import com.intellij.openapi.util.text.StringUtil
+import org.jetbrains.kotlin.backend.common.output.OutputFileCollection
+import org.jetbrains.kotlin.cli.common.output.outputUtils.writeAllTo
+import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.codegen.CodegenTestCase
+import org.jetbrains.kotlin.codegen.CodegenTestFiles
+import org.jetbrains.kotlin.codegen.GenerationUtils
+import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
+import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.idea.KotlinFileType
+import org.jetbrains.kotlin.name.NameUtils
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.test.*
+import org.jetbrains.kotlin.utils.Printer
+import org.junit.Assert
+import org.junit.Ignore
+import java.io.File
+import java.io.FileWriter
+import java.io.IOException
+import java.util.*
+
+data class ConfigurationKey(val kind: ConfigurationKind, val jdkKind: TestJdkKind, val configuration: String)
+
+@Ignore
+class CodegenTestsOnAndroidGenerator private constructor(private val pathManager: PathManager) : CodegenTestCase() {
+    private var writtenFilesCount = 0
+
+    private var currentModuleIndex = 1
+
+    private val generatedTestNames = Lists.newArrayList<String>()
+
+    private fun generateOutputFiles() {
+        prepareAndroidModule()
+        generateAndSave()
+    }
+
+    private fun prepareAndroidModule() {
+        println("Copying kotlin-runtime.jar and kotlin-reflect.jar in android module...")
+        copyKotlinRuntimeJars()
+
+        println("Check 'libs' folder in tested android module...")
+        val libsFolderInTestedModule = File(pathManager.libsFolderInAndroidTestedModuleTmpFolder)
+        if (!libsFolderInTestedModule.exists()) {
+            libsFolderInTestedModule.mkdirs()
+        }
+    }
+
+    private fun copyKotlinRuntimeJars() {
+        FileUtil.copy(
+            ForTestCompileRuntime.runtimeJarForTests(),
+            File(pathManager.libsFolderInAndroidTmpFolder + "/kotlin-runtime.jar")
+        )
+        FileUtil.copy(
+            ForTestCompileRuntime.reflectJarForTests(),
+            File(pathManager.libsFolderInAndroidTmpFolder + "/kotlin-reflect.jar")
+        )
+
+        FileUtil.copy(
+            ForTestCompileRuntime.kotlinTestJarForTests(),
+            File(pathManager.libsFolderInAndroidTmpFolder + "/kotlin-test.jar")
+        )
+    }
+
+    private fun generateAndSave() {
+        println("Generating test files...")
+        val testSourceFilePath =
+            pathManager.srcFolderInAndroidTmpFolder + "/" + testClassPackage.replace(".", "/") + "/" + testClassName + ".java"
+
+        FileWriter(File(testSourceFilePath)).use {
+            val p = Printer(it)
+            p.print(FileUtil.loadFile(File("license/LICENSE.txt")))
+            p.println(
+                """package $testClassPackage;
+                |
+                |import $baseTestClassPackage.$baseTestClassName;
+                |
+                |/* This class is generated by $generatorName. DO NOT MODIFY MANUALLY */
+                |public class $testClassName extends $baseTestClassName {
+                |
+            """.trimMargin()
+            )
+            p.pushIndent()
+
+            generateTestMethodsForDirectories(p, File("compiler/testData/codegen/box"), File("compiler/testData/codegen/boxInline"))
+
+            p.popIndent()
+            p.println("}")
+        }
+    }
+
+    private fun generateTestMethodsForDirectories(p: Printer, vararg dirs: File) {
+        val holders = mutableMapOf<ConfigurationKey, FilesWriter>()
+
+        for (dir in dirs) {
+            val files = dir.listFiles() ?: error("Folder with testData is empty: ${dir.absolutePath}")
+            processFiles(p, files, holders)
+        }
+
+        holders.values.forEach {
+            it.writeFilesOnDisk()
+        }
+    }
+
+    internal inner class FilesWriter(
+        private val configuration: CompilerConfiguration
+    ) {
+        private val rawFiles: MutableList<Pair<String, String>> = ArrayList()
+
+        private fun shouldWriteFilesOnDisk(): Boolean = rawFiles.size > 300
+
+        fun writeFilesOnDiskIfNeeded() {
+            if (shouldWriteFilesOnDisk()) {
+                writeFilesOnDisk()
+            }
+        }
+
+        fun writeFilesOnDisk() {
+            val disposable = TestDisposable()
+
+            val environment = KotlinCoreEnvironment.createForTests(
+                disposable,
+                configuration.copy().apply { put(CommonConfigurationKeys.MODULE_NAME, "android-module-" + currentModuleIndex++) },
+                EnvironmentConfigFiles.JVM_CONFIG_FILES
+            )
+
+            writeFiles(
+                rawFiles.map {
+                    CodegenTestFiles.create(it.first, it.second, environment.project).psiFile
+                }, environment
+            )
+            Disposer.dispose(disposable)
+            rawFiles.clear()
+        }
+
+        fun addFile(name: String, content: String) {
+            rawFiles.add(name to content)
+        }
+
+        private fun writeFiles(filesToCompile: List<KtFile>, environment: KotlinCoreEnvironment) {
+            if (filesToCompile.isEmpty()) return
+
+            //1000 files per folder, each folder would be jared by build.gradle script
+            // We can't create one big jar with all test cause dex has problem with memory on teamcity
+            writtenFilesCount += filesToCompile.size
+            val outputDir = File(pathManager.getOutputForCompiledFiles(writtenFilesCount / 1000))
+
+            println("Generating ${filesToCompile.size} files into ${outputDir.name}, configuration: '${environment.configuration}'...")
+
+            val outputFiles = GenerationUtils.compileFiles(filesToCompile, environment).run { destroy(); factory }
+
+            if (!outputDir.exists()) {
+                outputDir.mkdirs()
+            }
+            Assert.assertTrue("Cannot create directory for compiled files", outputDir.exists())
+
+            outputFiles.writeAllTo(outputDir)
+        }
+    }
+
+    @Throws(IOException::class)
+    private fun processFiles(
+        printer: Printer,
+        files: Array<File>,
+        holders: MutableMap<ConfigurationKey, FilesWriter>
+    ) {
+        holders.values.forEach {
+            it.writeFilesOnDiskIfNeeded()
+        }
+
+        for (file in files) {
+            if (SpecialFiles.getExcludedFiles().contains(file.name)) {
+                continue
+            }
+            if (file.isDirectory) {
+                val listFiles = file.listFiles()
+                if (listFiles != null) {
+                    processFiles(printer, listFiles, holders)
+                }
+            } else if (FileUtilRt.getExtension(file.name) != KotlinFileType.EXTENSION) {
+                // skip non kotlin files
+            } else {
+                if (!InTextDirectivesUtils.isPassingTarget(TargetBackend.JVM, file)) {
+                    continue
+                }
+
+                val fullFileText = FileUtil.loadFile(file, true)
+                //TODO support JvmPackageName
+                if (fullFileText.contains("@file:JvmPackageName(")) continue
+
+                if (hasBoxMethod(fullFileText)) {
+                    val testFiles = createTestFiles(file, fullFileText)
+                    val kind = extractConfigurationKind(testFiles)
+                    val jdkKind = getJdkKind(testFiles)
+                    val keyConfiguration = CompilerConfiguration()
+                    updateConfigurationByDirectivesInTestFiles(testFiles, keyConfiguration)
+
+                    val key = ConfigurationKey(kind, jdkKind, keyConfiguration.toString())
+                    val filesHolder = holders.getOrPut(key) {
+                        FilesWriter(KotlinTestUtils.newConfiguration(kind, jdkKind, KotlinTestUtils.getAnnotationsJar()).apply {
+                            println("Creating new configuration by $key")
+                            updateConfigurationByDirectivesInTestFiles(testFiles, this)
+                        })
+                    }
+
+                    val classWithBoxMethod = patchFiles(file, testFiles, filesHolder) ?: continue
+
+                    val generatedTestName = generateTestName(file.name)
+                    generateTestMethod(
+                        printer,
+                        generatedTestName,
+                        classWithBoxMethod.asString(),
+                        StringUtil.escapeStringCharacters(file.path)
+                    )
+                }
+            }
+        }
+    }
+
+    private fun createTestFiles(file: File, expectedText: String): List<CodegenTestCase.TestFile> =
+        KotlinTestUtils.createTestFiles(
+            file.name,
+            expectedText,
+            object : KotlinTestUtils.TestFileFactoryNoModules<CodegenTestCase.TestFile>() {
+                override fun create(fileName: String, text: String, directives: Map<String, String>): CodegenTestCase.TestFile {
+                    return CodegenTestCase.TestFile(fileName, text)
+                }
+            })
+
+
+    private fun generateTestName(fileName: String): String {
+        var result = NameUtils.sanitizeAsJavaIdentifier(FileUtil.getNameWithoutExtension(StringUtil.capitalize(fileName)))
+
+        var i = 0
+        while (generatedTestNames.contains(result)) {
+            result += "_" + i++
+        }
+        generatedTestNames.add(result)
+        return result
+    }
+
+    companion object {
+        private const val testClassPackage = "org.jetbrains.kotlin.android.tests"
+        private const val testClassName = "CodegenTestCaseOnAndroid"
+        private const val baseTestClassPackage = "org.jetbrains.kotlin.android.tests"
+        private const val baseTestClassName = "AbstractCodegenTestCaseOnAndroid"
+        private const val generatorName = "CodegenTestsOnAndroidGenerator"
+
+
+        @JvmStatic
+        @Throws(Throwable::class)
+        fun generate(pathManager: PathManager) {
+            CodegenTestsOnAndroidGenerator(pathManager).generateOutputFiles()
+        }
+
+
+        private fun hasBoxMethod(text: String): Boolean {
+            return text.contains("fun box()")
+        }
+
+        private fun generateTestMethod(p: Printer, testName: String, className: String, filePath: String) {
+            p.println("public void test$testName() throws Exception {")
+            p.pushIndent()
+            p.println("invokeBoxMethod($className.class, \"$filePath\", \"OK\");")
+            p.popIndent()
+            p.println("}")
+            p.println()
+        }
+    }
+}
--- a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/SpecialFiles.java
+++ b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/SpecialFiles.java
@@ -48,6 +48,11 @@ public class SpecialFiles {
        excludedFiles.add("enumKClassAnnotation.kt");
        excludedFiles.add("primitivesAndArrays.kt");
        excludedFiles.add("getDelegateWithoutReflection.kt");
+        excludedFiles.add("parameterAnnotationInDefaultImpls.kt");
+        excludedFiles.add("kt17091.kt");
+        excludedFiles.add("kt17091_2.kt");
+        excludedFiles.add("kt17091_3.kt");
+        excludedFiles.add("kt22906.kt");

        // Reflection is used to check full class name
        excludedFiles.add("native");
@@ -127,9 +132,8 @@ public class SpecialFiles {
        //wrong function resolution after package renaming
        excludedFiles.add("apiVersionAtLeast1.kt");

-        //special flags
-        excludedFiles.add("inlineFunInConstructorCallWithEnabledNormalization.kt");
-        excludedFiles.add("kt9532_lv10.kt");
+        //special symbols in names
+        excludedFiles.add("nameWithWhitespace.kt");
    }

    private SpecialFiles() {
--- a/compiler/backend-common/build.gradle.kts
+++ b/compiler/backend-common/build.gradle.kts
@@ -1,5 +1,6 @@

 apply { plugin("kotlin") }
+apply { plugin("jps-compatible") }

 jvmTarget = "1.6"

@@ -9,7 +10,7 @@ dependencies {
    compile(project(":compiler:util"))
    compile(project(":compiler:frontend"))
    compile(project(":compiler:ir.tree"))
-    compile(project(":compiler:cli-common"))
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }

 sourceSets {
--- a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.kt
+++ b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.kt
@@ -20,14 +20,18 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.backend.common.bridges.findInterfaceImplementation
 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.diagnostics.DiagnosticSink
+import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.hasExpectModifier
 import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.bindingContextUtil.isUsedAsExpression
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
+import org.jetbrains.kotlin.resolve.multiplatform.ExpectedActualResolver
 import org.jetbrains.kotlin.types.KotlinType

 object CodegenUtil {
@@ -146,14 +150,14 @@ object CodegenUtil {


    @JvmStatic
-    fun BindingContext.isExhaustive(whenExpression: KtWhenExpression, isStatement: Boolean): Boolean {
-        val slice = if (isStatement && !whenExpression.isUsedAsExpression(this)) {
+    fun isExhaustive(bindingContext: BindingContext, whenExpression: KtWhenExpression, isStatement: Boolean): Boolean {
+        val slice = if (isStatement && !whenExpression.isUsedAsExpression(bindingContext)) {
            BindingContext.IMPLICIT_EXHAUSTIVE_WHEN
        }
        else {
            BindingContext.EXHAUSTIVE_WHEN
        }
-        return this[slice, whenExpression] == true
+        return bindingContext[slice, whenExpression] == true
    }

    @JvmStatic
@@ -166,4 +170,37 @@ object CodegenUtil {
    @JvmStatic
    fun getActualDeclarations(file: KtFile): List<KtDeclaration> =
            file.declarations.filterNot(KtDeclaration::hasExpectModifier)
+
+    @JvmStatic
+    fun findExpectedFunctionForActual(descriptor: FunctionDescriptor): FunctionDescriptor? {
+        val compatibleExpectedFunctions = with(ExpectedActualResolver) {
+            descriptor.findCompatibleExpectedForActual(DescriptorUtils.getContainingModule(descriptor))
+        }
+        return compatibleExpectedFunctions.firstOrNull() as FunctionDescriptor?
+    }
+
+    @JvmStatic
+    fun getFunctionParametersForDefaultValueGeneration(
+        descriptor: FunctionDescriptor,
+        trace: DiagnosticSink?
+    ): List<ValueParameterDescriptor> {
+        if (descriptor.isActual) {
+            val expected = CodegenUtil.findExpectedFunctionForActual(descriptor)
+            if (expected != null && expected.valueParameters.any(ValueParameterDescriptor::declaresDefaultValue)) {
+                val element = DescriptorToSourceUtils.descriptorToDeclaration(expected)
+                if (element == null) {
+                    if (trace != null) {
+                        val actualDeclaration = DescriptorToSourceUtils.descriptorToDeclaration(descriptor)
+                                ?: error("Not a source declaration: $descriptor")
+                        trace.report(Errors.EXPECTED_FUNCTION_SOURCE_WITH_DEFAULT_ARGUMENTS_NOT_FOUND.on(actualDeclaration))
+                    }
+                    return descriptor.valueParameters
+                }
+
+                return expected.valueParameters
+            }
+        }
+
+        return descriptor.valueParameters
+    }
 }
--- a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/bridges/impl.kt
+++ b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/bridges/impl.kt
@@ -17,20 +17,18 @@
 package org.jetbrains.kotlin.backend.common.bridges

 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.OverridingUtil
 import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isOrOverridesSynthesized

 fun <Signature> generateBridgesForFunctionDescriptor(
-        descriptor: FunctionDescriptor,
-        signature: (FunctionDescriptor) -> Signature,
-        isBodyOwner: (DeclarationDescriptor) -> Boolean
+    descriptor: FunctionDescriptor,
+    signature: (FunctionDescriptor) -> Signature,
+    areDeclarationAndDefinitionSame: (CallableMemberDescriptor) -> Boolean
 ): Set<Bridge<Signature>> {
-    return generateBridges(DescriptorBasedFunctionHandle(descriptor, isBodyOwner), { signature(it.descriptor) })
+    return generateBridges(DescriptorBasedFunctionHandle(descriptor, areDeclarationAndDefinitionSame), { signature(it.descriptor) })
 }

 /**
@@ -51,26 +49,28 @@ fun <Signature> generateBridgesForFunctionDescriptor(
 * eases the process of determining what bridges are already generated in our supertypes and need to be inherited, not regenerated.
 */
 class DescriptorBasedFunctionHandle(
-        val descriptor: FunctionDescriptor,
-        /*
-        To generate proper bridges for non-abstract function
-        we should know if the function declaration and its definition in the target platform are the same or not.
-        For JS and JVM8 they are placed in interface classes and we need generate bridge for such function ('isAbstract' will return false).
-        For JVM6 target function body generated in separate place (DefaultImpl) and method in interface is abstract
-        For JVM6 target function body is generated in a separate place (DefaultImpls) and
-        the method in the interface is abstract so we must not generate bridges for such cases.
-        */
-        isBodyOwner: (DeclarationDescriptor) -> Boolean
+    val descriptor: FunctionDescriptor,
+    /*
+    To generate proper bridges for non-abstract function
+    we should know if the function declaration and its definition in the target platform are the same or not.
+    For JS and @JvmDefault JVM members they are placed in interface classes and
+    we need generate bridge for such function ('isAbstract' will return false).
+    For non-@JvmDefault function, its body is generated in a separate place (DefaultImpls) and
+    the method in the interface is abstract so we must not generate bridges for such cases.
+    */
+    areDeclarationAndDefinitionSame: (CallableMemberDescriptor) -> Boolean
 ) : FunctionHandle {
-    private val overridden = descriptor.overriddenDescriptors.map { DescriptorBasedFunctionHandle(it.original, isBodyOwner) }
+    private val overridden = descriptor.overriddenDescriptors.map {
+        DescriptorBasedFunctionHandle(
+            it.original,
+            areDeclarationAndDefinitionSame
+        )
+    }

-    override val isDeclaration: Boolean =
-            descriptor.kind.isReal ||
-            findInterfaceImplementation(descriptor) != null
+    override val isDeclaration: Boolean = descriptor.kind.isReal || findInterfaceImplementation(descriptor) != null

    override val isAbstract: Boolean =
-            descriptor.modality == Modality.ABSTRACT ||
-            isBodyOwner(descriptor.containingDeclaration)
+        descriptor.modality == Modality.ABSTRACT || !areDeclarationAndDefinitionSame(descriptor)

    override val isInterfaceDeclaration: Boolean
        get() = DescriptorUtils.isInterface(descriptor.containingDeclaration)
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`implementation-class=org.jetbrains.kotlin.pill.JpsCompatiblePlugin`